@interactive-inc/claude-funnel 0.60.1 → 0.64.0

package/dist/gateway.d.ts

@@ -1,3 +1,3 @@
-import { C as StoredRawEvent, E as connectorRawEventSchema, S as StoredProcessedEvent, T as connectorProcessedEventSchema, _ as ConnectorQuery, b as ConnectorRawRecord, c as CONNECTOR_CONNECTION_STATUSES, d as ConnectorConnectionRecord, f as ConnectorConnectionStatus, g as ConnectorProcessedRecord, h as ConnectorProcessedQuery, l as ConnectorConnectionEvent, m as ConnectorProcessedEvent, p as ConnectorDiagnosticLog, u as ConnectorConnectionQuery, v as ConnectorRawEvent, w as connectorConnectionEventSchema, x as StoredConnectionEvent, y as ConnectorRawQuery } from "./connector-descriptor-6SXJoszo.js";
-import { A as FunnelBroadcaster, C as funnelEventSchema, D as FunnelListenerSupervisor, 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-CgY8NdMz.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, FunnelListenerSupervisor, 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 };
+import { A as connectorRawEventSchema, C as ConnectorRawQuery, D as StoredRawEvent, E as StoredProcessedEvent, O as connectorConnectionEventSchema, S as ConnectorRawEvent, T as StoredConnectionEvent, _ as ConnectorDiagnosticLog, b as ConnectorProcessedRecord, f as CONNECTOR_CONNECTION_STATUSES, g as ConnectorConnectionStatus, h as ConnectorConnectionRecord, k as connectorProcessedEventSchema, m as ConnectorConnectionQuery, p as ConnectorConnectionEvent, v as ConnectorProcessedEvent, w as ConnectorRawRecord, x as ConnectorQuery, y as ConnectorProcessedQuery } from "./connector-descriptor-BFIhyTfa.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-Ds6sHhA-.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 { t as gatewayLoopbackUrl } from "./gateway-base-url-Dy4Ykuoh.js";
-import { S as publishResponseSchema, _ as funnelEventSchema, a as connectorConnectionEventSchema, b as FunnelChannelPublisher, c as MemoryFunnelEventLog, d as DEFAULT_GATEWAY_TOKEN_PATH, f as FunnelGatewayToken, g as FunnelEventLog, h as SqliteFunnelEventLog, i as ConnectorDiagnosticLog, l as channelWsProtocols, m as FunnelListenerSupervisor, n as SqliteConnectorDiagnosticLog, o as connectorProcessedEventSchema, p as FunnelGatewayServer, r as CONNECTOR_CONNECTION_STATUSES, s as connectorRawEventSchema, t as MemoryConnectorDiagnosticLog, u as channelWsUrl, v as FunnelBroadcaster, x as publishRequestSchema } from "./memory-diagnostic-log-CI60kNfB.js";
-export { CONNECTOR_CONNECTION_STATUSES, ConnectorDiagnosticLog, DEFAULT_GATEWAY_TOKEN_PATH, FunnelBroadcaster, FunnelChannelPublisher, FunnelEventLog, FunnelGatewayServer, FunnelGatewayToken, FunnelListenerSupervisor, MemoryConnectorDiagnosticLog, MemoryFunnelEventLog, SqliteConnectorDiagnosticLog, SqliteFunnelEventLog, channelWsProtocols, channelWsUrl, connectorConnectionEventSchema, connectorProcessedEventSchema, connectorRawEventSchema, funnelEventSchema, gatewayLoopbackUrl, publishRequestSchema, publishResponseSchema };
+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-DOTPW-tG.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

@@ -0,0 +1,187 @@
+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 { FlumeGitHubSource } from "@interactive-inc/flume/github";
+//#region lib/engine/connectors/gh-adapter.ts
+const defaultProcess$1 = new NodeFunnelProcessRunner();
+var FunnelGhAdapter = class extends FunnelConnectorAdapter {
+	process;
+	constructor(deps = {}) {
+		super();
+		this.process = deps.process ?? defaultProcess$1;
+		Object.freeze(this);
+	}
+	async call(input) {
+		const args = ["api", input.path];
+		if (input.method && input.method.toLowerCase() !== "get") args.push("-X", input.method.toUpperCase());
+		const hasBody = input.body && typeof input.body === "object" && Object.keys(input.body).length > 0;
+		if (hasBody) args.push("--input", "-");
+		const result = await this.process.run(["gh", ...args], { input: hasBody ? JSON.stringify(input.body) : void 0 });
+		if (result.exitCode !== 0) throw new Error(`gh api failed: ${result.stderr.trim() || result.stdout.trim()}`);
+		try {
+			return JSON.parse(result.stdout);
+		} catch {
+			return result.stdout;
+		}
+	}
+};
+//#endregion
+//#region lib/engine/connectors/gh-flume-listener.ts
+const defaultProcess = new NodeFunnelProcessRunner();
+/**
+* GitHub listener backed by `@interactive-inc/flume`'s `FlumeGitHubSource`
+* (raw REST polling of `/notifications` + Zod).
+*
+* Token resolution order mirrors the other connectors' literal-or-env-ref
+* slot, with a `gh auth token` fallback as the convenience path:
+*
+*   1. `config.token` (literal)
+*   2. `config.tokenEnv` (env var name → value)
+*   3. `gh auth token` (reuses the `gh` CLI's authenticated session)
+*
+* The adapter still uses `gh api` for outbound calls, so when the fallback
+* is in use the auth model is unchanged end-to-end.
+*/
+var FunnelFlumeGhListener = class extends FunnelFlumeSourceListener {
+	config;
+	env;
+	process;
+	flumeDeps;
+	signal;
+	constructor(deps) {
+		super({
+			type: "gh",
+			connectorId: deps.config.id,
+			channelId: deps.channelId ?? null,
+			logger: deps.logger,
+			diagnosticLog: deps.diagnosticLog
+		});
+		this.config = deps.config;
+		this.env = deps.env ?? process.env;
+		this.process = deps.process ?? defaultProcess;
+		this.flumeDeps = deps.flumeDeps ?? {};
+		this.signal = deps.signal;
+	}
+	async start(notify) {
+		this.diagnostics.recordConnection("started", "");
+		let token;
+		try {
+			token = await this.resolveToken();
+		} catch (error) {
+			this.diagnostics.recordConnection("auth-failed", errorMessageOf(error));
+			throw error;
+		}
+		const source = new FlumeGitHubSource({
+			token,
+			pollInterval: this.config.pollInterval ?? 60
+		});
+		await this.runStart({
+			source,
+			onLog: flumeLogHandler(this.logger),
+			deps: resolveFlumeDeps(this.flumeDeps),
+			signal: this.signal,
+			onEvent: (event) => {
+				if (event.source !== "github") return Promise.resolve();
+				return this.handleEvent(event, notify);
+			}
+		});
+	}
+	async resolveToken() {
+		if (this.config.token) return this.config.token;
+		if (this.config.tokenEnv) {
+			const fromEnv = this.env[this.config.tokenEnv];
+			if (typeof fromEnv === "string" && fromEnv !== "") return fromEnv;
+			throw new Error(`${this.config.name}.token references env var "${this.config.tokenEnv}" but it is not set`);
+		}
+		const result = await this.process.run([
+			"gh",
+			"auth",
+			"token"
+		]);
+		if (result.exitCode !== 0) throw new Error(`gh auth token failed: ${result.stderr.trim() || result.stdout.trim()}`);
+		return result.stdout.trim();
+	}
+	async handleEvent(event, notify) {
+		const eventId = event.data.id;
+		const rawJson = JSON.stringify(event.data);
+		this.diagnostics.recordRaw(eventId, rawJson);
+		const meta = {
+			...event.meta,
+			event_type: "gh",
+			subject_url: event.data.subject.url ?? "",
+			updated_at: event.data.updated_at
+		};
+		await this.deliver(notify, eventId, rawJson, meta);
+	}
+	async deliver(notify, eventId, content, meta) {
+		try {
+			await notify(content, meta);
+		} catch (error) {
+			this.diagnostics.recordProcessed(eventId, "emitted:delivery-failed", content);
+			this.logger?.error("gh notify error", { error: errorMessageOf(error) });
+			return;
+		}
+		this.diagnostics.recordProcessed(eventId, "emitted", content);
+	}
+};
+//#endregion
+//#region lib/engine/connectors/gh-connector.ts
+/**
+* GitHub connector descriptor. Pass `ghConnector()` to
+* `new Funnel({ connectors: [...] })` to enable the type.
+*
+* The listener is backed by `@interactive-inc/flume`'s `FlumeGitHubSource`
+* (raw REST polling + Zod), authenticating with a token resolved from the
+* environment or `gh auth token`. The adapter still uses `gh api` for
+* outbound calls, so the auth model is unchanged end-to-end.
+*/
+const ghConnector = () => ({
+	type: "gh",
+	toolExposed: true,
+	createListener(config, deps) {
+		return new FunnelFlumeGhListener({
+			config: ghConnectorSchema.parse(config),
+			channelId: deps.channelId,
+			process: deps.process,
+			logger: deps.logger,
+			diagnosticLog: deps.diagnosticLog,
+			signal: deps.signal
+		});
+	},
+	createAdapter(config, deps) {
+		ghConnectorSchema.parse(config);
+		return new FunnelGhAdapter({ process: deps.process });
+	},
+	secretTokens(config) {
+		return [ghConnectorSchema.parse(config).token].filter((token) => token !== void 0);
+	},
+	buildConfig(input, context) {
+		return ghConnectorSchema.parse({
+			id: context.id,
+			type: "gh",
+			name: input.name,
+			...typeof input.pollInterval === "number" ? { pollInterval: input.pollInterval } : {},
+			...typeof input.token === "string" ? { token: input.token } : {},
+			...typeof input.tokenEnv === "string" ? { tokenEnv: input.tokenEnv } : {},
+			createdAt: context.now,
+			updatedAt: context.now
+		});
+	},
+	applyUpdate(config, fields, context) {
+		const current = ghConnectorSchema.parse(config);
+		return ghConnectorSchema.parse({
+			id: current.id,
+			name: current.name,
+			type: "gh",
+			pollInterval: typeof fields.pollInterval === "number" ? fields.pollInterval : current.pollInterval,
+			createdAt: current.createdAt,
+			updatedAt: context.now,
+			...slotFields("token", "tokenEnv", fields, current)
+		});
+	},
+	operations: {}
+});
+//#endregion
+export { FunnelFlumeGhListener as n, FunnelGhAdapter as r, ghConnector as t };

package/dist/{gh-connector-schema-Rzwc1c1N.js → gh-connector-schema-CAqIhzGr.js}

@@ -5,6 +5,13 @@ const ghConnectorSchema = z.object({
 	name: z.string(),
 	type: z.literal("gh"),
 	pollInterval: z.number().int().positive().optional(),
+	/**
+	* Explicit PAT/OAuth token. When neither this nor `tokenEnv` is set, the
+	* listener falls back to `gh auth token`, reusing the `gh` CLI's session.
+	*/
+	token: z.string().optional(),
+	/** Name of an env var to read the token from at start time. */
+	tokenEnv: z.string().optional(),
 	createdAt: z.string().datetime().optional(),
 	updatedAt: z.string().datetime().optional()
 });

package/dist/gh-connector-schema-DWQaB6gX.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+
+//#region lib/engine/connectors/gh-connector-schema.d.ts
+declare const ghConnectorSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  type: z.ZodLiteral<"gh">;
+  pollInterval: z.ZodOptional<z.ZodNumber>;
+  token: z.ZodOptional<z.ZodString>;
+  tokenEnv: z.ZodOptional<z.ZodString>;
+  createdAt: z.ZodOptional<z.ZodString>;
+  updatedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GhConnectorConfig = z.infer<typeof ghConnectorSchema>;
+//#endregion
+export { ghConnectorSchema as n, GhConnectorConfig as t };

package/dist/{index-CgY8NdMz.d.ts → index-Ds6sHhA-.d.ts}

@@ -1,6 +1,6 @@
-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 { B as FunnelProcessRunner, C as ConnectorRawQuery, D as StoredRawEvent, E as StoredProcessedEvent, I as BaseConnectorConfig, T as StoredConnectionEvent, W as FunnelLogger, _ as ConnectorDiagnosticLog, b as ConnectorProcessedRecord, c as FunnelClock, h as ConnectorConnectionRecord, j as FunnelConnectorListener, m as ConnectorConnectionQuery, w as ConnectorRawRecord, y as ConnectorProcessedQuery } from "./connector-descriptor-BFIhyTfa.js";
+import { n as FunnelFileSystem } from "./file-system-VhwwXZbm.js";
+import { n as ChannelConnectorView, r as FunnelChannels } from "./channels-CRGb6B5_.js";
 import { z } from "zod";
 import { Hono } from "hono";
 import { ServerWebSocket } from "bun";
@@ -142,7 +142,7 @@ declare class FunnelBroadcaster {
   seedLatestOffset(offset: number): void;
 }
 //#endregion
-//#region lib/gateway/listener-supervisor.d.ts
+//#region lib/gateway/listener-registry.d.ts
 type ConnectorRegistry = {
   listAllConnectors(): ChannelConnectorView[];
   createListener(channelName: string, connectorName: string): {
@@ -151,10 +151,10 @@ type ConnectorRegistry = {
     listener: FunnelConnectorListener;
   } | null;
 };
-type SupervisorNotify = (channelName: string, connectorName: string, content: string, meta?: Record<string, string>) => Promise<void>;
+type ListenerRegistryNotify = (channelName: string, connectorName: string, content: string, meta?: Record<string, string>) => Promise<void>;
 type Deps$3 = {
   channels: ConnectorRegistry;
-  notify: SupervisorNotify;
+  notify: ListenerRegistryNotify;
   logger?: FunnelLogger; /** Host hook for surfacing listener lifecycle exceptions. Defaults to no-op. */
   onError?: OnFunnelError;
   healthCheckIntervalMs?: number;
@@ -189,13 +189,14 @@ type ListenerEntryStatus = {
  * dead listeners with exponential backoff (1s, 2s, 4s, ... capped). Resets
  * the backoff counter on successful restart.
  */
-declare class FunnelListenerSupervisor {
+declare class FunnelListenerRegistry {
   private readonly channels;
   private readonly notify;
   private readonly logger;
   private readonly onError;
   private readonly running;
   private readonly failureCounts;
+  private readonly starting;
   private readonly stats;
   private readonly healthCheckIntervalMs;
   private readonly maxBackoffMs;
@@ -213,14 +214,18 @@ declare class FunnelListenerSupervisor {
   start(channelName: string, connectorName: string): Promise<{
     ok: boolean;
     reason?: string;
+    retriable?: boolean;
   }>;
+  private startLocked;
   stop(channelName: string, connectorName: string): Promise<{
     ok: boolean;
     reason?: string;
+    retriable?: boolean;
   }>;
   restart(channelName: string, connectorName: string): Promise<{
     ok: boolean;
     reason?: string;
+    retriable?: boolean;
   }>;
   startAll(): Promise<void>;
   stopAll(): Promise<void>;
@@ -232,6 +237,7 @@ declare class FunnelListenerSupervisor {
   /** Run one health-check pass synchronously. Test-only seam. */
   runHealthCheckForTest(): Promise<void>;
   private runHealthCheck;
+  private attemptRetry;
   private recoverDead;
 }
 //#endregion
@@ -248,7 +254,7 @@ type GatewayRouteDeps = {
    *  daemon answering on a shared port belongs to the expected repo/scope. */
   dir: string;
   broadcaster: FunnelBroadcaster;
-  supervisor: FunnelListenerSupervisor;
+  registry: FunnelListenerRegistry;
   channels: FunnelChannels;
   uptimeMs: () => number;
   emit: (input: GatewayEmitInput) => {
@@ -357,7 +363,7 @@ type Deps$2 = GatewayEventStore & {
 };
 /**
  * In-process gateway: runs `Bun.serve` (HTTP + WebSocket /ws), boots connector
- * listeners through `FunnelListenerSupervisor`, fans events out via
+ * listeners through `FunnelListenerRegistry`, 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
@@ -380,11 +386,13 @@ declare class FunnelGatewayServer {
   private readonly allowInsecureHost;
   private readonly broadcaster;
   private readonly eventLog;
-  private readonly supervisor;
+  private readonly registry;
   private readonly nowMs;
   private readonly extraRoutes;
+  private readonly ownsEventLog;
   private startedAt;
   private server;
+  private disposed;
   constructor(deps: Deps$2);
   /**
    * The resolved listen port: the live Bun server's port once started (so
@@ -403,7 +411,7 @@ declare class FunnelGatewayServer {
     }[];
   };
   getBroadcaster(): FunnelBroadcaster;
-  getSupervisor(): FunnelListenerSupervisor;
+  getRegistry(): FunnelListenerRegistry;
   getEventLog(): FunnelEventLog;
   /**
    * Register an in-process observer for every broadcast event. Fires after
@@ -517,12 +525,12 @@ declare class FunnelGatewayToken {
   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.
+   * Returns the existing token or, if missing, generates one and writes it
+   * with mode 0600. Read+write runs inside an exclusive lock so two
+   * concurrent `ensure()` calls (a daemon spawn racing a CLI helper that
+   * reads the token before the gateway PID lock is acquired) cannot each
+   * persist a different token and leave one side authenticating against a
+   * value the other never sees.
    */
   ensure(): string;
   getPath(): string;
@@ -582,7 +590,13 @@ declare class FunnelChannelPublisher {
 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. */
+  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. */
@@ -609,6 +623,7 @@ declare class SqliteFunnelEventLog extends FunnelEventLog {
   private readonly sink;
   private readonly now;
   private readonly logger;
+  private readonly onError;
   constructor(props: Props$1);
   /**
    * Persist a broadcaster-driven event with its assigned offset. Caller
@@ -896,6 +911,7 @@ declare function buildGatewayRoutes(): _$hono_hono_base0.HonoBase<Env, {
       output: {
         ok: boolean;
         reason?: string | undefined;
+        retriable?: boolean | undefined;
       };
       outputFormat: "json";
       status: 200 | 400;
@@ -926,6 +942,7 @@ declare function buildGatewayRoutes(): _$hono_hono_base0.HonoBase<Env, {
       output: {
         ok: boolean;
         reason?: string | undefined;
+        retriable?: boolean | undefined;
       };
       outputFormat: "json";
       status: 200 | 400;
@@ -956,6 +973,7 @@ declare function buildGatewayRoutes(): _$hono_hono_base0.HonoBase<Env, {
       output: {
         ok: boolean;
         reason?: string | undefined;
+        retriable?: boolean | undefined;
       };
       outputFormat: "json";
       status: 200 | 400;
@@ -1054,4 +1072,4 @@ declare function buildGatewayRoutes(): _$hono_hono_base0.HonoBase<Env, {
   };
 }, "/", "/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 };
+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 };