@interactive-inc/claude-funnel 0.65.0 → 0.67.0

package/dist/channel.d.ts

@@ -0,0 +1,185 @@
+import { n as FunnelClock, t as FunnelLogger } from "./logger-mMZvblTx.js";
+import { n as FunnelFileSystem } from "./file-system-BNtl997T.js";
+import { FlumeCatchupPolicy, FlumeErrorHandler, FlumeEvent, FlumeRuntimeDeps, FlumeSource, FlumeStatePersister } from "@interactive-inc/flume";
+//#region lib/engine/channel/channel.d.ts
+/**
+ * Payload shaped for `broadcaster.broadcast(content, meta)`. A transform
+ * returning `null` means "drop" (do not broadcast)
+ */
+type ChannelBroadcastPayload = {
+  readonly content: string;
+  readonly meta?: Record<string, string>;
+};
+type ChannelTransform = (event: FlumeEvent) => ChannelBroadcastPayload | null;
+/**
+ * Narrow broadcast seam the supervisor depends on. The gateway
+ * `FunnelBroadcaster` satisfies it structurally, so the engine layer never
+ * imports from the gateway layer
+ */
+type ChannelBroadcastSink = {
+  broadcast(content: string, meta?: Record<string, string>): void;
+};
+/**
+ * What `Channel.build(ctx)` returns: the flume sources to run plus an optional
+ * transform, handed to the supervisor as one unit
+ */
+type ChannelRuntime = {
+  readonly sources: ReadonlyArray<FlumeSource>;
+  /**
+   * Converts each source's FlumeEvent into a broadcast payload. Defaults to
+   * `{ content: JSON.stringify(event.data), meta: event.meta }` when omitted
+   */
+  readonly transform?: ChannelTransform;
+};
+/**
+ * Environment passed to `Channel.build`. IO boundaries stay abstract via
+ * FunnelClock / FunnelLogger / FunnelFileSystem. `statePersister` builds a
+ * funnel-fs-backed `FlumeStatePersister<S>` scoped to the channel id
+ */
+type ChannelBuildContext = {
+  readonly channelId: string;
+  readonly channelName: string;
+  readonly signal: AbortSignal;
+  readonly logger: FunnelLogger;
+  readonly clock: FunnelClock;
+  readonly fs: FunnelFileSystem;
+  /**
+   * Reads/writes `<funnelDir>/channels/<channelId>/<filename>.json` in the
+   * `FlumeStatePersister<S>` shape flume expects
+   */
+  readonly statePersister: <S>(filename: string) => FlumeStatePersister<S>;
+};
+/**
+ * One channel = one inbound intake unit. `build` returns the sources to plug
+ * into the confluence and may be re-invoked any number of times (host abort,
+ * token rotation, ...) — treat it as a pure factory
+ */
+type Channel = {
+  readonly id: string;
+  readonly name?: string;
+  readonly build: (ctx: ChannelBuildContext) => ChannelRuntime | Promise<ChannelRuntime>;
+};
+/** Frozen identity helper that keeps consumer type inference tidy */
+declare function defineChannel(channel: Channel): Channel;
+//#endregion
+//#region lib/engine/channel/channel-supervisor.d.ts
+type Props$2 = {
+  readonly broadcaster: ChannelBroadcastSink;
+  readonly logger: FunnelLogger;
+  readonly clock: FunnelClock;
+  readonly fs: FunnelFileSystem;
+  /**
+   * Root for per-channel state files. Writes go under
+   * `<root>/channels/<channelId>/`
+   */
+  readonly dir: string;
+  readonly deps?: FlumeRuntimeDeps;
+  readonly onError?: FlumeErrorHandler;
+  /** Host abort. Once fired the supervisor closes every channel and goes inert */
+  readonly signal?: AbortSignal;
+};
+/**
+ * Maps the Channel manifest onto a single `FlumeConfluence`.
+ *
+ *  - channels accepted via `register(channel)` are `build(ctx)`-ed on `start()`
+ *    and their sources inserted with `add(channelId, sources)`
+ *  - the confluence onItem stream (tagged with groupId) is routed through the
+ *    owning channel's `transform`, then into `broadcaster.broadcast(content, meta)`
+ *  - `unregister(id)` stops one channel, `stop()` stops them all
+ *
+ * Independent from the ConnectorDescriptor system (`FunnelListenerRegistry`);
+ * the two run side-by-side so callers can migrate incrementally
+ */
+declare class FunnelChannelSupervisor {
+  private readonly props;
+  private readonly confluence;
+  private readonly registered;
+  private readonly pending;
+  private readonly opening;
+  private started;
+  private aborted;
+  constructor(props: Props$2);
+  /**
+   * Accepted before or after start (post-start registers open immediately,
+   * tracked in `opening` until settled). No-op once the host signal aborted
+   */
+  register(channel: Channel): void;
+  /** Waits for an in-flight post-start open of the same id before removing */
+  unregister(id: string): Promise<void>;
+  start(): Promise<void>;
+  stop(): Promise<void>;
+  ids(): ReadonlyArray<string>;
+  has(id: string): boolean;
+  /** Never rejects: build/add failures are logged and the channel is skipped */
+  private openChannel;
+  private buildRuntime;
+  private handleItem;
+  /** Never throws: a throwing user transform is logged and the event dropped */
+  private transformToPayload;
+}
+//#endregion
+//#region lib/engine/channel/time-channel.d.ts
+type Options = {
+  readonly id: string;
+  readonly name?: string;
+  readonly cron: string;
+  /** Default: `{ mode: "lastOnly" }` (recover only the most recent missed tick on startup) */
+  readonly catchupPolicy?: FlumeCatchupPolicy;
+  /**
+   * Converts each tick into a broadcast payload. Defaults to the equivalent of
+   * `{ content: "tick", meta: { cron, firedAt } }`
+   */
+  readonly transform?: ChannelTransform;
+  /**
+   * Whether to enable `statePersister` (default true). `false` also disables
+   * catchup
+   */
+  readonly persist?: boolean;
+};
+/**
+ * Factory for a single-cron-entry time channel.
+ *
+ * Example (inta jiho):
+ * ```ts
+ * const jiho = timeChannel({
+ *   id: "inta-jiho",
+ *   cron: "0 * * * *",
+ *   transform: (event) => ({
+ *     content: `⏰ ${new Date(event.data.firedAt as number).getHours()}時をお知らせします。`,
+ *     meta: { event_type: "schedule", source: "inta-jiho", target_role: "primary" },
+ *   }),
+ * })
+ * ```
+ *
+ * With `persist: true` (default), `lastFiredAt` is kept in `<channelDir>/time.json`
+ * and missed ticks are recovered on startup according to `catchupPolicy`
+ * (default lastOnly)
+ */
+declare function timeChannel(options: Options): Channel;
+//#endregion
+//#region lib/engine/channel/file-state-persister.d.ts
+type Props$1 = {
+  readonly fs: FunnelFileSystem;
+  readonly path: string;
+};
+/**
+ * `FlumeStatePersister` storing one JSON document per file on top of
+ * `FunnelFileSystem`. The target directory is created recursively before save.
+ * load returns `null` when the file is absent, empty, or unparsable (flume
+ * then treats the source as first-run)
+ */
+declare function createFileStatePersister<S>(props: Props$1): FlumeStatePersister<S>;
+//#endregion
+//#region lib/engine/channel/channel-state-persister-factory.d.ts
+type Props = {
+  readonly fs: FunnelFileSystem;
+  /** Absolute path of `<funnelDir>/channels/<channelId>` */
+  readonly channelDir: string;
+};
+/**
+ * Per-channel state persister factory: `statePersister<S>("time")` returns a
+ * persister bound to `<channelDir>/time.json`
+ */
+declare function createChannelStatePersisterFactory(props: Props): <S>(filename: string) => FlumeStatePersister<S>;
+//#endregion
+export { type Channel, type ChannelBroadcastPayload, type ChannelBroadcastSink, type ChannelBuildContext, type ChannelRuntime, type ChannelTransform, FunnelChannelSupervisor, createChannelStatePersisterFactory, createFileStatePersister, defineChannel, timeChannel };

package/dist/channel.js

@@ -0,0 +1,238 @@
+import { dirname, join } from "node:path";
+import { FlumeConfluence } from "@interactive-inc/flume";
+import { FlumeTimeSource } from "@interactive-inc/flume/time";
+//#region lib/engine/channel/channel.ts
+/** Frozen identity helper that keeps consumer type inference tidy */
+function defineChannel(channel) {
+	return Object.freeze({ ...channel });
+}
+//#endregion
+//#region lib/engine/channel/file-state-persister.ts
+/**
+* `FlumeStatePersister` storing one JSON document per file on top of
+* `FunnelFileSystem`. The target directory is created recursively before save.
+* load returns `null` when the file is absent, empty, or unparsable (flume
+* then treats the source as first-run)
+*/
+function createFileStatePersister(props) {
+	return {
+		async load() {
+			if (!props.fs.existsSync(props.path)) return null;
+			const raw = props.fs.readFileSync(props.path);
+			if (raw === "") return null;
+			try {
+				return JSON.parse(raw);
+			} catch {
+				return null;
+			}
+		},
+		async save(state) {
+			const dir = dirname(props.path);
+			if (!props.fs.existsSync(dir)) props.fs.mkdirSync(dir, { recursive: true });
+			props.fs.writeFileSync(props.path, JSON.stringify(state));
+		}
+	};
+}
+//#endregion
+//#region lib/engine/channel/channel-state-persister-factory.ts
+/**
+* Per-channel state persister factory: `statePersister<S>("time")` returns a
+* persister bound to `<channelDir>/time.json`
+*/
+function createChannelStatePersisterFactory(props) {
+	return (filename) => createFileStatePersister({
+		fs: props.fs,
+		path: join(props.channelDir, `${filename}.json`)
+	});
+}
+//#endregion
+//#region lib/engine/channel/channel-supervisor.ts
+/**
+* Maps the Channel manifest onto a single `FlumeConfluence`.
+*
+*  - channels accepted via `register(channel)` are `build(ctx)`-ed on `start()`
+*    and their sources inserted with `add(channelId, sources)`
+*  - the confluence onItem stream (tagged with groupId) is routed through the
+*    owning channel's `transform`, then into `broadcaster.broadcast(content, meta)`
+*  - `unregister(id)` stops one channel, `stop()` stops them all
+*
+* Independent from the ConnectorDescriptor system (`FunnelListenerRegistry`);
+* the two run side-by-side so callers can migrate incrementally
+*/
+var FunnelChannelSupervisor = class {
+	props;
+	confluence;
+	registered = /* @__PURE__ */ new Map();
+	pending = /* @__PURE__ */ new Map();
+	opening = /* @__PURE__ */ new Map();
+	started = false;
+	aborted = false;
+	constructor(props) {
+		this.props = props;
+		this.confluence = new FlumeConfluence({
+			onEvent: (item) => this.handleItem(item),
+			onError: props.onError,
+			deps: props.deps
+		});
+		if (props.signal) if (props.signal.aborted) this.aborted = true;
+		else {
+			const onAbort = () => {
+				this.aborted = true;
+				this.stop().catch(() => {});
+			};
+			props.signal.addEventListener("abort", onAbort, { once: true });
+		}
+	}
+	/**
+	* Accepted before or after start (post-start registers open immediately,
+	* tracked in `opening` until settled). No-op once the host signal aborted
+	*/
+	register(channel) {
+		if (this.aborted) return;
+		if (this.has(channel.id)) throw new Error(`FunnelChannelSupervisor: channel id already registered: ${channel.id}`);
+		if (!this.started) {
+			this.pending.set(channel.id, channel);
+			return;
+		}
+		const open = this.openChannel(channel).finally(() => {
+			this.opening.delete(channel.id);
+		});
+		this.opening.set(channel.id, open);
+	}
+	/** Waits for an in-flight post-start open of the same id before removing */
+	async unregister(id) {
+		this.pending.delete(id);
+		const open = this.opening.get(id);
+		if (open) await open;
+		const entry = this.registered.get(id);
+		if (!entry) return;
+		this.registered.delete(id);
+		entry.abortController.abort();
+		await this.confluence.remove(id);
+	}
+	async start() {
+		if (this.started || this.aborted) return;
+		this.started = true;
+		const channels = [...this.pending.values()];
+		this.pending.clear();
+		for (const channel of channels) await this.openChannel(channel);
+	}
+	async stop() {
+		this.started = false;
+		this.pending.clear();
+		await Promise.all(this.opening.values());
+		for (const entry of this.registered.values()) entry.abortController.abort();
+		this.registered.clear();
+		await this.confluence.closeAll();
+	}
+	ids() {
+		return [...this.registered.keys()];
+	}
+	has(id) {
+		return this.registered.has(id) || this.pending.has(id) || this.opening.has(id);
+	}
+	/** Never rejects: build/add failures are logged and the channel is skipped */
+	async openChannel(channel) {
+		const abortController = new AbortController();
+		const runtime = await this.buildRuntime(channel, abortController.signal);
+		if (runtime instanceof Error) {
+			this.props.logger.error(`channel "${channel.id}" failed to build`, { error: runtime.message });
+			abortController.abort();
+			return;
+		}
+		const result = await this.confluence.add(channel.id, runtime.sources);
+		if (result instanceof Error) {
+			this.props.logger.error(`channel "${channel.id}" failed to start`, { error: result.message });
+			abortController.abort();
+			return;
+		}
+		this.registered.set(channel.id, {
+			channel,
+			runtime,
+			abortController
+		});
+	}
+	async buildRuntime(channel, signal) {
+		const channelDir = join(this.props.dir, "channels", channel.id);
+		try {
+			return await channel.build({
+				channelId: channel.id,
+				channelName: channel.name ?? channel.id,
+				signal,
+				logger: this.props.logger,
+				clock: this.props.clock,
+				fs: this.props.fs,
+				statePersister: createChannelStatePersisterFactory({
+					fs: this.props.fs,
+					channelDir
+				})
+			});
+		} catch (error) {
+			return error instanceof Error ? error : new Error(String(error));
+		}
+	}
+	handleItem(item) {
+		if (item.kind !== "event") return;
+		const entry = this.registered.get(item.groupId);
+		if (!entry) return;
+		const payload = this.transformToPayload(entry, item.event);
+		if (payload === null) return;
+		this.props.broadcaster.broadcast(payload.content, payload.meta);
+	}
+	/** Never throws: a throwing user transform is logged and the event dropped */
+	transformToPayload(entry, event) {
+		const transform = entry.runtime.transform;
+		if (transform === void 0) return {
+			content: JSON.stringify(event.data),
+			meta: event.meta
+		};
+		try {
+			return transform(event);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			this.props.logger.error(`channel "${entry.channel.id}" transform threw`, { error: message });
+			return null;
+		}
+	}
+};
+//#endregion
+//#region lib/engine/channel/time-channel.ts
+/**
+* Factory for a single-cron-entry time channel.
+*
+* Example (inta jiho):
+* ```ts
+* const jiho = timeChannel({
+*   id: "inta-jiho",
+*   cron: "0 * * * *",
+*   transform: (event) => ({
+*     content: `⏰ ${new Date(event.data.firedAt as number).getHours()}時をお知らせします。`,
+*     meta: { event_type: "schedule", source: "inta-jiho", target_role: "primary" },
+*   }),
+* })
+* ```
+*
+* With `persist: true` (default), `lastFiredAt` is kept in `<channelDir>/time.json`
+* and missed ticks are recovered on startup according to `catchupPolicy`
+* (default lastOnly)
+*/
+function timeChannel(options) {
+	const persist = options.persist ?? true;
+	const catchupPolicy = options.catchupPolicy ?? { mode: "lastOnly" };
+	return defineChannel({
+		id: options.id,
+		name: options.name ?? options.id,
+		build: (ctx) => {
+			return {
+				sources: [new FlumeTimeSource({
+					cron: options.cron,
+					statePersister: persist ? ctx.statePersister("time") : void 0,
+					catchupPolicy: persist ? catchupPolicy : { mode: "off" }
+				})],
+				transform: options.transform
+			};
+		}
+	});
+}
+//#endregion
+export { FunnelChannelSupervisor, createChannelStatePersisterFactory, createFileStatePersister, defineChannel, timeChannel };

package/dist/{channels-CRGb6B5_.d.ts → channels-BBA3GTAa.d.ts}

@@ -1,8 +1,8 @@
-import { n as ChannelDeliveryMode, t as ChannelConfig } from "./settings-schema-BL_c2Udm.js";
-import { n as FunnelIdGenerator, t as FunnelSettingsReader } from "./settings-reader-BNxjsxCB.js";
-import { B as FunnelProcessRunner, I as BaseConnectorConfig, N as CallInput, P as FunnelConnectorAdapter, W as FunnelLogger, _ as ConnectorDiagnosticLog, c as FunnelClock, j as FunnelConnectorListener, l as FunnelHttpClient, n as ConnectorBuildContext, o as ConnectorOperationContext, r as ConnectorDescriptor, s as ConnectorUpdateContext } from "./connector-descriptor-BFIhyTfa.js";
-import { n as FunnelFileSystem } from "./file-system-VhwwXZbm.js";
-
+import { n as FunnelClock, t as FunnelLogger } from "./logger-mMZvblTx.js";
+import { n as FunnelFileSystem } from "./file-system-BNtl997T.js";
+import { n as ChannelDeliveryMode, t as ChannelConfig } from "./settings-schema-B-CKLuST.js";
+import { n as FunnelIdGenerator, t as FunnelSettingsReader } from "./settings-reader-CyTpbAre.js";
+import { A as FunnelConnectorListener, F as BaseConnectorConfig, M as CallInput, N as FunnelConnectorAdapter, c as FunnelHttpClient, g as ConnectorDiagnosticLog, n as ConnectorBuildContext, o as ConnectorOperationContext, r as ConnectorDescriptor, s as ConnectorUpdateContext, z as FunnelProcessRunner } from "./connector-descriptor-F75ZI8Fh.js";
 //#region lib/engine/connectors/connector-registry.d.ts
 type Deps$1 = {
   /** Connector types this funnel handles. Each is a self-describing descriptor;

package/dist/claude.d.ts

@@ -1,8 +1,7 @@
-import { a as ProcessGuard, c as ChannelResolver, i as SessionStore, n as FunnelClaude, o as McpInstaller, r as LaunchOptions, s as GatewayController, t as FunnelFileProcessGuard } from "./file-process-guard-tVcgckH6.js";
-import { r as ConnectorDescriptor } from "./connector-descriptor-BFIhyTfa.js";
-import { n as FunnelFileSystem } from "./file-system-VhwwXZbm.js";
-import { t as FunnelProfiles } from "./profiles-cVZQkM69.js";
-
+import { n as FunnelFileSystem } from "./file-system-BNtl997T.js";
+import { a as ProcessGuard, c as ChannelResolver, i as SessionStore, n as FunnelClaude, o as McpInstaller, r as LaunchOptions, s as GatewayController, t as FunnelFileProcessGuard } from "./file-process-guard-DAYe9Ndt.js";
+import { r as ConnectorDescriptor } from "./connector-descriptor-F75ZI8Fh.js";
+import { t as FunnelProfiles } from "./profiles-CePRnv3F.js";
 //#region lib/engine/mcp/mcp.d.ts
 declare const FUNNEL_MCP_COMMAND = "bun";
 declare const FUNNEL_MCP_ARGS: string[];
@@ -35,9 +34,13 @@ declare class FunnelMcp {
 //#endregion
 //#region lib/engine/mcp/channel-server.d.ts
 type ChannelServerOptions = {
-  /** Funnel home directory (settings.json + gateway.token). Defaults to ~/.funnel. */dir?: string; /** Gateway base URL. Defaults to `$FUNNEL_GATEWAY_URL` or `http://127.0.0.1:<port>`. */
-  gatewayUrl?: string; /** Channel id to subscribe to. Defaults to `$FUNNEL_CHANNEL_ID`. */
-  channelId?: string; /** Auth token. Defaults to `$FUNNEL_GATEWAY_TOKEN` then `<dir>/gateway.token`. */
+  /** Funnel home directory (settings.json + gateway.token). Defaults to ~/.funnel. */
+  dir?: string;
+  /** Gateway base URL. Defaults to `$FUNNEL_GATEWAY_URL` or `http://127.0.0.1:<port>`. */
+  gatewayUrl?: string;
+  /** Channel id to subscribe to. Defaults to `$FUNNEL_CHANNEL_ID`. */
+  channelId?: string;
+  /** Auth token. Defaults to `$FUNNEL_GATEWAY_TOKEN` then `<dir>/gateway.token`. */
   token?: string;
   /** Connector descriptors whose tools this MCP server exposes. Defaults to the
    *  four built-in connectors; the tool-exposed subset is derived from them. */

package/dist/claude.js

@@ -1,13 +1,13 @@
-import { n as gatewayLoopbackUrl, t as loopbackFetch } from "./loopback-fetch-CVNuN3YZ.js";
-import { f as settingsSchema, s as resolveFunnelPort } from "./settings-store-ccv291GV.js";
-import { a as FunnelMcp, i as FUNNEL_MCP_NAME, n as FUNNEL_MCP_ARGS, o as FunnelFileProcessGuard, r as FUNNEL_MCP_COMMAND, s as FunnelClaude, t as renderYaml } from "./yaml-render-DVEtYuF1.js";
-import { t as errorMessageOf } from "./error-message-of-ColuYmAk.js";
-import { t as FunnelDocs } from "./funnel-docs-C-ge0MuB.js";
-import { t as FunnelProfiles } from "./profiles-ZHLONml4.js";
-import { t as discordConnector } from "./discord-connector-DXARcO6w.js";
-import { t as ghConnector } from "./gh-connector-BUGCOEWS.js";
-import { t as scheduleConnector } from "./schedule-connector-9k3gOIgl.js";
-import { t as slackConnector } from "./slack-connector-CxpWagbT.js";
+import { n as gatewayLoopbackUrl, t as loopbackFetch } from "./loopback-fetch-HP-bo9Kv.js";
+import { f as settingsSchema, s as resolveFunnelPort } from "./settings-store-ZFWBhOnp.js";
+import { a as FunnelMcp, i as FUNNEL_MCP_NAME, n as FUNNEL_MCP_ARGS, o as FunnelFileProcessGuard, r as FUNNEL_MCP_COMMAND, s as FunnelClaude, t as renderYaml } from "./yaml-render-DxxRQT-V.js";
+import { t as FunnelProfiles } from "./profiles-KpN7_gBw.js";
+import { t as errorMessageOf } from "./error-message-of-BG4ezZ_s.js";
+import { t as FunnelDocs } from "./funnel-docs-BFcqITFA.js";
+import { t as discordConnector } from "./discord-connector-CdjwPoty.js";
+import { t as ghConnector } from "./gh-connector-D-iyjl-d.js";
+import { t as scheduleConnector } from "./schedule-connector-teeDMHUe.js";
+import { t as slackConnector } from "./slack-connector-BE0KAjCs.js";
 import { join } from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
@@ -506,11 +506,14 @@ const MAX_RECONNECT_DELAY = 1e4;
 * Reconnects with exponential backoff and replays missed events via `?since=<offset>`.
 */
 var FunnelChannelSubscriber = class {
+	props;
 	state = {
 		reconnectDelay: RECONNECT_DELAY,
 		lastOffset: 0,
 		isStarted: false,
-		hasPendingReconnect: false
+		hasPendingReconnect: false,
+		hasDeliveryFailure: false,
+		messageQueue: Promise.resolve()
 	};
 	constructor(props) {
 		this.props = props;
@@ -529,14 +532,17 @@ var FunnelChannelSubscriber = class {
 			this.state.reconnectDelay = RECONNECT_DELAY;
 			process.stderr.write(`funnel: connected (${wsUrl})\n`);
 		});
-		ws.addEventListener("message", (event) => this.handleMessage(event));
+		ws.addEventListener("message", (event) => this.enqueueMessage(event, ws));
 		ws.addEventListener("close", () => {
 			if (this.state.hasPendingReconnect) return;
 			this.state.hasPendingReconnect = true;
 			process.stderr.write(`funnel: disconnected, reconnecting in ${this.state.reconnectDelay}ms\n`);
 			setTimeout(() => {
-				this.state.hasPendingReconnect = false;
-				this.connect();
+				this.state.messageQueue.then(() => {
+					this.state.hasPendingReconnect = false;
+					this.state.hasDeliveryFailure = false;
+					this.connect();
+				});
 			}, this.state.reconnectDelay);
 			this.state.reconnectDelay = Math.min(this.state.reconnectDelay * 2, MAX_RECONNECT_DELAY);
 		});
@@ -545,12 +551,19 @@ var FunnelChannelSubscriber = class {
 			process.stderr.write(`funnel: ws error: ${reason}\n`);
 		});
 	}
+	enqueueMessage(event, socket) {
+		this.state.messageQueue = this.state.messageQueue.then(async () => {
+			if (this.state.hasDeliveryFailure) return;
+			if (await this.handleMessage(event)) return;
+			this.state.hasDeliveryFailure = true;
+			socket?.close();
+		});
+	}
 	async handleMessage(event) {
 		try {
 			const payload = JSON.parse(String(event.data));
 			const eventType = payload.meta?.event_type ?? "unknown";
 			const offset = typeof payload.offset === "number" ? payload.offset : null;
-			if (offset !== null && offset > this.state.lastOffset) this.state.lastOffset = offset;
 			process.stderr.write(`funnel: received event (${eventType})\n`);
 			await this.props.server.notification({
 				method: "notifications/claude/channel",
@@ -559,8 +572,11 @@ var FunnelChannelSubscriber = class {
 					meta: payload.meta
 				}
 			});
+			if (offset !== null && offset > this.state.lastOffset) this.state.lastOffset = offset;
+			return true;
 		} catch (error) {
 			process.stderr.write(`funnel: error handling ws message (offset=${this.state.lastOffset}): ${errorMessageOf(error)}\n`);
+			return false;
 		}
 	}
 };