@snakechat/commskit-node 0.0.0-stage → 0.1.0

package/dist/chunk-LY2GJWN7.js

@@ -0,0 +1,708 @@
+import {
+  NoopPush,
+  NullUserDirectory,
+  resolveUserId
+} from "./chunk-XQ6FLRX7.js";
+import {
+  HttpError,
+  detectDialect,
+  matchPath
+} from "./chunk-GR4PMGCS.js";
+import {
+  RateLimiter
+} from "./chunk-BBFVG7QU.js";
+import {
+  LRU,
+  TaskSet,
+  formatIso,
+  nowIso,
+  utcnow
+} from "./chunk-KLKRK6OG.js";
+import {
+  logger,
+  setLogger
+} from "./chunk-5BJ2SNM5.js";
+
+// src/core/compat.ts
+var PONG_TYPE = "PONG";
+
+// src/core/connections.ts
+import { randomBytes } from "crypto";
+var USER_ROLE = "user";
+var OPEN = 1;
+function sendText(ws, text) {
+  return new Promise((resolve, reject) => {
+    if (ws.readyState !== OPEN) return reject(new Error("socket not open"));
+    try {
+      ws.send(text, (err) => err ? reject(err) : resolve());
+    } catch (err) {
+      reject(err);
+    }
+  });
+}
+var ConnectionManager = class {
+  bridge;
+  serverId;
+  /** A user may hold several sockets (devices / screens); all get every frame. */
+  userSockets = /* @__PURE__ */ new Map();
+  activeConnections = /* @__PURE__ */ new Map();
+  roles = /* @__PURE__ */ new Map();
+  rooms = /* @__PURE__ */ new Map();
+  userRooms = /* @__PURE__ */ new Map();
+  /** user.came_online: 0 = only dedupe concurrent connects; > 0 = at most once per cooldown (seconds). */
+  cameOnlineCooldown;
+  cameOnlineDedupeSeconds;
+  cameOnlineAt = new LRU(1e5);
+  offlineHooks = [];
+  partnersLookup = null;
+  tasks = new TaskSet();
+  constructor(opts = {}) {
+    this.bridge = opts.bridge ?? null;
+    this.serverId = opts.serverId ?? `${process.env.HOSTNAME ?? "server"}-${process.pid}-${randomBytes(3).toString("hex")}`;
+    this.cameOnlineCooldown = opts.cameOnlineCooldown ?? 0;
+    this.cameOnlineDedupeSeconds = opts.cameOnlineDedupeSeconds ?? 10;
+  }
+  // ----------------------------------------------------------- lifecycle
+  /** Start the bridge consumer (call at app start). */
+  async start() {
+    if (this.bridge) {
+      this.bridge.setRoomDeliver?.((room, env) => this.deliverRoomFromBridge(room, env));
+      await this.bridge.start((uid, env) => this.deliverFromBridge(uid, env), this.serverId);
+    }
+  }
+  async stop() {
+    await this.tasks.settle();
+    if (this.bridge) await this.bridge.stop();
+  }
+  /** `hook(userId)` runs when the user's last socket on this worker closes (users only unless `allRoles`). */
+  addOfflineHook(hook, allRoles = false) {
+    this.offlineHooks.push([hook, allRoles]);
+  }
+  /** Who should receive this user's `user_status` (chat installs this). */
+  setPartnersLookup(lookup) {
+    this.partnersLookup = lookup;
+  }
+  roleOf(userId) {
+    return this.roles.get(userId) ?? USER_ROLE;
+  }
+  // ---------------------------------------------------------- connections
+  /**
+   * Register an already-accepted socket. Returns true when this connect is the user's
+   * offline -> online transition across all workers; always false for non-user roles.
+   */
+  async register(userId, ws, role = USER_ROLE) {
+    const firstSocket = !this.userSockets.get(userId)?.size;
+    let set = this.userSockets.get(userId);
+    if (!set) this.userSockets.set(userId, set = /* @__PURE__ */ new Set());
+    set.add(ws);
+    this.roles.set(userId, role);
+    this.activeConnections.set(userId, { userId, status: "online", lastSeen: utcnow() });
+    let cameOnline = false;
+    if (firstSocket && role === USER_ROLE) cameOnline = await this.claimCameOnline(userId);
+    if (this.bridge) {
+      await this.bridge.setOnline(userId, this.serverId);
+      await this.bridge.setAway(userId, false);
+    }
+    if (firstSocket) await this.broadcastUserStatus(userId, "online");
+    return cameOnline;
+  }
+  async claimCameOnline(userId) {
+    if (this.bridge) {
+      let others = [];
+      try {
+        others = (await this.bridge.getUserServers(userId)).filter((s) => s !== this.serverId);
+      } catch {
+        others = [];
+      }
+      if (others.length) return false;
+      if (this.bridge.claimCameOnline) {
+        const ttl = this.cameOnlineCooldown || this.cameOnlineDedupeSeconds;
+        try {
+          return Boolean(await this.bridge.claimCameOnline(userId, ttl));
+        } catch (err) {
+          logger.error(`claimCameOnline(${userId}) failed`, err);
+        }
+      }
+    }
+    if (this.cameOnlineCooldown > 0) {
+      const now = performance.now() / 1e3;
+      const last = this.cameOnlineAt.get(userId);
+      if (last !== void 0 && now - last < this.cameOnlineCooldown) return false;
+      this.cameOnlineAt.put(userId, now);
+    }
+    return true;
+  }
+  async heartbeat(userId) {
+    if (this.bridge && this.userSockets.get(userId)?.size) await this.bridge.setOnline(userId, this.serverId);
+  }
+  /** Remove one socket (or all). The user stays online while any socket remains. Idempotent. */
+  disconnect(userId, ws) {
+    const sockets = this.userSockets.get(userId);
+    if (sockets && ws) {
+      sockets.delete(ws);
+      if (sockets.size) return;
+    }
+    this.userSockets.delete(userId);
+    const role = this.roles.get(userId) ?? USER_ROLE;
+    this.roles.delete(userId);
+    for (const room of this.userRooms.get(userId) ?? []) {
+      const members = this.rooms.get(room);
+      if (members) {
+        members.delete(userId);
+        if (!members.size) this.rooms.delete(room);
+      }
+    }
+    this.userRooms.delete(userId);
+    if (!this.activeConnections.delete(userId)) return;
+    this.tasks.spawn(() => this.wentOffline(userId, role));
+    for (const [hook, allRoles] of this.offlineHooks) {
+      if (role === USER_ROLE || allRoles) this.tasks.spawn(async () => hook(userId));
+    }
+  }
+  async wentOffline(userId, role) {
+    if (this.userSockets.get(userId)?.size) return;
+    if (this.bridge) await this.bridge.setOffline(userId, this.serverId);
+    if (await this.isConnected(userId)) return;
+    if (role !== USER_ROLE) return;
+    if (this.bridge?.releaseCameOnline && !this.cameOnlineCooldown) {
+      try {
+        await this.bridge.releaseCameOnline(userId);
+      } catch (err) {
+        logger.error(`releaseCameOnline(${userId}) failed`, err);
+      }
+    }
+    await this.broadcastStatus(userId, "offline");
+  }
+  /** Client-reported foreground ("online") / background (anything else). */
+  async setStatus(userId, status) {
+    const now = utcnow();
+    const conn = this.activeConnections.get(userId);
+    if (conn) {
+      conn.status = status;
+      conn.lastSeen = now;
+    }
+    if (this.bridge) await this.bridge.setAway(userId, status !== "online");
+    await this.broadcastUserStatus(userId, status, now);
+  }
+  // ------------------------------------------------------------- presence
+  /** Local only: foreground socket on this worker. */
+  isUserOnline(userId) {
+    return this.activeConnections.get(userId)?.status === "online";
+  }
+  /** Cluster-wide: connected somewhere with the app in the foreground. */
+  async isOnline(userId) {
+    if (this.isUserOnline(userId)) return true;
+    return this.bridge ? this.bridge.isOnline(userId) : false;
+  }
+  /** Cluster-wide: any open socket (foreground or background). */
+  async isConnected(userId) {
+    if (this.userSockets.get(userId)?.size) return true;
+    return this.bridge ? (await this.bridge.getUserServers(userId)).length > 0 : false;
+  }
+  async getOnlineUsers(userIds) {
+    const local = new Set(userIds.filter((u) => this.isUserOnline(u)));
+    if (!this.bridge) return local;
+    const remote = await this.bridge.getOnlineUsers(userIds.filter((u) => !local.has(u)));
+    return /* @__PURE__ */ new Set([...local, ...remote]);
+  }
+  // ------------------------------------------------------------- delivery
+  async sendLocal(userId, text) {
+    let delivered = false;
+    const dead = [];
+    for (const ws of [...this.userSockets.get(userId) ?? []]) {
+      try {
+        await sendText(ws, text);
+        delivered = true;
+      } catch (err) {
+        logger.warn(`Send to ${userId} failed: ${err.message}`);
+        dead.push(ws);
+      }
+    }
+    for (const ws of dead) this.disconnect(userId, ws);
+    return delivered;
+  }
+  /** Deliver to every socket of the user on any worker. True if at least one got it. */
+  async send(userId, payload) {
+    let delivered = await this.sendLocal(userId, JSON.stringify(payload));
+    if (this.bridge) {
+      const remote = (await this.bridge.getUserServers(userId)).filter((s) => s !== this.serverId);
+      if (remote.length) {
+        await this.bridge.publish(userId, payload, this.serverId);
+        delivered = true;
+      }
+    }
+    return delivered;
+  }
+  async sendToSocket(ws, payload) {
+    await sendText(ws, JSON.stringify(payload));
+  }
+  /** Every socket on this worker (e.g. host community events). */
+  async broadcast(payload) {
+    const text = JSON.stringify(payload);
+    for (const userId of [...this.userSockets.keys()]) await this.sendLocal(userId, text);
+  }
+  async deliverFromBridge(userId, envelope) {
+    if (envelope && "origin" in envelope && "data" in envelope) {
+      if (envelope.origin === this.serverId) return;
+      envelope = envelope.data;
+    }
+    await this.sendLocal(userId, JSON.stringify(envelope));
+  }
+  // ---------------------------------------------------------------- rooms
+  /** Add the user's sockets on this worker to `room` (left automatically on disconnect). False when none. */
+  joinRoom(userId, room) {
+    if (!this.userSockets.get(userId)?.size) return false;
+    if (!this.rooms.has(room)) this.rooms.set(room, /* @__PURE__ */ new Set());
+    this.rooms.get(room).add(userId);
+    if (!this.userRooms.has(userId)) this.userRooms.set(userId, /* @__PURE__ */ new Set());
+    this.userRooms.get(userId).add(room);
+    return true;
+  }
+  leaveRoom(userId, room) {
+    const members = this.rooms.get(room);
+    if (members) {
+      members.delete(userId);
+      if (!members.size) this.rooms.delete(room);
+    }
+    const rooms = this.userRooms.get(userId);
+    if (rooms) {
+      rooms.delete(room);
+      if (!rooms.size) this.userRooms.delete(userId);
+    }
+  }
+  /** Members on this worker. */
+  roomMembers(room) {
+    return new Set(this.rooms.get(room) ?? []);
+  }
+  async sendRoomLocal(room, payload) {
+    const text = JSON.stringify(payload);
+    let reached = 0;
+    for (const userId of [...this.rooms.get(room) ?? []]) if (await this.sendLocal(userId, text)) reached += 1;
+    return reached;
+  }
+  /** Send `payload` unchanged to every member on every worker. Returns how many local members got it. */
+  async broadcastRoom(room, payload) {
+    const reached = await this.sendRoomLocal(room, payload);
+    if (this.bridge?.publishRoom) await this.bridge.publishRoom(room, payload, this.serverId);
+    return reached;
+  }
+  async deliverRoomFromBridge(room, envelope) {
+    if (envelope && "origin" in envelope && "data" in envelope) {
+      if (envelope.origin === this.serverId) return;
+      envelope = envelope.data;
+    }
+    await this.sendRoomLocal(room, envelope);
+  }
+  // ------------------------------------------------------------- presence
+  /** Presence goes only to the user's conversation partners (never for non-user roles). */
+  async broadcastUserStatus(userId, status, timestamp) {
+    if (this.roleOf(userId) !== USER_ROLE) return;
+    await this.broadcastStatus(userId, status, timestamp);
+  }
+  async broadcastStatus(userId, status, timestamp) {
+    if (!this.partnersLookup) return;
+    const payload = { type: "user_status", user_id: userId, status, timestamp: formatIso(timestamp ?? utcnow()) };
+    let partners;
+    try {
+      partners = [...await this.partnersLookup(userId)];
+    } catch (err) {
+      logger.error(`Partner lookup for ${userId} failed`, err);
+      return;
+    }
+    for (const partnerId of partners) await this.send(partnerId, payload);
+  }
+};
+
+// src/core/events.ts
+var EventBus = class {
+  listeners = /* @__PURE__ */ new Map();
+  on(name, listener) {
+    const list = this.listeners.get(name) ?? [];
+    list.push(listener);
+    this.listeners.set(name, list);
+    return listener;
+  }
+  off(name, listener) {
+    const list = this.listeners.get(name);
+    if (!list) return;
+    const i = list.indexOf(listener);
+    if (i >= 0) list.splice(i, 1);
+  }
+  /** Run listeners in registration order; a failing listener is logged, not thrown. */
+  async emit(name, ...args) {
+    for (const listener of [...this.listeners.get(name) ?? []]) {
+      try {
+        await listener(...args);
+      } catch (err) {
+        logger.error(`Listener for ${name} failed`, err);
+      }
+    }
+  }
+};
+
+// src/core/websocket.ts
+import { WebSocketServer } from "ws";
+var WsEndpoint = class {
+  constructor(hub) {
+    this.hub = hub;
+  }
+  hub;
+  wss = new WebSocketServer({ noServer: true });
+  /** Token from `/ws/<token>` (query string ignored), or null. */
+  match(url) {
+    if (!url) return null;
+    const pathOnly = url.split("?", 1)[0];
+    const m = /^\/ws\/([^/]+)$/.exec(pathOnly);
+    if (!m) return null;
+    try {
+      return decodeURIComponent(m[1]);
+    } catch {
+      return m[1];
+    }
+  }
+  handleUpgrade(req, socket, head) {
+    const token = this.match(req.url);
+    if (token === null) {
+      socket.destroy();
+      return;
+    }
+    this.wss.handleUpgrade(req, socket, head, (ws) => this.onSocket(ws, token));
+  }
+  closeAll() {
+    for (const ws of this.wss.clients) ws.terminate();
+  }
+  onSocket(ws, token) {
+    const hub = this.hub;
+    let userId = null;
+    let heartbeat = null;
+    let chain = (async () => {
+      try {
+        userId = await resolveUserId(hub.auth, token);
+      } catch (err) {
+        logger.info(`WS auth failed: ${err.message}`);
+        ws.close(1008, "Invalid token");
+        return;
+      }
+      try {
+        const role = await hub.roleOf(userId);
+        const cameOnline = await hub.connections.register(userId, ws, role);
+        await hub.runConnectHooks(userId, ws, role, cameOnline);
+        const bridge = hub.connections.bridge;
+        if (bridge) {
+          const uid = userId;
+          heartbeat = setInterval(() => void hub.connections.heartbeat(uid).catch(() => void 0), bridge.heartbeatSeconds * 1e3);
+          heartbeat.unref();
+        }
+      } catch (err) {
+        logger.error(`WS setup for ${userId} crashed`, err);
+        ws.close(1011, "Internal server error");
+      }
+    })();
+    ws.on("message", (data) => {
+      chain = chain.then(async () => {
+        if (userId !== null) await this.handleFrame(userId, ws, rawToString(data));
+      });
+    });
+    ws.on("error", (err) => logger.warn(`WS error: ${err.message}`));
+    ws.on("close", () => {
+      chain = chain.then(() => {
+        if (heartbeat) clearInterval(heartbeat);
+        if (userId !== null) hub.connections.disconnect(userId, ws);
+      });
+    });
+  }
+  async handleFrame(userId, ws, raw) {
+    const hub = this.hub;
+    const reply = (payload) => hub.connections.sendToSocket(ws, payload).catch(() => void 0);
+    let message;
+    try {
+      message = JSON.parse(raw);
+    } catch (err) {
+      await hub.reportHandlerError(userId, raw, err);
+      await reply({ type: "error", error: "Invalid JSON" });
+      return;
+    }
+    if (message === null || typeof message !== "object" || Array.isArray(message)) {
+      await hub.reportHandlerError(userId, message, new TypeError("Message must be a JSON object"));
+      await reply({ type: "error", error: "Message must be a JSON object" });
+      return;
+    }
+    const frame = message;
+    try {
+      await hub.dispatch(userId, frame);
+    } catch (err) {
+      logger.error(`Handler for ${JSON.stringify(frame.type)} failed`, err);
+      await hub.reportHandlerError(userId, frame, err);
+      const text = err instanceof Error ? err.message : String(err);
+      await hub.send(userId, { type: "error", error: `Message processing failed: ${text}` }).catch(() => void 0);
+    }
+  }
+};
+function rawToString(data) {
+  if (typeof data === "string") return data;
+  if (Array.isArray(data)) return Buffer.concat(data).toString("utf8");
+  return Buffer.from(data).toString("utf8");
+}
+
+// src/core/hub.ts
+var CommsHub = class {
+  auth;
+  db;
+  dialect;
+  users;
+  pushSender;
+  connections;
+  rateLimiter;
+  roleResolver;
+  onHandlerError;
+  events = new EventBus();
+  features = {};
+  handlers = /* @__PURE__ */ new Map();
+  connectHooks = [];
+  routes = [];
+  tasks = new TaskSet();
+  ws;
+  constructor(opts) {
+    this.auth = opts.auth;
+    this.db = opts.db;
+    this.dialect = opts.dialect ?? detectDialect(opts.db);
+    this.users = opts.users ?? new NullUserDirectory();
+    this.pushSender = opts.push ?? new NoopPush();
+    this.connections = opts.connections ?? new ConnectionManager();
+    if (opts.cameOnlineCooldown !== void 0) this.connections.cameOnlineCooldown = Number(opts.cameOnlineCooldown);
+    this.rateLimiter = opts.rateLimiter ?? new RateLimiter();
+    this.roleResolver = opts.roleResolver;
+    this.onHandlerError = opts.onHandlerError;
+    if (opts.logger) setLogger(opts.logger);
+    this.connections.addOfflineHook((uid) => this.events.emit("user.disconnected", uid));
+    this.on("ping", async (userId) => {
+      await this.send(userId, { type: PONG_TYPE, timestamp: nowIso() });
+    });
+    this.on(
+      "user_status",
+      (userId, message) => this.connections.setStatus(userId, String(message.status ?? "online"))
+    );
+    this.ws = new WsEndpoint(this);
+  }
+  // ------------------------------------------------------------ registry
+  /** Install a feature (`hub.install(new ChatFeature({...}))`). Returns the feature. */
+  install(feature) {
+    feature.install(this);
+    return feature;
+  }
+  registerFeature(name, feature) {
+    if (name in this.features) throw new Error(`Feature '${name}' is already installed on this hub`);
+    this.features[name] = feature;
+  }
+  /** Register a WS handler for frames of `type`. Registering again replaces the previous handler. */
+  on(type, handler) {
+    this.handlers.set(type, handler);
+    return handler;
+  }
+  handles(type) {
+    return this.handlers.has(type);
+  }
+  /** Run the handler for `message.type`. Unknown types are ignored (false). */
+  async dispatch(userId, message) {
+    const handler = this.handlers.get(message.type);
+    if (!handler) return false;
+    await handler(userId, message, this.db);
+    return true;
+  }
+  /** `hook(userId, ws)` after a socket is registered (runs before frames). Users only unless `allRoles`. */
+  onConnect(hook, allRoles = false) {
+    this.connectHooks.push([hook, allRoles]);
+    return hook;
+  }
+  /** `hook(userId)` when the user's last socket on this worker closes (users only unless `allRoles`). */
+  onDisconnect(hook, allRoles = false) {
+    this.connections.addOfflineHook(hook, allRoles);
+    return hook;
+  }
+  /** `roleResolver(userId)`; "user" without a resolver or when it fails. */
+  async roleOf(userId) {
+    if (!this.roleResolver) return USER_ROLE;
+    try {
+      return String(await this.roleResolver(userId) || USER_ROLE);
+    } catch (err) {
+      logger.error(`roleResolver failed for ${userId}`, err);
+      return USER_ROLE;
+    }
+  }
+  /** Call `onHandlerError`; never throws (hook failures are logged). */
+  async reportHandlerError(userId, frame, err) {
+    if (!this.onHandlerError) return;
+    try {
+      await this.onHandlerError(userId, frame, err);
+    } catch (e) {
+      logger.error("onHandlerError hook failed", e);
+    }
+  }
+  // ---------------------------------------------------------------- rooms
+  joinRoom(userId, room) {
+    return this.connections.joinRoom(userId, room);
+  }
+  leaveRoom(userId, room) {
+    this.connections.leaveRoom(userId, room);
+  }
+  /** Send `frame` as given to every member (every worker, with a room-capable bridge). */
+  broadcastRoom(room, frame) {
+    return this.connections.broadcastRoom(room, frame);
+  }
+  // ------------------------------------------------------------------ REST
+  /** Features call this from `install` to contribute routes. */
+  includeRoutes(routes) {
+    this.routes.push(...routes);
+  }
+  /** `Authorization: Bearer <token>` -> user id (401 otherwise). */
+  async authenticate(headers) {
+    const raw = headers["authorization"];
+    const value = Array.isArray(raw) ? raw[0] : raw;
+    const m = value ? /^bearer\s+(.+)$/i.exec(value.trim()) : null;
+    if (!m || !m[1]) throw new HttpError(401, "Not authenticated");
+    try {
+      return await resolveUserId(this.auth, m[1].trim());
+    } catch {
+      throw new HttpError(401, "Invalid token");
+    }
+  }
+  /** All routes, ready for an adapter: auth is resolved and HttpError / crashes become `{status, body}`. */
+  restRoutes() {
+    return this.routes.map((route) => ({
+      ...route,
+      handler: async (ctx) => {
+        try {
+          const userId = route.auth === false ? null : await this.authenticate(ctx.headers);
+          return await route.handler({ ...ctx, userId });
+        } catch (err) {
+          if (err instanceof HttpError) return { status: err.status, headers: err.headers, body: { detail: err.detail } };
+          logger.error(`REST ${route.method} ${route.path} failed`, err);
+          return { status: 500, body: { detail: "Internal Server Error" } };
+        }
+      }
+    }));
+  }
+  // -------------------------------------------------------------------- WS
+  /** True when `url` is a `/ws/<token>` request. */
+  matchesWs(url) {
+    return this.ws.match(url) !== null;
+  }
+  /** Handle an HTTP upgrade for `/ws/:token` (accept first, then authenticate: 1008 on a bad token). */
+  handleUpgrade(req, socket, head) {
+    this.ws.handleUpgrade(req, socket, head);
+  }
+  /** Listen for `/ws/:token` upgrades on an http.Server (other upgrade paths are left to other listeners). */
+  attach(server) {
+    server.on("upgrade", (req, socket, head) => {
+      if (this.matchesWs(req.url)) this.handleUpgrade(req, socket, head);
+    });
+  }
+  get wsServer() {
+    return this.ws.wss;
+  }
+  // ------------------------------------------------------------- services
+  spawn(task) {
+    this.tasks.spawn(task);
+  }
+  /** Close sockets and wait briefly for background work. */
+  async shutdown() {
+    this.ws.closeAll();
+    await this.tasks.settle();
+    await this.connections.stop();
+  }
+  async send(userId, payload) {
+    return this.connections.send(userId, payload);
+  }
+  async runConnectHooks(userId, ws, role = USER_ROLE, cameOnline = false) {
+    const isUser = role === USER_ROLE;
+    for (const [hook, allRoles] of [...this.connectHooks]) {
+      if (!(isUser || allRoles)) continue;
+      try {
+        await hook(userId, ws);
+      } catch (err) {
+        logger.error(`onConnect hook failed for ${userId}`, err);
+      }
+    }
+    if (!isUser) return;
+    await this.events.emit("user.connected", userId);
+    if (cameOnline) await this.events.emit("user.came_online", userId);
+  }
+  async profiles(userIds) {
+    const ids = [...new Set(userIds)].filter(Boolean);
+    if (!ids.length) return {};
+    try {
+      return await this.users.getProfiles(ids);
+    } catch (err) {
+      logger.error("UserDirectory.getProfiles failed", err);
+      return {};
+    }
+  }
+  async profile(userId) {
+    return (await this.profiles([userId]))[userId];
+  }
+  async displayName(userId, fallback = "Someone") {
+    const p = await this.profile(userId);
+    return p?.name ? p.name : fallback;
+  }
+  /** Never throws: push failures are logged. */
+  async push(userId, title, body, data, channel = "default", ttl = null) {
+    try {
+      await this.pushSender.send(userId, title, body, data, channel, ttl);
+    } catch (err) {
+      logger.error(`Push to ${userId} failed`, err);
+    }
+  }
+};
+
+// src/core/http.ts
+async function readBody(req) {
+  const chunks = [];
+  for await (const c of req) chunks.push(c);
+  const text = Buffer.concat(chunks).toString("utf8");
+  if (!text) return void 0;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+function restListener(hub) {
+  const routes = hub.restRoutes();
+  return async (req, res) => {
+    const url = new URL(req.url ?? "/", "http://localhost");
+    const method = (req.method ?? "GET").toUpperCase();
+    for (const route of routes) {
+      if (route.method !== method) continue;
+      const params = matchPath(route.path, url.pathname);
+      if (!params) continue;
+      const query = {};
+      for (const key of new Set(url.searchParams.keys())) {
+        const all = url.searchParams.getAll(key);
+        query[key] = all.length > 1 ? all : all[0];
+      }
+      const result = await route.handler({
+        method,
+        path: route.path,
+        params,
+        query,
+        headers: req.headers,
+        body: await readBody(req),
+        userId: null
+      });
+      res.writeHead(result.status, { "content-type": "application/json", ...result.headers });
+      res.end(JSON.stringify(result.body));
+      return true;
+    }
+    return false;
+  };
+}
+
+export {
+  PONG_TYPE,
+  USER_ROLE,
+  ConnectionManager,
+  EventBus,
+  CommsHub,
+  restListener
+};
+//# sourceMappingURL=chunk-LY2GJWN7.js.map