@interactive-inc/claude-funnel 0.64.2 → 0.66.0

package/dist/broadcaster-DVNcw00K.d.ts

@@ -0,0 +1,138 @@
+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 };

package/dist/channel.d.ts

@@ -0,0 +1,161 @@
+import { n as FunnelClock, t as FunnelLogger } from "./logger-Bc_Ooypb.js";
+import { n as FunnelFileSystem } from "./file-system-DHgbuTFb.js";
+import { r as FunnelBroadcaster } from "./broadcaster-DVNcw00K.js";
+import { FlumeCatchupPolicy, FlumeErrorHandler, FlumeEvent, FlumeRuntimeDeps, FlumeSource, FlumeStatePersister } from "@interactive-inc/flume";
+
+//#region lib/engine/channel/channel.d.ts
+/**
+ * 1 tick / 1 event を `broadcaster.broadcast(content, meta)` に流すための整形済みペイロード。
+ * `null` を返すと「drop」(broadcast しない) を意味する
+ */
+type ChannelBroadcastPayload = {
+  readonly content: string;
+  readonly meta?: Record<string, string>;
+};
+type ChannelTransform = (event: FlumeEvent) => ChannelBroadcastPayload | null;
+/**
+ * Channel が `build(ctx)` で返す実体。flume sources の集合と任意の transform を 1 まとまりとして
+ * supervisor に渡す
+ */
+type ChannelRuntime = {
+  readonly sources: ReadonlyArray<FlumeSource>;
+  /**
+   * 各 source の FlumeEvent を broadcast payload に変換する関数。
+   * 省略時は `{ content: JSON.stringify(event.data), meta: event.meta }` でフォールバック
+   */
+  readonly transform?: ChannelTransform;
+};
+/**
+ * Channel.build に渡される環境。FunnelClock / FunnelLogger / FunnelFileSystem を経由して
+ * IO 境界を抽象化する。statePersister は funnel-fs に紐づいた `FlumeStatePersister<S>` を
+ * channel id-scoped なファイル名で生成するヘルパー
+ */
+type ChannelBuildContext = {
+  readonly channelId: string;
+  readonly channelName: string;
+  readonly signal: AbortSignal;
+  readonly logger: FunnelLogger;
+  readonly clock: FunnelClock;
+  readonly fs: FunnelFileSystem;
+  /**
+   * `<funnelDir>/channels/<channelId>/<filename>.json` に Read/Write する純粋 DI 用 helper。
+   * flume が要求する `FlumeStatePersister<S>` 形に合わせる
+   */
+  readonly statePersister: <S>(filename: string) => FlumeStatePersister<S>;
+};
+/**
+ * 1 channel = 1 inbound 受信単位。`build` が confluence に挿す sources を返す。
+ * `build` は host abort / token rotation 等で何度でも再呼び出しされうる「純粋なファクトリ」
+ */
+type Channel = {
+  readonly id: string;
+  readonly name?: string;
+  readonly build: (ctx: ChannelBuildContext) => ChannelRuntime | Promise<ChannelRuntime>;
+};
+/** `Channel` を frozen で返す identity helper。consumer の型推論を整える */
+declare function defineChannel(channel: Channel): Channel;
+//#endregion
+//#region lib/engine/channel/channel-supervisor.d.ts
+type Props$1 = {
+  readonly broadcaster: FunnelBroadcaster;
+  readonly logger: FunnelLogger;
+  readonly clock: FunnelClock;
+  readonly fs: FunnelFileSystem;
+  /**
+   * Channel ごとの state / 永続化ファイルの起点。
+   * `<root>/channels/<channelId>/` 配下に書き込む
+   */
+  readonly dir: string;
+  readonly deps?: FlumeRuntimeDeps;
+  readonly onError?: FlumeErrorHandler; /** Host abort. fired すると全 channel を close する */
+  readonly signal?: AbortSignal;
+};
+/**
+ * Channel-manifest を `FlumeConfluence` 1 つにマッピングする supervisor。
+ *
+ *  - `register(channel)` で受け入れた channel は `start()` 時に `build(ctx)` され
+ *    sources が confluence に `add(channelId, sources)` で挿される
+ *  - confluence の onItem (groupId 付き) を 1 本受けて、対応する channel の `transform`
+ *    を通してから `broadcaster.broadcast(content, meta)` に流す
+ *  - `unregister(id)` で個別停止、`stop()` で全停止
+ *
+ * 既存の `FunnelListenerRegistry` (ConnectorDescriptor 系) とは独立。
+ * 並走させて段階的に移行する設計
+ */
+declare class FunnelChannelSupervisor {
+  private readonly props;
+  private readonly confluence;
+  private readonly registered;
+  private readonly pending;
+  private started;
+  constructor(props: Props$1);
+  /** start 前 / 後どちらでも受け付ける。start 後は即座に build + add する */
+  register(channel: Channel): void;
+  unregister(id: string): Promise<void>;
+  start(): Promise<void>;
+  stop(): Promise<void>;
+  ids(): ReadonlyArray<string>;
+  has(id: string): boolean;
+  private openChannel;
+  private handleItem;
+  private transformToPayload;
+}
+//#endregion
+//#region lib/engine/channel/time-channel.d.ts
+type Options = {
+  readonly id: string;
+  readonly name?: string;
+  readonly cron: string; /** 既定: `{ mode: "lastOnly" }` (起動時に直近 1 件だけ取り戻す) */
+  readonly catchupPolicy?: FlumeCatchupPolicy;
+  /**
+   * 各 tick を broadcast payload に変換する関数。省略時は
+   * `{ content: "tick", meta: { cron, firedAt } }` 相当
+   */
+  readonly transform?: ChannelTransform;
+  /**
+   * `statePersister` を有効にするかどうか (既定 true)。`false` にすると catchup も無効
+   */
+  readonly persist?: boolean;
+};
+/**
+ * 1 cron entry の time channel を作る factory。
+ *
+ * 使用例 (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" },
+ *   }),
+ * })
+ * ```
+ *
+ * `persist: true` (既定) の場合、`<channelDir>/time.json` に `lastFiredAt` を残し、
+ * 起動時に `catchupPolicy` (既定 lastOnly) に従って過去 tick を取り戻す
+ */
+declare function timeChannel(options: Options): Channel;
+//#endregion
+//#region lib/engine/channel/file-state-persister.d.ts
+type Props = {
+  readonly fs: FunnelFileSystem;
+  readonly path: string;
+};
+/**
+ * `FunnelFileSystem` 上に JSON で 1 行 / 1 状態を保存する `FlumeStatePersister`。
+ * 保存先ディレクトリは load/save の前に再帰作成する。
+ * load は不在 / parse 失敗時に `null` を返す (flume 側で素直に「初回扱い」になる)
+ */
+declare function createFileStatePersister<S>(props: Props): FlumeStatePersister<S>;
+type DirProps = {
+  readonly fs: FunnelFileSystem; /** `<funnelDir>/channels/<channelId>` の絶対パス */
+  readonly channelDir: string;
+};
+/**
+ * channel 単位の state persister ファクトリ。`statePersister<S>("time")` を呼ぶと
+ * `<channelDir>/time.json` 用の persister を返す
+ */
+declare function createChannelStatePersisterFactory(props: DirProps): <S>(filename: string) => FlumeStatePersister<S>;
+//#endregion
+export { type Channel, type ChannelBroadcastPayload, type ChannelBuildContext, type ChannelRuntime, type ChannelTransform, FunnelChannelSupervisor, createChannelStatePersisterFactory, createFileStatePersister, defineChannel, timeChannel };

package/dist/channel.js

@@ -0,0 +1,203 @@
+import { dirname, join } from "node:path";
+import { FlumeConfluence, FlumeTimeSource } from "@interactive-inc/flume";
+//#region lib/engine/channel/channel.ts
+/** `Channel` を frozen で返す identity helper。consumer の型推論を整える */
+function defineChannel(channel) {
+	return Object.freeze({ ...channel });
+}
+//#endregion
+//#region lib/engine/channel/file-state-persister.ts
+/**
+* `FunnelFileSystem` 上に JSON で 1 行 / 1 状態を保存する `FlumeStatePersister`。
+* 保存先ディレクトリは load/save の前に再帰作成する。
+* load は不在 / parse 失敗時に `null` を返す (flume 側で素直に「初回扱い」になる)
+*/
+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));
+		}
+	};
+}
+/**
+* channel 単位の state persister ファクトリ。`statePersister<S>("time")` を呼ぶと
+* `<channelDir>/time.json` 用の persister を返す
+*/
+function createChannelStatePersisterFactory(props) {
+	return (filename) => createFileStatePersister({
+		fs: props.fs,
+		path: join(props.channelDir, `${filename}.json`)
+	});
+}
+//#endregion
+//#region lib/engine/channel/channel-supervisor.ts
+/**
+* Channel-manifest を `FlumeConfluence` 1 つにマッピングする supervisor。
+*
+*  - `register(channel)` で受け入れた channel は `start()` 時に `build(ctx)` され
+*    sources が confluence に `add(channelId, sources)` で挿される
+*  - confluence の onItem (groupId 付き) を 1 本受けて、対応する channel の `transform`
+*    を通してから `broadcaster.broadcast(content, meta)` に流す
+*  - `unregister(id)` で個別停止、`stop()` で全停止
+*
+* 既存の `FunnelListenerRegistry` (ConnectorDescriptor 系) とは独立。
+* 並走させて段階的に移行する設計
+*/
+var FunnelChannelSupervisor = class {
+	confluence;
+	registered = /* @__PURE__ */ new Map();
+	pending = /* @__PURE__ */ new Map();
+	started = false;
+	constructor(props) {
+		this.props = props;
+		this.confluence = new FlumeConfluence({
+			onEvent: (item) => this.handleItem(item),
+			onError: props.onError,
+			deps: props.deps
+		});
+		if (props.signal) {
+			const onAbort = () => {
+				this.stop().catch(() => {});
+			};
+			if (props.signal.aborted) this.started = true;
+			else props.signal.addEventListener("abort", onAbort, { once: true });
+		}
+	}
+	/** start 前 / 後どちらでも受け付ける。start 後は即座に build + add する */
+	register(channel) {
+		if (this.registered.has(channel.id) || this.pending.has(channel.id)) throw new Error(`FunnelChannelSupervisor: channel id already registered: ${channel.id}`);
+		if (!this.started) {
+			this.pending.set(channel.id, channel);
+			return;
+		}
+		this.openChannel(channel);
+	}
+	async unregister(id) {
+		this.pending.delete(id);
+		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) 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;
+		for (const entry of this.registered.values()) entry.abortController.abort();
+		this.registered.clear();
+		this.pending.clear();
+		await this.confluence.closeAll();
+	}
+	ids() {
+		return [...this.registered.keys()];
+	}
+	has(id) {
+		return this.registered.has(id) || this.pending.has(id);
+	}
+	async openChannel(channel) {
+		const channelDir = join(this.props.dir, "channels", channel.id);
+		const abortController = new AbortController();
+		const runtime = await channel.build({
+			channelId: channel.id,
+			channelName: channel.name ?? channel.id,
+			signal: abortController.signal,
+			logger: this.props.logger,
+			clock: this.props.clock,
+			fs: this.props.fs,
+			statePersister: createChannelStatePersisterFactory({
+				fs: this.props.fs,
+				channelDir
+			})
+		});
+		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
+		});
+	}
+	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);
+	}
+	transformToPayload(entry, event) {
+		const transform = entry.runtime.transform;
+		if (transform === void 0) return {
+			content: JSON.stringify(event.data),
+			meta: event.meta
+		};
+		const out = transform(event);
+		if (out === null) return null;
+		return {
+			content: out.content,
+			meta: out.meta
+		};
+	}
+};
+//#endregion
+//#region lib/engine/channel/time-channel.ts
+/**
+* 1 cron entry の time channel を作る factory。
+*
+* 使用例 (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" },
+*   }),
+* })
+* ```
+*
+* `persist: true` (既定) の場合、`<channelDir>/time.json` に `lastFiredAt` を残し、
+* 起動時に `catchupPolicy` (既定 lastOnly) に従って過去 tick を取り戻す
+*/
+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-DR90RmUP.d.ts}

@@ -1,7 +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-Bc_Ooypb.js";
+import { n as FunnelFileSystem } from "./file-system-DHgbuTFb.js";
+import { n as ChannelDeliveryMode, t as ChannelConfig } from "./settings-schema-IShSMm5G.js";
+import { n as FunnelIdGenerator, t as FunnelSettingsReader } from "./settings-reader-BnKIbmsD.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-CmyHlEiT.js";
 
 //#region lib/engine/connectors/connector-registry.d.ts
 type Deps$1 = {

package/dist/claude.d.ts

@@ -1,7 +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-DHgbuTFb.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-CiBwXjzm.js";
+import { r as ConnectorDescriptor } from "./connector-descriptor-CmyHlEiT.js";
+import { t as FunnelProfiles } from "./profiles-M24JrcOh.js";
 
 //#region lib/engine/mcp/mcp.d.ts
 declare const FUNNEL_MCP_COMMAND = "bun";

package/dist/claude.js

@@ -4,7 +4,7 @@ import { a as FunnelMcp, i as FUNNEL_MCP_NAME, n as FUNNEL_MCP_ARGS, o as Funnel
 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-DIFkYBbi.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";

package/dist/{connector-descriptor-BFIhyTfa.d.ts → connector-descriptor-CmyHlEiT.d.ts}

@@ -1,19 +1,7 @@
-import { n as FunnelFileSystem } from "./file-system-VhwwXZbm.js";
+import { n as FunnelClock, t as FunnelLogger } from "./logger-Bc_Ooypb.js";
+import { n as FunnelFileSystem } from "./file-system-DHgbuTFb.js";
 import { z } from "zod";
 
-//#region lib/engine/logger/logger.d.ts
-/**
- * Structured logger with three levels and an optional log-file path.
- * Defaults to NodeFunnelLogger (appends to `<os.tmpdir()>/funnel/funnel.log`);
- * MemoryFunnelLogger captures entries in memory and NoopFunnelLogger silences output.
- */
-declare abstract class FunnelLogger {
-  abstract info(message: string, meta?: Record<string, unknown>): void;
-  abstract warn(message: string, meta?: Record<string, unknown>): void;
-  abstract error(message: string, meta?: Record<string, unknown>): void;
-  abstract readonly file: string | null;
-}
-//#endregion
 //#region lib/engine/process/process-runner.d.ts
 type RunOptions = {
   cwd?: string;
@@ -315,17 +303,6 @@ declare abstract class FunnelHttpClient {
   abstract fetch(request: HttpRequest): Promise<HttpResponse>;
 }
 //#endregion
-//#region lib/engine/time/clock.d.ts
-/**
- * Time boundary. Default NodeFunnelClock returns `new Date()`; MemoryFunnelClock
- * is settable and `advance(ms)`-able for deterministic schedule / timeout tests.
- */
-declare abstract class FunnelClock {
-  abstract now(): Date;
-  millis(): number;
-  iso(): string;
-}
-//#endregion
 //#region lib/engine/connectors/connector-descriptor.d.ts
 /** Boundaries a listener needs, supplied by the registry at build time. */
 type ConnectorListenerDeps = {
@@ -400,4 +377,4 @@ type ConnectorDescriptor = {
   operations: Record<string, ConnectorOperation>;
 };
 //#endregion
-export { connectorRawEventSchema as A, FunnelProcessRunner as B, ConnectorRawQuery as C, StoredRawEvent as D, StoredProcessedEvent as E, JsonValue as F, RunOptions as H, BaseConnectorConfig as I, baseConnectorConfigSchema as L, NotifyFn as M, CallInput as N, connectorConnectionEventSchema as O, FunnelConnectorAdapter as P, AttachOptions as R, ConnectorRawEvent as S, StoredConnectionEvent as T, RunResult as U, ProcessSnapshot as V, FunnelLogger as W, ConnectorDiagnosticLog as _, ConnectorOperation as a, ConnectorProcessedRecord as b, FunnelClock as c, HttpResponse as d, CONNECTOR_CONNECTION_STATUSES as f, ConnectorConnectionStatus as g, ConnectorConnectionRecord as h, ConnectorListenerDeps as i, FunnelConnectorListener as j, connectorProcessedEventSchema as k, FunnelHttpClient as l, ConnectorConnectionQuery as m, ConnectorBuildContext as n, ConnectorOperationContext as o, ConnectorConnectionEvent as p, ConnectorDescriptor as r, ConnectorUpdateContext as s, ConnectorAdapterDeps as t, HttpRequest as u, ConnectorProcessedEvent as v, ConnectorRawRecord as w, ConnectorQuery as x, ConnectorProcessedQuery as y, DetachOptions as z };
+export { FunnelConnectorListener as A, ProcessSnapshot as B, ConnectorRawRecord as C, connectorConnectionEventSchema as D, StoredRawEvent as E, BaseConnectorConfig as F, RunResult as H, baseConnectorConfigSchema as I, AttachOptions as L, CallInput as M, FunnelConnectorAdapter as N, connectorProcessedEventSchema as O, JsonValue as P, DetachOptions as R, ConnectorRawQuery as S, StoredProcessedEvent as T, RunOptions as V, ConnectorProcessedEvent as _, ConnectorOperation as a, ConnectorQuery as b, FunnelHttpClient as c, CONNECTOR_CONNECTION_STATUSES as d, ConnectorConnectionEvent as f, ConnectorDiagnosticLog as g, ConnectorConnectionStatus as h, ConnectorListenerDeps as i, NotifyFn as j, connectorRawEventSchema as k, HttpRequest as l, ConnectorConnectionRecord as m, ConnectorBuildContext as n, ConnectorOperationContext as o, ConnectorConnectionQuery as p, ConnectorDescriptor as r, ConnectorUpdateContext as s, ConnectorAdapterDeps as t, HttpResponse as u, ConnectorProcessedQuery as v, StoredConnectionEvent as w, ConnectorRawEvent as x, ConnectorProcessedRecord as y, FunnelProcessRunner as z };

package/dist/connectors/discord.d.ts

@@ -1,6 +1,7 @@
-import { M as NotifyFn, N as CallInput, P as FunnelConnectorAdapter, W as FunnelLogger, _ as ConnectorDiagnosticLog, l as FunnelHttpClient, r as ConnectorDescriptor } from "../connector-descriptor-BFIhyTfa.js";
-import { n as discordConnectorSchema, t as DiscordConnectorConfig } from "../discord-connector-schema-D-bOVAKt.js";
-import { t as FunnelFlumeSourceListener } from "../flume-source-listener-BNyAII7N.js";
+import { t as FunnelLogger } from "../logger-Bc_Ooypb.js";
+import { M as CallInput, N as FunnelConnectorAdapter, c as FunnelHttpClient, g as ConnectorDiagnosticLog, j as NotifyFn, r as ConnectorDescriptor } from "../connector-descriptor-CmyHlEiT.js";
+import { n as discordConnectorSchema, t as DiscordConnectorConfig } from "../discord-connector-schema-D1dyxhXk.js";
+import { t as FunnelFlumeSourceListener } from "../flume-source-listener-FzR5lGpL.js";
 import { FlumeRuntimeDeps } from "@interactive-inc/flume";
 
 //#region lib/engine/connectors/discord-adapter.d.ts
@@ -17,6 +18,24 @@ declare class FunnelDiscordAdapter extends FunnelConnectorAdapter {
 }
 //#endregion
 //#region lib/engine/connectors/discord-connector.d.ts
+type DiscordConnectorOptions = {
+  /**
+   * Discord gateway dispatch types funnel forwards to the broadcaster.
+   * Pass an explicit allowlist (`["MESSAGE_CREATE", "MESSAGE_UPDATE"]`) for
+   * fine-grained control, or `"all"` to skip the filter entirely and forward
+   * every dispatch type the gateway emits. Defaults to MESSAGE_CREATE and
+   * MESSAGE_UPDATE so the typical chat-style consumer is not flooded by
+   * GUILD_CREATE / PRESENCE_UPDATE / VOICE_STATE_UPDATE snapshots on
+   * connect. Reactions, interactivity, and guild-state dispatches require
+   * opt-in via this list.
+   *
+   * Common values:
+   *   ["MESSAGE_CREATE", "MESSAGE_UPDATE", "MESSAGE_REACTION_ADD"]
+   *   ["MESSAGE_CREATE", "INTERACTION_CREATE"]
+   *   "all"   — debug / firehose
+   */
+  eventTypes?: ReadonlyArray<string> | "all";
+};
 /**
  * Discord connector descriptor. Pass `discordConnector()` to
  * `new Funnel({ connectors: [...] })` to enable the type.
@@ -24,7 +43,7 @@ declare class FunnelDiscordAdapter extends FunnelConnectorAdapter {
  * The listener is backed by `@interactive-inc/flume`'s `FlumeDiscordSource`
  * (raw Gateway WebSocket).
  */
-declare const discordConnector: () => ConnectorDescriptor;
+declare const discordConnector: (options?: DiscordConnectorOptions) => ConnectorDescriptor;
 //#endregion
 //#region lib/engine/connectors/discord-event-processor.d.ts
 type DiscordInboundMessage = {
@@ -61,7 +80,8 @@ type Deps = {
   logger?: FunnelLogger;
   diagnosticLog?: ConnectorDiagnosticLog;
   flumeDeps?: Partial<FlumeRuntimeDeps>; /** Shutdown signal forwarded to the underlying Flume. */
-  signal?: AbortSignal;
+  signal?: AbortSignal; /** See `DiscordConnectorOptions.eventTypes`. */
+  eventTypes?: ReadonlyArray<string> | "all";
 };
 /**
  * Discord listener backed by `@interactive-inc/flume`'s `FlumeDiscordSource`
@@ -77,6 +97,7 @@ declare class FunnelFlumeDiscordListener extends FunnelFlumeSourceListener {
   private readonly env;
   private readonly flumeDeps;
   private readonly signal;
+  private readonly eventTypes;
   private processor;
   constructor(deps: Deps);
   start(notify: NotifyFn): Promise<void>;
@@ -86,4 +107,4 @@ declare class FunnelFlumeDiscordListener extends FunnelFlumeSourceListener {
   private deliver;
 }
 //#endregion
-export { DiscordConnectorConfig, DiscordInboundMessage, DiscordProcessed, DiscordProcessedEmit, DiscordProcessedSkip, FunnelDiscordAdapter, FunnelDiscordEventProcessor, FunnelFlumeDiscordListener, discordConnector, discordConnectorSchema };
+export { DiscordConnectorConfig, DiscordConnectorOptions, DiscordInboundMessage, DiscordProcessed, DiscordProcessedEmit, DiscordProcessedSkip, FunnelDiscordAdapter, FunnelDiscordEventProcessor, FunnelFlumeDiscordListener, discordConnector, discordConnectorSchema };

package/dist/connectors/discord.js

@@ -1,3 +1,3 @@
 import { t as discordConnectorSchema } from "../discord-connector-schema-B4YpWpR3.js";
-import { i as FunnelDiscordAdapter, n as FunnelFlumeDiscordListener, r as FunnelDiscordEventProcessor, t as discordConnector } from "../discord-connector-DIFkYBbi.js";
+import { i as FunnelDiscordAdapter, n as FunnelFlumeDiscordListener, r as FunnelDiscordEventProcessor, t as discordConnector } from "../discord-connector-DXARcO6w.js";
 export { FunnelDiscordAdapter, FunnelDiscordEventProcessor, FunnelFlumeDiscordListener, discordConnector, discordConnectorSchema };