@interactive-inc/claude-funnel 0.66.0 → 0.68.0

package/dist/{profiles-ZHLONml4.js → profiles-KpN7_gBw.js}

@@ -1,6 +1,17 @@
-import { t as NodeFunnelFileSystem } from "./node-file-system-BOXIHW_Q.js";
+import { t as NodeFunnelFileSystem } from "./node-file-system-xJx7dymE.js";
 import { join } from "node:path";
 import { homedir } from "node:os";
+//#region lib/engine/claude/session-file-exists.ts
+/**
+* Checks the Claude session path selected by the launch environment and rejects
+* empty jsonl files that Claude itself cannot resume.
+*/
+function sessionFileExists(props) {
+	const path = join(props.env.CLAUDE_CONFIG_DIR ?? globalThis.process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude"), "projects", props.cwd.replace(/\//g, "-"), `${props.sessionId}.jsonl`);
+	if (!props.fs.existsSync(path)) return false;
+	return props.fs.readFileSync(path).trim().length > 0;
+}
+//#endregion
 //#region lib/engine/profiles/profiles.ts
 const defaultFs = new NodeFunnelFileSystem();
 /**
@@ -106,9 +117,12 @@ var FunnelProfiles = class {
 	* bad resume.
 	*/
 	sessionFileExists(cwd, sessionId, env) {
-		const path = join(env.CLAUDE_CONFIG_DIR ?? globalThis.process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude"), "projects", cwd.replace(/\//g, "-"), `${sessionId}.jsonl`);
-		if (!this.fs.existsSync(path)) return false;
-		return this.fs.readFileSync(path).trim().length > 0;
+		return sessionFileExists({
+			fs: this.fs,
+			cwd,
+			sessionId,
+			env
+		});
 	}
 	update(name, fields) {
 		this.store.update((settings) => {
@@ -126,4 +140,4 @@ var FunnelProfiles = class {
 	}
 };
 //#endregion
-export { FunnelProfiles as t };
+export { sessionFileExists as n, FunnelProfiles as t };

package/dist/profiles.d.ts

@@ -1,2 +1,2 @@
-import { t as FunnelProfiles } from "./profiles-M24JrcOh.js";
+import { t as FunnelProfiles } from "./profiles-CePRnv3F.js";
 export { FunnelProfiles };

package/dist/profiles.js

@@ -1,2 +1,2 @@
-import { t as FunnelProfiles } from "./profiles-ZHLONml4.js";
+import { t as FunnelProfiles } from "./profiles-KpN7_gBw.js";
 export { FunnelProfiles };

package/dist/recovery.d.ts

@@ -1,2 +1,2 @@
-import { a as RecoveryListenerControl, i as RecoveryGatewayControl, n as RecoveryAction, o as RecoveryResult, r as RecoveryChannelSource, t as FunnelRecovery } from "./funnel-recovery-D8MkiTpk.js";
+import { a as RecoveryListenerControl, i as RecoveryGatewayControl, n as RecoveryAction, o as RecoveryResult, r as RecoveryChannelSource, t as FunnelRecovery } from "./funnel-recovery-BwcSNNSN.js";
 export { FunnelRecovery, RecoveryAction, RecoveryChannelSource, RecoveryGatewayControl, RecoveryListenerControl, RecoveryResult };

package/dist/recovery.js

@@ -1,2 +1,2 @@
-import { t as FunnelRecovery } from "./funnel-recovery-DKnEutUS.js";
+import { t as FunnelRecovery } from "./funnel-recovery-DYbSYGWC.js";
 export { FunnelRecovery };

package/dist/{schedule-connector-9k3gOIgl.js → schedule-connector-BXUOYgwZ.js}

@@ -1,85 +1,10 @@
-import { t as NodeFunnelFileSystem } from "./node-file-system-BOXIHW_Q.js";
-import { t as errorMessageOf } from "./error-message-of-ColuYmAk.js";
-import { t as FunnelConnectorListener } from "./connector-listener-mPGZYa8e.js";
-import { n as scheduleConnectorSchema, r as scheduleEntrySchema } from "./schedule-connector-schema-DKEPZnVv.js";
-import { t as FunnelConnectorDiagnosticsRecorder } from "./connector-diagnostics-recorder-COtNEmUp.js";
+import { t as NodeFunnelFileSystem } from "./node-file-system-xJx7dymE.js";
+import { t as errorMessageOf } from "./error-message-of-BG4ezZ_s.js";
+import { t as FunnelConnectorListener } from "./connector-listener-BcQMzY6Q.js";
+import { a as scheduleConnectorSchema, c as matchCron, o as scheduleEntryInputSchema, s as scheduleEntrySchema } from "./schedule-connector-schema-CNV8PgWX.js";
+import { t as FunnelConnectorDiagnosticsRecorder } from "./connector-diagnostics-recorder-BmOijU1p.js";
 import { dirname, join } from "node:path";
 import { z } from "zod";
-//#region lib/engine/connectors/match-cron.ts
-const parseField = (expr, min, max) => {
-	const values = /* @__PURE__ */ new Set();
-	for (const part of expr.split(",")) {
-		const [rangePart, stepPart] = part.split("/");
-		const step = stepPart ? Number(stepPart) : 1;
-		if (!Number.isFinite(step) || step <= 0) throw new Error(`invalid cron step: "${stepPart}"`);
-		let lo = min;
-		let hi = max;
-		if (rangePart === "*" || rangePart === void 0 || rangePart === "") {
-			lo = min;
-			hi = max;
-		} else if (rangePart.includes("-")) {
-			const [aStr, bStr] = rangePart.split("-");
-			const a = Number(aStr);
-			const b = Number(bStr);
-			if (!Number.isFinite(a) || !Number.isFinite(b)) throw new Error(`invalid cron range: "${rangePart}"`);
-			lo = a;
-			hi = b;
-		} else {
-			const n = Number(rangePart);
-			if (!Number.isFinite(n)) throw new Error(`invalid cron value: "${rangePart}"`);
-			lo = n;
-			hi = stepPart ? max : n;
-		}
-		if (lo < min || hi > max || lo > hi) throw new Error(`cron value out of range: ${rangePart} (must be ${min}-${max})`);
-		for (let i = lo; i <= hi; i += step) values.add(i);
-	}
-	return {
-		min,
-		max,
-		values
-	};
-};
-/**
-* Returns true when `date` (local time) satisfies a 5-field cron expression.
-*
-* Two deliberate deviations from Vixie cron, called out so schedules are not
-* written expecting the other behavior:
-*   - Day-of-month and day-of-week are ANDed, not ORed. Vixie cron fires when
-*     EITHER matches once both are restricted; here every field must match.
-*   - Day-of-week is 0-6 (Sunday=0). `7` for Sunday is NOT accepted (it throws
-*     as out-of-range); use `0`.
-*/
-const matchCron = (expr, date) => {
-	const parts = expr.trim().split(/\s+/);
-	if (parts.length !== 5) throw new Error(`cron must have 5 fields (got ${parts.length}): "${expr}"`);
-	const [minute, hour, dom, month, dow] = parts;
-	if (!minute || !hour || !dom || !month || !dow) throw new Error(`cron has empty fields: "${expr}"`);
-	const fields = [
-		{
-			field: parseField(minute, 0, 59),
-			value: date.getMinutes()
-		},
-		{
-			field: parseField(hour, 0, 23),
-			value: date.getHours()
-		},
-		{
-			field: parseField(dom, 1, 31),
-			value: date.getDate()
-		},
-		{
-			field: parseField(month, 1, 12),
-			value: date.getMonth() + 1
-		},
-		{
-			field: parseField(dow, 0, 6),
-			value: date.getDay()
-		}
-	];
-	for (const { field, value } of fields) if (!field.values.has(value)) return false;
-	return true;
-};
-//#endregion
 //#region lib/engine/connectors/schedule-state-store.ts
 const defaultFs = new NodeFunnelFileSystem();
 /**
@@ -190,16 +115,35 @@ var FunnelScheduleListener = class extends FunnelConnectorListener {
 	async tick(notify) {
 		const now = this.truncateToMinute(this.now());
 		const state = this.lastFiredStore.load();
-		let changed = false;
+		const changes = [this.pruneRemovedEntries(state)];
 		for (const entry of this.config.entries) {
 			if (!entry.enabled) continue;
-			if (await this.fireEntry(entry, now, state, notify)) changed = true;
+			const fired = await this.fireEntry(entry, now, state, notify);
+			changes.push(fired);
 		}
-		if (changed) this.lastFiredStore.save(state);
+		if (changes.includes(true)) this.lastFiredStore.save(state);
 	}
 	async fireEntry(entry, now, state, notify) {
+		if (entry.kind === "once") return this.fireOnceEntry(entry, now, state, notify);
+		return this.fireCronEntry(entry, now, state, notify);
+	}
+	async fireOnceEntry(entry, now, state, notify) {
+		if (state.has(entry.id)) return false;
+		const runAt = new Date(entry.runAt);
+		if (now.getTime() < runAt.getTime()) return false;
+		const lateness = now.getTime() - runAt.getTime();
+		if (entry.catchupPolicy === "skip" && lateness >= 6e4) {
+			state.set(entry.id, runAt);
+			return true;
+		}
+		await this.notifyOne(entry, runAt, notify, lateness > 0);
+		state.set(entry.id, runAt);
+		return true;
+	}
+	async fireCronEntry(entry, now, state, notify) {
 		const lastFired = state.get(entry.id);
-		const searchFrom = lastFired ? new Date(lastFired.getTime() + 6e4) : now;
+		const createdAt = entry.createdAt ? this.truncateToMinute(new Date(entry.createdAt)) : now;
+		const searchFrom = lastFired ? new Date(lastFired.getTime() + 6e4) : createdAt;
 		if (searchFrom.getTime() > now.getTime()) return false;
 		if (entry.catchupPolicy === "skip") {
 			try {
@@ -214,30 +158,38 @@ var FunnelScheduleListener = class extends FunnelConnectorListener {
 		}
 		if (entry.catchupPolicy === "all") {
 			const matches = this.findAllMatches(entry.cron, searchFrom, now, entry.id);
-			if (matches.length === 0) return false;
+			if (matches.length === 0) return this.seedSearchWatermark(entry.id, lastFired, now, state);
 			for (const match of matches) await this.notifyOne(entry, match, notify, match.getTime() !== now.getTime());
 			state.set(entry.id, matches[matches.length - 1] ?? now);
 			return true;
 		}
 		const match = this.findMostRecentMatch(entry.cron, searchFrom, now, entry.id);
-		if (!match) return false;
+		if (!match) return this.seedSearchWatermark(entry.id, lastFired, now, state);
 		await this.notifyOne(entry, match, notify, match.getTime() !== now.getTime());
 		state.set(entry.id, match);
 		return true;
 	}
+	seedSearchWatermark(entryId, lastFired, now, state) {
+		if (lastFired !== void 0) return false;
+		state.set(entryId, now);
+		return true;
+	}
 	async notifyOne(entry, firedAt, notify, catchup) {
 		const meta = {
 			event_type: "schedule",
 			schedule_id: entry.id,
-			cron: entry.cron,
+			schedule_kind: entry.kind,
 			fired_at: firedAt.toISOString(),
 			catchup_policy: entry.catchupPolicy
 		};
+		if (entry.kind === "cron") meta.cron = entry.cron;
+		else meta.run_at = entry.runAt;
 		if (catchup) meta.catchup = "true";
 		const eventId = `${entry.id}@${firedAt.toISOString()}`;
 		this.diagnostics.recordRaw(eventId, JSON.stringify({
 			schedule_id: entry.id,
-			cron: entry.cron,
+			kind: entry.kind,
+			...entry.kind === "cron" ? { cron: entry.cron } : { run_at: entry.runAt },
 			prompt: entry.prompt,
 			fired_at: firedAt.toISOString(),
 			catchup
@@ -308,16 +260,19 @@ var FunnelScheduleListener = class extends FunnelConnectorListener {
 		copy.setSeconds(0, 0);
 		return copy;
 	}
+	pruneRemovedEntries(state) {
+		const configuredIds = new Set(this.config.entries.map((entry) => entry.id));
+		const removedIds = [];
+		for (const id of state.keys()) {
+			if (configuredIds.has(id)) continue;
+			state.delete(id);
+			removedIds.push(id);
+		}
+		return removedIds.length > 0;
+	}
 };
 //#endregion
 //#region lib/engine/connectors/schedule-connector.ts
-const addEntryArgsSchema = z.object({
-	cron: z.string(),
-	prompt: z.string(),
-	id: z.string().optional(),
-	enabled: z.boolean().optional(),
-	catchupPolicy: scheduleEntrySchema.shape.catchupPolicy.optional()
-});
 const removeEntryArgsSchema = z.object({ id: z.string() });
 /**
 * Schedule connector descriptor. Pass `scheduleConnector()` to
@@ -375,11 +330,20 @@ const scheduleConnector = (options = {}) => ({
 		},
 		addEntry(props) {
 			const parsed = scheduleConnectorSchema.parse(props.config);
-			const args = addEntryArgsSchema.parse(props.args);
+			const args = scheduleEntryInputSchema.parse(props.args);
+			const id = args.id ?? props.context.generateId();
+			if (parsed.entries.some((entry) => entry.id === id)) throw new Error(`schedule entry "${id}" already exists`);
 			const entry = scheduleEntrySchema.parse({
-				id: args.id ?? props.context.generateId(),
-				cron: args.cron,
+				id,
+				..."cron" in args ? {
+					kind: "cron",
+					cron: args.cron
+				} : {
+					kind: "once",
+					runAt: args.runAt
+				},
 				prompt: args.prompt,
+				createdAt: props.context.now,
 				...args.enabled !== void 0 ? { enabled: args.enabled } : {},
 				...args.catchupPolicy !== void 0 ? { catchupPolicy: args.catchupPolicy } : {}
 			});
@@ -408,4 +372,4 @@ const scheduleConnector = (options = {}) => ({
 	}
 });
 //#endregion
-export { matchCron as i, FunnelScheduleListener as n, FunnelScheduleStateStore as r, scheduleConnector as t };
+export { FunnelScheduleListener as n, FunnelScheduleStateStore as r, scheduleConnector as t };

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

@@ -0,0 +1,137 @@
+import { z } from "zod";
+//#region lib/engine/connectors/match-cron.ts
+const parseField = (expr, min, max) => {
+	const values = /* @__PURE__ */ new Set();
+	for (const part of expr.split(",")) {
+		if (part.length === 0) throw new Error(`invalid empty cron list item: "${expr}"`);
+		const stepSegments = part.split("/");
+		if (stepSegments.length > 2) throw new Error(`invalid cron step: "${part}"`);
+		const rangePart = stepSegments[0];
+		const stepPart = stepSegments[1];
+		if (stepSegments.length === 2 && stepPart === "") throw new Error(`invalid cron step: "${part}"`);
+		const step = stepPart ? Number(stepPart) : 1;
+		if (!Number.isInteger(step) || step <= 0) throw new Error(`invalid cron step: "${stepPart}"`);
+		let lo = min;
+		let hi = max;
+		if (rangePart === "*" || rangePart === void 0 || rangePart === "") {
+			lo = min;
+			hi = max;
+		} else if (rangePart.includes("-")) {
+			const rangeSegments = rangePart.split("-");
+			if (rangeSegments.length !== 2) throw new Error(`invalid cron range: "${rangePart}"`);
+			const aStr = rangeSegments[0];
+			const bStr = rangeSegments[1];
+			const a = Number(aStr);
+			const b = Number(bStr);
+			if (!Number.isInteger(a) || !Number.isInteger(b)) throw new Error(`invalid cron range: "${rangePart}"`);
+			lo = a;
+			hi = b;
+		} else {
+			const n = Number(rangePart);
+			if (!Number.isInteger(n)) throw new Error(`invalid cron value: "${rangePart}"`);
+			lo = n;
+			hi = stepPart ? max : n;
+		}
+		if (lo < min || hi > max || lo > hi) throw new Error(`cron value out of range: ${rangePart} (must be ${min}-${max})`);
+		for (let i = lo; i <= hi; i += step) values.add(i);
+	}
+	return {
+		min,
+		max,
+		values
+	};
+};
+const parseCron = (expr) => {
+	const parts = expr.trim().split(/\s+/);
+	if (parts.length !== 5) throw new Error(`cron must have 5 fields (got ${parts.length}): "${expr}"`);
+	const [minute, hour, dom, month, dow] = parts;
+	if (!minute || !hour || !dom || !month || !dow) throw new Error(`cron has empty fields: "${expr}"`);
+	return {
+		minute: parseField(minute, 0, 59),
+		hour: parseField(hour, 0, 23),
+		dayOfMonth: parseField(dom, 1, 31),
+		month: parseField(month, 1, 12),
+		dayOfWeek: parseField(dow, 0, 7),
+		dayOfMonthRestricted: dom !== "*",
+		dayOfWeekRestricted: dow !== "*"
+	};
+};
+/** Throws with a user-facing reason when `expr` is not a supported cron expression. */
+const validateCronExpression = (expr) => {
+	parseCron(expr);
+};
+/**
+* Returns true when `date` (local time) satisfies a standard 5-field cron
+* expression. Sunday accepts both 0 and 7. When day-of-month and day-of-week
+* are both restricted, either field matching is sufficient (Vixie cron).
+*/
+const matchCron = (expr, date) => {
+	const cron = parseCron(expr);
+	if (!cron.minute.values.has(date.getMinutes())) return false;
+	if (!cron.hour.values.has(date.getHours())) return false;
+	if (!cron.month.values.has(date.getMonth() + 1)) return false;
+	const dayOfMonthMatches = cron.dayOfMonth.values.has(date.getDate());
+	const day = date.getDay();
+	const dayOfWeekMatches = cron.dayOfWeek.values.has(day) || day === 0 && cron.dayOfWeek.values.has(7);
+	if (cron.dayOfMonthRestricted && cron.dayOfWeekRestricted) return dayOfMonthMatches || dayOfWeekMatches;
+	return dayOfMonthMatches && dayOfWeekMatches;
+};
+//#endregion
+//#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 cronExpressionSchema = z.string().superRefine((expression, context) => {
+	try {
+		validateCronExpression(expression);
+	} catch (error) {
+		context.addIssue({
+			code: "custom",
+			message: error instanceof Error ? error.message : String(error)
+		});
+	}
+});
+const scheduleEntryBaseSchema = z.object({
+	id: z.string(),
+	prompt: z.string(),
+	enabled: z.boolean().default(true),
+	catchupPolicy: scheduleCatchupPolicySchema.default("latest"),
+	createdAt: z.string().datetime().optional()
+});
+const scheduleEntryInputBaseSchema = z.object({
+	id: z.string().optional(),
+	prompt: z.string(),
+	enabled: z.boolean().optional(),
+	catchupPolicy: scheduleCatchupPolicySchema.optional()
+});
+const cronScheduleEntryInputSchema = scheduleEntryInputBaseSchema.extend({ cron: cronExpressionSchema }).strict();
+const onceScheduleEntryInputSchema = scheduleEntryInputBaseSchema.extend({ runAt: z.string().datetime({ offset: true }) }).strict();
+const scheduleEntryInputSchema = z.union([onceScheduleEntryInputSchema, cronScheduleEntryInputSchema]);
+const cronScheduleEntrySchema = scheduleEntryBaseSchema.extend({
+	kind: z.literal("cron").default("cron"),
+	cron: cronExpressionSchema
+});
+const onceScheduleEntrySchema = scheduleEntryBaseSchema.extend({
+	kind: z.literal("once"),
+	runAt: z.string().datetime({ offset: true })
+});
+const scheduleEntrySchema = z.union([onceScheduleEntrySchema, cronScheduleEntrySchema]);
+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 a, matchCron as c, scheduleCatchupPolicySchema as i, validateCronExpression as l, cronScheduleEntrySchema as n, scheduleEntryInputSchema as o, onceScheduleEntrySchema as r, scheduleEntrySchema as s, cronExpressionSchema as t };

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

@@ -0,0 +1,127 @@
+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 cronExpressionSchema: z.ZodString;
+declare const scheduleEntryInputSchema: z.ZodUnion<readonly [z.ZodObject<{
+  id: z.ZodOptional<z.ZodString>;
+  prompt: z.ZodString;
+  enabled: z.ZodOptional<z.ZodBoolean>;
+  catchupPolicy: z.ZodOptional<z.ZodEnum<{
+    latest: "latest";
+    all: "all";
+    skip: "skip";
+  }>>;
+  runAt: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+  id: z.ZodOptional<z.ZodString>;
+  prompt: z.ZodString;
+  enabled: z.ZodOptional<z.ZodBoolean>;
+  catchupPolicy: z.ZodOptional<z.ZodEnum<{
+    latest: "latest";
+    all: "all";
+    skip: "skip";
+  }>>;
+  cron: z.ZodString;
+}, z.core.$strict>]>;
+type ScheduleEntryInput = z.input<typeof scheduleEntryInputSchema>;
+declare const cronScheduleEntrySchema: z.ZodObject<{
+  id: z.ZodString;
+  prompt: z.ZodString;
+  enabled: z.ZodDefault<z.ZodBoolean>;
+  catchupPolicy: z.ZodDefault<z.ZodEnum<{
+    latest: "latest";
+    all: "all";
+    skip: "skip";
+  }>>;
+  createdAt: z.ZodOptional<z.ZodString>;
+  kind: z.ZodDefault<z.ZodLiteral<"cron">>;
+  cron: z.ZodString;
+}, z.core.$strip>;
+declare const onceScheduleEntrySchema: z.ZodObject<{
+  id: z.ZodString;
+  prompt: z.ZodString;
+  enabled: z.ZodDefault<z.ZodBoolean>;
+  catchupPolicy: z.ZodDefault<z.ZodEnum<{
+    latest: "latest";
+    all: "all";
+    skip: "skip";
+  }>>;
+  createdAt: z.ZodOptional<z.ZodString>;
+  kind: z.ZodLiteral<"once">;
+  runAt: z.ZodString;
+}, z.core.$strip>;
+declare const scheduleEntrySchema: z.ZodUnion<readonly [z.ZodObject<{
+  id: z.ZodString;
+  prompt: z.ZodString;
+  enabled: z.ZodDefault<z.ZodBoolean>;
+  catchupPolicy: z.ZodDefault<z.ZodEnum<{
+    latest: "latest";
+    all: "all";
+    skip: "skip";
+  }>>;
+  createdAt: z.ZodOptional<z.ZodString>;
+  kind: z.ZodLiteral<"once">;
+  runAt: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  id: z.ZodString;
+  prompt: z.ZodString;
+  enabled: z.ZodDefault<z.ZodBoolean>;
+  catchupPolicy: z.ZodDefault<z.ZodEnum<{
+    latest: "latest";
+    all: "all";
+    skip: "skip";
+  }>>;
+  createdAt: z.ZodOptional<z.ZodString>;
+  kind: z.ZodDefault<z.ZodLiteral<"cron">>;
+  cron: z.ZodString;
+}, z.core.$strip>]>;
+type ScheduleEntry = z.infer<typeof scheduleEntrySchema>;
+type CronScheduleEntry = z.infer<typeof cronScheduleEntrySchema>;
+type OnceScheduleEntry = z.infer<typeof onceScheduleEntrySchema>;
+declare const scheduleConnectorSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  type: z.ZodLiteral<"schedule">;
+  entries: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+    id: z.ZodString;
+    prompt: z.ZodString;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    catchupPolicy: z.ZodDefault<z.ZodEnum<{
+      latest: "latest";
+      all: "all";
+      skip: "skip";
+    }>>;
+    createdAt: z.ZodOptional<z.ZodString>;
+    kind: z.ZodLiteral<"once">;
+    runAt: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    prompt: z.ZodString;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    catchupPolicy: z.ZodDefault<z.ZodEnum<{
+      latest: "latest";
+      all: "all";
+      skip: "skip";
+    }>>;
+    createdAt: z.ZodOptional<z.ZodString>;
+    kind: z.ZodDefault<z.ZodLiteral<"cron">>;
+    cron: z.ZodString;
+  }, z.core.$strip>]>>>;
+  createdAt: z.ZodOptional<z.ZodString>;
+  updatedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type ScheduleConnectorConfig = z.infer<typeof scheduleConnectorSchema>;
+//#endregion
+export { ScheduleEntry as a, cronScheduleEntrySchema as c, scheduleConnectorSchema as d, scheduleEntryInputSchema as f, ScheduleConnectorConfig as i, onceScheduleEntrySchema as l, OnceScheduleEntry as n, ScheduleEntryInput as o, scheduleEntrySchema as p, ScheduleCatchupPolicy as r, cronExpressionSchema as s, CronScheduleEntry as t, scheduleCatchupPolicySchema as u };

package/dist/{settings-reader-BnKIbmsD.d.ts → settings-reader-CyTpbAre.d.ts}

@@ -1,5 +1,4 @@
-import { a as Settings } from "./settings-schema-IShSMm5G.js";
-
+import { a as Settings } from "./settings-schema-B-CKLuST.js";
 //#region lib/engine/id/id-generator.d.ts
 /**
  * ID generator boundary. Default NodeFunnelIdGenerator wraps `crypto.randomUUID()`;

package/dist/{settings-schema-IShSMm5G.d.ts → settings-schema-B-CKLuST.d.ts}

@@ -1,5 +1,4 @@
 import { z } from "zod";
-
 //#region lib/engine/settings/settings-schema.d.ts
 /**
  * Routing mode when multiple WS clients are subscribed to the same channel.

package/dist/{settings-store-ccv291GV.js → settings-store-ZFWBhOnp.js}

@@ -1,8 +1,14 @@
-import { t as NodeFunnelFileSystem } from "./node-file-system-BOXIHW_Q.js";
-import { n as FunnelIdGenerator, t as FunnelSettingsReader } from "./settings-reader-9FcX3qS1.js";
+import { t as NodeFunnelFileSystem } from "./node-file-system-xJx7dymE.js";
 import { dirname, join } from "node:path";
 import { homedir } from "node:os";
 import { z } from "zod";
+//#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/id/node-id-generator.ts
 var NodeFunnelIdGenerator = class extends FunnelIdGenerator {
 	generate() {
@@ -10,6 +16,9 @@ var NodeFunnelIdGenerator = class extends FunnelIdGenerator {
 	}
 };
 //#endregion
+//#region lib/engine/settings/settings-reader.ts
+var FunnelSettingsReader = class {};
+//#endregion
 //#region lib/engine/connectors/base-connector-config.ts
 /**
 * Fields every connector config carries, regardless of type. The discriminated
@@ -240,4 +249,4 @@ var FunnelSettingsStore = class extends FunnelSettingsReader {
 	}
 };
 //#endregion
-export { expandHomeDir as a, SETTINGS_VERSION as c, profileConfigSchema as d, settingsSchema as f, SETTINGS_PATH as i, channelConfigSchema as l, NodeFunnelIdGenerator as m, FUNNEL_DIR as n, resolveFunnelDir as o, baseConnectorConfigSchema as p, FunnelSettingsStore as r, resolveFunnelPort as s, DEFAULT_GATEWAY_PORT as t, channelDeliveryModeSchema as u };
+export { expandHomeDir as a, SETTINGS_VERSION as c, profileConfigSchema as d, settingsSchema as f, FunnelIdGenerator as g, NodeFunnelIdGenerator as h, SETTINGS_PATH as i, channelConfigSchema as l, FunnelSettingsReader as m, FUNNEL_DIR as n, resolveFunnelDir as o, baseConnectorConfigSchema as p, FunnelSettingsStore as r, resolveFunnelPort as s, DEFAULT_GATEWAY_PORT as t, channelDeliveryModeSchema as u };

package/dist/{slack-connector-CxpWagbT.js → slack-connector-CC3V2VXQ.js}

@@ -1,11 +1,11 @@
-import { t as NodeFunnelHttpClient } from "./node-http-client-u00atiKx.js";
-import { t as FunnelAuthFailedError } from "./funnel-error-0t1MK1R6.js";
-import { t as errorMessageOf } from "./error-message-of-ColuYmAk.js";
-import { t as slackConnectorSchema } from "./slack-connector-schema-Dem8to4P.js";
-import { t as FunnelConnectorAdapter } from "./connector-adapter-Dvs8N7ew.js";
-import { t as FunnelSlackEventProcessor } from "./slack-event-processor-xFDG3US0.js";
-import { t as resolveConnectorToken } from "./resolve-connector-token-DxDG9mhf.js";
-import { i as resolveFlumeDeps, n as FunnelFlumeSourceListener, r as flumeLogHandler, t as slotFields } from "./slot-fields-D-pvMgTK.js";
+import { t as NodeFunnelHttpClient } from "./node-http-client-SX3xFh4h.js";
+import { t as FunnelAuthFailedError } from "./funnel-error-DoSBCogD.js";
+import { t as errorMessageOf } from "./error-message-of-BG4ezZ_s.js";
+import { t as slackConnectorSchema } from "./slack-connector-schema-EGVuuqSX.js";
+import { t as FunnelConnectorAdapter } from "./connector-adapter-BL2ehMej.js";
+import { t as FunnelSlackEventProcessor } from "./slack-event-processor-Cs_YuI3w.js";
+import { t as resolveConnectorToken } from "./resolve-connector-token-BwiJCu82.js";
+import { i as resolveFlumeDeps, n as FunnelFlumeSourceListener, r as flumeLogHandler, t as slotFields } from "./slot-fields-eCWizJqS.js";
 import { z } from "zod";
 import { FlumeSlackSource } from "@interactive-inc/flume/slack";
 //#region lib/engine/connectors/slack-adapter.ts
@@ -289,7 +289,8 @@ var FunnelFlumeSlackListener = class extends FunnelFlumeSourceListener {
 				name: "eyes"
 			}).toString()
 		});
-		const parsed = parseSlackResponse(await res.text());
+		const text = await res.text();
+		const parsed = parseSlackResponse(text);
 		if (!parsed.ok) throw new Error(`slack reactions.add: ${parsed.error ?? `status=${res.status}`}`);
 	}
 };

package/dist/{slack-event-processor-xFDG3US0.js → slack-event-processor-Cs_YuI3w.js}

@@ -83,8 +83,8 @@ const minifySlackEvent = (event) => {
 };
 //#endregion
 //#region lib/engine/connectors/slack-event-processor.ts
-const ALLOWED_EVENTS = new Set(["message", "app_mention"]);
-const ALLOWED_SUBTYPES = new Set([
+const ALLOWED_EVENTS = /* @__PURE__ */ new Set(["message", "app_mention"]);
+const ALLOWED_SUBTYPES = /* @__PURE__ */ new Set([
 	void 0,
 	"thread_broadcast",
 	"bot_message",

package/dist/{slack-event-processor-BDTr62cN.d.ts → slack-event-processor-DmAlq4cV.d.ts}

@@ -1,5 +1,4 @@
 import { z } from "zod";
-
 //#region lib/engine/connectors/slack-connector-schema.d.ts
 /**
  * A slack connector resolves its tokens one of two ways, set at sync time: