dsh-interconnect 0.6.4 → 0.9.0

package/lib/index.js

@@ -1,10 +1,5 @@
 // src/interconnect/index.ts
 import { Service } from "@deepseek-ai/cordis";
-import {
-  clientRequestSchema,
-  serverResponseSchema,
-  RpcId
-} from "@deepseek-ai/dsh-host-apiproxy/api";
 import { credentialRef } from "@deepseek-ai/dsh-credentials";
 import { boundContextSummary, createUserMessage } from "@deepseek-ai/dsh-llm";
 import { hasApiRemoteSubagentOwner } from "@deepseek-ai/dsh-api-remotes";
@@ -826,12 +821,9 @@ defineMethod("transform", [
 import WebSocket, { WebSocketServer } from "ws";
 
 // src/interconnect/types.ts
-var INTERCONNECT_CHANNEL = "/interconnect";
 var INTERCONNECT_TOKEN_REF = "DSH_INTERCONNECT_TOKEN";
 
 // src/interconnect/index.ts
-var INVALID_REQUEST_RPC_ID = RpcId("invalid-request");
-var MAX_REQUEST_BODY_BYTES = 1024 * 1024;
 var PLUGIN_SOURCE = "dsh-interconnect";
 var LINK_CHANNEL = "/interconnect/link";
 var notificationSchema = Schema.union([
@@ -842,26 +834,49 @@ var notificationSchema = Schema.union([
   Schema.object({ kind: Schema.const("session/disposed"), sessionId: Schema.string() }),
   Schema.object({ kind: Schema.const("subagent/end"), provider: Schema.string(), childSessionId: Schema.string(), stopReason: Schema.string() })
 ]);
+var senderSchema = Schema.object({ instanceId: Schema.string(), sessionId: Schema.string() });
+var messageSchema = Schema.union([
+  Schema.object({
+    kind: Schema.const("send"),
+    sessionId: Schema.string(),
+    text: Schema.string(),
+    sender: senderSchema,
+    delivery: Schema.union([Schema.const("followup"), Schema.const("steer"), Schema.const("inject")]),
+    resume: Schema.boolean()
+  }),
+  Schema.object({
+    kind: Schema.const("reply"),
+    sessionId: Schema.string(),
+    text: Schema.string(),
+    sender: senderSchema,
+    delivery: Schema.union([Schema.const("followup"), Schema.const("steer"), Schema.const("inject")]),
+    resume: Schema.boolean()
+  })
+]);
+var querySchema = Schema.union([
+  Schema.object({ kind: Schema.const("ping") }),
+  Schema.object({ kind: Schema.const("list") }),
+  Schema.object({ kind: Schema.const("event"), notification: notificationSchema })
+]);
 var linkFrameSchema = Schema.union([
   Schema.object({ type: Schema.const("hello"), sender: Schema.string() }),
-  Schema.object({ type: Schema.const("event"), notification: notificationSchema })
+  Schema.object({ type: Schema.const("event"), notification: notificationSchema }),
+  Schema.object({ type: Schema.const("msg"), reqId: Schema.string(), message: messageSchema }),
+  Schema.object({ type: Schema.const("msg-result"), reqId: Schema.string(), result: Schema.object({
+    delivered: Schema.boolean(),
+    instance: Schema.string(),
+    delivery: Schema.union([Schema.const("followup"), Schema.const("steer"), Schema.const("inject")]),
+    reason: Schema.string()
+  }) }),
+  Schema.object({ type: Schema.const("query"), reqId: Schema.string(), query: querySchema }),
+  Schema.object({ type: Schema.const("query-result"), reqId: Schema.string(), result: Schema.any() })
 ]);
-var sendPayloadSchema = Schema.object({
-  sessionId: Schema.string(),
-  text: Schema.string(),
-  delivery: Schema.union([Schema.const("followup"), Schema.const("steer"), Schema.const("inject")]),
-  resume: Schema.boolean()
-});
-var eventPayloadSchema = Schema.object({
-  sender: Schema.string(),
-  notification: notificationSchema
-});
 var InterconnectService = class extends Service {
   static inject = ["webServer", "agents", "credentials"];
   static Config = Schema.object({
     instanceId: Schema.string().default("dsh"),
     requestTimeoutMs: Schema.natural().max(6e4).default(1e4),
-    peers: Schema.array(Schema.string()).default([]),
+    peers: Schema.object({}).default({}),
     delivery: Schema.union([Schema.const("followup"), Schema.const("steer"), Schema.const("inject")]).default("followup"),
     allowResume: Schema.boolean().default(true)
   });
@@ -869,27 +884,28 @@ var InterconnectService = class extends Service {
   requestTimeoutMs;
   delivery;
   allowResume;
-  peers = /* @__PURE__ */ new Set();
   subscriptions = [];
   server = new WebSocketServer({ noServer: true });
   sockets = /* @__PURE__ */ new Set();
+  /** Outbound peer links keyed by the peer's `instanceId`. */
   linkStates = /* @__PURE__ */ new Map();
   heartbeatTimer;
   /** Peer identity each live socket announced via its `hello` frame, if any. */
   peerOf = /* @__PURE__ */ new WeakMap();
+  /** Sender each local session last received a send from, keyed by local session id. */
+  senders = /* @__PURE__ */ new Map();
+  /** In-flight frames sent over a peer link, keyed by `reqId`, awaiting a correlated result. */
+  pendingMessages = /* @__PURE__ */ new Map();
+  reqIdCounter = 0;
   constructor(ctx, config) {
     super(ctx, "interconnect");
     this.instanceId = config.instanceId;
     this.requestTimeoutMs = config.requestTimeoutMs;
     this.delivery = config.delivery ?? "followup";
     this.allowResume = config.allowResume ?? true;
-    for (const peer of config.peers ?? []) this.peers.add(trimBase(peer));
-    const route = {
-      kind: "prefix",
-      path: INTERCONNECT_CHANNEL,
-      handler: (req, res) => this.handle(req, res)
-    };
-    ctx.effect(() => ctx.webServer.register(route), "interconnect: /interconnect route");
+    for (const [peerInstanceId, origin] of Object.entries(config.peers ?? {})) {
+      this.link(peerInstanceId, origin);
+    }
     const upgrade = {
       path: LINK_CHANNEL,
       handler: (req, socket, head) => {
@@ -950,72 +966,173 @@ var InterconnectService = class extends Service {
       this.server.close();
     }, "interconnect: websocket teardown");
   }
+  /**
+   * This instance's identity to attach to outbound messages. Always present:
+   * it needs no address, only this instance's id and the calling session.
+   * @param sessionId - the local session that is sending, used as the reply target.
+   */
+  selfSender(sessionId) {
+    return { instanceId: this.instanceId, sessionId };
+  }
   async send(request) {
     const payload = {
       sessionId: request.sessionId,
       text: request.text,
+      ...request.sender === void 0 ? {} : { sender: request.sender },
       ...request.delivery === void 0 ? {} : { delivery: request.delivery },
       ...request.resume === void 0 ? {} : { resume: request.resume }
     };
-    const result = await this.post(request.baseUrl, "send", payload);
+    const result = await this.msgRequest(request.instanceId, "send", payload);
+    return result ?? { delivered: false, instance: this.instanceId, reason: "unreachable" };
+  }
+  /**
+   * Deliver one text message back to the peer that a local session last
+   * received a send from. `sessionId` names the LOCAL replying session; the
+   * outbound target is the `sender` that session recorded, addressed through
+   * this instance's own link to the sender's instance.
+   */
+  async reply(request) {
+    const sender = this.senders.get(request.sessionId);
+    if (sender === void 0) {
+      return { delivered: false, instance: this.instanceId, reason: "no-sender-known" };
+    }
+    const payload = {
+      sessionId: sender.sessionId,
+      text: request.text,
+      ...request.delivery === void 0 ? {} : { delivery: request.delivery },
+      ...request.resume === void 0 ? {} : { resume: request.resume },
+      // Attribute the reply to this instance so the peer, in turn, can reply
+      // back — chaining the conversation.
+      sender: this.selfSender(request.sessionId)
+    };
+    const result = await this.msgRequest(sender.instanceId, "send", payload);
     return result ?? { delivered: false, instance: this.instanceId, reason: "unreachable" };
   }
-  async ping(baseUrl) {
-    return this.post(baseUrl, "ping", {});
+  /**
+   * Probe a peer instance for liveness and identity over its persistent link.
+   * Returns the peer identity when reachable, or undefined when the link is
+   * not up or no answer arrives.
+   */
+  async ping(instanceId) {
+    return this.queryRequest(instanceId, { kind: "ping" });
+  }
+  /**
+   * List a peer instance's live sessions over its persistent link. Undefined on
+   * transport failure, matching `ping`.
+   */
+  async list(instanceId) {
+    return this.queryRequest(instanceId, { kind: "list" });
+  }
+  /** The origin this instance dials to reach a configured peer, or undefined. */
+  originOf(instanceId) {
+    const state = this.linkStates.get(instanceId);
+    return state?.peer;
   }
   /**
-   * List the peer's live sessions so a caller can discover a valid `send`
-   * target. `undefined` on transport or auth failure, matching `ping`.
+   * Send a `msg` frame over the live link to a peer and resolve with its
+   * correlated `msg-result`. Undefined when the peer has no live link here
+   * (not configured, or the link is down) — sends can only address configured+
+   * connected peers by design.
    */
-  async list(baseUrl) {
-    return this.post(baseUrl, "list", {});
+  async msgRequest(instanceId, kind, payload) {
+    const state = this.linkStates.get(instanceId);
+    if (state === void 0 || !state.writable()) return void 0;
+    const reqId = `m${++this.reqIdCounter}-${crypto.randomUUID()}`;
+    const message = {
+      kind,
+      sessionId: payload.sessionId,
+      text: payload.text,
+      ...payload.sender === void 0 ? {} : { sender: payload.sender },
+      ...payload.delivery === void 0 ? {} : { delivery: payload.delivery },
+      ...payload.resume === void 0 ? {} : { resume: payload.resume }
+    };
+    return this.waitForResult(reqId, (failure) => {
+      const wrote = state.sendFrame({ type: "msg", reqId, message });
+      if (!wrote) failure(new Error(`interconnect: peer link to ${instanceId} closed while sending`));
+    });
+  }
+  /** Send a `query` frame over the live link to a peer and resolve its result. */
+  async queryRequest(instanceId, query) {
+    const state = this.linkStates.get(instanceId);
+    if (state === void 0 || !state.writable()) return void 0;
+    const reqId = `q${++this.reqIdCounter}-${crypto.randomUUID()}`;
+    return this.waitForResult(reqId, (failure) => {
+      const wrote = state.sendFrame({ type: "query", reqId, query });
+      if (!wrote) failure(new Error(`interconnect: peer link to ${instanceId} closed while querying`));
+    });
+  }
+  /** Settle a `reqId` frame against its `*-result`, timing out at `requestTimeoutMs`. */
+  waitForResult(reqId, send) {
+    return new Promise((resolve2, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingMessages.delete(reqId);
+        reject(new Error(`interconnect: no result for ${reqId} within ${this.requestTimeoutMs}ms`));
+      }, this.requestTimeoutMs);
+      this.pendingMessages.set(reqId, { timer });
+      const pending = this.pendingMessages.get(reqId);
+      if (pending === void 0) return;
+      pending.resolve = (result) => {
+        clearTimeout(timer);
+        this.pendingMessages.delete(reqId);
+        resolve2(result);
+      };
+      pending.reject = (error) => {
+        clearTimeout(timer);
+        this.pendingMessages.delete(reqId);
+        reject(error instanceof Error ? error : new Error(String(error)));
+      };
+      send((error) => {
+        clearTimeout(timer);
+        this.pendingMessages.delete(reqId);
+        reject(error instanceof Error ? error : new Error(String(error)));
+      });
+    });
   }
   /**
-   * Add a peer origin to the event fan-out set at runtime. Returns a disposer
-   * that removes it. Duplicate origins are idempotent.
-   * @param peer - receiver origin, e.g. `http://127.0.0.1:3080`.
-   * @returns disposer removing the peer from the fan-out set.
+   * Add a peer route at runtime. Returns a disposer that removes it. Re-adding
+   * an existing instanceId re-routes it to the new origin.
+   * @param instanceId - the peer's `instanceId`.
+   * @param origin - origin this instance dials to reach that peer.
+   * @returns disposer removing the peer route.
    */
-  subscribe(peer) {
-    const trimmed = trimBase(peer);
-    this.peers.add(trimmed);
+  subscribe(instanceId, origin) {
+    this.link(instanceId, origin);
     return () => {
-      this.peers.delete(trimmed);
+      this.forgetLink(instanceId);
     };
   }
-  /** Remove a peer origin from the event fan-out set. */
-  unsubscribe(peer) {
-    this.peers.delete(trimBase(peer));
+  /** Remove a peer route, closing its outbound link. */
+  unsubscribe(instanceId) {
+    const state = this.linkStates.get(instanceId);
+    if (state !== void 0) state.close();
+    this.linkStates.delete(instanceId);
   }
   /**
    * Open (and, on drop, re-open) a persistent WebSocket link to a peer. Local
    * events stream over the link in real time, and events the peer pushes are
-   * surfaced as `interconnect/event`. Repeating for the same peer returns the
-   * existing handle.
-   * @param peer - receiver origin, e.g. `http://127.0.0.1:3080` (dialed as `ws:`).
+   * surfaced as `interconnect/event`. Repeating for the same instanceId
+   * re-routes the link to the new origin.
+   * @param instanceId - the peer's `instanceId`.
+   * @param origin - receiver origin this instance dials, e.g. `http://127.0.0.1:13080`.
    * @returns a handle closing the link and cancelling reconnection.
    */
-  link(peer) {
-    const trimmed = trimBase(peer);
-    const existing = this.linkStates.get(trimmed);
-    if (existing !== void 0) return existing;
-    const state = new LinkState(this, trimmed);
-    this.linkStates.set(trimmed, state);
+  link(instanceId, origin) {
+    const existing = this.linkStates.get(instanceId);
+    if (existing !== void 0) {
+      existing.reroute(trimBase(origin));
+      return existing;
+    }
+    const state = new LinkState(this, instanceId, trimBase(origin));
+    this.linkStates.set(instanceId, state);
     state.dial();
     return state;
   }
   /** Remove a closed outbound link's state so a later `link` re-dials fresh. */
-  forgetLink(peer) {
-    this.linkStates.delete(peer);
+  forgetLink(instanceId) {
+    this.linkStates.delete(instanceId);
   }
-  /** Fan one serialized lifecycle fact out to every registered peer, fire-and-forget. */
+  /** Push one serialized lifecycle fact out to every linked peer over WS. */
   fanout(notification) {
-    const payload = { sender: this.instanceId, notification };
-    for (const peer of this.peers) {
-      void this.post(peer, "event", payload).catch((error) => {
-        this.ctx.logger.warn(`interconnect: event fan-out to ${peer} failed: ${error instanceof Error ? error.message : String(error)}`);
-      });
-    }
     this.broadcast(notification);
   }
   /** Push one fact over every live WebSocket link, dropping closed sockets. */
@@ -1031,123 +1148,47 @@ var InterconnectService = class extends Service {
       socket.send(encoded);
     }
   }
-  /** Inbound route handler: bearer auth first, then envelope dispatch. */
-  async handle(req, res) {
-    const token = await this.resolveToken();
-    if (token === void 0) {
-      res.writeHead(403);
-      res.end("forbidden");
-      return;
-    }
-    const expected = `Bearer ${token}`;
-    const header = req.headers.authorization;
-    if (header === void 0 || !timingSafeEqual(header, expected)) {
-      res.writeHead(401);
-      res.end("unauthorized");
-      return;
-    }
-    await this.dispatch(req, res);
-  }
-  /** Parse the ClientRequest envelope and route to the named endpoint. */
-  async dispatch(req, res) {
-    const pathname = new URL(req.url ?? "/", "http://dsh.internal").pathname;
-    const endpoint = endpointFromPath(INTERCONNECT_CHANNEL, pathname);
-    if (req.method !== "POST" || endpoint === void 0) {
-      res.writeHead(404);
-      res.end("not found");
-      return;
-    }
-    const mediaType = (req.headers["content-type"] ?? "").split(";", 1)[0]?.trim().toLowerCase();
-    if (mediaType !== "application/json") {
-      res.writeHead(415);
-      res.end("content type must be application/json");
-      return;
-    }
-    const body = await readBody(req);
-    if (body === void 0) {
-      res.writeHead(413);
-      res.end("body too large");
-      return;
-    }
-    let envelope;
-    try {
-      envelope = JSON.parse(body);
-    } catch {
-      res.writeHead(400);
-      res.end("body is not JSON");
-      return;
-    }
-    const parsed = clientRequestSchema.safeParse(envelope);
-    const rpcId = typeof envelope.rpcId === "string" ? RpcId(envelope.rpcId) : INVALID_REQUEST_RPC_ID;
-    if (!parsed.success) {
-      writeError(res, rpcId, {
-        code: "bad-request",
-        message: "invalid client-request message",
-        details: { issues: parsed.error.issues }
-      });
-      return;
-    }
-    if (parsed.data.method !== endpoint) {
-      writeError(res, rpcId, {
-        code: "bad-request",
-        message: `method ${JSON.stringify(parsed.data.method)} does not match endpoint ${JSON.stringify(endpoint)}`,
-        details: { issues: [] }
+  /**
+   * Dispatch one inbound `msg` frame: deliver a `send`/`reply` and answer the
+   * correlated `msg-result` on the same socket. Errors are surfaced as the
+   * result so a throwing handler cannot escape the socket's message callback.
+   */
+  async handleMsgFrame(socket, reqId, message) {
+    let result;
+    if (message.kind === "reply") {
+      result = await this.replyForSession({
+        sessionId: message.sessionId,
+        text: message.text,
+        ...message.delivery === void 0 ? {} : { delivery: message.delivery },
+        ...message.resume === void 0 ? {} : { resume: message.resume }
       });
-      return;
-    }
-    try {
-      const value = await this.runEndpoint(endpoint, parsed.data.payload);
-      writeFull(res, rpcId, { ok: true, value });
-    } catch (error) {
-      if (error instanceof UnknownEndpointError) {
-        res.writeHead(404);
-        res.end("not found");
-        return;
-      }
-      if (error instanceof InvalidPayloadError) {
-        writeError(res, rpcId, {
-          code: "bad-request",
-          message: error.message,
-          details: { issues: [] }
-        });
-        return;
-      }
-      this.ctx.logger.warn(error instanceof Error ? error : new Error(String(error)));
-      writeError(res, rpcId, {
-        code: "internal",
-        message: error instanceof Error ? error.message : String(error),
-        details: {}
+    } else {
+      result = await this.deliver({
+        sessionId: message.sessionId,
+        text: message.text,
+        ...message.sender === void 0 ? {} : { sender: message.sender },
+        ...message.delivery === void 0 ? {} : { delivery: message.delivery },
+        ...message.resume === void 0 ? {} : { resume: message.resume }
       });
     }
-  }
-  /** Dispatch one authenticated business call. */
-  async runEndpoint(endpoint, payload) {
-    if (endpoint === "ping") {
-      return { pong: true, instance: this.instanceId };
-    }
-    if (endpoint === "send") {
-      let parsed;
-      try {
-        parsed = Schema.resolve(payload, sendPayloadSchema, {})[0];
-      } catch (error) {
-        throw new InvalidPayloadError(`send payload invalid: ${error instanceof Error ? error.message : String(error)}`);
-      }
-      return this.deliver(parsed);
-    }
-    if (endpoint === "list") {
-      return this.listSessions();
-    }
-    if (endpoint === "event") {
-      let eventPayload;
-      try {
-        eventPayload = Schema.resolve(payload, eventPayloadSchema, {})[0];
-      } catch (error) {
-        throw new InvalidPayloadError(`event payload invalid: ${error instanceof Error ? error.message : String(error)}`);
-      }
-      this.receiveEvent(eventPayload);
-      return { accepted: true };
+    this.sendFrame(socket, { type: "msg-result", reqId, result });
+  }
+  /** Dispatch one inbound `query` frame (ping/list/event) and answer on the socket. */
+  async handleQueryFrame(socket, reqId, query) {
+    let result;
+    if (query.kind === "ping") {
+      result = { pong: true, instance: this.instanceId };
+    } else if (query.kind === "list") {
+      result = this.listSessions();
+    } else {
+      const payload = {
+        sender: this.peerOf.get(socket) ?? "unknown-peer",
+        notification: query.notification
+      };
+      this.receiveEvent(payload);
+      result = { accepted: true };
     }
-    throw new UnknownEndpointError(endpoint);
+    this.sendFrame(socket, { type: "query-result", reqId, result });
   }
   /** Surface one remote notification to local listeners and the log. */
   receiveEvent(eventPayload) {
@@ -1226,12 +1267,21 @@ var InterconnectService = class extends Service {
     if (hasApiRemoteSubagentOwner(this.ctx, agent.session, agent)) {
       return { delivered: false, instance: this.instanceId, reason: "session-owned-by-subagent" };
     }
+    const sender = (() => {
+      const candidate = payload.sender;
+      return candidate === void 0 || typeof candidate.instanceId !== "string" ? void 0 : candidate;
+    })();
+    if (sender !== void 0) {
+      this.senders.set(payload.sessionId, sender);
+    }
     const message = createUserMessage({
       source: {
         kind: "plugin",
         plugin: PLUGIN_SOURCE,
         form: "notice",
-        summary: boundContextSummary(`interconnect handoff delivered on instance ${this.instanceId}`)
+        summary: boundContextSummary(
+          sender === void 0 ? `interconnect handoff delivered on instance ${this.instanceId}` : `interconnect handoff from ${sender.instanceId} (session ${sender.sessionId}) delivered on instance ${this.instanceId}`
+        )
       },
       content: [{ type: "text", text: payload.text }]
     });
@@ -1249,35 +1299,18 @@ var InterconnectService = class extends Service {
     }
     return { delivered: true, instance: this.instanceId, delivery: mode };
   }
-  /** POST one business call to a peer instance; undefined on transport/auth failure. */
-  async post(baseUrl, endpoint, payload) {
-    const token = await this.resolveToken();
-    if (token === void 0) return void 0;
-    const url = `${trimBase(baseUrl)}${INTERCONNECT_CHANNEL}/${endpoint}`;
-    const envelope = {
-      type: "client-request",
-      rpcId: crypto.randomUUID(),
-      method: endpoint,
-      payload
-    };
-    try {
-      const response = await fetch(url, {
-        method: "POST",
-        headers: {
-          "content-type": "application/json",
-          authorization: `Bearer ${token}`
-        },
-        body: JSON.stringify(envelope),
-        signal: AbortSignal.timeout(this.requestTimeoutMs)
-      });
-      if (!response.ok) return void 0;
-      const body = await response.json();
-      if (body.result?.ok !== true) return void 0;
-      return body.result.value;
-    } catch (error) {
-      this.ctx.logger.warn(`interconnect: ${endpoint} to ${baseUrl} failed: ${error instanceof Error ? error.message : String(error)}`);
-      return void 0;
-    }
+  /**
+   * Inbound `reply` dispatch: forward a request to {link reply}, resolving the
+   * outbound sender for the named local session. Kept separate from {link
+   * deliver} so the two wire endpoints stay distinct in the request pipeline.
+   */
+  async replyForSession(payload) {
+    return this.reply({
+      sessionId: payload.sessionId,
+      text: payload.text,
+      ...payload.delivery === void 0 ? {} : { delivery: payload.delivery },
+      ...payload.resume === void 0 ? {} : { resume: payload.resume }
+    });
   }
   async resolveToken() {
     const credential = await this.ctx.credentials.resolve(credentialRef(INTERCONNECT_TOKEN_REF));
@@ -1350,36 +1383,82 @@ var InterconnectService = class extends Service {
       this.peerOf.set(socket, frame.sender);
       return;
     }
-    const sender = this.peerOf.get(socket) ?? "unknown-peer";
-    try {
-      this.receiveEvent({ sender, notification: frame.notification });
-    } catch (error) {
-      this.ctx.logger.warn(`interconnect: listener for a ${frame.notification.kind} event from ${sender} threw: ${error instanceof Error ? error.message : String(error)}`);
+    if (frame.type === "event") {
+      const sender = this.peerOf.get(socket) ?? "unknown-peer";
+      try {
+        this.receiveEvent({ sender, notification: frame.notification });
+      } catch (error) {
+        this.ctx.logger.warn(`interconnect: listener for a ${frame.notification.kind} event from ${sender} threw: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      return;
     }
+    if (frame.type === "msg-result") {
+      const pending = this.pendingMessages.get(frame.reqId);
+      if (pending !== void 0) {
+        ;
+        pending.resolve?.(frame.result);
+      }
+      return;
+    }
+    if (frame.type === "query-result") {
+      const pending = this.pendingMessages.get(frame.reqId);
+      if (pending !== void 0) {
+        ;
+        pending.resolve?.(frame.result);
+      }
+      return;
+    }
+    if (frame.type === "msg") {
+      void Promise.resolve().then(async () => {
+        await this.handleMsgFrame(socket, frame.reqId, frame.message);
+      }).catch((error) => {
+        this.ctx.logger.warn(`interconnect: msg ${frame.reqId} handler threw: ${error instanceof Error ? error.message : String(error)}`);
+        void this.sendFrame(socket, {
+          type: "msg-result",
+          reqId: frame.reqId,
+          result: { delivered: false, instance: this.instanceId, reason: "unreachable" }
+        });
+      });
+      return;
+    }
+    void Promise.resolve().then(async () => {
+      await this.handleQueryFrame(socket, frame.reqId, frame.query);
+    }).catch((error) => {
+      this.ctx.logger.warn(`interconnect: query ${frame.reqId} handler threw: ${error instanceof Error ? error.message : String(error)}`);
+    });
   }
-};
-var UnknownEndpointError = class extends Error {
-  constructor(endpoint) {
-    super(`unknown interconnect endpoint ${JSON.stringify(endpoint)}`);
-    this.name = "UnknownEndpointError";
-  }
-};
-var InvalidPayloadError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "InvalidPayloadError";
+  /** Write one frame to a socket, returning false when the socket cannot take it. */
+  sendFrame(socket, frame) {
+    if (socket.readyState !== WebSocket.OPEN) return false;
+    socket.send(JSON.stringify(frame));
+    return true;
   }
 };
 var LinkState = class {
-  constructor(owner, peer) {
+  constructor(owner, instanceId, origin) {
     this.owner = owner;
-    this.peer = peer;
+    this.instanceId = instanceId;
+    this.peer = origin;
   }
   socket;
   closed = false;
   retry = 0;
   reconnectTimer;
+  // `peer` is mutable so `reroute` can point the link at a new origin.
   peer;
+  instanceId;
+  /** Point this link at a different origin; re-dials immediately. */
+  reroute(origin) {
+    if (origin === this.peer) return;
+    this.peer = origin;
+    const socket = this.socket;
+    if (socket !== void 0) {
+      socket.removeAllListeners();
+      socket.terminate();
+      this.socket = void 0;
+    }
+    this.dial();
+  }
   /** Open the socket; reconnect is scheduled by the close handler. */
   dial() {
     if (this.closed) return;
@@ -1406,6 +1485,17 @@ var LinkState = class {
       this.scheduleReconnect();
     });
   }
+  /** Whether this link currently holds an open socket that can carry frames. */
+  writable() {
+    return this.socket !== void 0 && this.socket.readyState === WebSocket.OPEN;
+  }
+  /** Write one frame over this link's outbound socket; false when not open. */
+  sendFrame(frame) {
+    const socket = this.socket;
+    if (socket === void 0 || socket.readyState !== WebSocket.OPEN) return false;
+    socket.send(JSON.stringify(frame));
+    return true;
+  }
   close() {
     this.closed = true;
     this.owner.forgetLink(this.peer);
@@ -1425,21 +1515,6 @@ var LinkState = class {
     }, delay);
   }
 };
-function endpointFromPath(channel, pathname) {
-  if (!pathname.startsWith(`${channel}/`)) return void 0;
-  return pathname.slice(channel.length + 1);
-}
-async function readBody(req) {
-  let size = 0;
-  const chunks = [];
-  for await (const chunk of req) {
-    const buffer = chunk;
-    size += buffer.byteLength;
-    if (size > MAX_REQUEST_BODY_BYTES) return void 0;
-    chunks.push(buffer);
-  }
-  return Buffer.concat(chunks).toString();
-}
 function timingSafeEqual(a, b) {
   if (a.length !== b.length) return false;
   let diff = 0;
@@ -1451,21 +1526,8 @@ function timingSafeEqual(a, b) {
 function trimBase(baseUrl) {
   return baseUrl.replace(/\/+$/, "");
 }
-function writeFull(res, rpcId, result) {
-  const body = serverResponseSchema.parse({
-    type: "server-response",
-    rpcId,
-    result
-  });
-  res.writeHead(200, { "content-type": "application/json" });
-  res.end(JSON.stringify(body));
-}
-function writeError(res, rpcId, error) {
-  writeFull(res, rpcId, { ok: false, error });
-}
 var interconnect_default = InterconnectService;
 export {
-  INTERCONNECT_CHANNEL,
   INTERCONNECT_TOKEN_REF,
   InterconnectService,
   interconnect_default as default