@interactive-inc/claude-funnel 0.66.0 → 0.68.0

package/dist/sqlite-event-log-BYgCFMxC.d.ts

@@ -0,0 +1,284 @@
+//#region lib/event-log/event-log-entry.d.ts
+/**
+ * Wrapper that `EventLog.append` puts around every event before handing it
+ * to a sink. `seq` is monotonic across the lifetime of the underlying store —
+ * sinks persist it as the primary key so replay (and broadcaster seeding
+ * after restart) is an indexed range scan, not a full table walk. `ts` is
+ * epoch milliseconds. `event` is the caller-defined payload validated by the
+ * validation function passed to the log.
+ */
+type EventLogEntry<E> = {
+  seq: number;
+  ts: number;
+  event: E;
+};
+//#endregion
+//#region lib/event-log/event-log-store.d.ts
+/**
+ * Relay sink. Receives records that already have a `seq` assigned by the
+ * primary and stores or forwards them — memory ring, stdout, network push,
+ * a second SQLite mirror, etc. Does not generate seq itself, so any number
+ * can be attached and they all observe the same monotonic stream.
+ *
+ * `write` returns `void` on success or an `Error` the `EventLog` surfaces via
+ * `onSinkError`. Throwing is also tolerated (`EventLog` catches it), but
+ * returning is preferred so the failure path is part of the type.
+ */
+type EventLogRelay<E> = {
+  write(record: EventLogEntry<E>): void | Error;
+  close?(): void;
+};
+/**
+ * Primary sink. Owns the canonical seq sequence for the log. `insert` is
+ * the atomic boundary — it assigns a seq strictly greater than every
+ * previously assigned one, persists the record, and returns it. SQLite
+ * implementations get atomicity for free by delegating to `INTEGER PRIMARY
+ * KEY` so two processes sharing one database file see one monotonic
+ * stream without coordinating through `EventLog`.
+ *
+ * `getMaxSeq` is the highest seq currently in the sink — used for
+ * observability and for replay seeding by clients reading the store.
+ */
+type EventLogStore<E> = {
+  insert(input: {
+    ts: number;
+    event: E;
+  }): EventLogEntry<E> | Error;
+  getMaxSeq(): number;
+  close?(): void;
+};
+//#endregion
+//#region lib/event-log/event-log.d.ts
+type Listener<E> = (record: EventLogEntry<E>) => void;
+type SinkErrorHandler<E> = (error: Error, record: EventLogEntry<E>, sink: EventLogRelay<E>) => void;
+type EventLogValidator<E> = (event: unknown) => {
+  success: true;
+  data: E;
+} | {
+  success: false;
+  error: Error;
+};
+type EventLogProps<E> = {
+  /** Validates each event before emission. Use `schema.safeParse` from any validation library, or a plain function. */
+  validate: EventLogValidator<E>;
+  /** Owns seq assignment + durability. Use `SqliteEventLog` for multi-process safety. */
+  primary: EventLogStore<E>;
+  /** Optional fanout for already-sequenced records (memory ring, stdout, network mirror). */
+  relays?: ReadonlyArray<EventLogRelay<E>>;
+  /** Override for tests. Defaults to `Date.now`. */
+  now?: () => number;
+  /** Observer for relay failures. Default: silently swallow. */
+  onSinkError?: SinkErrorHandler<E>;
+};
+/**
+ * Validated event log. Three responsibilities and nothing else:
+ * validate the event, delegate seq + persistence to the primary sink, and
+ * fan the resulting record out to relays and live subscribers.
+ *
+ * Splitting "primary" from "relays" makes the seq invariant honest: there
+ * is exactly one source of truth (the primary's atomic insert). Two
+ * `EventLog` instances pointed at the same SQLite file therefore see
+ * one monotonic stream without coordinating with each other. Relays mirror
+ * already-sequenced records, so they can be added or removed without
+ * affecting correctness.
+ *
+ * Failure isolation:
+ *   - Primary failure short-circuits append and is returned to the caller.
+ *   - Relay failures never block the primary path — they surface via the
+ *     optional `onSinkError` callback so the caller can observe without
+ *     being interrupted.
+ *   - A subscriber that throws is contained; the rest of the fanout
+ *     completes normally.
+ */
+declare class EventLog<E> {
+  private readonly validate;
+  private readonly primary;
+  private readonly relays;
+  private readonly now;
+  private readonly onSinkError;
+  private readonly listeners;
+  constructor(props: EventLogProps<E>);
+  append(event: E): EventLogEntry<E> | Error;
+  subscribe(listener: Listener<E>): () => void;
+  getMaxSeq(): number;
+  close(): void;
+  private callPrimary;
+  private fanOutToRelays;
+  private callRelay;
+  private fanOutToListeners;
+  private callClose;
+}
+//#endregion
+//#region lib/event-log/memory-event-log.d.ts
+type MemoryEventLogProps = {
+  /** Hard cap on retained records. The oldest is evicted on overflow. 0 disables retention. */
+  capacity?: number;
+};
+/**
+ * In-memory ring buffer that doubles as primary or relay. As primary it
+ * owns its own seq counter (single-process only — for multi-process
+ * safety, use `SqliteEventLog` as primary and place this as a
+ * relay). As relay it accepts whatever seq the primary assigned and
+ * advances its own counter to match, so `getMaxSeq` stays meaningful.
+ *
+ * Useful as a test double, as a short-window replay buffer paired with a
+ * persistent primary (covering reconnects without round-tripping disk),
+ * or as a backing store for live subscribers.
+ */
+declare class MemoryEventLog<E> implements EventLogStore<E>, EventLogRelay<E> {
+  private readonly capacity;
+  private readonly buffer;
+  private seq;
+  constructor(props?: MemoryEventLogProps);
+  insert(input: {
+    ts: number;
+    event: E;
+  }): EventLogEntry<E>;
+  write(record: EventLogEntry<E>): void;
+  getMaxSeq(): number;
+  query(): ReadonlyArray<EventLogEntry<E>>;
+  clear(): void;
+  private append;
+}
+//#endregion
+//#region lib/event-log/sqlite-event-log.d.ts
+type IndexValues<I extends ReadonlyArray<string>> = Record<I[number], string | null>;
+type IndexPrefixes<I extends ReadonlyArray<string>> = Partial<Record<I[number], string>>;
+type IndexSets<I extends ReadonlyArray<string>> = Partial<Record<I[number], ReadonlyArray<string | null>>>;
+/**
+ * Constructor props. The shape narrows on `I`: when no indexes are
+ * declared (the default), `extractIndexes` is forbidden; when indexes
+ * are declared, both `indexes` and `extractIndexes` are required and
+ * `extractIndexes` is type-checked against the index keys.
+ */
+type SqliteEventLogProps<E, I extends ReadonlyArray<string>> = I extends readonly [] ? {
+  path: string;
+  maxRows?: number;
+  maxAgeMs?: number;
+  maxBytes?: number;
+  targetBytes?: number;
+  now?: () => number;
+  indexes?: I;
+  extractIndexes?: never;
+} : {
+  path: string;
+  maxRows?: number;
+  maxAgeMs?: number;
+  maxBytes?: number;
+  targetBytes?: number;
+  now?: () => number;
+  indexes: I;
+  extractIndexes: (event: E) => IndexValues<I>;
+};
+type SqliteEventLogQuery<I extends ReadonlyArray<string>> = {
+  /** Return only records with seq strictly greater than this. */
+  sinceSeq?: number;
+  /** Match one sequence number exactly instead of using `sinceSeq`. */
+  seq?: number;
+  /** Filter by the top-level `event.type` discriminator. */
+  type?: string;
+  /** Filter by indexed columns. Keys are constrained to the declared `indexes`. */
+  where?: Partial<IndexValues<I>>;
+  /** Prefix-match indexed text columns. */
+  wherePrefix?: IndexPrefixes<I>;
+  /** Match any value in a set for indexed columns. */
+  whereIn?: IndexSets<I>;
+  /** Maximum rows returned. Default 1000. */
+  limit?: number;
+  /**
+   * Which end of the seq range to take when `limit` clips the result.
+   * "asc" (default) returns the oldest matching rows; "desc" returns the
+   * newest. Rows are always sorted ascending by seq before returning, so the
+   * caller sees a chronological slice either way — "desc" just picks the tail.
+   */
+  order?: "asc" | "desc";
+};
+/**
+ * SQLite-backed sink built on `bun:sqlite`. Implements both primary and
+ * relay roles so the same instance can own seq generation for one log and
+ * mirror records from another (e.g. cross-process replication, restore
+ * from a backup stream).
+ *
+ * Concurrency model: seq is `INTEGER PRIMARY KEY`, so SQLite assigns it
+ * atomically via `lastInsertRowid`. Two `EventLog` instances pointed
+ * at the same database file therefore see one monotonically increasing
+ * seq stream without coordinating through `EventLog` — the database itself is
+ * the synchronization point.
+ *
+ * Schema is version-managed via `PRAGMA user_version`. Migrations are
+ * append-only and run in a transaction on every construct so a partial
+ * upgrade rolls back cleanly. Caller-defined `indexes` are layered on top
+ * via `ALTER TABLE ADD COLUMN` + `CREATE INDEX IF NOT EXISTS`, so adding
+ * a new index to an existing database is a no-downtime operation.
+ *
+ * Type safety: the second generic parameter `I` is the literal tuple of
+ * index column names. `extractIndexes` and `query({ where })` are
+ * both type-checked against this tuple, so a typo at the call site is a
+ * compile-time error rather than a silent miss at runtime.
+ *
+ * Retention is bounded by `maxRows` and/or `maxAgeMs`. Both run on every
+ * insert as a single indexed DELETE that no-ops below the cap.
+ *
+ * Bulk inserts use `insertMany`, which wraps the batch in one transaction
+ * for ~10–100x throughput at the cost of one fsync per batch instead of
+ * one per row.
+ */
+declare class SqliteEventLog<E, const I extends ReadonlyArray<string> = readonly []> implements EventLogStore<E>, EventLogRelay<E> {
+  private readonly db;
+  private readonly maxRows;
+  private readonly maxAgeMs;
+  private readonly maxBytes;
+  private readonly targetBytes;
+  private readonly now;
+  private readonly indexes;
+  private readonly extractIndexes;
+  private readonly insertStmt;
+  private readonly insertWithSeqStmt;
+  private readonly maxSeqStmt;
+  private readonly countStmt;
+  private readonly trimRowsStmt;
+  private readonly trimAgeStmt;
+  private readonly trimOldestStmt;
+  private insertsSinceByteCheck;
+  constructor(props: SqliteEventLogProps<E, I>);
+  insert(input: {
+    ts: number;
+    event: E;
+  }): EventLogEntry<E> | Error;
+  insertMany(inputs: ReadonlyArray<{
+    ts: number;
+    event: E;
+  }>): EventLogEntry<E>[] | Error;
+  write(record: EventLogEntry<E>): void | Error;
+  getMaxSeq(): number;
+  query(props?: SqliteEventLogQuery<I>): EventLogEntry<E>[];
+  /**
+   * Current schema version. Useful for diagnostics and for tests that want
+   * to verify migrations ran. Reads `PRAGMA user_version` once per call.
+   */
+  getSchemaVersion(): number;
+  close(): void;
+  private buildInsertParams;
+  private appendWhereConditions;
+  private appendPrefixConditions;
+  private appendSetConditions;
+  private trim;
+  private indexKeys;
+  /**
+   * Throttled byte-size enforcement. Only every BYTE_CHECK_INTERVAL inserts do
+   * we measure the file; on overflow we estimate how many of the oldest rows to
+   * drop to land near targetBytes (by the byte/row ratio), delete them in one
+   * statement, then VACUUM once to return the freed pages to the filesystem (a
+   * plain DELETE only frees pages inside the file). One DELETE + one VACUUM per
+   * overflow keeps the expensive rewrite rare — the file must refill the whole
+   * maxBytes→targetBytes delta before the next overflow can trigger.
+   */
+  private maybeTrimBytes;
+  private byteSize;
+  /** Drop every row and reclaim the file space. Used by `<log>.clear()`. */
+  clear(): void;
+  private syncIndexColumns;
+  private migrate;
+}
+//#endregion
+export { MemoryEventLogProps as a, EventLogValidator as c, EventLogEntry as d, MemoryEventLog as i, EventLogRelay as l, SqliteEventLogProps as n, EventLog as o, SqliteEventLogQuery as r, EventLogProps as s, SqliteEventLog as t, EventLogStore as u };

package/dist/{funnel-log-sqlite-sink-DLYkY0pZ.js → sqlite-event-log-eZuXKszJ.js}

@@ -1,12 +1,12 @@
 import { dirname } from "node:path";
 import { existsSync, mkdirSync } from "node:fs";
 import { Database } from "bun:sqlite";
-//#region lib/logger/funnel-log-sqlite-sink.ts
+//#region lib/event-log/sqlite-event-log.ts
 /** Conservative whitelist for column names interpolated into SQL. */
 const COLUMN_NAME_RE = /^[a-z_][a-z0-9_]*$/;
 /** How many inserts between on-disk size checks (see insertsSinceByteCheck). */
 const BYTE_CHECK_INTERVAL = 500;
-const RESERVED_COLUMNS = new Set([
+const RESERVED_COLUMNS = /* @__PURE__ */ new Set([
 	"seq",
 	"ts",
 	"type",
@@ -32,14 +32,14 @@ const MIGRATIONS = [[
 ]];
 /**
 * SQLite-backed sink built on `bun:sqlite`. Implements both primary and
-* relay roles so the same instance can own seq generation for one bus and
+* relay roles so the same instance can own seq generation for one log and
 * mirror records from another (e.g. cross-process replication, restore
 * from a backup stream).
 *
 * Concurrency model: seq is `INTEGER PRIMARY KEY`, so SQLite assigns it
-* atomically via `lastInsertRowid`. Two `FunnelLog` instances pointed
+* atomically via `lastInsertRowid`. Two `EventLog` instances pointed
 * at the same database file therefore see one monotonically increasing
-* seq stream without any bus-level coordination — the database itself is
+* seq stream without coordinating through `EventLog` — the database itself is
 * the synchronization point.
 *
 * Schema is version-managed via `PRAGMA user_version`. Migrations are
@@ -60,7 +60,7 @@ const MIGRATIONS = [[
 * for ~10–100x throughput at the cost of one fsync per batch instead of
 * one per row.
 */
-var FunnelLogSqliteSink = class {
+var SqliteEventLog = class {
 	db;
 	maxRows;
 	maxAgeMs;
@@ -163,13 +163,22 @@ var FunnelLogSqliteSink = class {
 		return row ? row.max : 0;
 	}
 	query(props = {}) {
-		const conditions = ["seq > ?"];
-		const params = [props.sinceSeq ?? 0];
+		const conditions = [];
+		const params = [];
+		if (props.seq !== void 0) {
+			conditions.push("seq = ?");
+			params.push(props.seq);
+		} else {
+			conditions.push("seq > ?");
+			params.push(props.sinceSeq ?? 0);
+		}
 		if (typeof props.type === "string") {
 			conditions.push("type = ?");
 			params.push(props.type);
 		}
 		if (props.where) this.appendWhereConditions(props.where, conditions, params);
+		if (props.wherePrefix) this.appendPrefixConditions(props.wherePrefix, conditions, params);
+		if (props.whereIn) this.appendSetConditions(props.whereIn, conditions, params);
 		const limit = props.limit ?? 1e3;
 		params.push(limit);
 		const dir = props.order === "desc" ? "DESC" : "ASC";
@@ -205,9 +214,8 @@ var FunnelLogSqliteSink = class {
 		];
 	}
 	appendWhereConditions(where, conditions, params) {
-		const widened = where;
-		for (const col of this.indexes) {
-			const value = widened[col];
+		for (const col of this.indexKeys()) {
+			const value = where[col];
 			if (value === void 0) continue;
 			if (value === null) conditions.push(`${col} IS NULL`);
 			else {
@@ -216,6 +224,33 @@ var FunnelLogSqliteSink = class {
 			}
 		}
 	}
+	appendPrefixConditions(prefixes, conditions, params) {
+		for (const col of this.indexKeys()) {
+			const value = prefixes[col];
+			if (value === void 0) continue;
+			conditions.push(`${col} LIKE ? ESCAPE '\\'`);
+			params.push(`${escapeLike(value)}%`);
+		}
+	}
+	appendSetConditions(sets, conditions, params) {
+		for (const col of this.indexKeys()) {
+			const values = sets[col];
+			if (values === void 0) continue;
+			if (values.length === 0) {
+				conditions.push("1 = 0");
+				continue;
+			}
+			const nonNull = values.filter((value) => value !== null);
+			const hasNull = nonNull.length !== values.length;
+			const alternatives = [];
+			if (nonNull.length > 0) {
+				alternatives.push(`${col} IN (${nonNull.map(() => "?").join(", ")})`);
+				params.push(...nonNull);
+			}
+			if (hasNull) alternatives.push(`${col} IS NULL`);
+			conditions.push(`(${alternatives.join(" OR ")})`);
+		}
+	}
 	trim() {
 		if (this.maxRows !== null) {
 			const row = this.countStmt.get();
@@ -224,6 +259,9 @@ var FunnelLogSqliteSink = class {
 		if (this.maxAgeMs !== null) this.trimAgeStmt.run(this.now() - this.maxAgeMs);
 		this.maybeTrimBytes();
 	}
+	indexKeys() {
+		return this.indexes;
+	}
 	/**
 	* Throttled byte-size enforcement. Only every BYTE_CHECK_INTERVAL inserts do
 	* we measure the file; on overflow we estimate how many of the oldest rows to
@@ -278,6 +316,9 @@ var FunnelLogSqliteSink = class {
 		}
 	}
 };
+function escapeLike(value) {
+	return value.replaceAll("\\", "\\\\").replaceAll("%", "\\%").replaceAll("_", "\\_");
+}
 function validateIndexNames(names) {
 	for (const name of names) {
 		if (!COLUMN_NAME_RE.test(name)) throw new Error(`invalid index column name: ${name}`);
@@ -298,4 +339,4 @@ function toRecord(row) {
 	};
 }
 //#endregion
-export { FunnelLogSqliteSink as t };
+export { SqliteEventLog as t };

package/dist/{yaml-render-DVEtYuF1.js → yaml-render-DxxRQT-V.js}

@@ -1,6 +1,6 @@
-import { t as NodeFunnelFileSystem } from "./node-file-system-BOXIHW_Q.js";
-import { t as NodeFunnelProcessRunner } from "./node-process-runner-DxTvycoK.js";
-import { m as NodeFunnelIdGenerator, n as FUNNEL_DIR, s as resolveFunnelPort } from "./settings-store-ccv291GV.js";
+import { t as NodeFunnelFileSystem } from "./node-file-system-xJx7dymE.js";
+import { t as NodeFunnelProcessRunner } from "./node-process-runner-D4rzPl8Q.js";
+import { h as NodeFunnelIdGenerator, n as FUNNEL_DIR, s as resolveFunnelPort } from "./settings-store-ZFWBhOnp.js";
 import { join } from "node:path";
 import { stringify } from "yaml";
 //#region lib/engine/claude/claude.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@interactive-inc/claude-funnel",
-  "version": "0.66.0",
+  "version": "0.68.0",
   "description": "Hub CLI that routes external events (Slack / GitHub / Discord) to Claude Code agents through subscription channels over MCP.",
   "keywords": [
     "bun",
@@ -23,8 +23,8 @@
     "url": "git+https://github.com/interactive-inc/open-claude-funnel.git"
   },
   "bin": {
-    "fnl": "./dist/bin.js",
-    "funnel": "./dist/bin.js"
+    "fnl": "dist/bin.js",
+    "funnel": "dist/bin.js"
   },
   "files": [
     "dist/**/*",
@@ -102,6 +102,11 @@
       "import": "./dist/connectors/schedule.js",
       "default": "./dist/connectors/schedule.js"
     },
+    "./event-log": {
+      "types": "./dist/event-log.d.ts",
+      "import": "./dist/event-log.js",
+      "default": "./dist/event-log.js"
+    },
     "./logger": {
       "types": "./dist/logger.d.ts",
       "import": "./dist/logger.js",
@@ -122,18 +127,28 @@
     "prepack": "make build"
   },
   "dependencies": {
-    "@hono/zod-validator": "0.8.0",
-    "@interactive-inc/flume": "^0.10.0",
-    "@modelcontextprotocol/sdk": "^1.29.0",
-    "hono": "^4.12.19",
+    "@hono/zod-validator": "0.9.0",
+    "@interactive-inc/flume": "^0.10.1",
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "hono": "^4.12.32",
     "yaml": "^2.9.0",
     "zod": "^4.4.3"
   },
   "devDependencies": {
     "@types/bun": "^1.3.14",
-    "@typescript/native-preview": "^7.0.0-dev.20260516.1",
-    "vite-plus": "^0.1.21",
-    "vitest": "^4.1.8"
+    "@typescript/native-preview": "^7.0.0-dev.20260707.2",
+    "vite-plus": "^0.2.6",
+    "vitest": "^4.1.10"
+  },
+  "overrides": {
+    "@hono/node-server": "2.0.12",
+    "body-parser": "2.3.0",
+    "fast-uri": "4.1.1",
+    "ip-address": "10.3.1",
+    "postcss": "8.5.23",
+    "qs": "6.15.3",
+    "vite": "8.1.5",
+    "ws": "8.21.1"
   },
   "engines": {
     "bun": ">=1.3.0"

package/dist/broadcaster-DVNcw00K.d.ts

@@ -1,138 +0,0 @@
-import { t as FunnelLogger } from "./logger-Bc_Ooypb.js";
-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 = {
-  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);
-  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
-export { OnFunnelError as a, ReplayableEvent as i, BroadcastSubscriber as n, FunnelBroadcaster as r, BroadcastEvent as t };