@interactive-inc/claude-funnel 0.60.1 → 0.64.0

package/dist/connectors/gh.d.ts

@@ -1,5 +1,7 @@
-import { A as FunnelConnectorAdapter, B as FunnelLogger, D as FunnelConnectorListener, I as FunnelProcessRunner, O as NotifyFn, k as CallInput, p as ConnectorDiagnosticLog, r as ConnectorDescriptor } from "../connector-descriptor-6SXJoszo.js";
-import { z } from "zod";
+import { B as FunnelProcessRunner, M as NotifyFn, N as CallInput, P as FunnelConnectorAdapter, W as FunnelLogger, _ as ConnectorDiagnosticLog, r as ConnectorDescriptor } from "../connector-descriptor-BFIhyTfa.js";
+import { t as FunnelFlumeSourceListener } from "../flume-source-listener-BNyAII7N.js";
+import { n as ghConnectorSchema, t as GhConnectorConfig } from "../gh-connector-schema-DWQaB6gX.js";
+import { FlumeRuntimeDeps } from "@interactive-inc/flume";
 
 //#region lib/engine/connectors/gh-adapter.d.ts
 type Deps$1 = {
@@ -15,48 +17,50 @@ declare class FunnelGhAdapter extends FunnelConnectorAdapter {
 /**
  * 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.
  */
 declare const ghConnector: () => ConnectorDescriptor;
 //#endregion
-//#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>;
-  createdAt: z.ZodOptional<z.ZodString>;
-  updatedAt: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-type GhConnectorConfig = z.infer<typeof ghConnectorSchema>;
-//#endregion
-//#region lib/engine/connectors/gh-listener.d.ts
+//#region lib/engine/connectors/gh-flume-listener.d.ts
 type Deps = {
-  config: GhConnectorConfig; /** Funnel channel uuid this connector lives under; stamped onto diagnostic-log rows. */
+  config: GhConnectorConfig;
   channelId?: string;
+  env?: NodeJS.ProcessEnv;
   process?: FunnelProcessRunner;
-  logger?: FunnelLogger; /** Diagnostic log of inbound events, before and after processing. No-op when absent. */
+  logger?: FunnelLogger;
   diagnosticLog?: ConnectorDiagnosticLog;
-  now?: () => Date;
+  flumeDeps?: Partial<FlumeRuntimeDeps>; /** Shutdown signal forwarded to the underlying Flume. */
+  signal?: AbortSignal;
 };
-declare class FunnelGhListener extends FunnelConnectorListener {
+/**
+ * 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.
+ */
+declare class FunnelFlumeGhListener extends FunnelFlumeSourceListener {
   private readonly config;
-  private readonly channelId;
+  private readonly env;
   private readonly process;
-  private readonly logger;
-  private readonly diagnosticLog;
-  private readonly now;
-  private readonly seen;
-  private bootstrapped;
-  private since;
-  private timer;
+  private readonly flumeDeps;
+  private readonly signal;
   constructor(deps: Deps);
   start(notify: NotifyFn): Promise<void>;
-  stop(): Promise<void>;
-  isAlive(): boolean;
-  pollOnce(notify: NotifyFn): Promise<void>;
-  private recordRaw;
-  private recordProcessed;
-  private recordConnection;
+  private resolveToken;
+  private handleEvent;
+  private deliver;
 }
 //#endregion
-export { FunnelGhAdapter, FunnelGhListener, GhConnectorConfig, ghConnector, ghConnectorSchema };
+export { FunnelFlumeGhListener, FunnelGhAdapter, GhConnectorConfig, ghConnector, ghConnectorSchema };

package/dist/connectors/gh.js

@@ -1,3 +1,3 @@
-import { t as ghConnectorSchema } from "../gh-connector-schema-Rzwc1c1N.js";
-import { n as FunnelGhListener, r as FunnelGhAdapter, t as ghConnector } from "../gh-connector-DpiixfQZ.js";
-export { FunnelGhAdapter, FunnelGhListener, ghConnector, ghConnectorSchema };
+import { t as ghConnectorSchema } from "../gh-connector-schema-CAqIhzGr.js";
+import { n as FunnelFlumeGhListener, r as FunnelGhAdapter, t as ghConnector } from "../gh-connector-BUGCOEWS.js";
+export { FunnelFlumeGhListener, FunnelGhAdapter, ghConnector, ghConnectorSchema };

package/dist/connectors/schedule.d.ts

@@ -1,6 +1,6 @@
-import { B as FunnelLogger, D as FunnelConnectorListener, O as NotifyFn, p as ConnectorDiagnosticLog, r as ConnectorDescriptor } from "../connector-descriptor-6SXJoszo.js";
-import { n as FunnelFileSystem } from "../file-system-o51IsM0W.js";
-import { z } from "zod";
+import { M as NotifyFn, W as FunnelLogger, _ as ConnectorDiagnosticLog, j as FunnelConnectorListener, r as ConnectorDescriptor } from "../connector-descriptor-BFIhyTfa.js";
+import { n as FunnelFileSystem } from "../file-system-VhwwXZbm.js";
+import { a as scheduleConnectorSchema, i as scheduleCatchupPolicySchema, n as ScheduleConnectorConfig, o as scheduleEntrySchema, r as ScheduleEntry, t as ScheduleCatchupPolicy } from "../schedule-connector-schema-Z0RXLgPI.js";
 
 //#region lib/engine/connectors/match-cron.d.ts
 /**
@@ -26,7 +26,7 @@ type Deps$1 = {
  * connectorDir) so this store does not know about the funnel directory layout
  * (`channels/<id>/connectors/<id>/state.json` lives outside this class).
  */
-declare class ScheduleStateStore {
+declare class FunnelScheduleStateStore {
   private readonly path;
   private readonly fs;
   constructor(deps: Deps$1);
@@ -34,57 +34,11 @@ declare class ScheduleStateStore {
   save(state: Map<string, Date>): void;
 }
 //#endregion
-//#region lib/engine/connectors/schedule-connector-schema.d.ts
-/**
- * Catch-up behavior when the daemon was down past one or more matching minutes.
- *
- * - `latest`: fire once with the most recent missed match (default; preserves prior behavior).
- * - `all`: fire once per missed minute, oldest first (capped at 24 h).
- * - `skip`: never fire missed matches; only fire when the current minute matches.
- */
-declare const scheduleCatchupPolicySchema: z.ZodEnum<{
-  latest: "latest";
-  all: "all";
-  skip: "skip";
-}>;
-type ScheduleCatchupPolicy = z.infer<typeof scheduleCatchupPolicySchema>;
-declare const scheduleEntrySchema: z.ZodObject<{
-  id: z.ZodString;
-  cron: z.ZodString;
-  prompt: z.ZodString;
-  enabled: z.ZodDefault<z.ZodBoolean>;
-  catchupPolicy: z.ZodDefault<z.ZodEnum<{
-    latest: "latest";
-    all: "all";
-    skip: "skip";
-  }>>;
-}, z.core.$strip>;
-type ScheduleEntry = z.infer<typeof scheduleEntrySchema>;
-declare const scheduleConnectorSchema: z.ZodObject<{
-  id: z.ZodString;
-  name: z.ZodString;
-  type: z.ZodLiteral<"schedule">;
-  entries: z.ZodDefault<z.ZodArray<z.ZodObject<{
-    id: z.ZodString;
-    cron: z.ZodString;
-    prompt: z.ZodString;
-    enabled: z.ZodDefault<z.ZodBoolean>;
-    catchupPolicy: z.ZodDefault<z.ZodEnum<{
-      latest: "latest";
-      all: "all";
-      skip: "skip";
-    }>>;
-  }, z.core.$strip>>>;
-  createdAt: z.ZodOptional<z.ZodString>;
-  updatedAt: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-type ScheduleConnectorConfig = z.infer<typeof scheduleConnectorSchema>;
-//#endregion
 //#region lib/engine/connectors/schedule-listener.d.ts
 type ScheduleOnFired = (entry: ScheduleEntry, firedAt: Date) => void | Promise<void>;
 type Deps = {
   config: ScheduleConnectorConfig;
-  lastFiredStore: ScheduleStateStore; /** Funnel channel uuid this connector lives under; stamped onto diagnostic-log rows. */
+  lastFiredStore: FunnelScheduleStateStore; /** Funnel channel uuid this connector lives under; stamped onto diagnostic-log rows. */
   channelId?: string;
   logger?: FunnelLogger; /** Diagnostic log of fired entries and lifecycle. No-op when absent. */
   diagnosticLog?: ConnectorDiagnosticLog;
@@ -99,16 +53,17 @@ type Deps = {
 declare class FunnelScheduleListener extends FunnelConnectorListener {
   private readonly config;
   private readonly lastFiredStore;
-  private readonly channelId;
   private readonly logger;
-  private readonly diagnosticLog;
+  private readonly diagnostics;
   private readonly now;
   private readonly onFired;
   private timer;
   private stopped;
+  private tickScheduled;
   constructor(deps: Deps);
   start(notify: NotifyFn): Promise<void>;
   stop(): Promise<void>;
+  private recordTickError;
   isAlive(): boolean;
   tick(notify: NotifyFn): Promise<void>;
   private fireEntry;
@@ -117,9 +72,6 @@ declare class FunnelScheduleListener extends FunnelConnectorListener {
   private findAllMatches;
   private logInvalidCron;
   private truncateToMinute;
-  private recordRaw;
-  private recordProcessed;
-  private recordConnection;
 }
 //#endregion
 //#region lib/engine/connectors/schedule-connector.d.ts
@@ -135,4 +87,4 @@ type ScheduleConnectorOptions = {
  */
 declare const scheduleConnector: (options?: ScheduleConnectorOptions) => ConnectorDescriptor;
 //#endregion
-export { FunnelScheduleListener, ScheduleCatchupPolicy, ScheduleConnectorConfig, ScheduleConnectorOptions, ScheduleEntry, ScheduleOnFired, ScheduleStateStore, matchCron, scheduleCatchupPolicySchema, scheduleConnector, scheduleConnectorSchema, scheduleEntrySchema };
+export { FunnelScheduleListener, FunnelScheduleStateStore, ScheduleCatchupPolicy, ScheduleConnectorConfig, ScheduleConnectorOptions, ScheduleEntry, ScheduleOnFired, matchCron, scheduleCatchupPolicySchema, scheduleConnector, scheduleConnectorSchema, scheduleEntrySchema };

package/dist/connectors/schedule.js

@@ -1,3 +1,3 @@
-import { n as scheduleConnectorSchema, r as scheduleEntrySchema, t as scheduleCatchupPolicySchema } from "../schedule-connector-schema-CfyuMCMh.js";
-import { i as matchCron, n as FunnelScheduleListener, r as ScheduleStateStore, t as scheduleConnector } from "../schedule-connector-L4uzg5M8.js";
-export { FunnelScheduleListener, ScheduleStateStore, matchCron, scheduleCatchupPolicySchema, scheduleConnector, scheduleConnectorSchema, scheduleEntrySchema };
+import { n as scheduleConnectorSchema, r as scheduleEntrySchema, t as scheduleCatchupPolicySchema } from "../schedule-connector-schema-DKEPZnVv.js";
+import { i as matchCron, n as FunnelScheduleListener, r as FunnelScheduleStateStore, t as scheduleConnector } from "../schedule-connector-9k3gOIgl.js";
+export { FunnelScheduleListener, FunnelScheduleStateStore, matchCron, scheduleCatchupPolicySchema, scheduleConnector, scheduleConnectorSchema, scheduleEntrySchema };

package/dist/connectors/slack.d.ts

@@ -1,47 +1,24 @@
-import { A as FunnelConnectorAdapter, B as FunnelLogger, D as FunnelConnectorListener, O as NotifyFn, k as CallInput, p as ConnectorDiagnosticLog, r as ConnectorDescriptor } from "../connector-descriptor-6SXJoszo.js";
-import { z } from "zod";
-import { App } from "@slack/bolt";
+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 { t as FunnelFlumeSourceListener } from "../flume-source-listener-BNyAII7N.js";
+import { a as SlackRawEvent, c as SlackMessageEvent, d as slackConnectorSchema, i as SlackProcessedSkip, l as SlackReactionEvent, n as SlackProcessed, o as SlackSkipReason, r as SlackProcessedEmit, s as SlackEvent, t as FunnelSlackEventProcessor, u as SlackConnectorConfig } from "../slack-event-processor-BhCf5Wiy.js";
+import { FlumeRuntimeDeps } from "@interactive-inc/flume";
 
-//#region lib/engine/connectors/slack-connector-schema.d.ts
-/**
- * A slack connector resolves its tokens one of two ways, set at sync time:
- *
- *   - literal: `botToken` / `appToken` hold the real `xoxb-`/`xapp-` secret
- *     (set by a `fnl channels` command or a TTY prompt at launch).
- *   - by reference: `botTokenEnv` / `appTokenEnv` hold the *name* of an env var.
- *     The secret never lands in settings.json; the listener resolves it from
- *     `process.env` at start. This form is only set through the engine API
- *     (`new Funnel(...)`) — funnel.json and the `fnl` CLI produce literals.
- *
- * Both are optional at the schema level (a discriminated-union member can't
- * carry a cross-field refine); the listener requires exactly one resolved
- * token per slot and errors loudly otherwise.
- */
-declare const slackConnectorSchema: z.ZodObject<{
-  id: z.ZodString;
-  name: z.ZodString;
-  type: z.ZodLiteral<"slack">;
-  botToken: z.ZodOptional<z.ZodString>;
-  appToken: z.ZodOptional<z.ZodString>;
-  botTokenEnv: z.ZodOptional<z.ZodString>;
-  appTokenEnv: z.ZodOptional<z.ZodString>;
-  minify: z.ZodDefault<z.ZodBoolean>;
-  createdAt: z.ZodOptional<z.ZodString>;
-  updatedAt: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-type SlackConnectorConfig = z.infer<typeof slackConnectorSchema>;
-//#endregion
 //#region lib/engine/connectors/slack-adapter.d.ts
-type SlackWebClientLike = {
-  apiCall: (method: string, options?: Record<string, unknown>) => Promise<unknown>;
-};
 type Deps$1 = {
-  config: SlackConnectorConfig; /** Environment used to resolve a `botTokenEnv` reference. Defaults to process.env. */
-  env?: NodeJS.ProcessEnv;
-  client?: SlackWebClientLike;
+  config: SlackConnectorConfig;
+  env?: NodeJS.ProcessEnv; /** HTTP client injection — defaults to `NodeFunnelHttpClient`. Tests inject `MemoryFunnelHttpClient`. */
+  http?: FunnelHttpClient;
 };
+/**
+ * Slack Web API adapter over the injected `FunnelHttpClient`. `call()` posts
+ * to `https://slack.com/api/<method>` with `Authorization: Bearer <botToken>`
+ * and returns the parsed JSON body verbatim — Slack signals failures with
+ * `{ ok: false, error: "..." }` in a 200 response, so we surface that body
+ * unchanged and let the caller inspect `ok`.
+ */
 declare class FunnelSlackAdapter extends FunnelConnectorAdapter {
-  private readonly client;
+  private readonly token;
+  private readonly http;
   constructor(deps: Deps$1);
   call(input: CallInput): Promise<unknown>;
   postMessage(props: {
@@ -61,118 +38,115 @@ declare class FunnelSlackAdapter extends FunnelConnectorAdapter {
   }): Promise<unknown>;
 }
 //#endregion
-//#region lib/engine/connectors/slack-event-types.d.ts
-type SlackMessageEvent = {
-  kind: "message";
-  channel: string;
-  user: string;
-  rawText: string;
-  text: string;
-  threadTs: string;
-  ts: string;
-  isThreadRoot: boolean;
-  mentioned: boolean;
-  source: "app_mention" | "message";
-};
-type SlackReactionEvent = {
-  kind: "reaction_added" | "reaction_removed";
-  channel: string;
-  user: string;
-  emoji: string;
-  targetTs: string;
-  targetUser: string | null;
-};
-type SlackEvent = SlackMessageEvent | SlackReactionEvent;
-//#endregion
-//#region lib/engine/connectors/slack-event-processor.d.ts
-type SlackRawEvent = Record<string, unknown>;
+//#region lib/engine/connectors/slack-flume-listener.d.ts
 /**
- * Why the processor dropped an event. Mirrored verbatim into the diagnostic
- * log's processed `outcome` column so "Slack delivered it but no notification arrived" is
- * traceable to the exact gate that dropped it. The listener may additionally
- * record `skip:preprocess` for events a host preprocessor dropped before the
- * processor ran — that gate is outside this type.
+ * Optional host hook: inspect the raw Slack event after envelope unwrap and
+ * before the funnel processor runs. Return the event (possibly transformed)
+ * to keep processing, or `null` to drop it with a `skip:preprocess` row in
+ * the diagnostic log. The funnel does not assume any specific transform —
+ * stripping images, neutralizing channel-tag injection, redacting PII, etc.
+ * are all valid uses.
  */
-type SlackSkipReason = "skip:type" | "skip:subtype" | "skip:dedup" | "skip:self-user" | "skip:self-bot";
-type SlackProcessedSkip = {
-  skip: true;
-  reason: SlackSkipReason;
-};
-type SlackProcessedEmit = {
-  skip: false;
-  event: SlackEvent;
-  content: string;
-  meta: Record<string, string>;
-  shouldReact: boolean;
-  channel: string;
-  timestamp: string;
-};
-type SlackProcessed = SlackProcessedSkip | SlackProcessedEmit;
-type Props = {
-  ownBotUserId: string;
-  ownBotId: string;
-  minify?: boolean;
-  now?: () => number;
-};
-declare class FunnelSlackEventProcessor {
-  private readonly ownBotUserId;
-  private readonly ownBotId;
-  private readonly minify;
-  private readonly now;
-  private readonly dedup;
-  constructor(props: Props);
-  process(event: SlackRawEvent): SlackProcessed;
-}
-//#endregion
-//#region lib/engine/connectors/slack-listener.d.ts
-type SlackOnAppCreated = (app: App) => void | Promise<void>;
-type SlackPreprocessEvent = (event: SlackRawEvent) => SlackRawEvent | null;
+type SlackPreprocessEvent = (event: SlackRawEvent) => SlackRawEvent | null | Promise<SlackRawEvent | null>;
+/**
+ * Optional host hook for Slack interactivity (`block_actions`,
+ * `view_submission`, `view_closed`, `message_action`, `shortcut`) delivered
+ * via Socket Mode under the `interactive` envelope type. Funnel auto-acks
+ * the envelope for the host (flume's socket layer sends `{envelope_id}` back
+ * regardless of payload), so the host can take its time responding via the
+ * Slack web API (`views.open`, `chat.update`, …). Returning is enough — the
+ * return value is unused. Thrown errors land in the funnel logger and the
+ * connector's diagnostic log but never bubble up to flume's queue.
+ *
+ * Payload shape is intentionally `Record<string, unknown>` because Slack's
+ * interactive payload is a wide discriminated union (`type: "block_actions" |
+ * "view_submission" | "view_closed" | "message_action" | "shortcut"`) whose
+ * narrowest accurate type would couple funnel to Slack's API revisions.
+ * Hosts that need a typed payload should parse it with their own zod schema
+ * scoped to the interaction types they care about.
+ */
+type SlackInteractiveHandler = (payload: Record<string, unknown>) => void | Promise<void>;
 type Deps = {
-  config: SlackConnectorConfig; /** Funnel channel uuid this connector lives under; stamped onto diagnostic-log rows. */
-  channelId?: string; /** Environment used to resolve `botTokenEnv`/`appTokenEnv` references. Defaults to process.env. */
+  config: SlackConnectorConfig;
+  channelId?: string;
   env?: NodeJS.ProcessEnv;
-  logger?: FunnelLogger; /** Diagnostic log of inbound events, before and after processing. No-op when absent. */
+  logger?: FunnelLogger;
   diagnosticLog?: ConnectorDiagnosticLog;
-  /**
-   * Invoked after the Bolt App is constructed, before it starts.
-   * Use to attach app.action handlers, custom middleware, etc.
-   */
-  onAppCreated?: SlackOnAppCreated;
-  /**
-   * Transform or drop the raw Slack event before the built-in processor sees it.
-   * Return null to drop the event entirely.
-   */
-  preprocessEvent?: SlackPreprocessEvent;
+  flumeDeps?: Partial<FlumeRuntimeDeps>; /** HTTP client for `auth.test` and `reactions.add`. Defaults to NodeFunnelHttpClient. */
+  http?: FunnelHttpClient; /** Shutdown signal forwarded to the underlying Flume. */
+  signal?: AbortSignal; /** See `SlackPreprocessEvent`. Default: identity (no preprocessing). */
+  preprocessEvent?: SlackPreprocessEvent; /** See `SlackInteractiveHandler`. Default: drop interactive envelopes silently. */
+  onInteractive?: SlackInteractiveHandler;
 };
-declare class FunnelSlackListener extends FunnelConnectorListener {
+/**
+ * Slack listener backed by `@interactive-inc/flume`'s `FlumeSlackSource` (raw
+ * Socket Mode WebSocket + Zod). The processor layer
+ * (`FunnelSlackEventProcessor`) is the application layer — self-skip, mention
+ * detection, dedup, minify. Self-detection needs `auth.test` to learn the
+ * bot's own user/bot id, which the listener calls once at start using the
+ * bot token. Flume delivers the events API envelope and nothing else; Bolt's
+ * `app.action` / `app.command` / `preprocessEvent` hooks have no equivalent
+ * here and must be re-implemented against Slack's HTTP endpoints if needed.
+ */
+declare class FunnelFlumeSlackListener extends FunnelFlumeSourceListener {
   private readonly config;
-  private readonly channelId;
   private readonly env;
-  private readonly logger;
-  private readonly diagnosticLog;
-  private readonly onAppCreated;
+  private readonly flumeDeps;
+  private readonly http;
+  private readonly signal;
   private readonly preprocessEvent;
-  private app;
-  private connected;
+  private readonly onInteractive;
+  private processor;
+  private botToken;
   constructor(deps: Deps);
   start(notify: NotifyFn): Promise<void>;
-  stop(): Promise<void>;
-  isAlive(): boolean;
-  private recordRaw;
-  private recordProcessed;
-  private recordConnection;
+  protected onStop(): void;
+  private handleInteractive;
+  private callAuthTest;
+  private handleEvent;
+  private deliver;
+  private postReaction;
 }
 //#endregion
 //#region lib/engine/connectors/slack-connector.d.ts
 type SlackConnectorOptions = {
-  /** Invoked after the Bolt App is constructed, before start — attach app.action handlers etc. */onAppCreated?: SlackOnAppCreated; /** Transform or drop a raw Slack event before the built-in processor sees it. */
+  /**
+   * Optional host-side preprocessor applied to every raw Slack event after
+   * the envelope is unwrapped and BEFORE the funnel processor runs. Return
+   * the (possibly transformed) event to keep processing, or `null` to drop
+   * it (the listener records `skip:preprocess` so the drop is auditable).
+   *
+   * Useful for tenant-specific concerns funnel deliberately does not
+   * enshrine: stripping attachments, neutralizing channel-tag injection,
+   * fan-out to multiple processors, etc. Returning `null` here is the only
+   * way to drop an event for a reason the processor's gates do not cover.
+   */
   preprocessEvent?: SlackPreprocessEvent;
+  /**
+   * Optional host handler for Slack interactivity (button clicks, modal
+   * submissions, message actions, global shortcuts) delivered via Socket
+   * Mode under the `interactive` envelope type. Funnel auto-acks the
+   * envelope for the host, so the handler can take its time and respond via
+   * the Slack web API. Setting this is the supported alternative to running
+   * a parallel Bolt app alongside funnel just for interactivity.
+   */
+  onInteractive?: SlackInteractiveHandler;
 };
 /**
  * Slack connector descriptor. Pass `slackConnector()` to
- * `new Funnel({ connectors: [...] })` to enable the type. Host launch hooks are
- * closed over here, so they need no Funnel-level option plumbing.
+ * `new Funnel({ connectors: [...] })` to enable the type.
+ *
+ * The listener is backed by `@interactive-inc/flume`'s `FlumeSlackSource`
+ * (raw Socket Mode WebSocket). Both the `events_api` envelope (messages,
+ * mentions, reactions, …) and the `interactive` envelope (block actions,
+ * view submissions, message actions, shortcuts) are delivered — the former
+ * runs through the funnel processor and emits notifications, the latter is
+ * handed to the optional `onInteractive` host hook (funnel auto-acks the
+ * envelope, so the host can respond via the Slack web API at its leisure).
+ * Slash commands (`slash_commands` envelope) and Bolt's middleware chain
+ * have no equivalent here yet — wire those via the Slack HTTP endpoints if
+ * needed.
  */
 declare const slackConnector: (options?: SlackConnectorOptions) => ConnectorDescriptor;
 //#endregion
-export { FunnelSlackAdapter, FunnelSlackEventProcessor, FunnelSlackListener, SlackConnectorConfig, SlackConnectorOptions, SlackEvent, SlackMessageEvent, SlackOnAppCreated, SlackPreprocessEvent, SlackProcessed, SlackProcessedEmit, SlackProcessedSkip, SlackRawEvent, SlackReactionEvent, SlackSkipReason, SlackWebClientLike, slackConnector, slackConnectorSchema };
+export { FunnelFlumeSlackListener, FunnelSlackAdapter, FunnelSlackEventProcessor, SlackConnectorConfig, SlackConnectorOptions, SlackEvent, SlackInteractiveHandler, SlackMessageEvent, SlackPreprocessEvent, SlackProcessed, SlackProcessedEmit, SlackProcessedSkip, SlackRawEvent, SlackReactionEvent, SlackSkipReason, slackConnector, slackConnectorSchema };

package/dist/connectors/slack.js

@@ -1,3 +1,4 @@
-import { t as slackConnectorSchema } from "../slack-connector-schema-C1zEf4TG.js";
-import { i as FunnelSlackAdapter, n as FunnelSlackListener, r as FunnelSlackEventProcessor, t as slackConnector } from "../slack-connector-DQIFPdBF.js";
-export { FunnelSlackAdapter, FunnelSlackEventProcessor, FunnelSlackListener, slackConnector, slackConnectorSchema };
+import { t as slackConnectorSchema } from "../slack-connector-schema-Dem8to4P.js";
+import { t as FunnelSlackEventProcessor } from "../slack-event-processor-xFDG3US0.js";
+import { n as FunnelFlumeSlackListener, r as FunnelSlackAdapter, t as slackConnector } from "../slack-connector-CxpWagbT.js";
+export { FunnelFlumeSlackListener, FunnelSlackAdapter, FunnelSlackEventProcessor, slackConnector, slackConnectorSchema };

package/dist/diagnostics.d.ts

@@ -1,2 +1,2 @@
-import { a as DiagnosticsGatewayProbe, c as FunnelDiagnostics, d as DiagnosticEvent, f as previewOf, h as toDiagnosticEvent, i as DiagnosticsChannelSource, l as ReplayResult, m as toDiagnosticConnectionError, n as DiagnoseAllReport, o as DiagnosticsPublisher, p as queryRows, r as DiagnosisStatus, s as DiagnosticsTokenReader, t as ChannelDiagnosis, u as DiagnosticConnectionError } from "./funnel-diagnostics-DpXOsCty.js";
+import { a as DiagnosticsGatewayProbe, c as FunnelDiagnostics, d as DiagnosticEvent, f as previewOf, h as toDiagnosticEvent, i as DiagnosticsChannelSource, l as ReplayResult, m as toDiagnosticConnectionError, n as DiagnoseAllReport, o as DiagnosticsPublisher, p as queryRows, r as DiagnosisStatus, s as DiagnosticsTokenReader, t as ChannelDiagnosis, u as DiagnosticConnectionError } from "./funnel-diagnostics-b9ar0Ing.js";
 export { ChannelDiagnosis, DiagnoseAllReport, DiagnosisStatus, DiagnosticConnectionError, DiagnosticEvent, DiagnosticsChannelSource, DiagnosticsGatewayProbe, DiagnosticsPublisher, DiagnosticsTokenReader, FunnelDiagnostics, ReplayResult, previewOf, queryRows, toDiagnosticConnectionError, toDiagnosticEvent };

package/dist/diagnostics.js

@@ -1,2 +1,2 @@
-import { a as toDiagnosticEvent, i as toDiagnosticConnectionError, n as previewOf, r as queryRows, t as FunnelDiagnostics } from "./funnel-diagnostics-CSiJmPlZ.js";
+import { a as toDiagnosticEvent, i as toDiagnosticConnectionError, n as previewOf, r as queryRows, t as FunnelDiagnostics } from "./funnel-diagnostics-Cvk6Sk4x.js";
 export { FunnelDiagnostics, previewOf, queryRows, toDiagnosticConnectionError, toDiagnosticEvent };