@super-line/server 0.2.0 → 0.4.0

package/dist/index.js

@@ -1,33 +1,38 @@
+import "./chunk-MLKGABMK.js";
+
 // src/index.ts
 import { randomUUID } from "crypto";
-import { WebSocketServer } from "ws";
 import {
   jsonSerializer,
   validate,
-  SocketError
+  SuperLineError,
+  INSPECTOR_ROLE,
+  classifyContract
 } from "@super-line/core";
 
 // src/conn.ts
 var Conn = class {
-  constructor(ws, id, role, ctx, serializer, backpressure) {
-    this.ws = ws;
+  constructor(raw, id, role, ctx, serializer, onEmit) {
+    this.raw = raw;
     this.id = id;
     this.role = role;
     this.ctx = ctx;
     this.serializer = serializer;
-    this.backpressure = backpressure;
+    this.onEmit = onEmit;
   }
-  ws;
+  raw;
   id;
   role;
   ctx;
   serializer;
-  backpressure;
+  onEmit;
   /** Namespaced channels (rooms + topics) this connection belongs to. */
   channels = /* @__PURE__ */ new Set();
   /** Mutable per-connection scratch state, typed per role by the contract's `data` schema. */
   data = {};
-  /** When this connection was accepted (`Date.now()` at the upgrade). */
+  /** The client↔server transport (wire) this connection was accepted on (set by the server at accept). */
+  transport;
+  /** When this connection was accepted (`Date.now()`). */
   connectedAt = Date.now();
   /** When the server last sent a heartbeat ping to this connection (managed by the server). */
   lastPingAt;
@@ -35,34 +40,28 @@ var Conn = class {
   lastPongAt;
   /** Pings sent since the last pong; drives reaping (managed by the server). */
   missedPongs = 0;
-  // true => the frame was handled by the backpressure policy and must not be sent
-  overBackpressure() {
-    const bp = this.backpressure;
-    if (!bp || this.ws.bufferedAmount <= bp.maxBufferedBytes) return false;
-    if (bp.onExceed === "drop") {
-      console.warn(`[super-line] dropping frame: conn ${this.id} over backpressure limit`);
-      return true;
-    }
-    this.ws.close(1013);
-    return true;
-  }
   /** Encode and send a frame (unicast, e.g. req/res). */
   send(frame) {
-    if (this.ws.readyState !== this.ws.OPEN || this.overBackpressure()) return;
-    this.ws.send(this.serializer.encode(frame));
+    if (!this.raw.writable) return;
+    this.raw.send(this.serializer.encode(frame));
   }
   /** Forward an already-encoded frame (fan-out path; encoded once at the source). */
   sendRaw(payload) {
-    if (this.ws.readyState !== this.ws.OPEN || this.overBackpressure()) return;
-    this.ws.send(payload);
+    if (!this.raw.writable) return;
+    this.raw.send(payload);
   }
   /** Push an event to THIS connection (node-local). Scoped to the role's events. */
   emit(event, data) {
+    this.onEmit?.(String(event), data);
     this.send({ t: "evt", e: String(event), d: data });
   }
-  /** Close the underlying socket. */
+  /** Graceful close of the underlying transport connection. */
   close() {
-    this.ws.close();
+    this.raw.close();
+  }
+  /** Hard close with no handshake — used by heartbeat reaping. */
+  terminate() {
+    this.raw.terminate();
   }
 };
 
@@ -139,6 +138,7 @@ var MemoryPresence = class {
     }
     return [...byNode.entries()].map(([nodeId, ds]) => ({
       nodeId,
+      nodeName: ds[0]?.nodeName ?? nodeId,
       connections: ds.length,
       rooms: new Set(ds.flatMap((d) => d.rooms)).size,
       alive: true
@@ -179,16 +179,21 @@ var TOPIC = "t:";
 var CONN = "c:";
 var USER = "u:";
 var REPLY = "reply:";
-var S2S = "s2s";
-function createSocketServer(contract, opts) {
+var INSPECT = "i:";
+function createSuperLineServer(contract, opts) {
   const c = contract;
   const serializer = opts.serializer ?? jsonSerializer;
   const adapter = opts.adapter ?? createInMemoryAdapter();
-  const wss = new WebSocketServer({ noServer: true });
+  const inspectorEnabled = !!opts.inspector;
+  const inspectorRedact = new Set(
+    opts.inspector && typeof opts.inspector === "object" ? opts.inspector.redact ?? [] : []
+  );
   const conns = /* @__PURE__ */ new Set();
+  const inspectorConns = /* @__PURE__ */ new Set();
   const members = /* @__PURE__ */ new Map();
-  const serverListeners = /* @__PURE__ */ new Map();
+  const busListeners = /* @__PURE__ */ new Map();
   const instanceId = randomUUID();
+  const nodeName = opts.nodeName ?? process.env.SUPER_LINE_NODE_NAME ?? instanceId.slice(0, 8);
   const replyChannel = REPLY + instanceId;
   let impl = {};
   let closing = false;
@@ -203,9 +208,11 @@ function createSocketServer(contract, opts) {
       id: conn.id,
       role: conn.role,
       nodeId: instanceId,
+      nodeName,
       connectedAt: conn.connectedAt,
       ...userId !== void 0 ? { userId } : {},
       rooms,
+      ...conn.transport !== void 0 ? { transport: conn.transport } : {},
       ...opts.describeConn?.(conn)
     };
   }
@@ -214,10 +221,6 @@ function createSocketServer(contract, opts) {
     return adapter.presence;
   }
   adapter.onMessage((channel, payload) => {
-    if (channel === S2S) {
-      handleServerMessage(payload);
-      return;
-    }
     if (channel === replyChannel) {
       handleReply(payload);
       return;
@@ -227,8 +230,9 @@ function createSocketServer(contract, opts) {
       return;
     }
     const set = members.get(channel);
-    if (!set) return;
-    for (const conn of set) conn.sendRaw(payload);
+    if (set) for (const conn of set) conn.sendRaw(payload);
+    const busSet = busListeners.get(channel);
+    if (busSet) deliverBus(payload, busSet);
   });
   void adapter.subscribe(replyChannel);
   function handlePersonal(channel, payload) {
@@ -265,7 +269,7 @@ function createSocketServer(contract, opts) {
     originWaiters.delete(env.i);
     if (w.timer) clearTimeout(w.timer);
     if (env.ok) w.resolve(env.d);
-    else w.reject(new SocketError(env.code, env.m, env.d));
+    else w.reject(new SuperLineError(env.code, env.m, env.d));
   }
   async function handleClientReply(conn, localId, result) {
     const r = ownerRouting.get(localId);
@@ -278,15 +282,24 @@ function createSocketServer(contract, opts) {
         const out = def && "output" in def ? await validate(def.output, result.d) : result.d;
         env = { i: r.corrId, ok: true, d: out };
       } catch (err) {
-        const e = err instanceof SocketError ? err : new SocketError("INTERNAL", "Internal server error");
+        const e = err instanceof SuperLineError ? err : new SuperLineError("INTERNAL", "Internal server error");
         env = { i: r.corrId, ok: false, code: e.code, m: e.message, d: e.data };
       }
     } else {
       env = { i: r.corrId, ok: false, code: result.code, m: result.m, d: result.d };
     }
+    if (inspectorEnabled)
+      emitInspectorEvent(
+        env.ok ? { type: "msg.serverReply", target: conn.id, name: r.name, ok: true, output: safeSnapshot(env.d) } : {
+          type: "msg.serverReply",
+          target: conn.id,
+          name: r.name,
+          ok: false,
+          error: { code: env.code, message: env.m }
+        }
+      );
     void adapter.publish(REPLY + r.origin, serializer.encode(env));
   }
-  if (c.serverToServer) void adapter.subscribe(S2S);
   const hb = opts.heartbeat === false ? null : opts.heartbeat ?? {};
   let hbTimer;
   if (hb) {
@@ -295,47 +308,53 @@ function createSocketServer(contract, opts) {
       void adapter.presence?.beat(instanceId);
       for (const conn of conns) {
         if (hb.maxMissed != null && conn.missedPongs >= hb.maxMissed) {
-          conn.ws.terminate();
+          conn.terminate();
           continue;
         }
         conn.missedPongs++;
         conn.lastPingAt = now;
-        conn.ws.ping();
+        conn.send({ t: "ping" });
       }
     }, hb.interval ?? 3e4);
     hbTimer.unref?.();
   }
-  function handleServerMessage(payload) {
-    let msg;
-    try {
-      msg = serializer.decode(payload);
-    } catch {
-      return;
-    }
-    if (msg.from === instanceId) return;
-    const set = serverListeners.get(msg.e);
-    if (set) for (const cb of set) cb(msg.d);
+  function emitInspectorEvent(event) {
+    if (!inspectorEnabled) return;
+    void adapter.publish(INSPECT + "events", serializer.encode({ t: "pub", c: "events", d: event }));
   }
   function joinChannel(conn, channel) {
     conn.channels.add(channel);
-    if (channel.startsWith(ROOM)) void adapter.presence?.addRoom(conn.id, channel.slice(ROOM.length));
+    if (channel.startsWith(ROOM)) {
+      const room2 = channel.slice(ROOM.length);
+      void adapter.presence?.addRoom(conn.id, room2);
+      emitInspectorEvent({ type: "room.add", connId: conn.id, room: room2 });
+    } else if (channel.startsWith(TOPIC)) {
+      emitInspectorEvent({ type: "topic.sub", connId: conn.id, topic: channel.slice(channel.indexOf(":", TOPIC.length) + 1) });
+    }
     const set = members.get(channel);
     if (set) {
       set.add(conn);
       return;
     }
+    const alreadySubscribed = busListeners.has(channel);
     members.set(channel, /* @__PURE__ */ new Set([conn]));
-    return adapter.subscribe(channel);
+    if (!alreadySubscribed) return adapter.subscribe(channel);
   }
   function leaveChannel(conn, channel) {
     const set = members.get(channel);
     if (!set) return;
     set.delete(conn);
     conn.channels.delete(channel);
-    if (channel.startsWith(ROOM)) void adapter.presence?.removeRoom(conn.id, channel.slice(ROOM.length));
+    if (channel.startsWith(ROOM)) {
+      const room2 = channel.slice(ROOM.length);
+      void adapter.presence?.removeRoom(conn.id, room2);
+      emitInspectorEvent({ type: "room.remove", connId: conn.id, room: room2 });
+    } else if (channel.startsWith(TOPIC)) {
+      emitInspectorEvent({ type: "topic.unsub", connId: conn.id, topic: channel.slice(channel.indexOf(":", TOPIC.length) + 1) });
+    }
     if (set.size === 0) {
       members.delete(channel);
-      void adapter.unsubscribe(channel);
+      if (!busListeners.has(channel)) void adapter.unsubscribe(channel);
     }
   }
   function isTopic(name, block) {
@@ -347,54 +366,187 @@ function createSocketServer(contract, opts) {
     if (isTopic(name, c.shared)) return "shared";
     return void 0;
   }
-  if (opts.server) {
-    opts.server.on("upgrade", (req, socket, head) => {
-      void handleUpgrade(req, socket, head);
-    });
+  function localRooms() {
+    const out = [];
+    for (const channel of members.keys()) if (channel.startsWith(ROOM)) out.push(channel.slice(ROOM.length));
+    return out;
+  }
+  function localTopics() {
+    const out = [];
+    for (const channel of members.keys()) {
+      if (!channel.startsWith(TOPIC)) continue;
+      out.push(channel.slice(channel.indexOf(":", TOPIC.length) + 1));
+    }
+    return out;
+  }
+  async function onInspectorFrame(conn, frame) {
+    if (frame.t === "req") await handleInspectorReq(conn, frame);
+    else if (frame.t === "sub") await handleInspectorSub(conn, frame);
+    else if (frame.t === "unsub") leaveChannel(conn, INSPECT + "events");
+  }
+  async function handleInspectorSub(conn, frame) {
+    if (frame.c !== "events") {
+      conn.send({ t: "err", i: frame.i, code: "NOT_FOUND", m: `Unknown topic: ${frame.c}` });
+      return;
+    }
+    await joinChannel(conn, INSPECT + "events");
+    conn.send({ t: "res", i: frame.i, d: null });
   }
-  async function handleUpgrade(req, socket, head) {
-    if (opts.path) {
-      const { pathname } = new URL(req.url ?? "/", "http://localhost");
-      if (pathname !== opts.path) return;
+  async function handleInspectorReq(conn, frame) {
+    const handler = inspectorHandlers[frame.m];
+    if (!handler) {
+      conn.send({ t: "err", i: frame.i, code: "NOT_FOUND", m: `Unknown message: ${frame.m}` });
+      return;
     }
-    let auth;
     try {
-      auth = await opts.authenticate(req);
+      const output = await handler(frame.d, conn);
+      conn.send({ t: "res", i: frame.i, d: output });
+    } catch (err) {
+      const e = err instanceof SuperLineError ? err : new SuperLineError("INTERNAL", "Internal server error");
+      conn.send({ t: "err", i: frame.i, code: e.code, m: e.message, d: e.data });
+    }
+  }
+  async function buildInspectedContract() {
+    let toJsonSchema;
+    try {
+      const mod = await import("./dist-S566F7HE.js");
+      toJsonSchema = mod.toJsonSchema;
     } catch {
-      socket.write("HTTP/1.1 401 Unauthorized\r\nConnection: close\r\n\r\n");
-      socket.destroy();
+      return classifyContract(c);
+    }
+    const schemas = /* @__PURE__ */ new Set();
+    classifyContract(c, (s) => {
+      schemas.add(s);
+      return void 0;
+    });
+    const converted = /* @__PURE__ */ new Map();
+    await Promise.all(
+      [...schemas].map(
+        (s) => toJsonSchema(s).then(
+          (j) => {
+            converted.set(s, j);
+          },
+          () => {
+          }
+          // unsupported vendor / missing per-vendor converter -> structure-only for this entry
+        )
+      )
+    );
+    return classifyContract(c, (s) => converted.get(s));
+  }
+  function safeSnapshot(value, depth = 0, seen = /* @__PURE__ */ new WeakSet()) {
+    if (value === null) return null;
+    const t = typeof value;
+    if (t === "bigint") return `${value.toString()}n`;
+    if (t === "function") return "[Function]";
+    if (t === "symbol") return value.toString();
+    if (t !== "object") return value;
+    const obj = value;
+    if (obj instanceof Date) return obj.toISOString();
+    if (seen.has(obj)) return "[Circular]";
+    if (depth >= 6) return "[MaxDepth]";
+    seen.add(obj);
+    try {
+      if (Array.isArray(obj)) return obj.slice(0, 1e3).map((v) => safeSnapshot(v, depth + 1, seen));
+      const ctor = Object.getPrototypeOf(obj)?.constructor?.name;
+      const out = {};
+      if (ctor && ctor !== "Object") out["#type"] = ctor;
+      for (const [k, v] of Object.entries(obj)) {
+        out[k] = inspectorRedact.has(k) ? "[Redacted]" : safeSnapshot(v, depth + 1, seen);
+      }
+      return out;
+    } finally {
+      seen.delete(obj);
+    }
+  }
+  const inspectorHandlers = {
+    getContract: () => buildInspectedContract(),
+    getTopology: async () => presenceOrThrow().topology(),
+    listConnections: async () => presenceOrThrow().list(),
+    getNode: async () => ({ nodeId: instanceId, nodeName, rooms: localRooms(), topics: localTopics() }),
+    getConn: async (input) => {
+      const id = input?.id;
+      if (!id) throw new SuperLineError("BAD_REQUEST", "getConn requires an id");
+      const local = [...conns].find((cn) => cn.id === id);
+      if (local) {
+        return {
+          descriptor: buildDescriptor(local),
+          ctx: safeSnapshot(local.ctx),
+          data: safeSnapshot(local.data),
+          ctxAvailable: true
+        };
+      }
+      const remote = await presenceOrThrow().get(id);
+      if (!remote) throw new SuperLineError("NOT_FOUND", `Unknown connection: ${id}`);
+      return { descriptor: remote, ctxAvailable: false };
+    }
+  };
+  const authHook = async (handshake) => {
+    const auth = await opts.authenticate(handshake);
+    return { role: auth.role, ctx: auth.ctx, transport: handshake.transport };
+  };
+  function acceptConn(raw, auth) {
+    const role = auth.role;
+    const ctx = auth.ctx;
+    const inspector = role === INSPECTOR_ROLE;
+    if (inspector && !inspectorEnabled) {
+      raw.close();
       return;
     }
-    wss.handleUpgrade(req, socket, head, (ws) => {
-      const conn = new Conn(ws, randomUUID(), auth.role, auth.ctx, serializer, opts.backpressure);
-      conns.add(conn);
-      ws.on("pong", () => {
-        conn.lastPongAt = Date.now();
-        conn.missedPongs = 0;
-      });
-      ws.on("message", (data, isBinary) => {
-        void onMessage(conn, data, isBinary);
-      });
-      ws.on("close", (code) => {
-        conns.delete(conn);
+    const connId = randomUUID();
+    const conn = new Conn(
+      raw,
+      connId,
+      role,
+      ctx,
+      serializer,
+      inspectorEnabled ? (event, data) => emitInspectorEvent({ type: "msg.event", target: connId, name: event, data: safeSnapshot(data) }) : void 0
+    );
+    conn.transport = auth.transport;
+    raw.onMessage((bytes) => {
+      void onMessage(conn, bytes);
+    });
+    if (inspector) {
+      inspectorConns.add(conn);
+      raw.onClose(() => {
+        inspectorConns.delete(conn);
         for (const channel of conn.channels) leaveChannel(conn, channel);
-        void adapter.presence?.del(conn.id);
-        opts.onDisconnect?.(conn, auth.ctx, code);
       });
-      opts.onConnection?.(conn, auth.ctx);
-      void adapter.presence?.set(buildDescriptor(conn));
-      void joinChannel(conn, CONN + conn.id);
-      const uid = opts.identify?.(conn);
-      if (uid !== void 0) void joinChannel(conn, USER + uid);
+      return;
+    }
+    conns.add(conn);
+    raw.onClose((code) => {
+      conns.delete(conn);
+      for (const channel of conn.channels) leaveChannel(conn, channel);
+      void adapter.presence?.del(conn.id);
+      const goneUserId = opts.identify?.(conn);
+      emitInspectorEvent({
+        type: "disconnect",
+        connId: conn.id,
+        nodeId: instanceId,
+        ...goneUserId !== void 0 ? { userId: goneUserId } : {}
+      });
+      opts.onDisconnect?.(conn, ctx, code);
     });
-  }
-  async function onMessage(conn, data, isBinary) {
+    opts.onConnection?.(conn, ctx);
+    const descriptor = buildDescriptor(conn);
+    void adapter.presence?.set(descriptor);
+    emitInspectorEvent({ type: "connect", descriptor });
+    void joinChannel(conn, CONN + conn.id);
+    const uid = opts.identify?.(conn);
+    if (uid !== void 0) void joinChannel(conn, USER + uid);
+  }
+  async function onMessage(conn, bytes) {
     let frame;
     try {
-      frame = serializer.decode(toWire(data, isBinary));
+      frame = serializer.decode(bytes);
     } catch {
       return;
     }
+    if (inspectorConns.has(conn)) {
+      await onInspectorFrame(conn, frame);
+      return;
+    }
     if (frame.t === "req") await handleReq(conn, frame);
     else if (frame.t === "sub") await handleSub(conn, frame);
     else if (frame.t === "unsub") {
@@ -404,8 +556,14 @@ function createSocketServer(contract, opts) {
       await handleClientReply(conn, frame.i, { ok: true, d: frame.d });
     } else if (frame.t === "serr") {
       await handleClientReply(conn, frame.i, { ok: false, code: frame.code, m: frame.m, d: frame.d });
+    } else if (frame.t === "pong") {
+      conn.lastPongAt = Date.now();
+      conn.missedPongs = 0;
     }
   }
+  for (const transport of opts.transports) {
+    void transport.start({ authenticate: authHook, onConnection: acceptConn });
+  }
   function runMiddleware(info, terminal) {
     const chain = opts.use ?? [];
     let last = -1;
@@ -427,10 +585,16 @@ function createSocketServer(contract, opts) {
       });
     } catch (err) {
       opts.onError?.(err, info);
-      if (!responded) {
-        const e = err instanceof SocketError ? err : new SocketError("INTERNAL", "Internal server error");
-        conn.send({ t: "err", i: id, code: e.code, m: e.message, d: e.data });
-      }
+      const e = err instanceof SuperLineError ? err : new SuperLineError("INTERNAL", "Internal server error");
+      if (!responded) conn.send({ t: "err", i: id, code: e.code, m: e.message, d: e.data });
+      if (inspectorEnabled && info.kind === "request")
+        emitInspectorEvent({
+          type: "msg.response",
+          connId: conn.id,
+          name: info.name,
+          ok: false,
+          error: { code: e.code, message: e.message }
+        });
     }
   }
   async function handleReq(conn, frame) {
@@ -442,7 +606,23 @@ function createSocketServer(contract, opts) {
     }
     await dispatchOp(conn, frame.i, { kind: "request", name: frame.m, conn }, async () => {
       const input = await validate(def.input, frame.d);
+      if (inspectorEnabled)
+        emitInspectorEvent({
+          type: "msg.request",
+          connId: conn.id,
+          role: conn.role,
+          name: frame.m,
+          input: safeSnapshot(input)
+        });
       const output = await handler(input, conn.ctx, conn);
+      if (inspectorEnabled)
+        emitInspectorEvent({
+          type: "msg.response",
+          connId: conn.id,
+          name: frame.m,
+          ok: true,
+          output: safeSnapshot(output)
+        });
       conn.send({ t: "res", i: frame.i, d: output });
     });
   }
@@ -455,7 +635,7 @@ function createSocketServer(contract, opts) {
     await dispatchOp(conn, frame.i, { kind: "subscribe", name: frame.c, conn }, async () => {
       if (opts.authorizeSubscribe) {
         const ok = await opts.authorizeSubscribe(frame.c, conn.ctx, conn);
-        if (ok === false) throw new SocketError("FORBIDDEN", `Subscribe denied: ${frame.c}`);
+        if (ok === false) throw new SuperLineError("FORBIDDEN", `Subscribe denied: ${frame.c}`);
       }
       await joinChannel(conn, TOPIC + ns + ":" + frame.c);
       conn.send({ t: "res", i: frame.i, d: null });
@@ -471,6 +651,8 @@ function createSocketServer(contract, opts) {
         leaveChannel(conn, channel);
       },
       broadcast(event, data) {
+        if (inspectorEnabled)
+          emitInspectorEvent({ type: "msg.broadcast", room: name, name: String(event), data: safeSnapshot(data) });
         void adapter.publish(channel, serializer.encode({ t: "evt", e: String(event), d: data }));
       },
       get size() {
@@ -482,11 +664,54 @@ function createSocketServer(contract, opts) {
     };
   }
   function publishTo(ns, name, data) {
-    void adapter.publish(TOPIC + ns + ":" + name, serializer.encode({ t: "pub", c: name, d: data }));
+    const channel = TOPIC + ns + ":" + name;
+    if (inspectorEnabled) emitInspectorEvent({ type: "msg.publish", topic: name, data: safeSnapshot(data) });
+    const busSet = busListeners.get(channel);
+    if (busSet) for (const cb of busSet) callBus(cb, data, instanceId, name);
+    void adapter.publish(channel, serializer.encode({ t: "pub", c: name, d: data, i: instanceId }));
+  }
+  function callBus(cb, data, from, name) {
+    try {
+      cb(data, { from });
+    } catch (err) {
+      opts.onError?.(err, { kind: "event", name });
+    }
+  }
+  function deliverBus(payload, set) {
+    let frame;
+    try {
+      frame = serializer.decode(payload);
+    } catch {
+      return;
+    }
+    if (frame.i === instanceId) return;
+    const from = frame.i ?? "";
+    const name = frame.c;
+    const def = c.shared?.serverToClient?.[name];
+    const schema = def && typeof def === "object" && "payload" in def ? def.payload : void 0;
+    void (async () => {
+      let data = frame.d;
+      if (schema) {
+        try {
+          data = await validate(schema, frame.d);
+        } catch (err) {
+          opts.onError?.(err, { kind: "event", name });
+          return;
+        }
+      }
+      for (const cb of set) callBus(cb, data, from, name);
+    })();
   }
   function personalTarget(channel) {
     return {
       emit(event, data) {
+        if (inspectorEnabled)
+          emitInspectorEvent({
+            type: "msg.event",
+            target: channel.slice(channel.indexOf(":") + 1),
+            name: event,
+            data: safeSnapshot(data)
+          });
         const env = { p: "emit", f: { t: "evt", e: event, d: data } };
         void adapter.publish(channel, serializer.encode(env));
       },
@@ -501,7 +726,7 @@ function createSocketServer(contract, opts) {
       const ms = opts2?.timeout ?? 3e4;
       const timer = ms > 0 ? setTimeout(() => {
         originWaiters.delete(reqId);
-        reject(new SocketError("TIMEOUT", `Request '${name}' timed out`));
+        reject(new SuperLineError("TIMEOUT", `Request '${name}' timed out`));
       }, ms) : void 0;
       originWaiters.set(reqId, { resolve, reject, timer });
       opts2?.signal?.addEventListener(
@@ -509,32 +734,28 @@ function createSocketServer(contract, opts) {
         () => {
           if (originWaiters.delete(reqId)) {
             if (timer) clearTimeout(timer);
-            reject(new SocketError("BAD_REQUEST", "Aborted"));
+            reject(new SuperLineError("BAD_REQUEST", "Aborted"));
           }
         },
         { once: true }
       );
+      if (inspectorEnabled)
+        emitInspectorEvent({ type: "msg.serverRequest", target: id, name, input: safeSnapshot(input) });
       const env = { p: "req", o: instanceId, i: reqId, m: name, d: input };
       void adapter.publish(CONN + id, serializer.encode(env));
     });
   }
   const api = {
     nodeId: instanceId,
+    nodeName,
     get local() {
       return {
         connections: [...conns],
         get rooms() {
-          const out = [];
-          for (const channel of members.keys()) if (channel.startsWith(ROOM)) out.push(channel.slice(ROOM.length));
-          return out;
+          return localRooms();
         },
         get topics() {
-          const out = [];
-          for (const channel of members.keys()) {
-            if (!channel.startsWith(TOPIC)) continue;
-            out.push(channel.slice(channel.indexOf(":", TOPIC.length) + 1));
-          }
-          return out;
+          return localTopics();
         }
       };
     },
@@ -578,29 +799,31 @@ function createSocketServer(contract, opts) {
     publish(topic, data) {
       publishTo("shared", String(topic), data);
     },
-    forRole(role) {
-      return {
-        publish(topic, data) {
-          publishTo(role, String(topic), data);
-        }
-      };
-    },
-    emitServer(event, data) {
-      void adapter.publish(S2S, serializer.encode({ from: instanceId, e: String(event), d: data }));
-    },
-    onServer(event, handler) {
-      const name = String(event);
-      let set = serverListeners.get(name);
+    subscribe(topic, handler) {
+      const channel = TOPIC + "shared:" + String(topic);
+      let set = busListeners.get(channel);
       if (!set) {
         set = /* @__PURE__ */ new Set();
-        serverListeners.set(name, set);
+        busListeners.set(channel, set);
+        if (!members.has(channel)) void adapter.subscribe(channel);
       }
-      set.add(handler);
+      const cb = handler;
+      set.add(cb);
       return () => {
-        const current = serverListeners.get(name);
+        const current = busListeners.get(channel);
         if (!current) return;
-        current.delete(handler);
-        if (current.size === 0) serverListeners.delete(name);
+        current.delete(cb);
+        if (current.size === 0) {
+          busListeners.delete(channel);
+          if (!members.has(channel)) void adapter.unsubscribe(channel);
+        }
+      };
+    },
+    forRole(role) {
+      return {
+        publish(topic, data) {
+          publishTo(role, String(topic), data);
+        }
       };
     },
     async close() {
@@ -608,23 +831,17 @@ function createSocketServer(contract, opts) {
       closing = true;
       if (hbTimer) clearInterval(hbTimer);
       for (const conn of conns) conn.close();
+      for (const conn of inspectorConns) conn.close();
       await adapter.presence?.clearNode(instanceId);
       await adapter.close?.();
-      await new Promise((resolve) => {
-        wss.close(() => resolve());
-      });
+      for (const transport of opts.transports) await transport.stop();
     }
   };
   return api;
 }
-function toWire(data, _isBinary) {
-  if (Array.isArray(data)) return Buffer.concat(data);
-  if (data instanceof ArrayBuffer) return new Uint8Array(data);
-  return data;
-}
 export {
   Conn,
   MemoryBus,
   createInMemoryAdapter,
-  createSocketServer
+  createSuperLineServer
 };