@interactive-inc/claude-funnel 0.66.0 → 0.68.0

package/dist/gateway.d.ts

@@ -1,4 +1,3 @@
-import { i as ReplayableEvent, n as BroadcastSubscriber, r as FunnelBroadcaster, t as BroadcastEvent } from "./broadcaster-DVNcw00K.js";
-import { C as ConnectorRawRecord, D as connectorConnectionEventSchema, E as StoredRawEvent, O as connectorProcessedEventSchema, S as ConnectorRawQuery, T as StoredProcessedEvent, _ as ConnectorProcessedEvent, b as ConnectorQuery, d as CONNECTOR_CONNECTION_STATUSES, f as ConnectorConnectionEvent, g as ConnectorDiagnosticLog, h as ConnectorConnectionStatus, k as connectorRawEventSchema, m as ConnectorConnectionRecord, p as ConnectorConnectionQuery, v as ConnectorProcessedQuery, w as StoredConnectionEvent, x as ConnectorRawEvent, y as ConnectorProcessedRecord } from "./connector-descriptor-CmyHlEiT.js";
-import { C as funnelEventSchema, D as FunnelListenerRegistry, E as GatewayRouteDeps, S as FunnelEventRecord, T as GatewayEmitInput, _ as channelWsUrl, a as SqliteFunnelEventLog, b as FunnelEvent, c as PublishResponse, d as publishResponseSchema, f as DEFAULT_GATEWAY_TOKEN_PATH, g as channelWsProtocols, h as ChannelWsUrlInput, i as MemoryFunnelEventLog, l as PublishResult, m as gatewayLoopbackUrl, n as MemoryConnectorDiagnosticLog, o as FunnelChannelPublisher, p as FunnelGatewayToken, r as SqliteConnectorDiagnosticLog, s as PublishRequest, t as GatewayApp, u as publishRequestSchema, v as FunnelGatewayServer, w as Env, x as FunnelEventLog, y as GatewayEventStore } from "./index-BU1TtuFy.js";
+import { _ as connectorConnectionEventSchema, a as ConnectorConnectionStatus, c as ConnectorProcessedQuery, d as ConnectorRawEvent, f as ConnectorRawQuery, g as StoredRawEvent, h as StoredProcessedEvent, i as ConnectorConnectionRecord, l as ConnectorProcessedRecord, m as StoredConnectionEvent, n as ConnectorConnectionEvent, o as ConnectorDiagnosticLog, p as ConnectorRawRecord, r as ConnectorConnectionQuery, s as ConnectorProcessedEvent, t as CONNECTOR_CONNECTION_STATUSES, u as ConnectorQuery, v as connectorProcessedEventSchema, y as connectorRawEventSchema } from "./diagnostic-log-BsAg5qZK.js";
+import { A as FunnelBroadcaster, C as funnelEventSchema, D as FunnelListenerRegistry, E as GatewayRouteDeps, O as BroadcastEvent, S as FunnelEventRecord, T as GatewayEmitInput, _ as channelWsUrl, a as SqliteFunnelEventLog, b as FunnelEvent, c as PublishResponse, d as publishResponseSchema, f as DEFAULT_GATEWAY_TOKEN_PATH, g as channelWsProtocols, h as ChannelWsUrlInput, i as MemoryFunnelEventLog, j as ReplayableEvent, k as BroadcastSubscriber, l as PublishResult, m as gatewayLoopbackUrl, n as MemoryConnectorDiagnosticLog, o as FunnelChannelPublisher, p as FunnelGatewayToken, r as SqliteConnectorDiagnosticLog, s as PublishRequest, t as GatewayApp, u as publishRequestSchema, v as FunnelGatewayServer, w as Env, x as FunnelEventLog, y as GatewayEventStore } from "./index-fHrKn4jm.js";
 export { BroadcastEvent, BroadcastSubscriber, CONNECTOR_CONNECTION_STATUSES, ChannelWsUrlInput, ConnectorConnectionEvent, ConnectorConnectionQuery, ConnectorConnectionRecord, ConnectorConnectionStatus, ConnectorDiagnosticLog, ConnectorProcessedEvent, ConnectorProcessedQuery, ConnectorProcessedRecord, ConnectorQuery, ConnectorRawEvent, ConnectorRawQuery, ConnectorRawRecord, DEFAULT_GATEWAY_TOKEN_PATH, FunnelBroadcaster, FunnelChannelPublisher, FunnelEvent, FunnelEventLog, FunnelEventRecord, FunnelGatewayServer, FunnelGatewayToken, FunnelListenerRegistry, type GatewayApp, type GatewayEmitInput, GatewayEventStore, type GatewayRouteDeps, type Env as GatewayServerEnv, MemoryConnectorDiagnosticLog, MemoryFunnelEventLog, PublishRequest, PublishResponse, PublishResult, ReplayableEvent, SqliteConnectorDiagnosticLog, SqliteFunnelEventLog, StoredConnectionEvent, StoredProcessedEvent, StoredRawEvent, channelWsProtocols, channelWsUrl, connectorConnectionEventSchema, connectorProcessedEventSchema, connectorRawEventSchema, funnelEventSchema, gatewayLoopbackUrl, publishRequestSchema, publishResponseSchema };

package/dist/gateway.js

@@ -1,3 +1,3 @@
-import { n as gatewayLoopbackUrl } from "./loopback-fetch-CVNuN3YZ.js";
-import { S as connectorRawEventSchema, _ as MemoryConnectorDiagnosticLog, a as DEFAULT_GATEWAY_TOKEN_PATH, b as connectorConnectionEventSchema, c as FunnelListenerRegistry, d as funnelEventSchema, f as FunnelBroadcaster, g as publishResponseSchema, h as publishRequestSchema, i as channelWsUrl, l as SqliteFunnelEventLog, m as FunnelChannelPublisher, n as MemoryFunnelEventLog, o as FunnelGatewayToken, r as channelWsProtocols, s as FunnelGatewayServer, t as SqliteConnectorDiagnosticLog, u as FunnelEventLog, v as CONNECTOR_CONNECTION_STATUSES, x as connectorProcessedEventSchema, y as ConnectorDiagnosticLog } from "./sqlite-diagnostic-log-CwhXE9Qh.js";
+import { n as gatewayLoopbackUrl } from "./loopback-fetch-HP-bo9Kv.js";
+import { S as connectorRawEventSchema, _ as MemoryConnectorDiagnosticLog, a as DEFAULT_GATEWAY_TOKEN_PATH, b as connectorConnectionEventSchema, c as FunnelListenerRegistry, d as funnelEventSchema, f as FunnelBroadcaster, g as publishResponseSchema, h as publishRequestSchema, i as channelWsUrl, l as SqliteFunnelEventLog, m as FunnelChannelPublisher, n as MemoryFunnelEventLog, o as FunnelGatewayToken, r as channelWsProtocols, s as FunnelGatewayServer, t as SqliteConnectorDiagnosticLog, u as FunnelEventLog, v as CONNECTOR_CONNECTION_STATUSES, x as connectorProcessedEventSchema, y as ConnectorDiagnosticLog } from "./sqlite-diagnostic-log-Qs4cf9I_.js";
 export { CONNECTOR_CONNECTION_STATUSES, ConnectorDiagnosticLog, DEFAULT_GATEWAY_TOKEN_PATH, FunnelBroadcaster, FunnelChannelPublisher, FunnelEventLog, FunnelGatewayServer, FunnelGatewayToken, FunnelListenerRegistry, MemoryConnectorDiagnosticLog, MemoryFunnelEventLog, SqliteConnectorDiagnosticLog, SqliteFunnelEventLog, channelWsProtocols, channelWsUrl, connectorConnectionEventSchema, connectorProcessedEventSchema, connectorRawEventSchema, funnelEventSchema, gatewayLoopbackUrl, publishRequestSchema, publishResponseSchema };

package/dist/{gh-connector-BUGCOEWS.js → gh-connector-DMwI6zJA.js}

@@ -1,8 +1,8 @@
-import { t as NodeFunnelProcessRunner } from "./node-process-runner-DxTvycoK.js";
-import { t as errorMessageOf } from "./error-message-of-ColuYmAk.js";
-import { t as ghConnectorSchema } from "./gh-connector-schema-CAqIhzGr.js";
-import { t as FunnelConnectorAdapter } from "./connector-adapter-Dvs8N7ew.js";
-import { i as resolveFlumeDeps, n as FunnelFlumeSourceListener, r as flumeLogHandler, t as slotFields } from "./slot-fields-D-pvMgTK.js";
+import { t as NodeFunnelProcessRunner } from "./node-process-runner-D4rzPl8Q.js";
+import { t as errorMessageOf } from "./error-message-of-BG4ezZ_s.js";
+import { t as ghConnectorSchema } from "./gh-connector-schema-DmZTrzUu.js";
+import { t as FunnelConnectorAdapter } from "./connector-adapter-BL2ehMej.js";
+import { i as resolveFlumeDeps, n as FunnelFlumeSourceListener, r as flumeLogHandler, t as slotFields } from "./slot-fields-eCWizJqS.js";
 import { FlumeGitHubSource } from "@interactive-inc/flume/github";
 //#region lib/engine/connectors/gh-adapter.ts
 const defaultProcess$1 = new NodeFunnelProcessRunner();

package/dist/{gh-connector-schema-BCHEqpUg.d.ts → gh-connector-schema-BrNsCl1T.d.ts}

@@ -1,5 +1,4 @@
 import { z } from "zod";
-
 //#region lib/engine/connectors/gh-connector-schema.d.ts
 declare const ghConnectorSchema: z.ZodObject<{
   id: z.ZodString;

package/dist/{index-BU1TtuFy.d.ts → index-fHrKn4jm.d.ts}

@@ -1,14 +1,155 @@
-import { n as FunnelClock, t as FunnelLogger } from "./logger-Bc_Ooypb.js";
-import { n as FunnelFileSystem } from "./file-system-DHgbuTFb.js";
-import { a as OnFunnelError, i as ReplayableEvent, n as BroadcastSubscriber, r as FunnelBroadcaster } from "./broadcaster-DVNcw00K.js";
-import { A as FunnelConnectorListener, C as ConnectorRawRecord, E as StoredRawEvent, F as BaseConnectorConfig, S as ConnectorRawQuery, T as StoredProcessedEvent, g as ConnectorDiagnosticLog, m as ConnectorConnectionRecord, p as ConnectorConnectionQuery, v as ConnectorProcessedQuery, w as StoredConnectionEvent, y as ConnectorProcessedRecord, z as FunnelProcessRunner } from "./connector-descriptor-CmyHlEiT.js";
-import { n as ChannelConnectorView, r as FunnelChannels } from "./channels-DR90RmUP.js";
+import { n as FunnelClock, t as FunnelLogger } from "./logger-mMZvblTx.js";
+import { n as FunnelFileSystem } from "./file-system-BNtl997T.js";
+import { b as FunnelProcessRunner, d as FunnelConnectorListener, g as BaseConnectorConfig } from "./connector-descriptor-D4XtEsH8.js";
+import { c as ConnectorProcessedQuery, f as ConnectorRawQuery, g as StoredRawEvent, h as StoredProcessedEvent, i as ConnectorConnectionRecord, l as ConnectorProcessedRecord, m as StoredConnectionEvent, o as ConnectorDiagnosticLog, p as ConnectorRawRecord, r as ConnectorConnectionQuery } from "./diagnostic-log-BsAg5qZK.js";
+import { n as ChannelConnectorView, r as FunnelChannels } from "./channels-B0cifCfw.js";
 import { z } from "zod";
 import { Hono } from "hono";
-import * as _$hono_utils_http_status0 from "hono/utils/http-status";
-import * as _$hono_utils_types0 from "hono/utils/types";
-import * as _$hono_hono_base0 from "hono/hono-base";
-
+import { ServerWebSocket } from "bun";
+//#region lib/engine/error/on-funnel-error.d.ts
+/**
+ * Host integration hook called when Funnel catches an exception that would
+ * otherwise be silently swallowed (subscriber throw, listener start failure,
+ * MCP forward failure, etc.). Pass `Sentry.captureException` from the host to
+ * pipe these into your error reporter. Defaults to a no-op when omitted.
+ *
+ * `context` carries the component name and any extra metadata the caller had
+ * at the catch site (channel / connector / subscriber id when available).
+ */
+type OnFunnelError = (error: Error, context?: Record<string, unknown>) => void;
+//#endregion
+//#region lib/gateway/broadcaster.d.ts
+type ClientData = {
+  /** Stable channel id (uuid) that the WS client subscribed to. */
+  channel: string;
+  /** Human-facing channel name resolved at upgrade time, kept for log readability. */
+  channelName?: string | null;
+  /** Connector names belonging to that channel. */
+  connectors: string[];
+  /** Routing mode resolved from channel config at upgrade time. Defaults to fanout. */
+  delivery?: "fanout" | "exclusive";
+  /**
+   * Opaque per-client id declared at upgrade time (`?id=<subscriberId>`). When an
+   * event carries `meta.target`, only the client whose `subscriberId` equals it
+   * receives the event among that channel's regular subscribers. Targeted delivery
+   * is how a publisher addresses one specific instance (e.g. a single agent
+   * session) without every subscriber having to receive and discard it.
+   */
+  subscriberId?: string;
+};
+type BroadcastEvent = {
+  content: string;
+  meta?: Record<string, string>;
+};
+type ReplayableEvent = BroadcastEvent & {
+  offset: number;
+};
+type BroadcastSubscriber = (event: ReplayableEvent) => void;
+/**
+ * Optional persistent replay source. Wired in by the gateway-server with a
+ * `FunnelEventLog` (SQLite-backed by default) so reconnects across daemon
+ * restarts can recover events older than the in-memory buffer via an indexed
+ * `seq > since` range scan.
+ */
+type ReplaySource = {
+  loadSince(since: number): ReplayableEvent[];
+};
+type Deps$4 = {
+  logger?: FunnelLogger;
+  /** Host hook for surfacing subscriber-throw exceptions. Defaults to no-op. */
+  onError?: OnFunnelError;
+  maxBufferedBytes?: number;
+  now?: () => number;
+  /** Number of recent events kept in the in-memory replay buffer. */
+  replayBufferSize?: number;
+  /** Hard byte cap on replay buffer payloads. Older events are evicted FIFO until under this cap. */
+  replayBufferMaxBytes?: number;
+  /** Persistent replay source consulted when the in-memory buffer cannot satisfy `since`. */
+  persistentReplay?: ReplaySource;
+};
+type BroadcasterMetrics = {
+  clients: number;
+  subscribers: number;
+  eventsBroadcast: number;
+  droppedSlowClients: number;
+  lastBroadcastAt: string | null;
+  /** Latest emitted offset. Clients can `?since=<offset>` to ask for events strictly after this point. */
+  latestOffset: number;
+  /** Oldest offset still held in the replay buffer. Older values cannot be replayed and trigger a full resync. */
+  oldestReplayableOffset: number | null;
+};
+/**
+ * In-process pub/sub for connector events.
+ *
+ * Two outbound paths:
+ *   - WS clients connected via the gateway's `/ws` endpoint, scoped per channel
+ *   - In-process subscribers registered via `subscribe()` (programmable API)
+ *
+ * Backpressure: if a WS client's `bufferedAmount` exceeds `maxBufferedBytes`
+ * (default 1 MiB), the client is closed with code 1009 and dropped from the
+ * registry to keep one slow consumer from blocking the daemon.
+ *
+ * Replay: every emitted event gets a strictly increasing `offset`. The latest
+ * `replayBufferSize` events are kept in memory; reconnecting WS clients can
+ * pass `?since=<offset>` and the broadcaster resends matching events before
+ * resuming the live stream. The in-memory ring covers short reconnects;
+ * older history is served from the event log wired in as `persistentReplay`.
+ */
+declare class FunnelBroadcaster {
+  private readonly clients;
+  private readonly subscribers;
+  private readonly logger;
+  private readonly onError;
+  private readonly maxBufferedBytes;
+  private readonly now;
+  private readonly replayBufferSize;
+  private readonly replayBufferMaxBytes;
+  private readonly replayBuffer;
+  private readonly persistentReplay;
+  private readonly exclusiveCursor;
+  private replayBufferBytes;
+  private eventsBroadcast;
+  private droppedSlowClients;
+  private lastBroadcastAt;
+  private latestOffset;
+  constructor(deps?: Deps$4);
+  getMetrics(): BroadcasterMetrics;
+  /**
+   * Returns events with offset > since, filtered by the connector subscription
+   * rules of `data`. Used at WS upgrade time when the client passes `?since=<offset>`.
+   *
+   * Two-tier lookup:
+   *   1. The in-memory ring buffer (covers short reconnects, last `replayBufferSize` events).
+   *   2. If `since` predates the oldest in-memory entry and a persistent replay source
+   *      is wired in (SQLite by default), the gap is filled from it. This covers reconnects
+   *      across daemon restarts where the in-memory buffer was lost.
+   *
+   * Result is sorted ascending by offset and de-duplicated against the in-memory buffer.
+   */
+  replaySince(since: number, data: ClientData): ReplayableEvent[];
+  private matchesClient;
+  /**
+   * Returns the list of WS clients that should receive `event`. For each per-channel group:
+   *   - fanout → every matching client receives
+   *   - exclusive → exactly one client receives, picked round-robin per channel
+   *
+   * `meta.target` narrows the recipient set via `matchesClient`: only the subscriber
+   * whose `subscriberId` equals `target` receives a targeted event.
+   */
+  private pickRecipients;
+  addClient(ws: ServerWebSocket<unknown>, data: ClientData): void;
+  removeClient(ws: ServerWebSocket<unknown>): void;
+  getClientCount(): number;
+  listChannels(): {
+    channel: string;
+    connectors: string[];
+  }[];
+  subscribe(handler: BroadcastSubscriber): () => void;
+  broadcast(content: string, meta?: Record<string, string>): ReplayableEvent;
+  /** Forward-seed the offset counter (used at startup from the persisted event store). */
+  seedLatestOffset(offset: number): void;
+}
+//#endregion
 //#region lib/gateway/listener-registry.d.ts
 type ConnectorRegistry = {
   listAllConnectors(): ChannelConnectorView[];
@@ -22,7 +163,8 @@ type ListenerRegistryNotify = (channelName: string, connectorName: string, conte
 type Deps$3 = {
   channels: ConnectorRegistry;
   notify: ListenerRegistryNotify;
-  logger?: FunnelLogger; /** Host hook for surfacing listener lifecycle exceptions. Defaults to no-op. */
+  logger?: FunnelLogger;
+  /** Host hook for surfacing listener lifecycle exceptions. Defaults to no-op. */
   onError?: OnFunnelError;
   healthCheckIntervalMs?: number;
   maxBackoffMs?: number;
@@ -127,6 +269,7 @@ type GatewayRouteDeps = {
   emit: (input: GatewayEmitInput) => {
     offset: number;
   };
+  diagnosticLog?: ConnectorDiagnosticLog;
 };
 //#endregion
 //#region lib/gateway/factory.d.ts
@@ -190,7 +333,7 @@ declare abstract class FunnelEventLog {
  * mutually exclusive — modeled as a union so you can't pass both (the old shape
  * silently ignored `dbPath` when `eventLog` was also given).
  *
- * - omit both → SQLite at the default path (`<os.tmpdir()>/funnel/events.db`)
+ * - omit both → SQLite under `<tmpDir>/events/`, isolated by funnel dir + port
  * - `dbPath` → SQLite at a custom path (parent dir created on demand)
  * - `eventLog` → bring your own `FunnelEventLog` (e.g. `MemoryFunnelEventLog`)
  */
@@ -203,15 +346,21 @@ type GatewayEventStore = {
 };
 type Deps$2 = GatewayEventStore & {
   channels: FunnelChannels;
-  port?: number; /** Bind address for `Bun.serve`. Defaults to `127.0.0.1` (loopback only). Set to `0.0.0.0` to expose on the network. */
+  port?: number;
+  /** Bind address for `Bun.serve`. Defaults to `127.0.0.1` (loopback only). Set to `0.0.0.0` to expose on the network. */
   hostname?: string;
   process?: FunnelProcessRunner;
   clock?: FunnelClock;
-  logger?: FunnelLogger; /** Host hook for surfacing internal exceptions (broadcaster / supervisor). Defaults to no-op. */
+  logger?: FunnelLogger;
+  /** Host hook for surfacing internal exceptions (broadcaster / supervisor). Defaults to no-op. */
   onError?: OnFunnelError;
-  selfPid?: number; /** Funnel home dir, used to scope kill-competing to daemons rooted at the same dir. Defaults to FUNNEL_DIR. */
+  selfPid?: number;
+  /** Funnel home dir, used to scope kill-competing to daemons rooted at the same dir. Defaults to FUNNEL_DIR. */
   dir?: string;
-  killCompetingSlack?: boolean; /** Bearer token required for `/listeners*`, `/status`, and `/ws`. Empty string disables auth (tests only). */
+  /** Runtime directory used by the default replay database. Defaults to `funnelTmpDir()`. */
+  tmpDir?: string;
+  killCompetingSlack?: boolean;
+  /** Bearer token required for `/listeners*`, `/status`, and `/ws`. Empty string disables auth (tests only). */
   token?: string;
   /**
    * Permit binding a non-loopback hostname without a token. Off by default:
@@ -227,6 +376,8 @@ type Deps$2 = GatewayEventStore & {
    * `/channels`, `/health` are mounted after and take precedence on conflict.
    */
   extraRoutes?: Hono<Env>;
+  /** Read-side diagnostic source exposed to the built-in debug route. */
+  diagnosticLog?: ConnectorDiagnosticLog;
 };
 /**
  * In-process gateway: runs `Bun.serve` (HTTP + WebSocket /ws), boots connector
@@ -257,6 +408,7 @@ declare class FunnelGatewayServer {
   private readonly nowMs;
   private readonly extraRoutes;
   private readonly ownsEventLog;
+  private readonly diagnosticLog;
   private startedAt;
   private server;
   private disposed;
@@ -344,9 +496,13 @@ declare class FunnelGatewayServer {
  * gateway requires a token.
  */
 type ChannelWsUrlInput = {
-  /** Base WS endpoint, e.g. `ws://localhost:9743/ws`. Existing query is preserved. */base: string; /** Channel name to subscribe to. Required — the broadcaster filters by it. */
-  channel: string; /** Opaque subscriber id for targeted delivery (`meta.target=<id>`). Omit for fanout. */
-  subscriberId?: string; /** Replay from this event offset (inclusive). Omit to receive only new events. */
+  /** Base WS endpoint, e.g. `ws://localhost:9743/ws`. Existing query is preserved. */
+  base: string;
+  /** Channel name to subscribe to. Required — the broadcaster filters by it. */
+  channel: string;
+  /** Opaque subscriber id for targeted delivery (`meta.target=<id>`). Omit for fanout. */
+  subscriberId?: string;
+  /** Replay from this event offset (inclusive). Omit to receive only new events. */
   since?: number;
 };
 declare function channelWsUrl(input: ChannelWsUrlInput): string;
@@ -436,7 +592,8 @@ type PublishResult = {
 //#region lib/gateway/channel-publisher.d.ts
 type Deps = {
   port: number;
-  isDaemonRunning: () => boolean; /** Returns the daemon's gateway token, or null if unavailable. Sent as `Authorization: Bearer`. */
+  isDaemonRunning: () => boolean;
+  /** Returns the daemon's gateway token, or null if unavailable. Sent as `Authorization: Bearer`. */
   getToken?: () => string | null;
 };
 /**
@@ -455,18 +612,25 @@ declare class FunnelChannelPublisher {
 //#endregion
 //#region lib/gateway/event-log/sqlite-event-log.d.ts
 type Props$1 = {
-  /** SQLite database file path. Created on first write. ":memory:" for tests. */path: string; /** Override for tests. Defaults to `Date.now`. */
-  now?: () => number; /** Surfaces a failed persist (PK collision, disk-full, locked WAL). Silent if absent. */
+  /** SQLite database file path. Created on first write. ":memory:" for tests. */
+  path: string;
+  /** Override for tests. Defaults to `Date.now`. */
+  now?: () => number;
+  /** Surfaces a failed persist (PK collision, disk-full, locked WAL). Silent if absent. */
   logger?: FunnelLogger;
   /**
    * Host-supplied error sink. Routed alongside the logger when a write
    * fails, so Sentry / Datadog / a custom alert pipeline sees the durable
    * replay loss too — not just the local log file. Silent if absent.
    */
-  onError?: OnFunnelError; /** Optional row cap. Pruned on every insert. */
-  maxRows?: number; /** Optional age cap in ms. Pruned on every insert. */
-  maxAgeMs?: number; /** Optional on-disk byte cap. Checked periodically; on overflow the oldest rows are dropped toward targetBytes and the file is VACUUMed. */
-  maxBytes?: number; /** Shrink target when maxBytes is exceeded. Defaults to maxBytes/4. */
+  onError?: OnFunnelError;
+  /** Optional row cap. Pruned on every insert. */
+  maxRows?: number;
+  /** Optional age cap in ms. Pruned on every insert. */
+  maxAgeMs?: number;
+  /** Optional on-disk byte cap. Checked periodically; on overflow the oldest rows are dropped toward targetBytes and the file is VACUUMed. */
+  maxBytes?: number;
+  /** Shrink target when maxBytes is exceeded. Defaults to maxBytes/4. */
   targetBytes?: number;
 };
 /**
@@ -540,18 +704,24 @@ declare class MemoryFunnelEventLog extends FunnelEventLog {
 //#endregion
 //#region lib/engine/diagnostic-log/sqlite-diagnostic-log.d.ts
 type Props = {
-  /** SQLite file for the raw (pre-filter) table. ":memory:" for tests. */rawPath: string; /** SQLite file for the processed (verdict) table. ":memory:" for tests. */
-  processedPath: string; /** SQLite file for the connection (lifecycle) table. ":memory:" for tests. */
+  /** SQLite file for the raw (pre-filter) table. ":memory:" for tests. */
+  rawPath: string;
+  /** SQLite file for the processed (verdict) table. ":memory:" for tests. */
+  processedPath: string;
+  /** SQLite file for the connection (lifecycle) table. ":memory:" for tests. */
   connectionPath: string;
-  now?: () => number; /** Row cap for the processed and connection tables. Pruned on every insert. */
+  now?: () => number;
+  /** Row cap for the processed and connection tables. Pruned on every insert. */
   maxRows?: number;
   /**
    * Row cap for the raw table specifically. Raw rows can each hold up to
    * `RAW_PAYLOAD_CAP` bytes, so they want a tighter cap than the small
    * processed/connection verdict rows. Defaults to `maxRows` when unset.
    */
-  rawMaxRows?: number; /** Age cap in ms for all tables — bounds how long untouched payloads (with PII) live. Pruned on every insert. */
-  maxAgeMs?: number; /** When set, `insert()` errors (disk full, WAL lock) are logged instead of silently dropped. */
+  rawMaxRows?: number;
+  /** Age cap in ms for all tables — bounds how long untouched payloads (with PII) live. Pruned on every insert. */
+  maxAgeMs?: number;
+  /** When set, `insert()` errors (disk full, WAL lock) are logged instead of silently dropped. */
   logger?: FunnelLogger;
 };
 /**
@@ -621,7 +791,7 @@ declare class MemoryConnectorDiagnosticLog extends ConnectorDiagnosticLog {
  * shape as CLI's `c.var.funnel`.
  */
 type GatewayApp = ReturnType<typeof buildGatewayRoutes>;
-declare function buildGatewayRoutes(): _$hono_hono_base0.HonoBase<Env, {
+declare function buildGatewayRoutes(): import("hono/hono-base").HonoBase<Env, {
   "/health": {
     $get: {
       input: {};
@@ -643,7 +813,7 @@ declare function buildGatewayRoutes(): _$hono_hono_base0.HonoBase<Env, {
         }[];
       };
       outputFormat: "json";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
+      status: import("hono/utils/http-status").ContentfulStatusCode;
     };
   };
 } & {
@@ -681,7 +851,7 @@ declare function buildGatewayRoutes(): _$hono_hono_base0.HonoBase<Env, {
         };
       };
       outputFormat: "json";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
+      status: import("hono/utils/http-status").ContentfulStatusCode;
     };
   };
 } & {
@@ -710,7 +880,7 @@ declare function buildGatewayRoutes(): _$hono_hono_base0.HonoBase<Env, {
             outcome: string;
             payload: string | null;
             payloadParsed: {
-              [x: string]: _$hono_utils_types0.JSONValue;
+              [x: string]: import("hono/utils/types").JSONValue;
             } | null;
             preview: string | null;
           }[];
@@ -729,7 +899,7 @@ declare function buildGatewayRoutes(): _$hono_hono_base0.HonoBase<Env, {
         }[];
       };
       outputFormat: "json";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
+      status: import("hono/utils/http-status").ContentfulStatusCode;
     };
   };
 } & {
@@ -750,7 +920,7 @@ declare function buildGatewayRoutes(): _$hono_hono_base0.HonoBase<Env, {
         }[];
       };
       outputFormat: "json";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
+      status: import("hono/utils/http-status").ContentfulStatusCode;
     };
   };
 } & {
@@ -870,10 +1040,10 @@ declare function buildGatewayRoutes(): _$hono_hono_base0.HonoBase<Env, {
       };
       output: {
         ok: true;
-        result: _$hono_utils_types0.JSONValue;
+        result: import("hono/utils/types").JSONValue;
       };
       outputFormat: "json";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
+      status: import("hono/utils/http-status").ContentfulStatusCode;
     };
   };
 } & {
@@ -934,9 +1104,9 @@ declare function buildGatewayRoutes(): _$hono_hono_base0.HonoBase<Env, {
         offset: number;
       };
       outputFormat: "json";
-      status: _$hono_utils_http_status0.ContentfulStatusCode;
+      status: import("hono/utils/http-status").ContentfulStatusCode;
     };
   };
 }, "/", "/channels/:channel/publish">;
 //#endregion
-export { funnelEventSchema as C, FunnelListenerRegistry as D, GatewayRouteDeps as E, FunnelEventRecord as S, GatewayEmitInput as T, channelWsUrl as _, SqliteFunnelEventLog as a, FunnelEvent as b, PublishResponse as c, publishResponseSchema as d, DEFAULT_GATEWAY_TOKEN_PATH as f, channelWsProtocols as g, ChannelWsUrlInput as h, MemoryFunnelEventLog as i, PublishResult as l, gatewayLoopbackUrl as m, MemoryConnectorDiagnosticLog as n, FunnelChannelPublisher as o, FunnelGatewayToken as p, SqliteConnectorDiagnosticLog as r, PublishRequest as s, GatewayApp as t, publishRequestSchema as u, FunnelGatewayServer as v, Env as w, FunnelEventLog as x, GatewayEventStore as y };
+export { FunnelBroadcaster as A, funnelEventSchema as C, FunnelListenerRegistry as D, GatewayRouteDeps as E, OnFunnelError as M, BroadcastEvent as O, FunnelEventRecord as S, GatewayEmitInput as T, channelWsUrl as _, SqliteFunnelEventLog as a, FunnelEvent as b, PublishResponse as c, publishResponseSchema as d, DEFAULT_GATEWAY_TOKEN_PATH as f, channelWsProtocols as g, ChannelWsUrlInput as h, MemoryFunnelEventLog as i, ReplayableEvent as j, BroadcastSubscriber as k, PublishResult as l, gatewayLoopbackUrl as m, MemoryConnectorDiagnosticLog as n, FunnelChannelPublisher as o, FunnelGatewayToken as p, SqliteConnectorDiagnosticLog as r, PublishRequest as s, GatewayApp as t, publishRequestSchema as u, FunnelGatewayServer as v, Env as w, FunnelEventLog as x, GatewayEventStore as y };