@interactive-inc/claude-funnel 0.59.1 → 0.60.1

package/dist/index-CgY8NdMz.d.ts

@@ -0,0 +1,1057 @@
+import { B as FunnelLogger, C as StoredRawEvent, D as FunnelConnectorListener, I as FunnelProcessRunner, M as BaseConnectorConfig, S as StoredProcessedEvent, b as ConnectorRawRecord, d as ConnectorConnectionRecord, g as ConnectorProcessedRecord, h as ConnectorProcessedQuery, p as ConnectorDiagnosticLog, u as ConnectorConnectionQuery, x as StoredConnectionEvent, y as ConnectorRawQuery } from "./connector-descriptor-6SXJoszo.js";
+import { n as FunnelFileSystem } from "./file-system-o51IsM0W.js";
+import { i as FunnelClock, n as ChannelConnectorView, r as FunnelChannels } from "./channels-2g_BU1N0.js";
+import { z } from "zod";
+import { Hono } from "hono";
+import { ServerWebSocket } from "bun";
+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";
+
+//#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-supervisor.d.ts
+type ConnectorRegistry = {
+  listAllConnectors(): ChannelConnectorView[];
+  createListener(channelName: string, connectorName: string): {
+    config: BaseConnectorConfig;
+    channelId: string;
+    listener: FunnelConnectorListener;
+  } | null;
+};
+type SupervisorNotify = (channelName: string, connectorName: string, content: string, meta?: Record<string, string>) => Promise<void>;
+type Deps$3 = {
+  channels: ConnectorRegistry;
+  notify: SupervisorNotify;
+  logger?: FunnelLogger; /** Host hook for surfacing listener lifecycle exceptions. Defaults to no-op. */
+  onError?: OnFunnelError;
+  healthCheckIntervalMs?: number;
+  maxBackoffMs?: number;
+  /** Per-listener timeout for `start()`. A listener that hangs beyond this is
+   *  treated as a startup failure — it won't block other listeners or the
+   *  health-check loop. Defaults to 30 seconds. */
+  startTimeoutMs?: number;
+  sleep?: (ms: number) => Promise<void>;
+  now?: () => number;
+};
+type ListenerEntryStatus = {
+  channelName: string;
+  channelId: string;
+  name: string;
+  type: string;
+  alive: boolean;
+  events: number;
+  errors: number;
+  failureCount: number;
+  lastEventAt: string | null;
+};
+/**
+ * Owns the running listener instances and their lifecycle.
+ *
+ * Lives in the gateway process and is the only place that calls
+ * `listener.start()` / `listener.stop()`. Each entry is keyed by
+ * `${channelName}/${connectorName}` so the same connector name can exist in
+ * multiple channels without colliding.
+ *
+ * Periodically polls each running listener's `isAlive()` and auto-restarts
+ * dead listeners with exponential backoff (1s, 2s, 4s, ... capped). Resets
+ * the backoff counter on successful restart.
+ */
+declare class FunnelListenerSupervisor {
+  private readonly channels;
+  private readonly notify;
+  private readonly logger;
+  private readonly onError;
+  private readonly running;
+  private readonly failureCounts;
+  private readonly stats;
+  private readonly healthCheckIntervalMs;
+  private readonly maxBackoffMs;
+  private readonly startTimeoutMs;
+  private readonly sleep;
+  private readonly now;
+  private healthCheckTimer;
+  private healthCheckInFlight;
+  /** Connectors that failed initial start — retried by the health check. */
+  private readonly pendingRetry;
+  constructor(deps: Deps$3);
+  static keyOf(channelName: string, connectorName: string): string;
+  isRunning(channelName: string, connectorName: string): boolean;
+  list(): ListenerEntryStatus[];
+  start(channelName: string, connectorName: string): Promise<{
+    ok: boolean;
+    reason?: string;
+  }>;
+  stop(channelName: string, connectorName: string): Promise<{
+    ok: boolean;
+    reason?: string;
+  }>;
+  restart(channelName: string, connectorName: string): Promise<{
+    ok: boolean;
+    reason?: string;
+  }>;
+  startAll(): Promise<void>;
+  stopAll(): Promise<void>;
+  private ensureStats;
+  private recordEvent;
+  private recordError;
+  private startHealthCheck;
+  private stopHealthCheck;
+  /** Run one health-check pass synchronously. Test-only seam. */
+  runHealthCheckForTest(): Promise<void>;
+  private runHealthCheck;
+  private recoverDead;
+}
+//#endregion
+//#region lib/gateway/routes/route-deps.d.ts
+type GatewayEmitInput = {
+  channel: string;
+  connector?: string;
+  content: string;
+  meta?: Record<string, string>;
+};
+type GatewayRouteDeps = {
+  selfPid: number;
+  /** Funnel home dir this daemon is rooted at. Lets a probe tell whether the
+   *  daemon answering on a shared port belongs to the expected repo/scope. */
+  dir: string;
+  broadcaster: FunnelBroadcaster;
+  supervisor: FunnelListenerSupervisor;
+  channels: FunnelChannels;
+  uptimeMs: () => number;
+  emit: (input: GatewayEmitInput) => {
+    offset: number;
+  };
+};
+//#endregion
+//#region lib/gateway/factory.d.ts
+type Env = {
+  Variables: {
+    deps: GatewayRouteDeps;
+  };
+};
+//#endregion
+//#region lib/gateway/event-log/event-log.d.ts
+/**
+ * Replayable event payload persisted by the gateway. Domain events the
+ * broadcaster emits to WS clients land here so reconnects across daemon
+ * restarts can be served from disk. System events (gateway start, channel
+ * connected, etc.) are routed to `FunnelLogger` instead — they never go
+ * through this log, which keeps the offset space clean for replay.
+ */
+declare const funnelEventSchema: z.ZodObject<{
+  type: z.ZodString;
+  content: z.ZodString;
+  channel_id: z.ZodNullable<z.ZodString>;
+  connector_id: z.ZodNullable<z.ZodString>;
+  meta: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+type FunnelEvent = z.infer<typeof funnelEventSchema>;
+/** One broadcast event to persist, carrying the offset the broadcaster assigned. */
+type FunnelEventRecord = {
+  content: string;
+  channelId: string | null;
+  connectorId: string | null;
+  meta: Record<string, string> | null;
+  offset: number;
+};
+/**
+ * Durable, append-only log of broadcaster events keyed by the offset the
+ * broadcaster assigns. The gateway persists every domain event here, and
+ * across restarts it both seeds the broadcaster's offset counter
+ * (`findMaxOffset`) and serves reconnect replay (`loadSince`) from it.
+ *
+ * `loadSince` is the only method the broadcaster itself needs, which makes
+ * any implementation assignable to the broadcaster's narrow `ReplaySource`.
+ *
+ * Implementations:
+ *   - `SqliteFunnelEventLog` — the default; durable across daemon restarts.
+ *   - `MemoryFunnelEventLog` — an in-process double for tests and embedders
+ *     that do not need durability (replay is lost when the process exits).
+ */
+declare abstract class FunnelEventLog {
+  abstract record(record: FunnelEventRecord): void;
+  abstract loadSince(since: number): ReplayableEvent[];
+  abstract findMaxOffset(): number;
+  /** Drop every stored event and reclaim the file. The broadcaster's in-memory
+   *  offset counter is unaffected, so offsets keep increasing after a clear. */
+  abstract clear(): void;
+  abstract close(): void;
+}
+//#endregion
+//#region lib/gateway/gateway-server.d.ts
+/**
+ * Where the gateway's durable replay log lives. The two ways to specify it are
+ * 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`)
+ * - `dbPath` → SQLite at a custom path (parent dir created on demand)
+ * - `eventLog` → bring your own `FunnelEventLog` (e.g. `MemoryFunnelEventLog`)
+ */
+type GatewayEventStore = {
+  dbPath?: string;
+  eventLog?: undefined;
+} | {
+  dbPath?: undefined;
+  eventLog: FunnelEventLog;
+};
+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. */
+  hostname?: string;
+  process?: FunnelProcessRunner;
+  clock?: FunnelClock;
+  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. */
+  dir?: 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:
+   * `start()` throws when `hostname` is reachable off-box and `token` is empty,
+   * because every privileged endpoint would then be open to the network. Set
+   * this only when you've deliberately fronted the gateway with your own auth.
+   */
+  allowInsecureHost?: boolean;
+  /**
+   * Additional hono app mounted before the built-in gateway routes.
+   * Use to embed host-specific endpoints (e.g. an MCP route, custom `/api/*`).
+   * Host routes are mounted first; built-in `/listeners`, `/status`,
+   * `/channels`, `/health` are mounted after and take precedence on conflict.
+   */
+  extraRoutes?: Hono<Env>;
+};
+/**
+ * In-process gateway: runs `Bun.serve` (HTTP + WebSocket /ws), boots connector
+ * listeners through `FunnelListenerSupervisor`, fans events out via
+ * `FunnelBroadcaster`, and persists them via a `FunnelEventLog` (SQLite by default).
+ * System events (gateway lifecycle, connect/disconnect) flow to `FunnelLogger`
+ * instead — keeping the SQLite seq space exclusive to broadcaster traffic so
+ * the broadcaster's offset counter and `getMaxSeq()` stay aligned without
+ * per-event coordination. Exposes `/listeners` HTTP for runtime
+ * start/stop/restart of individual connectors.
+ */
+declare class FunnelGatewayServer {
+  private readonly channels;
+  private readonly configuredPort;
+  private readonly configuredHostname;
+  private readonly dbPath;
+  private readonly process?;
+  private readonly logger;
+  private readonly onError;
+  private readonly selfPid;
+  private readonly dir;
+  private readonly killCompetingSlack;
+  private readonly token;
+  private readonly allowInsecureHost;
+  private readonly broadcaster;
+  private readonly eventLog;
+  private readonly supervisor;
+  private readonly nowMs;
+  private readonly extraRoutes;
+  private startedAt;
+  private server;
+  constructor(deps: Deps$2);
+  /**
+   * The resolved listen port: the live Bun server's port once started (so
+   * `port: 0` auto-assignment is visible), the configured value before that.
+   */
+  get port(): number;
+  /** The bind address: the live Bun server's hostname once started, the configured value before that. */
+  get hostname(): string;
+  start(): Promise<void>;
+  stop(): Promise<void>;
+  getStatus(): {
+    clients: number;
+    channels: {
+      channel: string;
+      connectors: string[];
+    }[];
+  };
+  getBroadcaster(): FunnelBroadcaster;
+  getSupervisor(): FunnelListenerSupervisor;
+  getEventLog(): FunnelEventLog;
+  /**
+   * Register an in-process observer for every broadcast event. Fires after
+   * the event is fanned out to WS clients and recorded in the event log.
+   * Returns an unsubscribe function. Only meaningful in-process (embedded
+   * hosts / `new Funnel(...)` running their own gateway-server); a separate
+   * daemon process cannot be observed this way — use a WS client for that.
+   */
+  onEvent(handler: BroadcastSubscriber): () => void;
+  private handleFetch;
+  private handleWsOpen;
+  private handleWsClose;
+  private logServerStarted;
+  private buildApp;
+  /**
+   * Reads the bearer token from the WebSocket upgrade request. Accepts:
+   *   - `Sec-WebSocket-Protocol: funnel.token.<value>` (preferred — header, never logged in URLs)
+   *   - `Authorization: Bearer <value>` (also header-based)
+   * Returns true on a constant-time match against the daemon token.
+   */
+  private tokenMatchesUpgrade;
+  private resolveChannel;
+  private killCompetingSlackIfNeeded;
+  private bootListeners;
+  /**
+   * Broadcast `content` to subscribers of `channel`, persisting the event in
+   * the SQLite store and stamping `meta.channel{,Id}` / `meta.connector{,Id}`
+   * when they resolve. Used by both the connector-listener path (via the
+   * supervisor's `notify` callback) and the public `/channels/:channel/publish`
+   * route. Returns the assigned event offset.
+   *
+   * Public SDK surface for hosts running this gateway in-process — the no-HTTP
+   * sibling of `funnel.publisher.publish()`, which targets a daemon instead
+   * (see fnl docs programmable-api).
+   */
+  emit(input: {
+    channel: string;
+    connector?: string;
+    content: string;
+    meta?: Record<string, string>;
+  }): {
+    offset: number;
+  };
+  private lookupChannelId;
+  private lookupConnectorId;
+}
+//#endregion
+//#region lib/gateway/channel-ws-url.d.ts
+/**
+ * Builds the WebSocket URL a client uses to subscribe to a gateway channel.
+ *
+ * The gateway's `/ws` upgrade handler reads three query params — `channel`
+ * (required), `id` (the subscriber id for targeted delivery), and `since`
+ * (replay offset). Forgetting `channel=` silently drops the subscription
+ * (the broadcaster never matches the client), which has caused outages when
+ * callers hand-built the URL with string concatenation. This builder makes
+ * `channel` a required field, so the mistake becomes a compile error.
+ *
+ * `subscriberId` enables targeted delivery: events carrying `meta.target=<id>`
+ * reach only this client. Omit it to receive the channel's fanout.
+ *
+ * Pair with `channelWsProtocols()` to authenticate the upgrade when the
+ * 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. */
+  since?: number;
+};
+declare function channelWsUrl(input: ChannelWsUrlInput): string;
+/**
+ * Builds the `Sec-WebSocket-Protocol` values that authenticate a gateway WS
+ * upgrade. Browser `WebSocket` cannot set an `Authorization` header, so the
+ * gateway also accepts the token as a `funnel.token.<token>` subprotocol.
+ * Returns an empty array when no token is given (auth disabled / loopback).
+ *
+ * Usage: `new WebSocket(channelWsUrl({ base, channel }), channelWsProtocols(token))`
+ */
+declare function channelWsProtocols(token?: string | null): string[];
+//#endregion
+//#region lib/engine/http/gateway-base-url.d.ts
+/**
+ * The HTTP base URL of a gateway daemon on the loopback interface. The daemon
+ * always binds 127.0.0.1 for its management API (only the WS `/ws` endpoint is
+ * ever exposed off-box), so every in-process HTTP client — publisher, listeners
+ * client, MCP channel server — talks to it here. Centralizing the construction
+ * keeps the host/port shape in one place instead of re-spelling
+ * `http://127.0.0.1:${port}` at each call site.
+ */
+declare function gatewayLoopbackUrl(port: number): string;
+//#endregion
+//#region lib/gateway/gateway-token.d.ts
+type Deps$1 = {
+  fs?: FunnelFileSystem;
+  dir?: string;
+  generate?: () => string;
+};
+/**
+ * Reads / generates the gateway daemon token used to authenticate
+ * `/listeners*`, `/status`, and `/ws` connections.
+ *
+ * Token file: `<dir>/gateway.token` (default `~/.funnel/gateway.token`),
+ * written with mode 0600. Clients on the same machine as the daemon read
+ * the file directly; the token never leaves the user's home directory.
+ */
+declare class FunnelGatewayToken {
+  private readonly fs;
+  private readonly path;
+  private readonly generate;
+  constructor(deps?: Deps$1);
+  read(): string | null;
+  /**
+   * Returns the existing token or, if missing, generates one and writes it with mode 0600.
+   *
+   * NOTE: not atomic — two concurrent `ensure()` calls (e.g., `fnl gateway start` racing
+   * itself before the PID lock is acquired) could each generate independent tokens. The
+   * gateway PID file makes this practically a non-issue; if you need stronger guarantees,
+   * take a file lock around this call externally.
+   */
+  ensure(): string;
+  getPath(): string;
+}
+declare const DEFAULT_GATEWAY_TOKEN_PATH: string;
+//#endregion
+//#region lib/gateway/publish-schema.d.ts
+/**
+ * Shared schema for `POST /channels/:channel/publish` — used by both the
+ * gateway route handler (input validation) and the CLI / programmable client
+ * (request shape). The route resolves `channel` from the path; this body
+ * covers everything else.
+ */
+declare const publishRequestSchema: z.ZodObject<{
+  content: z.ZodString;
+  meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  connector: z.ZodOptional<z.ZodString>;
+  target: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type PublishRequest = z.infer<typeof publishRequestSchema>;
+declare const publishResponseSchema: z.ZodObject<{
+  ok: z.ZodLiteral<true>;
+  offset: z.ZodNumber;
+}, z.core.$strip>;
+type PublishResponse = z.infer<typeof publishResponseSchema>;
+type PublishResult = {
+  state: "ok";
+  offset: number;
+} | {
+  state: "offline";
+} | {
+  state: "error";
+  reason: string;
+};
+//#endregion
+//#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`. */
+  getToken?: () => string | null;
+};
+/**
+ * HTTP client for `POST /channels/:channel/publish` on a running gateway
+ * daemon. Returns `{ state: "offline" }` when the daemon isn't up so callers
+ * can branch without exceptions, mirroring `FunnelListenersClient`.
+ */
+declare class FunnelChannelPublisher {
+  private readonly port;
+  private readonly isDaemonRunning;
+  private readonly getToken;
+  constructor(deps: Deps);
+  publish(channelName: string, request: PublishRequest): Promise<PublishResult>;
+  private authHeaders;
+}
+//#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. */
+  logger?: FunnelLogger; /** 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;
+};
+/**
+ * SQLite-backed `FunnelEventLog`. One indexed table holds every broadcaster
+ * event with `channel_id` and `connector_id` as dedicated columns, so
+ * per-channel and per-connector replay is an indexed range scan.
+ *
+ * Concurrency: `seq` is `INTEGER PRIMARY KEY`, so SQLite assigns it
+ * atomically. The broadcaster owns its own offset counter at runtime
+ * (seeded from `findMaxOffset()` at startup); each broadcaster event
+ * flows in here via `record()` with that pre-assigned offset, which the
+ * sink stores via `write()` — PK uniqueness catches double-emit bugs.
+ *
+ * System events (gateway lifecycle, channel connect/disconnect, etc.) do
+ * NOT go through this store. They are diagnostic only and live in
+ * `FunnelLogger`'s file so the seq space here stays exclusive to
+ * broadcaster traffic. This is what makes the broadcaster's seq seeding
+ * (`getMaxSeq()` at startup) correct without per-event coordination.
+ */
+declare class SqliteFunnelEventLog extends FunnelEventLog {
+  private readonly sink;
+  private readonly now;
+  private readonly logger;
+  constructor(props: Props$1);
+  /**
+   * Persist a broadcaster-driven event with its assigned offset. Caller
+   * (the gateway-server) supplies the offset from `broadcaster.broadcast()`
+   * so this store and the broadcaster's in-memory ring stay aligned.
+   */
+  record(record: FunnelEventRecord): void;
+  /**
+   * Returns events with offset > since. Filtering by channel/connector is
+   * the broadcaster's responsibility (it knows the client's subscription),
+   * so this returns the full slice and lets the caller filter.
+   */
+  loadSince(since: number): ReplayableEvent[];
+  /**
+   * Returns events for one channel (and optionally one connector). Used
+   * by the gateway logs CLI for scoped queries. Channel/connector filters
+   * are indexed columns, so this is an indexed range scan.
+   */
+  loadForChannel(props: {
+    channelId: string;
+    connectorId?: string;
+    sinceSeq?: number;
+    limit?: number;
+  }): ReplayableEvent[];
+  findMaxOffset(): number;
+  clear(): void;
+  close(): void;
+}
+//#endregion
+//#region lib/gateway/event-log/memory-event-log.d.ts
+/**
+ * In-process `FunnelEventLog` backed by a plain array. Used by tests and by
+ * embedders that do not need durability — replay works within the process
+ * lifetime but is lost when the process exits. Unlike the SQLite log it does
+ * not truncate content or prune, so it is not meant for unbounded production
+ * traffic.
+ */
+declare class MemoryFunnelEventLog extends FunnelEventLog {
+  private readonly events;
+  constructor();
+  record(record: FunnelEventRecord): void;
+  loadSince(since: number): ReplayableEvent[];
+  findMaxOffset(): number;
+  clear(): void;
+  close(): void;
+}
+//#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. */
+  connectionPath: string;
+  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. */
+  logger?: FunnelLogger;
+};
+/**
+ * Default `ConnectorDiagnosticLog`: three independent `FunnelLogSqliteSink`s, one
+ * per table (raw / processed / connection), in separate files. Each sink
+ * indexes the columns its queries filter on — `event_id` / `connector_id` /
+ * `channel_id` for raw, plus `outcome` for processed and `status` for
+ * connection — so those lookups are indexed scans (`type` is a fixed column
+ * the sink extracts separately, not an index, so filtering by it is a scan).
+ *
+ * The raw table offloads any payload over `RAW_PAYLOAD_CAP`: rather than
+ * truncating mid-string (which yields unparseable JSON), it replaces the
+ * body with a small JSON object that keeps the diagnostic essentials and
+ * records the dropped size under `_funnel_oversized`. Every stored payload
+ * therefore stays valid JSON.
+ */
+declare class SqliteConnectorDiagnosticLog extends ConnectorDiagnosticLog {
+  private readonly raw;
+  private readonly processed;
+  private readonly connection;
+  private readonly now;
+  private readonly logger;
+  constructor(props: Props);
+  recordRaw(record: ConnectorRawRecord): void;
+  recordProcessed(record: ConnectorProcessedRecord): void;
+  recordConnection(record: ConnectorConnectionRecord): void;
+  private report;
+  queryRaw(query: ConnectorRawQuery): StoredRawEvent[];
+  queryProcessed(query: ConnectorProcessedQuery): StoredProcessedEvent[];
+  queryConnection(query: ConnectorConnectionQuery): StoredConnectionEvent[];
+  clear(): void;
+  close(): void;
+}
+//#endregion
+//#region lib/engine/diagnostic-log/memory-diagnostic-log.d.ts
+/**
+ * In-process `ConnectorDiagnosticLog` backed by one array per table. Used by tests
+ * and embedders that do not need durability. Like the SQLite log it keeps
+ * `seq` per-table (each array's 1-based position) and returns the most recent
+ * `limit` rows oldest-first; unlike it, it never prunes and never offloads
+ * oversized payloads — it keeps whatever the caller hands it, which is fine
+ * for the bounded volumes a test produces. Payload-validity is therefore a
+ * SQLite-only guarantee; do not write a test that leans on this double
+ * rejecting a malformed payload.
+ */
+declare class MemoryConnectorDiagnosticLog extends ConnectorDiagnosticLog {
+  private readonly now;
+  private readonly raws;
+  private readonly processeds;
+  private readonly connections;
+  constructor(now?: () => number);
+  recordRaw(record: ConnectorRawRecord): void;
+  recordProcessed(record: ConnectorProcessedRecord): void;
+  recordConnection(record: ConnectorConnectionRecord): void;
+  queryRaw(query: ConnectorRawQuery): StoredRawEvent[];
+  queryProcessed(query: ConnectorProcessedQuery): StoredProcessedEvent[];
+  queryConnection(query: ConnectorConnectionQuery): StoredConnectionEvent[];
+  clear(): void;
+  close(): void;
+}
+//#endregion
+//#region lib/gateway/routes/index.d.ts
+/**
+ * Top-level Hono app for the gateway daemon. Mounts every HTTP endpoint flat
+ * (the WebSocket /ws upgrade is handled directly by `Bun.serve`). Deps come
+ * from the `deps` variable set by `FunnelGatewayServer`'s middleware — same
+ * shape as CLI's `c.var.funnel`.
+ */
+type GatewayApp = ReturnType<typeof buildGatewayRoutes>;
+declare function buildGatewayRoutes(): _$hono_hono_base0.HonoBase<Env, {
+  "/health": {
+    $get: {
+      input: {};
+      output: {
+        ok: true;
+        pid: number;
+        funnelDir: string;
+        clients: number;
+        listeners: {
+          channelName: string;
+          channelId: string;
+          name: string;
+          type: string;
+          alive: boolean;
+          events: number;
+          errors: number;
+          failureCount: number;
+          lastEventAt: string | null;
+        }[];
+      };
+      outputFormat: "json";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/status": {
+    $get: {
+      input: {};
+      output: {
+        ok: true;
+        pid: number;
+        funnelDir: string;
+        uptimeMs: number;
+        clients: {
+          channel: string;
+          connectors: string[];
+        }[];
+        listeners: {
+          channelName: string;
+          channelId: string;
+          name: string;
+          type: string;
+          alive: boolean;
+          events: number;
+          errors: number;
+          failureCount: number;
+          lastEventAt: string | null;
+        }[];
+        broadcaster: {
+          clients: number;
+          subscribers: number;
+          eventsBroadcast: number;
+          droppedSlowClients: number;
+          lastBroadcastAt: string | null;
+          latestOffset: number;
+          oldestReplayableOffset: number | null;
+        };
+      };
+      outputFormat: "json";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/debug": {
+    $get: {
+      input: {};
+      output: {
+        pid: number;
+        uptimeMs: number;
+        eventsBroadcast: number;
+        channels: {
+          id: string;
+          name: string;
+          connectors: string[];
+          listener: {
+            alive: boolean;
+            events: number;
+            errors: number;
+            lastEventAt: string | null;
+          } | null;
+          claudeClients: number;
+          recentEvents: {
+            seq: number | null;
+            ts: number | null;
+            type: string;
+            outcome: string;
+            payload: string | null;
+            payloadParsed: {
+              [x: string]: _$hono_utils_types0.JSONValue;
+            } | null;
+            preview: string | null;
+          }[];
+          connectionErrors: {
+            ts: number | null;
+            type: string;
+            status: string;
+            detail: string | null;
+          }[];
+          diagnosis: {
+            status: "ok" | "warn" | "error";
+            message: string;
+            nextActions: string[];
+            rootCause: string | null;
+          };
+        }[];
+      };
+      outputFormat: "json";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/listeners": {
+    $get: {
+      input: {};
+      output: {
+        listeners: {
+          channelName: string;
+          channelId: string;
+          name: string;
+          type: string;
+          alive: boolean;
+          events: number;
+          errors: number;
+          failureCount: number;
+          lastEventAt: string | null;
+        }[];
+      };
+      outputFormat: "json";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/listeners/:channel/:connector/start": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+        };
+      };
+      output: {
+        ok: boolean;
+        reason: string;
+      };
+      outputFormat: "json";
+      status: 400;
+    } | {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+        };
+      };
+      output: {
+        ok: boolean;
+        reason?: string | undefined;
+      };
+      outputFormat: "json";
+      status: 200 | 400;
+    };
+  };
+} & {
+  "/listeners/:channel/:connector": {
+    $delete: {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+        };
+      };
+      output: {
+        ok: boolean;
+        reason: string;
+      };
+      outputFormat: "json";
+      status: 400;
+    } | {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+        };
+      };
+      output: {
+        ok: boolean;
+        reason?: string | undefined;
+      };
+      outputFormat: "json";
+      status: 200 | 400;
+    };
+  };
+} & {
+  "/listeners/:channel/:connector/restart": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+        };
+      };
+      output: {
+        ok: boolean;
+        reason: string;
+      };
+      outputFormat: "json";
+      status: 400;
+    } | {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+        };
+      };
+      output: {
+        ok: boolean;
+        reason?: string | undefined;
+      };
+      outputFormat: "json";
+      status: 200 | 400;
+    };
+  };
+} & {
+  "/channels/:channel/connectors/:connector/call": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+        };
+      };
+      output: {
+        ok: boolean;
+        reason: string;
+      };
+      outputFormat: "json";
+      status: 400;
+    } | {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+        };
+      };
+      output: {
+        ok: true;
+        result: _$hono_utils_types0.JSONValue;
+      };
+      outputFormat: "json";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/publish": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+        };
+      } & {
+        json: {
+          content: string;
+          meta?: Record<string, string> | undefined;
+          connector?: string | undefined;
+          target?: string | undefined;
+        };
+      };
+      output: {
+        ok: boolean;
+        reason: string;
+      };
+      outputFormat: "json";
+      status: 400;
+    } | {
+      input: {
+        param: {
+          channel: string;
+        };
+      } & {
+        json: {
+          content: string;
+          meta?: Record<string, string> | undefined;
+          connector?: string | undefined;
+          target?: string | undefined;
+        };
+      };
+      output: {
+        ok: boolean;
+        reason: string;
+      };
+      outputFormat: "json";
+      status: 400;
+    } | {
+      input: {
+        param: {
+          channel: string;
+        };
+      } & {
+        json: {
+          content: string;
+          meta?: Record<string, string> | undefined;
+          connector?: string | undefined;
+          target?: string | undefined;
+        };
+      };
+      output: {
+        ok: true;
+        offset: number;
+      };
+      outputFormat: "json";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+}, "/", "/channels/:channel/publish">;
+//#endregion
+export { FunnelBroadcaster as A, funnelEventSchema as C, FunnelListenerSupervisor 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 };