@coderbuzz/ken 0.1.0

package/dist/chunk-DPU3PBLP.js

@@ -0,0 +1,815 @@
+// src/context/types.ts
+var EMPTY_PARAMS = Object.freeze({});
+var EMPTY_QUERY = Object.freeze({});
+
+// src/core/router.ts
+var NodeType = {
+  Param: 1,
+  OptionalParam: 2,
+  Wildcard: 3
+};
+function createRouteState() {
+  return {
+    staticChildren: /* @__PURE__ */ new Map(),
+    dynamicChildren: [],
+    handlers: /* @__PURE__ */ new Map()
+  };
+}
+var TreeNode = class {
+  type;
+  paramName;
+  state;
+  constructor(type, paramName) {
+    this.type = type;
+    this.paramName = paramName;
+    this.state = createRouteState();
+  }
+};
+function searchDynamic(method, parts, index, state, params) {
+  if (index === parts.length) {
+    const entry = state.handlers.get(method);
+    if (entry !== void 0) return entry;
+    const dynamicChildren2 = state.dynamicChildren;
+    for (let i = 0; i < dynamicChildren2.length; i++) {
+      const node = dynamicChildren2[i];
+      if (node.type === NodeType.OptionalParam) {
+        return node.state.handlers.get(method);
+      }
+    }
+    return void 0;
+  }
+  const part = parts[index];
+  const nextState = state.staticChildren.get(part);
+  if (nextState !== void 0) {
+    const result = searchDynamic(method, parts, index + 1, nextState, params);
+    if (result !== void 0) return result;
+  }
+  if (part === "") return void 0;
+  const dynamicChildren = state.dynamicChildren;
+  const len = dynamicChildren.length;
+  for (let i = 0; i < len; i++) {
+    const node = dynamicChildren[i];
+    const nodeType = node.type;
+    if (nodeType === NodeType.Param || nodeType === NodeType.OptionalParam) {
+      const paramName = node.paramName;
+      params[paramName] = part;
+      const result = searchDynamic(method, parts, index + 1, node.state, params);
+      if (result !== void 0) return result;
+      delete params[paramName];
+    } else if (nodeType === NodeType.Wildcard) {
+      let wildcardValue = parts[index];
+      for (let j = index + 1; j < parts.length; j++) {
+        wildcardValue += "/" + parts[j];
+      }
+      params["*"] = wildcardValue;
+      return node.state.handlers.get(method);
+    }
+  }
+  return void 0;
+}
+var Router = class {
+  // Static routes: path -> method -> entry
+  staticRoutes = /* @__PURE__ */ new Map();
+  // Dynamic routes tree
+  dynamicRoot = createRouteState();
+  // Raw route registrations (for runtime compilation)
+  routes = [];
+  /**
+   * Register a compiled route (called by runtime during compilation)
+   */
+  registerCompiled(method, path, handler, schema, response) {
+    const isDynamic = path.includes(":") || path.includes("*");
+    if (!isDynamic) {
+      let methodMap = this.staticRoutes.get(path);
+      if (!methodMap) {
+        methodMap = /* @__PURE__ */ new Map();
+        this.staticRoutes.set(path, methodMap);
+      }
+      const cachedResult = {
+        handler,
+        schema,
+        params: EMPTY_PARAMS,
+        response
+      };
+      methodMap.set(method, { handler, schema, response, cachedResult });
+      return;
+    }
+    this.insertDynamic(method, path, handler, schema, response);
+  }
+  insertDynamic(method, path, handler, schema, response) {
+    const parts = path === "/" ? [] : path.substring(1).split("/");
+    let currentState = this.dynamicRoot;
+    for (let i = 0; i < parts.length; i++) {
+      const part = parts[i];
+      if (part.startsWith(":") || part === "*") {
+        let type;
+        let paramName;
+        if (part === "*") {
+          type = NodeType.Wildcard;
+          paramName = "*";
+        } else if (part.endsWith("?")) {
+          type = NodeType.OptionalParam;
+          paramName = part.substring(1, part.length - 1);
+        } else {
+          type = NodeType.Param;
+          paramName = part.substring(1);
+        }
+        let node = currentState.dynamicChildren.find(
+          (c) => c.type === type && c.paramName === paramName
+        );
+        if (!node) {
+          node = new TreeNode(type, paramName);
+          currentState.dynamicChildren.push(node);
+          currentState.dynamicChildren.sort((a, b) => a.type - b.type);
+        }
+        currentState = node.state;
+      } else {
+        let nextState = currentState.staticChildren.get(part);
+        if (!nextState) {
+          nextState = createRouteState();
+          currentState.staticChildren.set(part, nextState);
+        }
+        currentState = nextState;
+      }
+    }
+    currentState.handlers.set(method, { handler, schema, response });
+  }
+  /**
+   * Create matcher function for route lookup
+   */
+  matcher() {
+    const staticRoutes = this.staticRoutes;
+    const dynamicRoot = this.dynamicRoot;
+    return (method, pathname) => {
+      const staticMethodMap = staticRoutes.get(pathname);
+      if (staticMethodMap !== void 0) {
+        const entry = staticMethodMap.get(method);
+        if (entry !== void 0) {
+          return entry.cachedResult;
+        }
+      }
+      const parts = pathname === "/" ? [] : pathname.substring(1).split("/");
+      const params = {};
+      const result = searchDynamic(method, parts, 0, dynamicRoot, params);
+      if (result !== void 0) {
+        return {
+          handler: result.handler,
+          schema: result.schema,
+          params,
+          response: result.response
+        };
+      }
+      return void 0;
+    };
+  }
+  /**
+   * Dynamic-only matcher (skips static routes)
+   * Used when native routing handles static routes
+   */
+  dynamicOnlyMatcher() {
+    const dynamicRoot = this.dynamicRoot;
+    return (method, pathname) => {
+      const parts = pathname === "/" ? [] : pathname.substring(1).split("/");
+      const params = {};
+      const result = searchDynamic(method, parts, 0, dynamicRoot, params);
+      if (result !== void 0) {
+        return {
+          handler: result.handler,
+          schema: result.schema,
+          params,
+          response: result.response
+        };
+      }
+      return void 0;
+    };
+  }
+  /**
+   * Get all registered routes as an array of { method, path } objects.
+   *
+   * @example
+   * ```ts
+   * const routes = app.getRoutes();
+   * // [{ method: 'GET', path: '/' }, { method: 'POST', path: '/users' }, ...]
+   * ```
+   */
+  getRoutes() {
+    return this.routes.map((r) => ({ method: r.method, path: r.path }));
+  }
+  /**
+   * Clear all compiled routes (for recompilation)
+   */
+  clear() {
+    this.staticRoutes.clear();
+    this.dynamicRoot = createRouteState();
+  }
+};
+
+// src/ws/types.ts
+var WsReadyState = {
+  CONNECTING: 0,
+  OPEN: 1,
+  CLOSING: 2,
+  CLOSED: 3
+};
+var WS_DEFAULTS = {
+  maxPayloadLength: 16777216,
+  backpressureLimit: 16777216,
+  pingInterval: 30,
+  pongTimeout: 10,
+  perMessageDeflate: false,
+  idleTimeout: 120
+};
+
+// src/runtime/compiler.ts
+function isAsyncHandler(handler, schema) {
+  if (handler.constructor.name === "AsyncFunction") {
+    return true;
+  }
+  if (schema?.state) {
+    for (const key in schema.state) {
+      if (schema.state[key].constructor.name === "AsyncFunction") {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+var JSON_ERROR_HEADERS = { "content-type": "application/json" };
+var INTERNAL_SERVER_ERROR = "Internal Server Error";
+function defaultErrorHandler(err) {
+  if (err instanceof Response) return err;
+  const message = err instanceof Error ? err.message : INTERNAL_SERVER_ERROR;
+  return new Response(
+    JSON.stringify({ status: 500, message }),
+    { status: 500, headers: JSON_ERROR_HEADERS }
+  );
+}
+function handleError(err, ctx, onError) {
+  if (onError) {
+    try {
+      const result = onError(err, ctx);
+      if (result && typeof result.then === "function") {
+        return result.then((resp2) => {
+          ctx._executeFinishCallbacks(resp2);
+          return resp2;
+        }).catch((innerErr) => {
+          const resp2 = defaultErrorHandler(innerErr);
+          ctx._executeFinishCallbacks(resp2);
+          return resp2;
+        });
+      }
+      ctx._executeFinishCallbacks(result);
+      return result;
+    } catch (innerErr) {
+      const resp2 = defaultErrorHandler(innerErr);
+      ctx._executeFinishCallbacks(resp2);
+      return resp2;
+    }
+  }
+  const resp = defaultErrorHandler(err);
+  ctx._executeFinishCallbacks(resp);
+  return resp;
+}
+function createSyncExecutorWithMiddleware(createContext, handler, schema) {
+  const state = schema.state;
+  const onError = schema.onError;
+  return (request, params, getRemoteInfo, ...args) => {
+    const ctx = createContext(request, params, getRemoteInfo, schema, ...args);
+    try {
+      const stateObj = ctx.state;
+      for (const key in state) {
+        const result = state[key](ctx);
+        if (result !== void 0) {
+          if (result instanceof Response) {
+            ctx._executeFinishCallbacks(result);
+            return result;
+          }
+          stateObj[key] = result;
+        }
+      }
+      const response = handler(ctx);
+      ctx._executeFinishCallbacks(response);
+      return response;
+    } catch (err) {
+      return handleError(err, ctx, onError);
+    }
+  };
+}
+function createSyncExecutorNoMiddleware(createContext, handler, schema) {
+  const onError = schema?.onError;
+  return (request, params, getRemoteInfo, ...args) => {
+    const ctx = createContext(request, params, getRemoteInfo, schema, ...args);
+    try {
+      const response = handler(ctx);
+      ctx._executeFinishCallbacks(response);
+      return response;
+    } catch (err) {
+      return handleError(err, ctx, onError);
+    }
+  };
+}
+function createAsyncExecutorWithMiddleware(createContext, handler, schema) {
+  const state = schema.state;
+  const onError = schema.onError;
+  return async (request, params, getRemoteInfo, ...args) => {
+    const ctx = createContext(request, params, getRemoteInfo, schema, ...args);
+    try {
+      const stateObj = ctx.state;
+      for (const key in state) {
+        const result = await state[key](ctx);
+        if (result !== void 0) {
+          if (result instanceof Response) {
+            ctx._executeFinishCallbacks(result);
+            return result;
+          }
+          stateObj[key] = result;
+        }
+      }
+      const response = await handler(ctx);
+      ctx._executeFinishCallbacks(response);
+      return response;
+    } catch (err) {
+      return handleError(err, ctx, onError);
+    }
+  };
+}
+function createAsyncExecutorNoMiddleware(createContext, handler, schema) {
+  const onError = schema?.onError;
+  return async (request, params, getRemoteInfo, ...args) => {
+    const ctx = createContext(request, params, getRemoteInfo, schema, ...args);
+    try {
+      const response = await handler(ctx);
+      ctx._executeFinishCallbacks(response);
+      return response;
+    } catch (err) {
+      return handleError(err, ctx, onError);
+    }
+  };
+}
+function createExecutor(createContext, handler, schema) {
+  const hasMiddleware = schema?.state && Object.keys(schema.state).length > 0;
+  const isAsync = isAsyncHandler(handler, schema);
+  if (isAsync) {
+    return hasMiddleware ? createAsyncExecutorWithMiddleware(createContext, handler, schema) : createAsyncExecutorNoMiddleware(createContext, handler, schema);
+  }
+  return hasMiddleware ? createSyncExecutorWithMiddleware(createContext, handler, schema) : createSyncExecutorNoMiddleware(createContext, handler, schema);
+}
+function createNotFoundExecutor(router, createContext) {
+  const entries = [];
+  if (router._notFoundHandler) {
+    entries.push({ prefix: "", handler: router._notFoundHandler });
+  }
+  if (router._notFoundEntries?.length > 0) {
+    entries.push(...router._notFoundEntries);
+  }
+  if (entries.length > 0) {
+    return buildPrefixNotFoundExecutor(router, createContext, entries);
+  }
+  if (typeof router.matchMiddleware !== "function" || typeof router.mergeSchemas !== "function") {
+    return null;
+  }
+  const globalMiddleware = router.matchMiddleware("/*");
+  const schema = router.mergeSchemas(globalMiddleware, void 0);
+  if (!schema || !schema.state || Object.keys(schema.state).length === 0) {
+    return null;
+  }
+  const notFoundHandler = () => new Response("Not Found", { status: 404 });
+  const executor = createExecutor(createContext, notFoundHandler, schema);
+  return (request, getRemoteInfo, _pathname, ...args) => {
+    return executor(request, {}, getRemoteInfo, ...args);
+  };
+}
+function buildPrefixNotFoundExecutor(router, createContext, entries) {
+  const hasMatchMiddleware = typeof router.matchMiddleware === "function" && typeof router.mergeSchemas === "function";
+  const compiledEntries = [];
+  for (const entry of entries) {
+    let schema = entry.schema;
+    if ((!schema || !schema.state) && hasMatchMiddleware) {
+      const matched = router.matchMiddleware(entry.prefix || "/*");
+      schema = router.mergeSchemas(matched, schema);
+    }
+    const executor = createExecutor(createContext, entry.handler, schema);
+    compiledEntries.push({ prefix: entry.prefix, executor });
+  }
+  const hasGlobalHandler = compiledEntries.some((e) => e.prefix === "");
+  if (!hasGlobalHandler) {
+    const defaultHandler = () => new Response("Not Found", { status: 404 });
+    let fallbackSchema;
+    if (hasMatchMiddleware) {
+      const globalMiddleware = router.matchMiddleware("/*");
+      fallbackSchema = router.mergeSchemas(globalMiddleware, void 0);
+    }
+    const fallbackExecutor = createExecutor(createContext, defaultHandler, fallbackSchema);
+    compiledEntries.push({ prefix: "", executor: fallbackExecutor });
+  }
+  compiledEntries.sort((a, b) => b.prefix.length - a.prefix.length);
+  const emptyParams = {};
+  if (compiledEntries.length === 1 && compiledEntries[0].prefix === "") {
+    const singleExecutor = compiledEntries[0].executor;
+    return (request, getRemoteInfo, _pathname, ...args) => {
+      return singleExecutor(request, emptyParams, getRemoteInfo, ...args);
+    };
+  }
+  const len = compiledEntries.length;
+  return (request, getRemoteInfo, pathname, ...args) => {
+    for (let i = 0; i < len; i++) {
+      const entry = compiledEntries[i];
+      if (entry.prefix === "" || pathname === entry.prefix || pathname.startsWith(entry.prefix + "/")) {
+        return entry.executor(request, emptyParams, getRemoteInfo, ...args);
+      }
+    }
+    return new Response("Not Found", { status: 404 });
+  };
+}
+
+// src/utils/response.ts
+var NO_CONTENT_RESPONSE = new Response(null, { status: 204 });
+function toResponse(value) {
+  if (value instanceof Response) {
+    return value;
+  }
+  if (value === null || value === void 0) {
+    return NO_CONTENT_RESPONSE.clone();
+  }
+  if (typeof value === "object") {
+    const textValue2 = JSON.stringify(value);
+    return new Response(textValue2, {
+      status: 200,
+      headers: {
+        "content-type": "application/json"
+        // 'content-length': Buffer.byteLength(textValue).toString()
+      }
+    });
+  }
+  const textValue = String(value);
+  return new Response(textValue, {
+    status: 200,
+    headers: {
+      "content-type": "text/plain"
+      // 'content-length': Buffer.byteLength(textValue).toString()
+    }
+  });
+}
+
+// src/ws/pubsub.ts
+var PubSubHub = class {
+  /** topic -> set of subscribers */
+  topics = /* @__PURE__ */ new Map();
+  /** peer -> set of subscribed topics (for fast cleanup) */
+  peerTopics = /* @__PURE__ */ new Map();
+  /** peer -> last-alive timestamp (ms) — for dead peer detection */
+  _lastPong = /* @__PURE__ */ new Map();
+  /**
+   * Subscribe a peer to a topic.
+   */
+  subscribe(peer, topic) {
+    let topicSet = this.topics.get(topic);
+    if (!topicSet) {
+      topicSet = /* @__PURE__ */ new Set();
+      this.topics.set(topic, topicSet);
+    }
+    topicSet.add(peer);
+    let peerSet = this.peerTopics.get(peer);
+    if (!peerSet) {
+      peerSet = /* @__PURE__ */ new Set();
+      this.peerTopics.set(peer, peerSet);
+    }
+    peerSet.add(topic);
+    if (!this._lastPong.has(peer)) {
+      this._lastPong.set(peer, Date.now());
+    }
+  }
+  /**
+   * Unsubscribe a peer from a topic.
+   */
+  unsubscribe(peer, topic) {
+    const topicSet = this.topics.get(topic);
+    if (topicSet) {
+      topicSet.delete(peer);
+      if (topicSet.size === 0) {
+        this.topics.delete(topic);
+      }
+    }
+    const peerSet = this.peerTopics.get(peer);
+    if (peerSet) {
+      peerSet.delete(topic);
+      if (peerSet.size === 0) {
+        this.peerTopics.delete(peer);
+        this._lastPong.delete(peer);
+      }
+    }
+  }
+  /**
+   * Remove a peer from all topics.
+   * Called on connection close.
+   */
+  removeAll(peer) {
+    const peerSet = this.peerTopics.get(peer);
+    if (!peerSet) return;
+    for (const topic of peerSet) {
+      const topicSet = this.topics.get(topic);
+      if (topicSet) {
+        topicSet.delete(peer);
+        if (topicSet.size === 0) {
+          this.topics.delete(topic);
+        }
+      }
+    }
+    this.peerTopics.delete(peer);
+    this._lastPong.delete(peer);
+  }
+  /**
+   * Check if a peer is subscribed to a topic.
+   */
+  isSubscribed(peer, topic) {
+    const topicSet = this.topics.get(topic);
+    return topicSet ? topicSet.has(peer) : false;
+  }
+  /**
+   * Publish a message to all subscribers of a topic, excluding the sender.
+   */
+  publish(sender, topic, data, compress) {
+    const topicSet = this.topics.get(topic);
+    if (!topicSet) return;
+    for (const peer of topicSet) {
+      if (peer !== sender) {
+        peer.send(data, compress);
+      }
+    }
+  }
+  /**
+   * Broadcast a message to ALL subscribers of a topic (including sender).
+   * Used internally by the server for ping broadcasts, etc.
+   */
+  broadcast(topic, data, compress) {
+    const topicSet = this.topics.get(topic);
+    if (!topicSet) return;
+    for (const peer of topicSet) {
+      peer.send(data, compress);
+    }
+  }
+  /**
+   * Get the number of subscribers for a topic.
+   */
+  subscriberCount(topic) {
+    return this.topics.get(topic)?.size ?? 0;
+  }
+  /**
+   * Get all topics a peer is subscribed to.
+   */
+  getTopics(peer) {
+    return this.peerTopics.get(peer) ?? /* @__PURE__ */ new Set();
+  }
+  // ── Dead peer detection ─────────────────────────────────────────────────
+  /**
+   * Mark a peer as alive.
+   *
+   * Call from `WsHandler.pong()` on runtimes that support protocol ping/pong
+   * (Bun, Node.js, uWS). On Deno, call from `WsHandler.message()` since
+   * protocol pong is unavailable and any inbound message signals liveness.
+   *
+   * No-op if the peer is not subscribed to any topic.
+   */
+  markAlive(peer) {
+    if (this._lastPong.has(peer)) {
+      this._lastPong.set(peer, Date.now());
+    }
+  }
+  /**
+   * Returns true if the peer was last marked alive within `timeoutMs` ms.
+   */
+  isPeerAlive(peer, timeoutMs) {
+    const last = this._lastPong.get(peer);
+    return last !== void 0 && Date.now() - last < timeoutMs;
+  }
+  /**
+   * Close and evict all peers that are either:
+   * - Already disconnected (`readyState !== OPEN`), or
+   * - Silent for longer than `timeoutMs` milliseconds.
+   *
+   * Collects dead peers before mutating state to avoid iterator interference.
+   * Called by the runtime adapters' `startHeartbeat()` loop, which owns the
+   * timer lifecycle — PubSubHub does not manage its own interval timer.
+   */
+  pruneDeadPeers(timeoutMs) {
+    const now = Date.now();
+    const dead = [];
+    for (const [peer, lastPong] of this._lastPong) {
+      if (peer.readyState !== WsReadyState.OPEN || now - lastPong >= timeoutMs) {
+        dead.push(peer);
+      }
+    }
+    for (const peer of dead) {
+      if (peer.readyState === WsReadyState.OPEN) {
+        try {
+          peer.close(1001, "ping timeout");
+        } catch {
+        }
+      }
+      this.removeAll(peer);
+    }
+  }
+};
+var WsTopicHub = class {
+  /** topic → Set<peer> — O(1) publish iteration */
+  _topics = /* @__PURE__ */ new Map();
+  /** peer → Map<topic, callback> — O(1) dispatch and cleanup */
+  _peerTopics = /* @__PURE__ */ new Map();
+  /** peer → last-pong timestamp (ms) — for dead peer detection */
+  _lastPong = /* @__PURE__ */ new Map();
+  _deadPeerTimer = null;
+  // ── Subscription management ───────────────────────────────────────────────
+  /**
+   * Subscribe a peer to a topic with a per-message callback.
+   *
+   * The callback is invoked whenever `hub.dispatch(peer, msg)` is called while
+   * the peer is subscribed to this topic.
+   *
+   * A peer may be subscribed to multiple topics simultaneously, each with its
+   * own callback. Subsequent calls with the same topic replace the handler.
+   *
+   * @param peer    - The connected WebSocket peer
+   * @param topic   - Topic name (e.g. 'chat', 'notifications', 'room/42')
+   * @param handler - Called with (peer, message) on each dispatched message
+   */
+  subscribe(peer, topic, handler) {
+    let topicSet = this._topics.get(topic);
+    if (!topicSet) {
+      topicSet = /* @__PURE__ */ new Set();
+      this._topics.set(topic, topicSet);
+    }
+    topicSet.add(peer);
+    let peerMap = this._peerTopics.get(peer);
+    if (!peerMap) {
+      peerMap = /* @__PURE__ */ new Map();
+      this._peerTopics.set(peer, peerMap);
+    }
+    peerMap.set(topic, handler);
+    if (!this._lastPong.has(peer)) {
+      this._lastPong.set(peer, Date.now());
+    }
+  }
+  /**
+   * Unsubscribe a peer from a specific topic.
+   * The peer remains subscribed to any other topics.
+   */
+  unsubscribe(peer, topic) {
+    const topicSet = this._topics.get(topic);
+    if (topicSet) {
+      topicSet.delete(peer);
+      if (topicSet.size === 0) this._topics.delete(topic);
+    }
+    const peerMap = this._peerTopics.get(peer);
+    if (peerMap) {
+      peerMap.delete(topic);
+      if (peerMap.size === 0) {
+        this._peerTopics.delete(peer);
+        this._lastPong.delete(peer);
+      }
+    }
+  }
+  /**
+   * Remove a peer from ALL topics and clean up liveness state.
+   * Call this from `WsHandler.close()` to prevent memory leaks.
+   */
+  leave(peer) {
+    const peerMap = this._peerTopics.get(peer);
+    if (!peerMap) return;
+    for (const topic of peerMap.keys()) {
+      const topicSet = this._topics.get(topic);
+      if (topicSet) {
+        topicSet.delete(peer);
+        if (topicSet.size === 0) this._topics.delete(topic);
+      }
+    }
+    this._peerTopics.delete(peer);
+    this._lastPong.delete(peer);
+  }
+  // ── Message routing ───────────────────────────────────────────────────────
+  /**
+   * Route an incoming message from a peer to all its registered topic handlers.
+   * Call this from `WsHandler.message()`.
+   *
+   * If the peer is subscribed to multiple topics, the message is dispatched
+   * to each topic's callback in insertion order.
+   */
+  dispatch(peer, msg) {
+    const peerMap = this._peerTopics.get(peer);
+    if (!peerMap) return;
+    for (const handler of peerMap.values()) {
+      try {
+        handler(peer, msg);
+      } catch {
+      }
+    }
+  }
+  // ── Broadcasting ──────────────────────────────────────────────────────────
+  /**
+   * Broadcast a message to ALL subscribers of a topic, including the sender.
+   *
+   * For "exclude self" semantics (the sender does not receive their own message),
+   * use `peer.publish(topic, data)` instead — which on Bun and uWS routes through
+   * the native C++ pub/sub engine.
+   */
+  publish(topic, data, compress) {
+    const topicSet = this._topics.get(topic);
+    if (!topicSet) return;
+    for (const peer of topicSet) {
+      peer.send(data, compress);
+    }
+  }
+  // ── Dead peer detection ───────────────────────────────────────────────────
+  /**
+   * Mark a peer as alive. Call from `WsHandler.pong()`.
+   *
+   * Works with native runtime protocol ping/pong (Bun, Node, uWS).
+   * On Deno, calling this has no effect as `handler.pong` is never triggered.
+   */
+  markAlive(peer) {
+    if (this._lastPong.has(peer)) {
+      this._lastPong.set(peer, Date.now());
+    }
+  }
+  /**
+   * Returns true if the peer last responded within `timeoutMs` milliseconds.
+   */
+  isPeerAlive(peer, timeoutMs) {
+    const last = this._lastPong.get(peer);
+    return last !== void 0 && Date.now() - last < timeoutMs;
+  }
+  /**
+   * Close and remove all peers that have not called `markAlive()` within `timeoutMs`.
+   * Recommended value: `(pingInterval + pongTimeout) * 1000`.
+   */
+  pruneDeadPeers(timeoutMs) {
+    const now = Date.now();
+    for (const [peer, lastPong] of this._lastPong) {
+      if (now - lastPong >= timeoutMs) {
+        try {
+          peer.close(1001, "ping timeout");
+        } catch {
+        }
+        this.leave(peer);
+      }
+    }
+  }
+  /**
+   * Start automatic dead peer detection at a fixed interval.
+   *
+   * @param checkIntervalMs - How often to scan for dead peers (ms)
+   * @param timeoutMs       - Peers unseen longer than this are closed and removed
+   *
+   * @example
+   * ```ts
+   * // Check every 5 seconds; close peers silent for 2 minutes
+   * hub.startDeadPeerCheck(5_000, 120_000);
+   *
+   * // Integrate with WsOptions:
+   * // { pingInterval: 30, pongTimeout: 10 }
+   * // → hub.startDeadPeerCheck(5_000, (30 + 10) * 1000);
+   * ```
+   */
+  startDeadPeerCheck(checkIntervalMs, timeoutMs) {
+    this.stopDeadPeerCheck();
+    this._deadPeerTimer = setInterval(() => {
+      this.pruneDeadPeers(timeoutMs);
+    }, checkIntervalMs);
+  }
+  /**
+   * Stop the automatic dead peer check started by `startDeadPeerCheck()`.
+   */
+  stopDeadPeerCheck() {
+    if (this._deadPeerTimer !== null) {
+      clearInterval(this._deadPeerTimer);
+      this._deadPeerTimer = null;
+    }
+  }
+  // ── Introspection ─────────────────────────────────────────────────────────
+  /** Number of peers currently subscribed to a topic. */
+  subscriberCount(topic) {
+    return this._topics.get(topic)?.size ?? 0;
+  }
+  /** Returns true if a peer is subscribed to the given topic. */
+  isSubscribed(peer, topic) {
+    return this._topics.get(topic)?.has(peer) ?? false;
+  }
+  /** Returns an array of all active topic names. */
+  topicNames() {
+    return [...this._topics.keys()];
+  }
+};
+
+export {
+  EMPTY_PARAMS,
+  EMPTY_QUERY,
+  Router,
+  WsReadyState,
+  WS_DEFAULTS,
+  defaultErrorHandler,
+  createExecutor,
+  createNotFoundExecutor,
+  toResponse,
+  PubSubHub,
+  WsTopicHub
+};
+//# sourceMappingURL=chunk-DPU3PBLP.js.map