@ridit/relay

One port. Any language. Monaco-ready LSP bridge.

@ridit/relay multiplexes any number of language servers over a single WebSocket port using path-based routing. Drop it into any Monaco editor project and get completions, hover, diagnostics, go-to-definition, references, signature help, formatting, and code lenses — wired automatically.

ws://127.0.0.1:9721/python      → pylsp / pyright
ws://127.0.0.1:9721/typescript  → typescript-language-server
ws://127.0.0.1:9721/rust        → rust-analyzer

---

Why

The standard approach to Monaco + LSP is monaco-languageclient — but it pulls in vscode-languageclient and the full VSCode extension host model just to wire up completions. That's hundreds of kilobytes of VSCode abstractions built for a different runtime, bolted onto Monaco as an afterthought.

Relay uses only the primitives it actually needs — vscode-ws-jsonrpc for WebSocket framing and vscode-languageserver-protocol for LSP message types — then talks directly to Monaco's provider APIs. No extension host, no VSCode shims, no adapter layers.

It was extracted from Meridia — a from-scratch code editor — where we needed LSP that fit the stack instead of fighting it. If you're building an editor or any Monaco-based tool, relay gives you full LSP integration without the overhead.

---

Install

npm install @ridit/relay
# or
bun add @ridit/relay

Monaco is a peer dependency — install it separately if you haven't:

npm install monaco-editor

---

Usage

Server (Node / Bun)

import { Server } from "@ridit/relay";

const server = new Server();

server.register({
  command: "pyright-langserver",
  args: ["--stdio"],
  languageId: "python",
});

server.register({
  command: "typescript-language-server",
  args: ["--stdio"],
  languageId: "typescript",
});

await server.start(9721);

Client (Browser)

import * as monaco from "monaco-editor";
import { Client } from "@ridit/relay";

const editor = monaco.editor.create(document.getElementById("app")!, {
  automaticLayout: true,
});

const model = monaco.editor.createModel(
  "print('hello')",
  "python",
  monaco.Uri.file("/workspace/main.py"), // real path required
);

editor.setModel(model);

const client = new Client(monaco);
client.register({ languageId: "python" });
await client.start("/workspace");

Windows: pass the workspace path with backslashes — "C:\\workspace".

---

What gets wired automatically

Once client.start() is called, relay registers the following Monaco providers for each language:

Feature	Provider
Completions	registerCompletionItemProvider
Hover	registerHoverProvider
Diagnostics	setModelMarkers via publishDiagnostics
Go to Definition	registerDefinitionProvider
Find References	registerReferenceProvider
Signature Help	registerSignatureHelpProvider
Formatting	registerDocumentFormattingEditProvider
Code Lenses	registerCodeLensProvider (with usage counts)

---

API

new Server()

server.register(def: LspServerDefinition): this
server.start(port?: number): Promise<void>   // default: 9721

LspServerDefinition

{
  command: string;       // binary name or full path
  languageId: string;    // e.g. "python", "typescript"
  args?: string[];       // e.g. ["--stdio"]
  cwd?: string;          // working directory override
}

new Client(monaco)

client.register(def: LspClientDefinition): this
client.start(workspacePath?: string, port?: number): Promise<void>
client.format_model(model: monaco.editor.ITextModel): Promise<boolean>
client.updateWorkspaceRoot(folderPath: string): Promise<void>
client.dispose(): Promise<void>

LspClientDefinition

{
  languageId: string;     // must match server registration
  extensions?: string[];  // file extensions to match, e.g. ["py", "pyw"]
}

---

Windows notes

On Windows, npm-installed language servers are .cmd wrappers. Relay resolves these automatically — pass the bare binary name and it will find the right executable:

server.register({
  command: "pyright-langserver",
  languageId: "python",
  args: ["--stdio"],
});

---

License

MIT