@interactive-inc/claude-funnel 0.66.0 → 0.68.0

package/dist/connector-descriptor-CmyHlEiT.d.ts

@@ -1,380 +0,0 @@
-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/process/process-runner.d.ts
-type RunOptions = {
-  cwd?: string;
-  env?: Record<string, string>;
-  input?: string;
-};
-type RunResult = {
-  exitCode: number;
-  stdout: string;
-  stderr: string;
-};
-type AttachOptions = {
-  cwd?: string;
-  env?: Record<string, string>;
-  /** Invoked synchronously after the child process has been spawned, with its PID.
-   *  Useful for hosts that need to register the spawned process before it exits. */
-  onSpawned?: (pid: number) => void;
-};
-type DetachOptions = {
-  env?: Record<string, string>; /** Append stdout to this file. Parent dir is the caller's responsibility. */
-  stdoutFile?: string; /** Append stderr to this file. Parent dir is the caller's responsibility. */
-  stderrFile?: string;
-};
-type ProcessSnapshot = {
-  pid: number;
-  command: string;
-};
-/**
- * Process boundary covering one-shot runs, sync runs, foreground attach, and
- * detached background spawns. Default is NodeFunnelProcessRunner (Bun.spawn);
- * MemoryFunnelProcessRunner records calls and lets tests stub responses.
- *
- * Liveness and process-listing helpers absorb POSIX/Windows differences so
- * callers do not branch on `process.platform`. `isAlive` checks whether a PID
- * names a live (non-zombie) process; `listProcessesContaining` enumerates
- * processes whose command line includes `marker`, used for funnel-gateway tag
- * matching across daemons that share a home dir. `getStartTime` returns a
- * stable string identifying when a PID was started, used to detect PID reuse
- * after the original process died abnormally (no exit hook fired).
- */
-declare abstract class FunnelProcessRunner {
-  abstract run(command: string[], options?: RunOptions): Promise<RunResult>;
-  abstract runSync(command: string[]): RunResult;
-  abstract attach(command: string[], options?: AttachOptions): Promise<number>;
-  abstract detach(command: string[], options?: DetachOptions): void;
-  abstract kill(pid: number, signal?: string): void;
-  abstract isAlive(pid: number): boolean;
-  abstract listProcessesContaining(marker: string): ProcessSnapshot[];
-  abstract getStartTime(pid: number): string | null;
-}
-//#endregion
-//#region lib/engine/connectors/base-connector-config.d.ts
-/**
- * Fields every connector config carries, regardless of type. The discriminated
- * union of concrete connector configs no longer lives in core: each connector
- * type owns its full schema inside its descriptor, and core handles connectors
- * through this base shape plus the injected registry. `type` is an open string
- * here on purpose — core does not enumerate the known connector types.
- */
-declare const baseConnectorConfigSchema: z.ZodObject<{
-  id: z.ZodString;
-  name: z.ZodString;
-  type: z.ZodString;
-  createdAt: z.ZodOptional<z.ZodString>;
-  updatedAt: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-type BaseConnectorConfig = z.infer<typeof baseConnectorConfigSchema>;
-//#endregion
-//#region lib/engine/connectors/connector-adapter.d.ts
-/**
- * A JSON-serializable value. Connector call bodies are sent to external APIs as
- * JSON, so the body must be representable as JSON — `JsonValue` says exactly
- * that, replacing a bare `unknown` that let non-serializable values (functions,
- * symbols, class instances) slip through to `JSON.stringify`.
- */
-type JsonValue = string | number | boolean | null | JsonValue[] | {
-  [key: string]: JsonValue;
-};
-type CallInput = {
-  method: string;
-  path: string; /** JSON request body. Omit for GET-like calls. */
-  body?: JsonValue;
-};
-declare abstract class FunnelConnectorAdapter {
-  /**
-   * Dispatches one Claude → external call. The response is the external API's
-   * raw payload, typed `unknown` because its shape is the provider's concern —
-   * the caller (Claude, via MCP) interprets it.
-   */
-  abstract call(input: CallInput): Promise<unknown>;
-}
-//#endregion
-//#region lib/engine/connectors/connector-listener.d.ts
-type NotifyFn = (content: string, meta?: Record<string, string>) => Promise<void>;
-/**
- * Long-lived event source for one connector.
- *
- * `start()` opens the underlying connection (Slack Socket Mode, Discord
- * Gateway, GH polling, schedule tick) and pushes events through `notify`.
- * `stop()` releases the resources so the supervisor can recreate the listener
- * with new config without restarting the whole gateway. `isAlive()` lets the
- * supervisor periodically health-check and auto-restart dead listeners; the
- * default optimistic implementation is fine for poll/tick-based listeners
- * that self-heal.
- */
-declare abstract class FunnelConnectorListener {
-  abstract start(notify: NotifyFn): Promise<void>;
-  abstract stop(): Promise<void>;
-  isAlive(): boolean;
-}
-//#endregion
-//#region lib/engine/diagnostic-log/diagnostic-log.d.ts
-/**
- * Points in the listener's connection lifecycle. The single source of truth
- * for the value set: the `status` column schema, the `ConnectorConnectionStatus`
- * union, and the runtime Set used to narrow on read-back all derive from this
- * array, so adding a status is a one-line change that cannot drift out of sync.
- *
- *   started       start() was called
- *   connected     the socket opened and events can flow
- *   disconnected  the socket was closed by a stop() call (a clean teardown)
- *   auth-failed   the token was rejected before the socket opened
- *   stopped       the listener was fully torn down (always follows a stop(),
- *                 paired with the disconnected/error that preceded it)
- *   error         start/stop threw, or Bolt surfaced an error frame — this is
- *                 also where an unsolicited socket drop shows up when Bolt
- *                 reports it (an `error` with no following `stopped` means the
- *                 supervisor recycled the listener, not a clean stop)
- *
- * A connection row is independent of any single inbound event, so it carries
- * no `eventId`. This is how "no notification arrived because the listener
- * never connected (or dropped, or failed auth)" becomes visible: the
- * raw/processed tables only hold events that *did* arrive.
- */
-declare const CONNECTOR_CONNECTION_STATUSES: readonly ["started", "connected", "disconnected", "auth-failed", "stopped", "error"];
-type ConnectorConnectionStatus = (typeof CONNECTOR_CONNECTION_STATUSES)[number];
-/**
- * Rows stored in the diagnostic tables. Connector-agnostic on purpose: `type`
- * carries the listener kind ("slack" | "discord" | "gh" | "schedule") so new
- * connectors land in the same tables without a schema change. `event_id` is
- * the correlation key the listener mints once per inbound event and stamps
- * onto both the raw and processed rows, so the two are joinable even though
- * they live in separate tables with independent `seq` counters.
- *
- * These schemas mirror the stored shape (snake_case columns) the way
- * `FunnelEvent` does for the replay log; they exist for `z.infer` and to
- * document the column set, not as a parse boundary.
- */
-declare const connectorRawEventSchema: z.ZodObject<{
-  event_id: z.ZodString;
-  type: z.ZodString;
-  connector_id: z.ZodNullable<z.ZodString>;
-  channel_id: z.ZodNullable<z.ZodString>;
-  payload: z.ZodString;
-}, z.core.$strip>;
-type ConnectorRawEvent = z.infer<typeof connectorRawEventSchema>;
-declare const connectorProcessedEventSchema: z.ZodObject<{
-  event_id: z.ZodString;
-  type: z.ZodString;
-  connector_id: z.ZodNullable<z.ZodString>;
-  channel_id: z.ZodNullable<z.ZodString>;
-  outcome: z.ZodString;
-  payload: z.ZodString;
-}, z.core.$strip>;
-type ConnectorProcessedEvent = z.infer<typeof connectorProcessedEventSchema>;
-declare const connectorConnectionEventSchema: z.ZodObject<{
-  type: z.ZodString;
-  connector_id: z.ZodNullable<z.ZodString>;
-  channel_id: z.ZodNullable<z.ZodString>;
-  status: z.ZodEnum<{
-    error: "error";
-    started: "started";
-    connected: "connected";
-    disconnected: "disconnected";
-    "auth-failed": "auth-failed";
-    stopped: "stopped";
-  }>;
-  detail: z.ZodString;
-}, z.core.$strip>;
-type ConnectorConnectionEvent = z.infer<typeof connectorConnectionEventSchema>;
-/** The connector a row belongs to — the axis every diagnostic table shares. */
-type ConnectorRef = {
-  type: string;
-  connectorId: string | null;
-  channelId: string | null;
-};
-/** A row tied to one inbound event, joinable to its twin by `eventId`. */
-type ConnectorEventKeys = ConnectorRef & {
-  /** Correlation id shared by the raw and processed rows of the same inbound event. */eventId: string;
-};
-/** One untouched inbound event to persist, before any processing. */
-type ConnectorRawRecord = ConnectorEventKeys & {
-  /** The listener's untouched payload, already JSON-stringified by the caller. */payload: string;
-};
-/** The processor's verdict for one inbound event. */
-type ConnectorProcessedRecord = ConnectorEventKeys & {
-  /**
-   * "emitted" on successful delivery, "emitted:delivery-failed" when the
-   * downstream notify threw, or "skip:<reason>" when the processor dropped it.
-   */
-  outcome: string;
-  /**
-   * The delivered body (content + meta) for an emitted event. For a skipped
-   * event there is no body, so the listener records the event JSON here
-   * instead — keeping a skipped row self-describing rather than blank.
-   */
-  payload: string;
-};
-type ConnectorConnectionRecord = ConnectorRef & {
-  status: ConnectorConnectionStatus; /** Free-form context (an error message, a reason) or "" when none. */
-  detail: string;
-};
-/**
- * Filters every table query accepts — the read-side mirror of `ConnectorRef`.
- * Each per-table query extends this with its own table's column, the same way
- * each record extends `ConnectorRef`, so neither half of the file treats one
- * table's shape as the base for the others.
- */
-type ConnectorQuery = {
-  type?: string;
-  connectorId?: string | null;
-  channelId?: string | null; /** Cap on returned rows. The most recent matching rows are returned, oldest first. */
-  limit?: number;
-};
-type ConnectorRawQuery = ConnectorQuery;
-type ConnectorProcessedQuery = ConnectorQuery & {
-  outcome?: string;
-};
-type ConnectorConnectionQuery = ConnectorQuery & {
-  status?: ConnectorConnectionStatus;
-};
-/**
- * A stored row, ascending by `seq`. `seq` is per-table (each table counts
- * independently) and is for ordering within one table, not for correlating
- * across them — use `eventId` to join raw and processed.
- */
-type StoredRawEvent = ConnectorRawRecord & {
-  seq: number;
-  ts: number;
-};
-type StoredProcessedEvent = ConnectorProcessedRecord & {
-  seq: number;
-  ts: number;
-};
-type StoredConnectionEvent = ConnectorConnectionRecord & {
-  seq: number;
-  ts: number;
-};
-/**
- * Three-table diagnostic log of everything a connector listener does, so
- * "why was there no notification?" is answerable whichever way it failed:
- *   - `raw` — every inbound event, before any filtering, with the listener's
- *     untouched payload (the Slack Bolt event, the GH webhook, …)
- *   - `processed` — the verdict for that event: `outcome` (emitted, or the
- *     reason it was dropped) and, when emitted, the body that was delivered.
- *     Shares an `eventId` with its raw row, so the two join into one story.
- *   - `connection` — the listener's lifecycle (started, connected, dropped,
- *     auth-failed, stopped, errored). This is the half the event tables can't
- *     show: an event that never arrived leaves no raw row, but a listener that
- *     never connected leaves a `connection` trail that says so.
- *
- * The three are physically separate (independent retention and payload-size
- * policy) so a query never crosses them by accident and a huge raw payload
- * never bloats the verdict or lifecycle trails. None flow to WS clients or the
- * MCP channel — this is a separate store from `FunnelEventLog` (replay) and
- * exists solely for debugging.
- *
- * Implementations:
- *   - `SqliteConnectorDiagnosticLog` — the default; survives daemon restarts,
- *     bounded by per-table row/age caps.
- *   - `MemoryConnectorDiagnosticLog` — an in-process double for tests.
- */
-declare abstract class ConnectorDiagnosticLog {
-  abstract recordRaw(record: ConnectorRawRecord): void;
-  abstract recordProcessed(record: ConnectorProcessedRecord): void;
-  abstract recordConnection(record: ConnectorConnectionRecord): void;
-  abstract queryRaw(query: ConnectorRawQuery): StoredRawEvent[];
-  abstract queryProcessed(query: ConnectorProcessedQuery): StoredProcessedEvent[];
-  abstract queryConnection(query: ConnectorConnectionQuery): StoredConnectionEvent[];
-  /** Drop every diagnostic row across all three tables and reclaim the files. */
-  abstract clear(): void;
-  abstract close(): void;
-}
-//#endregion
-//#region lib/engine/http/http-client.d.ts
-type HttpRequest = {
-  method: string;
-  url: string;
-  headers?: Record<string, string>;
-  body?: string;
-};
-type HttpResponse = {
-  status: number;
-  ok: boolean;
-  text(): Promise<string>;
-  json(): Promise<unknown>;
-};
-declare abstract class FunnelHttpClient {
-  abstract fetch(request: HttpRequest): Promise<HttpResponse>;
-}
-//#endregion
-//#region lib/engine/connectors/connector-descriptor.d.ts
-/** Boundaries a listener needs, supplied by the registry at build time. */
-type ConnectorListenerDeps = {
-  channelId: string;
-  fs: FunnelFileSystem;
-  process: FunnelProcessRunner; /** HTTP client for self-detection (Slack auth.test), reactions, and other listener-side REST calls. */
-  http: FunnelHttpClient; /** Wall clock — listeners that own a timer (schedule) read it from here so tests can inject a fake. */
-  clock: FunnelClock;
-  logger?: FunnelLogger;
-  diagnosticLog?: ConnectorDiagnosticLog;
-  /**
-   * Optional shutdown signal forwarded to flume-backed listeners. When the
-   * host aborts the signal, the listener's Flume tears down its WebSocket /
-   * fetch loop without waiting for the supervisor's `stop()`. Hosts that want
-   * a clean SIGTERM story wire `controller.signal` here and call
-   * `controller.abort()` in their shutdown handler.
-   */
-  signal?: AbortSignal; /** Resolves the per-connector state directory (`<dir>/channels/<id>/connectors/<id>`). */
-  connectorDir: (channelId: string, connectorId: string) => string;
-};
-/** Boundaries an adapter needs. Adapters are channel-agnostic. */
-type ConnectorAdapterDeps = {
-  fs: FunnelFileSystem;
-  process: FunnelProcessRunner; /** HTTP client for outbound calls. Used by the Slack adapter, future REST adapters. */
-  http: FunnelHttpClient;
-  logger?: FunnelLogger;
-};
-type ConnectorBuildContext = {
-  id: string;
-  now: string;
-};
-type ConnectorUpdateContext = {
-  now: string;
-};
-type ConnectorOperationContext = {
-  generateId: () => string;
-  now: string;
-};
-/**
- * One named operation a connector type exposes beyond plain CRUD (e.g. schedule
- * entry add/remove/list). Returns the next config and an arbitrary result; when
- * the returned config is reference-equal to the input, the channels layer treats
- * the call as a read and skips persistence.
- */
-type ConnectorOperation = (props: {
-  config: BaseConnectorConfig;
-  args: unknown;
-  context: ConnectorOperationContext;
-}) => {
-  config: BaseConnectorConfig;
-  result: unknown;
-};
-/**
- * Everything core needs to handle one connector type, without importing it. A
- * descriptor accepts/returns `BaseConnectorConfig` at every boundary and parses
- * to its concrete config internally (via `schema`), so the registry can hold a
- * homogeneous `ConnectorDescriptor[]` with no variance gymnastics. Type-specific
- * launch hooks (e.g. Schedule `onFired`) are closed over by the descriptor
- * factory, not threaded through here. Each descriptor parses configs to its
- * concrete shape internally (it owns its zod schema), so no schema is exposed
- * here — that also sidesteps the variance trap of a `ZodType<Slack>` field
- * declared as `ZodType<BaseConnectorConfig>`.
- */
-type ConnectorDescriptor = {
-  type: string;
-  createListener: (config: BaseConnectorConfig, deps: ConnectorListenerDeps) => FunnelConnectorListener;
-  createAdapter: ((config: BaseConnectorConfig, deps: ConnectorAdapterDeps) => FunnelConnectorAdapter) | null; /** Whether the MCP channel server exposes this type as a callable tool. */
-  toolExposed: boolean;
-  secretTokens: (config: BaseConnectorConfig) => string[];
-  buildConfig: (input: Record<string, unknown>, context: ConnectorBuildContext) => BaseConnectorConfig;
-  applyUpdate: (config: BaseConnectorConfig, fields: Record<string, unknown>, context: ConnectorUpdateContext) => BaseConnectorConfig;
-  operations: Record<string, ConnectorOperation>;
-};
-//#endregion
-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/diagnostic-sql-reader-oXZnWFf_.js

@@ -1,83 +0,0 @@
-import { Database } from "bun:sqlite";
-//#region lib/engine/diagnostic-log/diagnostic-sql-reader.ts
-/**
-* Read-only SQL surface over the three diagnostic tables, for Claude to query
-* the log with arbitrary `SELECT`s. It opens all files read-only and exposes
-* three views — `raw`, `processed`, `connection` — that hide the storage
-* details (the physical table is `logs` and each row's columns live
-* inside a JSON `event` blob): the views surface the columns as plain fields,
-* with `payload` already pulled out of the nested JSON.
-*
-* The tables are separate files. `raw` and `processed` share an `event_id`,
-* so a `JOIN` answers "the event arrived, but what verdict did it get?";
-* `connection` answers the other half — "did the listener ever connect at
-* all?". Writes are impossible: the connection is read-only and `query`
-* rejects anything but a single `SELECT`.
-*/
-var ConnectorDiagnosticSqlReader = class {
-	db;
-	constructor(props) {
-		const db = new Database(props.rawPath, { readonly: true });
-		try {
-			db.run("PRAGMA busy_timeout = 500");
-			db.prepare("ATTACH DATABASE ? AS processeddb").run(props.processedPath);
-			db.prepare("ATTACH DATABASE ? AS connectiondb").run(props.connectionPath);
-			db.run(rawViewSql);
-			db.run(processedViewSql);
-			db.run(connectionViewSql);
-		} catch (error) {
-			db.close();
-			throw error;
-		}
-		this.db = db;
-		Object.freeze(this);
-	}
-	/**
-	* Run one read-only `SELECT` and return the rows. Returns an `Error` (rather
-	* than throwing) for a non-SELECT statement or a SQL error, so the caller
-	* can surface the message without a stack trace.
-	*/
-	query(sql, params = []) {
-		const trimmed = sql.trim().replace(/;$/, "").trim();
-		if (!/^select\b/i.test(trimmed)) return /* @__PURE__ */ new Error("only a single SELECT statement is allowed");
-		if (trimmed.includes(";")) return /* @__PURE__ */ new Error("only a single statement is allowed (remove the ';')");
-		try {
-			return this.db.prepare(trimmed).all(...params);
-		} catch (error) {
-			return error instanceof Error ? error : new Error(String(error));
-		}
-	}
-	close() {
-		this.db.close();
-	}
-};
-const rawViewSql = `CREATE TEMP VIEW raw AS SELECT
-  seq,
-  ts,
-  json_extract(event, '$.event_id')     AS event_id,
-  json_extract(event, '$.type')         AS type,
-  json_extract(event, '$.connector_id') AS connector_id,
-  json_extract(event, '$.channel_id')   AS channel_id,
-  json_extract(event, '$.payload')      AS payload
-FROM main.logs`;
-const processedViewSql = `CREATE TEMP VIEW processed AS SELECT
-  seq,
-  ts,
-  json_extract(event, '$.event_id')     AS event_id,
-  json_extract(event, '$.type')         AS type,
-  json_extract(event, '$.connector_id') AS connector_id,
-  json_extract(event, '$.channel_id')   AS channel_id,
-  json_extract(event, '$.outcome')      AS outcome,
-  json_extract(event, '$.payload')      AS payload
-FROM processeddb.logs`;
-const connectionViewSql = `CREATE TEMP VIEW connection AS SELECT
-  seq,
-  ts,
-  json_extract(event, '$.type')         AS type,
-  json_extract(event, '$.connector_id') AS connector_id,
-  json_extract(event, '$.channel_id')   AS channel_id,
-  json_extract(event, '$.status')       AS status,
-  json_extract(event, '$.detail')       AS detail
-FROM connectiondb.logs`;
-//#endregion
-export { ConnectorDiagnosticSqlReader as t };

package/dist/file-system-Wvzc2ePY.js

@@ -1,9 +0,0 @@
-//#region lib/engine/fs/file-system.ts
-/**
-* Filesystem boundary used everywhere funnel reads or writes.
-* Default is NodeFunnelFileSystem (real `node:fs`); MemoryFunnelFileSystem
-* provides a sandbox for tests and embedded use.
-*/
-var FunnelFileSystem = class {};
-//#endregion
-export { FunnelFileSystem as t };

package/dist/logger-B6iyNbxM.js

@@ -1,9 +0,0 @@
-//#region lib/engine/logger/logger.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.
-*/
-var FunnelLogger = class {};
-//#endregion
-export { FunnelLogger as t };

package/dist/schedule-connector-schema-D7ZEKvit.d.ts

@@ -1,49 +0,0 @@
-import { z } from "zod";
-
-//#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
-export { scheduleConnectorSchema as a, scheduleCatchupPolicySchema as i, ScheduleConnectorConfig as n, scheduleEntrySchema as o, ScheduleEntry as r, ScheduleCatchupPolicy as t };

package/dist/schedule-connector-schema-DKEPZnVv.js

@@ -1,31 +0,0 @@
-import { z } from "zod";
-//#region lib/engine/connectors/schedule-connector-schema.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.
-*/
-const scheduleCatchupPolicySchema = z.enum([
-	"latest",
-	"all",
-	"skip"
-]);
-const scheduleEntrySchema = z.object({
-	id: z.string(),
-	cron: z.string(),
-	prompt: z.string(),
-	enabled: z.boolean().default(true),
-	catchupPolicy: scheduleCatchupPolicySchema.default("latest")
-});
-const scheduleConnectorSchema = z.object({
-	id: z.string(),
-	name: z.string(),
-	type: z.literal("schedule"),
-	entries: z.array(scheduleEntrySchema).default([]),
-	createdAt: z.string().datetime().optional(),
-	updatedAt: z.string().datetime().optional()
-});
-//#endregion
-export { scheduleConnectorSchema as n, scheduleEntrySchema as r, scheduleCatchupPolicySchema as t };

package/dist/settings-reader-9FcX3qS1.js

@@ -1,11 +0,0 @@
-//#region lib/engine/id/id-generator.ts
-/**
-* ID generator boundary. Default NodeFunnelIdGenerator wraps `crypto.randomUUID()`;
-* MemoryFunnelIdGenerator emits `<prefix>-1, <prefix>-2, ...` for deterministic tests.
-*/
-var FunnelIdGenerator = class {};
-//#endregion
-//#region lib/engine/settings/settings-reader.ts
-var FunnelSettingsReader = class {};
-//#endregion
-export { FunnelIdGenerator as n, FunnelSettingsReader as t };