@interactive-inc/claude-funnel 0.7.1 → 0.8.1

package/dist/cli/routes/profiles.$profile.as-default.d.ts

@@ -0,0 +1,38 @@
+export declare const asDefaultHelp = "funnel profiles <name> as-default \u2014 move profile to the front of the list\n\nusage: funnel profiles <name> as-default\n\nthe first profile in the list is treated as the default for fnl claude.";
+export declare const profilesAsDefaultHandler: [import("hono/types").H<import("hono").Env, string, {
+    in: {
+        param: {
+            profile: string;
+        };
+    };
+    out: {
+        param: {
+            profile: string;
+        };
+    };
+}, import("hono").TypedResponse<string, import("hono/utils/http-status").ContentfulStatusCode, "text">>, import("hono/types").H<import("hono").Env, string, {
+    in: {
+        query: Record<string, never>;
+    };
+    out: {
+        query: Record<string, never>;
+    };
+}, import("hono").TypedResponse<string, import("hono/utils/http-status").ContentfulStatusCode, "text">>, import("hono/types").H<import("../factory").Env, string, {
+    in: {
+        param: {
+            profile: string;
+        };
+    };
+    out: {
+        param: {
+            profile: string;
+        };
+    };
+} & {
+    in: {
+        query: Record<string, never>;
+    };
+    out: {
+        query: Record<string, never>;
+    };
+}, Response & import("hono").TypedResponse<`profile "${string}" is now the default`, import("hono/utils/http-status").ContentfulStatusCode, "text">>];

package/dist/cli/routes/profiles.$profile.rename.$newName.d.ts

@@ -0,0 +1,42 @@
+export declare const renameHelp = "funnel profiles rename \u2014 rename a profile\n\nusage:\n  funnel profiles rename <old> <new>\n  funnel profiles <old> rename <new>";
+export declare const profilesRenameHandler: [import("hono/types").H<import("hono").Env, string, {
+    in: {
+        param: {
+            profile: string;
+            newName: string;
+        };
+    };
+    out: {
+        param: {
+            profile: string;
+            newName: string;
+        };
+    };
+}, import("hono").TypedResponse<string, import("hono/utils/http-status").ContentfulStatusCode, "text">>, import("hono/types").H<import("hono").Env, string, {
+    in: {
+        query: Record<string, never>;
+    };
+    out: {
+        query: Record<string, never>;
+    };
+}, import("hono").TypedResponse<string, import("hono/utils/http-status").ContentfulStatusCode, "text">>, import("hono/types").H<import("../factory").Env, string, {
+    in: {
+        param: {
+            profile: string;
+            newName: string;
+        };
+    };
+    out: {
+        param: {
+            profile: string;
+            newName: string;
+        };
+    };
+} & {
+    in: {
+        query: Record<string, never>;
+    };
+    out: {
+        query: Record<string, never>;
+    };
+}, Response & import("hono").TypedResponse<`renamed profile "${string}" to "${string}"`, import("hono/utils/http-status").ContentfulStatusCode, "text">>];

package/dist/cli/routes/profiles.$profile.run.d.ts

@@ -0,0 +1,46 @@
+export declare const launchHelp = "funnel profiles <name> run \u2014 launch a profile (sugar for fnl claude)\n\nusage: funnel profiles <name> run [additional claude args...]\n       funnel profiles <name>     (alias)";
+export declare const profilesLaunchHandler: [import("hono/types").H<import("hono").Env, string, {
+    in: {
+        param: {
+            profile: string;
+        };
+    };
+    out: {
+        param: {
+            profile: string;
+        };
+    };
+}, import("hono").TypedResponse<string, import("hono/utils/http-status").ContentfulStatusCode, "text">>, import("hono/types").H<import("hono").Env, string, {
+    in: {
+        query: {
+            [x: string]: string | string[];
+        };
+    };
+    out: {
+        query: {
+            [x: string]: unknown;
+        };
+    };
+}, import("hono").TypedResponse<string, import("hono/utils/http-status").ContentfulStatusCode, "text">>, import("hono/types").H<import("../factory").Env, string, {
+    in: {
+        param: {
+            profile: string;
+        };
+    };
+    out: {
+        param: {
+            profile: string;
+        };
+    };
+} & {
+    in: {
+        query: {
+            [x: string]: string | string[];
+        };
+    };
+    out: {
+        query: {
+            [x: string]: unknown;
+        };
+    };
+}, Promise<never>>];

package/dist/cli/routes/profiles.add.$profile.d.ts

@@ -0,0 +1,54 @@
+export declare const addHelp = "funnel profiles add \u2014 add a profile\n\nusage: funnel profiles add <name> --path <path> --sub-agent <agent> --channel <channel-name>\n\noptions:\n  --path        working directory passed to claude as cwd\n  --sub-agent   sub-agent name passed to claude --agent\n  --channel     channel name (resolved to channel id internally)";
+export declare const profilesAddHandler: [import("hono/types").H<import("hono").Env, string, {
+    in: {
+        param: {
+            profile: string;
+        };
+    };
+    out: {
+        param: {
+            profile: string;
+        };
+    };
+}, import("hono").TypedResponse<string, import("hono/utils/http-status").ContentfulStatusCode, "text">>, import("hono/types").H<import("hono").Env, string, {
+    in: {
+        query: {
+            path: string;
+            "sub-agent": string;
+            channel: string;
+        };
+    };
+    out: {
+        query: {
+            path: string;
+            "sub-agent": string;
+            channel: string;
+        };
+    };
+}, import("hono").TypedResponse<string, import("hono/utils/http-status").ContentfulStatusCode, "text">>, import("hono/types").H<import("../factory").Env, string, {
+    in: {
+        param: {
+            profile: string;
+        };
+    };
+    out: {
+        param: {
+            profile: string;
+        };
+    };
+} & {
+    in: {
+        query: {
+            path: string;
+            "sub-agent": string;
+            channel: string;
+        };
+    };
+    out: {
+        query: {
+            path: string;
+            "sub-agent": string;
+            channel: string;
+        };
+    };
+}, Response & import("hono").TypedResponse<`added profile "${string}"`, import("hono/utils/http-status").ContentfulStatusCode, "text">>];

package/dist/cli/routes/profiles.d.ts

@@ -0,0 +1,16 @@
+export declare const groupHelp = "funnel profiles \u2014 manage launch profiles\n\nusage: funnel profiles [subcommand]\n\nsubcommands:\n  (none)                          list (first entry is the default)\n  add <name> --path <path> --sub-agent <agent> --channel <channel>\n  <name> set [--path ...] [--sub-agent ...] [--channel ...]\n  <name> as-default               move profile to the front (becomes default)\n  rename <old> <new>              rename\n  remove <name>                   remove\n  <name> run                      launch (sugar for fnl claude -p <name>)\n  <name>                          launch (alias for run)\n\nexamples:\n  funnel profiles add cto --path /repo/myapp --sub-agent cto --channel prod-inbox\n  funnel profiles cto as-default\n  funnel profiles cto run";
+export declare const profilesGroupHandler: [import("hono/types").H<import("hono").Env, string, {
+    in: {
+        query: Record<string, never>;
+    };
+    out: {
+        query: Record<string, never>;
+    };
+}, import("hono").TypedResponse<string, import("hono/utils/http-status").ContentfulStatusCode, "text">>, import("hono/types").H<import("../factory").Env, string, {
+    in: {
+        query: Record<string, never>;
+    };
+    out: {
+        query: Record<string, never>;
+    };
+}, Response & import("hono").TypedResponse<string, import("hono/utils/http-status").ContentfulStatusCode, "text">>];

package/dist/cli/routes/profiles.remove.$profile.d.ts

@@ -0,0 +1,38 @@
+export declare const removeHelp = "funnel profiles remove \u2014 remove a profile\n\nusage: funnel profiles remove <name>";
+export declare const profilesRemoveHandler: [import("hono/types").H<import("hono").Env, string, {
+    in: {
+        param: {
+            profile: string;
+        };
+    };
+    out: {
+        param: {
+            profile: string;
+        };
+    };
+}, import("hono").TypedResponse<string, import("hono/utils/http-status").ContentfulStatusCode, "text">>, import("hono/types").H<import("hono").Env, string, {
+    in: {
+        query: Record<string, never>;
+    };
+    out: {
+        query: Record<string, never>;
+    };
+}, import("hono").TypedResponse<string, import("hono/utils/http-status").ContentfulStatusCode, "text">>, import("hono/types").H<import("../factory").Env, string, {
+    in: {
+        param: {
+            profile: string;
+        };
+    };
+    out: {
+        param: {
+            profile: string;
+        };
+    };
+} & {
+    in: {
+        query: Record<string, never>;
+    };
+    out: {
+        query: Record<string, never>;
+    };
+}, Response & import("hono").TypedResponse<`removed profile "${string}"`, import("hono/utils/http-status").ContentfulStatusCode, "text">>];

package/dist/cli/routes/profiles.set.$profile.d.ts

@@ -0,0 +1,54 @@
+export declare const setHelp = "funnel profiles <name> set \u2014 update a profile\n\nusage: funnel profiles <name> set [--path <path>] [--sub-agent <agent>] [--channel <channel-name>]";
+export declare const profilesSetHandler: [import("hono/types").H<import("hono").Env, string, {
+    in: {
+        param: {
+            profile: string;
+        };
+    };
+    out: {
+        param: {
+            profile: string;
+        };
+    };
+}, import("hono").TypedResponse<string, import("hono/utils/http-status").ContentfulStatusCode, "text">>, import("hono/types").H<import("hono").Env, string, {
+    in: {
+        query: {
+            path?: string | undefined;
+            "sub-agent"?: string | undefined;
+            channel?: string | undefined;
+        };
+    };
+    out: {
+        query: {
+            path?: string | undefined;
+            "sub-agent"?: string | undefined;
+            channel?: string | undefined;
+        };
+    };
+}, import("hono").TypedResponse<string, import("hono/utils/http-status").ContentfulStatusCode, "text">>, import("hono/types").H<import("../factory").Env, string, {
+    in: {
+        param: {
+            profile: string;
+        };
+    };
+    out: {
+        param: {
+            profile: string;
+        };
+    };
+} & {
+    in: {
+        query: {
+            path?: string | undefined;
+            "sub-agent"?: string | undefined;
+            channel?: string | undefined;
+        };
+    };
+    out: {
+        query: {
+            path?: string | undefined;
+            "sub-agent"?: string | undefined;
+            channel?: string | undefined;
+        };
+    };
+}, Response & import("hono").TypedResponse<`updated profile "${string}"`, import("hono/utils/http-status").ContentfulStatusCode, "text">>];

package/dist/cli/routes/status.d.ts

@@ -0,0 +1,16 @@
+export declare const statusHelp = "funnel status \u2014 show overall connection status\n\nusage: funnel status\n\nLists configured connectors / channels / profiles, gateway running status,\nand active MCP WebSocket clients.";
+export declare const statusHandler: [import("hono/types").H<import("hono").Env, string, {
+    in: {
+        query: Record<string, never>;
+    };
+    out: {
+        query: Record<string, never>;
+    };
+}, import("hono").TypedResponse<string, import("hono/utils/http-status").ContentfulStatusCode, "text">>, import("hono/types").H<import("../factory").Env, string, {
+    in: {
+        query: Record<string, never>;
+    };
+    out: {
+        query: Record<string, never>;
+    };
+}, Promise<Response & import("hono").TypedResponse<string, import("hono/utils/http-status").ContentfulStatusCode, "text">>>];

package/dist/cli/routes/update.d.ts

@@ -0,0 +1,16 @@
+export declare const updateHelp = "funnel update \u2014 update funnel to the latest version\n\nusage: funnel update\n\nRuns \"bun i -g @interactive-inc/claude-funnel\".";
+export declare const updateHandler: [import("hono/types").H<import("hono").Env, string, {
+    in: {
+        query: Record<string, never>;
+    };
+    out: {
+        query: Record<string, never>;
+    };
+}, import("hono").TypedResponse<string, import("hono/utils/http-status").ContentfulStatusCode, "text">>, import("hono/types").H<import("../factory").Env, string, {
+    in: {
+        query: Record<string, never>;
+    };
+    out: {
+        query: Record<string, never>;
+    };
+}, Promise<Response & import("hono").TypedResponse<"updated @interactive-inc/claude-funnel", import("hono/utils/http-status").ContentfulStatusCode, "text">>>];

package/dist/connectors/connector-adapter.d.ts

@@ -0,0 +1,8 @@
+export type CallInput = {
+    method: string;
+    path: string;
+    body?: unknown;
+};
+export declare abstract class FunnelConnectorAdapter {
+    abstract call(input: CallInput): Promise<unknown>;
+}

package/dist/connectors/connector-config-schema.d.ts

@@ -0,0 +1,43 @@
+import { z } from "zod";
+export declare const connectorConfigSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    type: z.ZodLiteral<"slack">;
+    botToken: z.ZodString;
+    appToken: z.ZodString;
+    createdAt: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, 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>, z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    type: z.ZodLiteral<"discord">;
+    botToken: z.ZodString;
+    createdAt: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, 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">;
+export type ConnectorConfig = z.infer<typeof connectorConfigSchema>;
+export type ConnectorType = ConnectorConfig["type"];

package/dist/connectors/connector-factory.d.ts

@@ -0,0 +1,32 @@
+import type { FunnelConnectorAdapter } from "./connector-adapter";
+import type { ConnectorConfig } from "./connector-config-schema";
+import type { FunnelConnectorListener } from "./connector-listener";
+import { FunnelFileSystem } from "../engine/fs/file-system";
+import { FunnelLogger } from "../engine/logger/logger";
+import { FunnelProcessRunner } from "../engine/process/process-runner";
+type Deps = {
+    fs?: FunnelFileSystem;
+    process?: FunnelProcessRunner;
+    logger?: FunnelLogger;
+    dir?: string;
+};
+/**
+ * Pure factory for per-type listeners and adapters. The factory has no CRUD
+ * responsibility — connector configs live inside settings.json under their
+ * channel, and FunnelChannels passes them in by value.
+ *
+ * `dir` is the funnel home (defaults to ~/.funnel); per-connector state files
+ * land at `<dir>/channels/<channel-id>/connectors/<connector-id>/state.json`.
+ */
+export declare class FunnelConnectorFactory {
+    private readonly fs;
+    private readonly process;
+    private readonly logger;
+    private readonly dir;
+    constructor(deps?: Deps);
+    createListener(channelId: string, config: ConnectorConfig): FunnelConnectorListener;
+    createAdapter(config: ConnectorConfig): FunnelConnectorAdapter | null;
+    connectorDir(channelId: string, connectorId: string): string;
+    channelDir(channelId: string): string;
+}
+export {};

package/dist/connectors/connector-listener.d.ts

@@ -0,0 +1,17 @@
+export 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.
+ */
+export declare abstract class FunnelConnectorListener {
+    abstract start(notify: NotifyFn): Promise<void>;
+    abstract stop(): Promise<void>;
+    isAlive(): boolean;
+}

package/dist/connectors/discord-adapter.d.ts

@@ -0,0 +1,14 @@
+import { FunnelConnectorAdapter, type CallInput } from "./connector-adapter";
+import { FunnelHttpClient } from "../engine/http/http-client";
+import type { DiscordConnectorConfig } from "./discord-connector-schema";
+type Deps = {
+    config: DiscordConnectorConfig;
+    http?: FunnelHttpClient;
+};
+export declare class FunnelDiscordAdapter extends FunnelConnectorAdapter {
+    private readonly token;
+    private readonly http;
+    constructor(deps: Deps);
+    call(input: CallInput): Promise<unknown>;
+}
+export {};

package/dist/connectors/discord-connector-schema.d.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+export declare const discordConnectorSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    type: z.ZodLiteral<"discord">;
+    botToken: z.ZodString;
+    createdAt: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type DiscordConnectorConfig = z.infer<typeof discordConnectorSchema>;

package/dist/connectors/discord-event-processor.d.ts

@@ -0,0 +1,26 @@
+export type DiscordInboundMessage = {
+    authorId: string;
+    authorIsBot: boolean;
+    channelId: string;
+    guildId: string | null;
+    mentionedUserIds: string[];
+    raw: unknown;
+};
+export type DiscordProcessedSkip = {
+    skip: true;
+};
+export type DiscordProcessedEmit = {
+    skip: false;
+    content: string;
+    meta: Record<string, string>;
+};
+export type DiscordProcessed = DiscordProcessedSkip | DiscordProcessedEmit;
+type Props = {
+    ownUserId: string;
+};
+export declare class FunnelDiscordEventProcessor {
+    private readonly ownUserId;
+    constructor(props: Props);
+    process(message: DiscordInboundMessage): DiscordProcessed;
+}
+export {};

package/dist/connectors/discord-listener.d.ts

@@ -0,0 +1,17 @@
+import { FunnelConnectorListener, type NotifyFn } from "./connector-listener";
+import { FunnelLogger } from "../engine/logger/logger";
+import type { DiscordConnectorConfig } from "./discord-connector-schema";
+type Deps = {
+    config: DiscordConnectorConfig;
+    logger?: FunnelLogger;
+};
+export declare class FunnelDiscordListener extends FunnelConnectorListener {
+    private readonly config;
+    private readonly logger;
+    private client;
+    constructor(deps: Deps);
+    start(notify: NotifyFn): Promise<void>;
+    stop(): Promise<void>;
+    isAlive(): boolean;
+}
+export {};

package/dist/connectors/gh-adapter.d.ts

@@ -0,0 +1,11 @@
+import { FunnelConnectorAdapter, type CallInput } from "./connector-adapter";
+import { FunnelProcessRunner } from "../engine/process/process-runner";
+type Deps = {
+    process?: FunnelProcessRunner;
+};
+export declare class FunnelGhAdapter extends FunnelConnectorAdapter {
+    private readonly process;
+    constructor(deps?: Deps);
+    call(input: CallInput): Promise<unknown>;
+}
+export {};

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

@@ -0,0 +1,10 @@
+import { z } from "zod";
+export 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>;
+export type GhConnectorConfig = z.infer<typeof ghConnectorSchema>;

package/dist/connectors/gh-listener.d.ts

@@ -0,0 +1,26 @@
+import { FunnelConnectorListener, type NotifyFn } from "./connector-listener";
+import { FunnelLogger } from "../engine/logger/logger";
+import { FunnelProcessRunner } from "../engine/process/process-runner";
+import type { GhConnectorConfig } from "./gh-connector-schema";
+type Deps = {
+    config: GhConnectorConfig;
+    process?: FunnelProcessRunner;
+    logger?: FunnelLogger;
+    now?: () => Date;
+};
+export declare class FunnelGhListener extends FunnelConnectorListener {
+    private readonly config;
+    private readonly process;
+    private readonly logger;
+    private readonly now;
+    private readonly seen;
+    private bootstrapped;
+    private since;
+    private timer;
+    constructor(deps: Deps);
+    start(notify: NotifyFn): Promise<void>;
+    stop(): Promise<void>;
+    isAlive(): boolean;
+    pollOnce(notify: NotifyFn): Promise<void>;
+}
+export {};

package/dist/connectors/match-cron.d.ts

@@ -0,0 +1 @@
+export declare const matchCron: (expr: string, date: Date) => boolean;

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

@@ -0,0 +1,45 @@
+import { z } from "zod";
+/**
+ * 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.
+ */
+export declare const scheduleCatchupPolicySchema: z.ZodEnum<{
+    latest: "latest";
+    all: "all";
+    skip: "skip";
+}>;
+export type ScheduleCatchupPolicy = z.infer<typeof scheduleCatchupPolicySchema>;
+export 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>;
+export type ScheduleEntry = z.infer<typeof scheduleEntrySchema>;
+export 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>;
+export type ScheduleConnectorConfig = z.infer<typeof scheduleConnectorSchema>;

package/dist/connectors/schedule-listener.d.ts

@@ -0,0 +1,30 @@
+import { FunnelConnectorListener, type NotifyFn } from "./connector-listener";
+import { ScheduleStateStore } from "./schedule-state-store";
+import { FunnelLogger } from "../engine/logger/logger";
+import type { ScheduleConnectorConfig } from "./schedule-connector-schema";
+type Deps = {
+    config: ScheduleConnectorConfig;
+    lastFiredStore: ScheduleStateStore;
+    logger?: FunnelLogger;
+    now?: () => Date;
+};
+export declare class FunnelScheduleListener extends FunnelConnectorListener {
+    private readonly config;
+    private readonly lastFiredStore;
+    private readonly logger;
+    private readonly now;
+    private timer;
+    private stopped;
+    constructor(deps: Deps);
+    start(notify: NotifyFn): Promise<void>;
+    stop(): Promise<void>;
+    isAlive(): boolean;
+    tick(notify: NotifyFn): Promise<void>;
+    private fireEntry;
+    private notifyOne;
+    private findMostRecentMatch;
+    private findAllMatches;
+    private logInvalidCron;
+    private truncateToMinute;
+}
+export {};

package/dist/connectors/schedule-state-store.d.ts

@@ -0,0 +1,19 @@
+import { FunnelFileSystem } from "../engine/fs/file-system";
+type Deps = {
+    path: string;
+    fs?: FunnelFileSystem;
+};
+/**
+ * Per-connector lastFiredAt persistence for the schedule listener. The path is
+ * passed in by FunnelConnectorFactory so this store does not know about the
+ * funnel directory layout (`channels/<id>/connectors/<id>/state.json` lives
+ * outside this class).
+ */
+export declare class ScheduleStateStore {
+    private readonly path;
+    private readonly fs;
+    constructor(deps: Deps);
+    load(): Map<string, Date>;
+    save(state: Map<string, Date>): void;
+}
+export {};