@oomol-lab/open-flow 0.1.0-beta.3 → 0.1.0-beta.30

package/dist/common/cron-trigger.d.ts

@@ -1,5 +1,6 @@
 import type { JsonValue, TriggerSchedule } from '../browser/flow-change.js';
 export declare function validateTriggerSchedule(rules: readonly TriggerSchedule[]): void;
+export declare function validateCronExpression(expression: string, timezone: string): void;
 export declare function nextTriggerScheduledAt(rules: readonly TriggerSchedule[], afterMs: number): number;
 export declare function scheduledTriggerOccurrenceId(bindingId: string, runtimeVersion: number, scheduledAt: string): Promise<string>;
 export interface CronConformanceFixture {
@@ -8,7 +9,7 @@ export interface CronConformanceFixture {
 }
 export interface CronConformanceHarness {
     dispose(): Promise<void>;
-    payloads(): Promise<readonly JsonValue[]>;
+    outputs(): Promise<readonly Readonly<Record<string, JsonValue>>[]>;
     republish(at: string, rules: readonly TriggerSchedule[]): Promise<void>;
     retire(at: string): Promise<void>;
     tick(at: string): Promise<void>;

package/dist/common/cron-trigger.js

@@ -742,82 +742,85 @@ function E(e) {
 			if (t.unit == "month" && t.value > 12 || t.unit != "month" && t.value * T[t.unit] > C) throw TypeError("Every rule interval must not exceed one year.");
 			continue;
 		}
-		if (t.expression.trim().split(/\s+/).length != 5) throw TypeError("Cron expression must have exactly five fields.");
 		try {
 			Intl.DateTimeFormat("en-US", { timeZone: t.timezone });
 		} catch {
 			throw TypeError(`Invalid IANA timezone: ${t.timezone}`);
 		}
-		let e;
-		try {
-			e = new v(t.expression, { timezone: t.timezone });
-		} catch (e) {
-			throw TypeError(`Invalid cron expression: ${e instanceof Error ? e.message : String(e)}`, { cause: e });
-		}
-		if (e.nextRun() == null) throw TypeError("Cron expression has no future occurrence.");
+		D(t.expression, t.timezone);
 	}
 }
 function D(e, t) {
+	if (e.trim().split(/\s+/).length != 5) throw TypeError("Cron expression must have exactly five fields.");
+	let n;
+	try {
+		n = new v(e, { timezone: t });
+	} catch (e) {
+		throw TypeError(`Invalid cron expression: ${e instanceof Error ? e.message : String(e)}`, { cause: e });
+	}
+	if (n.nextRun() == null) throw TypeError("Cron expression has no future occurrence.");
+}
+function O(e, t) {
 	let n = Infinity;
-	for (let r of e) n = Math.min(n, M(r, t));
+	for (let r of e) n = Math.min(n, N(r, t));
 	if (!Number.isFinite(n)) throw Error("Schedule has no future occurrence.");
 	return n;
 }
-async function O(e, t, n) {
+async function k(e, t, n) {
 	let r = w.encode(`${e}\0${t}\0${n}`), i = await crypto.subtle.digest("SHA-256", r);
 	return `sha256:${Array.from(new Uint8Array(i), (e) => e.toString(16).padStart(2, "0")).join("")}`;
 }
-var k = [{
+var A = [{
 	type: "every",
 	unit: "hour",
 	value: 1
-}], A = [{
+}], j = [{
 	type: "every",
 	unit: "minute",
 	value: 1
-}], j = [
+}], M = [
 	{
 		fixture: {
 			publishedAt: "2026-08-21T00:30:00.000Z",
-			rules: k
+			rules: A
 		},
 		name: "admits an exact schedule grid once",
 		async verify(e) {
-			await e.tick("2026-08-21T01:00:00.000Z"), await e.tick("2026-08-21T01:00:00.000Z"), N(await e.payloads(), [{ scheduledAt: "2026-08-21T01:00:00.000Z" }], "Exact schedule payloads");
+			await e.tick("2026-08-21T01:00:00.000Z"), await e.tick("2026-08-21T01:00:00.000Z"), P(await e.outputs(), [{ scheduledAt: "2026-08-21T01:00:00.000Z" }], "Exact schedule outputs");
 		}
 	},
 	{
 		fixture: {
 			publishedAt: "2026-08-21T00:00:30.000Z",
-			rules: A
+			rules: j
 		},
 		name: "coalesces missed grids and preserves the earliest due time",
 		async verify(e) {
-			await e.tick("2026-08-21T00:03:30.000Z"), N(await e.payloads(), [{ scheduledAt: "2026-08-21T00:01:00.000Z" }], "Delayed schedule payloads"), await e.tick("2026-08-21T00:04:00.000Z"), N(await e.payloads(), [{ scheduledAt: "2026-08-21T00:01:00.000Z" }, { scheduledAt: "2026-08-21T00:04:00.000Z" }], "Advanced schedule payloads");
+			await e.tick("2026-08-21T00:03:30.000Z"), P(await e.outputs(), [{ scheduledAt: "2026-08-21T00:01:00.000Z" }], "Delayed schedule outputs"), await e.tick("2026-08-21T00:04:00.000Z"), P(await e.outputs(), [{ scheduledAt: "2026-08-21T00:01:00.000Z" }, { scheduledAt: "2026-08-21T00:04:00.000Z" }], "Advanced schedule outputs");
 		}
 	},
 	{
 		fixture: {
 			publishedAt: "2026-08-21T00:00:30.000Z",
-			rules: A
+			rules: j
 		},
 		name: "resets the schedule when its publication changes",
 		async verify(e) {
-			await e.republish("2026-08-21T00:00:45.000Z", k), await e.tick("2026-08-21T00:01:00.000Z"), N(await e.payloads(), [], "Payloads from the previous publication"), await e.tick("2026-08-21T01:00:00.000Z"), N(await e.payloads(), [{ scheduledAt: "2026-08-21T01:00:00.000Z" }], "Republished schedule payloads");
+			await e.republish("2026-08-21T00:00:45.000Z", A), await e.tick("2026-08-21T00:01:00.000Z"), P(await e.outputs(), [], "Outputs from the previous publication"), await e.tick("2026-08-21T01:00:00.000Z"), P(await e.outputs(), [{ scheduledAt: "2026-08-21T01:00:00.000Z" }], "Republished schedule outputs");
 		}
 	},
 	{
 		fixture: {
 			publishedAt: "2026-08-21T00:30:00.000Z",
-			rules: k
+			rules: A
 		},
 		name: "stops admitting runs after retirement",
 		async verify(e) {
-			await e.retire("2026-08-21T00:45:00.000Z"), await e.tick("2026-08-21T01:00:00.000Z"), N(await e.payloads(), [], "Retired schedule payloads");
+			await e.retire("2026-08-21T00:45:00.000Z"), await e.tick("2026-08-21T01:00:00.000Z"), P(await e.outputs(), [], "Retired schedule outputs");
 		}
 	}
 ];
-function M(e, t) {
+function N(e, t) {
 	if (e.type == "cron") return new v(e.expression, { timezone: e.timezone }).nextRun(new Date(t))?.getTime() ?? Infinity;
 	if (e.unit == "month") {
 		let n = new Date(t), r = (n.getUTCFullYear() - 1970) * 12 + n.getUTCMonth(), i = Math.floor(r / e.value) * e.value, a = Date.UTC(1970, i, 1);
@@ -827,8 +830,8 @@ function M(e, t) {
 	let n = e.value * T[e.unit], r = e.unit == "week" ? S : 0;
 	return r + (Math.floor((t - r) / n) + 1) * n;
 }
-function N(e, t, n) {
+function P(e, t, n) {
 	if (JSON.stringify(e) != JSON.stringify(t)) throw Error(`${n}: expected ${JSON.stringify(t)}, received ${JSON.stringify(e)}.`);
 }
 //#endregion
-export { j as cronConformanceCases, D as nextTriggerScheduledAt, O as scheduledTriggerOccurrenceId, E as validateTriggerSchedule };
+export { M as cronConformanceCases, O as nextTriggerScheduledAt, k as scheduledTriggerOccurrenceId, D as validateCronExpression, E as validateTriggerSchedule };

package/dist/common/draftOperations.d.ts

@@ -0,0 +1,14 @@
+import type { ChangeOperation, JsonValue, TriggerKeySnapshot, TriggerSchedule } from '../browser/flow-change.js';
+export type DraftOperation = ChangeOperation | {
+    readonly kind: 'graph.trigger.create';
+    readonly nodeId: string;
+    readonly bindingId: string;
+    readonly key: string;
+    readonly connectionId?: string;
+    readonly name?: string;
+    readonly config: Readonly<Record<string, JsonValue>>;
+    readonly schedule?: readonly TriggerSchedule[];
+};
+export declare function decodeDraftOperations(value: unknown): readonly DraftOperation[];
+export declare function draftOperationsSchema(kind?: string): JsonValue;
+export declare function resolveDraftOperations(operations: readonly DraftOperation[], definition: (key: string) => TriggerKeySnapshot): readonly ChangeOperation[];

package/dist/common/engine-contract.d.ts

@@ -1,7 +1,9 @@
 export interface EngineContract {
+    readonly builtinModules?: ReadonlySet<string>;
     readonly platformExports: ReadonlySet<string>;
     readonly platformModule: string;
     readonly platformSource: string;
 }
-export declare const currentEngineContract = "open-flow-engine/v1";
+export declare const currentEngineContract = "open-flow-engine/v5";
+export declare const nodejsEngineContract = "open-flow-engine/v5/nodejs-compat-v1";
 export declare function findEngineContract(contract: string): EngineContract | undefined;

package/dist/common/event-sources.d.ts

@@ -0,0 +1,50 @@
+export interface CreateEventSource {
+    readonly version: 1;
+    readonly name: string;
+    readonly connectionId: string;
+    readonly teamId: string | null;
+    readonly verificationToken: string;
+    readonly encryptKey: string;
+    readonly eventTypes: string[];
+    readonly manageSubscriptions: boolean;
+}
+export interface UpdateEventSource {
+    readonly version: 1;
+    readonly expectedRevision: number;
+    readonly name: string;
+    readonly enabled: boolean;
+    readonly eventTypes: string[];
+    readonly verificationToken?: string;
+    readonly encryptKey?: string;
+}
+export interface EventSource {
+    readonly version: 1;
+    readonly sourceId: string;
+    readonly revision: number;
+    readonly name: string;
+    readonly provider: 'feishu' | 'feishu_app_bot';
+    readonly appId: string;
+    readonly tenantKey: string;
+    readonly connectionId: string;
+    readonly teamId: string | null;
+    readonly enabled: boolean;
+    readonly eventTypes: string[];
+    readonly manageSubscriptions: boolean;
+    readonly verificationTokenConfigured: boolean;
+    readonly encryptKeyConfigured: boolean;
+    readonly endpointUrl: string | null;
+    readonly verifiedAt: string | null;
+    readonly lastReceivedAt: string | null;
+    readonly updatedAt: string;
+    readonly consumers: {
+        flowId: string;
+        flowName: string;
+        triggerNodeId: string;
+    }[];
+}
+export declare function decodeEventSource(value: unknown): EventSource;
+export declare function decodeEventSources(value: unknown): {
+    readonly version: 1;
+    readonly sources: readonly EventSource[];
+    readonly teamId?: string | null;
+};

package/dist/common/feishu-events.d.ts

@@ -0,0 +1,20 @@
+import type { JsonValue } from '../browser/flow-change.js';
+export interface FeishuEvent {
+    readonly id: string;
+    readonly type: string;
+    readonly appId: string;
+    readonly tenantKey: string;
+    readonly occurredAt: string | null;
+    readonly body: Readonly<Record<string, JsonValue>>;
+}
+export declare function receiveFeishuEvent(rawBody: Uint8Array, headers: Headers, source: {
+    readonly appId: string;
+    readonly tenantKey: string;
+    readonly verificationToken: string;
+    readonly encryptKey: string;
+}, now: number): Promise<{
+    readonly challenge: string;
+} | {
+    readonly event: FeishuEvent;
+}>;
+export declare function matchesFeishuEvent(config: Readonly<Record<string, JsonValue>>, event: FeishuEvent): boolean;

package/dist/common/feishu-subscriptions.d.ts

@@ -0,0 +1,10 @@
+import type { ConnectorProxyRequest, ConnectorProxyResult } from './connector-proxy.js';
+import type { JsonValue } from '../browser/flow-change.js';
+export interface FeishuSubscription {
+    readonly key: string;
+    readonly subscribe: ConnectorProxyRequest;
+    readonly unsubscribe: ConnectorProxyRequest;
+    readonly inspect?: ConnectorProxyRequest;
+}
+export declare function feishuSubscriptions(config: Readonly<Record<string, JsonValue>>, provider: string): readonly FeishuSubscription[];
+export declare function feishuResponse(result: ConnectorProxyResult): Readonly<Record<string, JsonValue>>;

package/dist/common/flow-agent.d.ts

@@ -0,0 +1,10 @@
+import type { AgentInput, AgentTool, JsonValue, ManagedTaskDefinition, ManagedTaskExecutor } from '../browser/flow-change.js';
+export type AgentConfig = Extract<ManagedTaskExecutor, {
+    readonly kind: 'agent';
+}>;
+export declare function agentConfigIssues(task: ManagedTaskDefinition, tasks: Readonly<Record<string, ManagedTaskDefinition>>): readonly string[];
+export declare function agentInput(source: Exclude<AgentInput, {
+    readonly kind: 'model';
+}>, input: Readonly<Record<string, JsonValue>>): JsonValue;
+export declare function agentToolSchema(tool: AgentTool): JsonValue;
+export declare function agentToolInput(tool: AgentTool, input: Readonly<Record<string, JsonValue>>, argumentsValue: unknown): Readonly<Record<string, JsonValue>>;

package/dist/common/flow-encoding.d.ts

@@ -1,11 +1,25 @@
-import type { CodeModule, FlowDocument, Graph, Group, InputPort, JsonValue, OutputMapping, Port, RevisionContent } from '@oomol-lab/open-flow/flow-change';
-export declare const maxJsonDepth = 64;
+import type { CodeModule, FlowDocument, Graph, Group, InputPort, JsonValue, OutputMapping, Port, RevisionContent, TriggerNode } from '@oomol-lab/open-flow/flow-change';
+export { maxJsonDepth } from './flow-json.js';
+export { decodeFlowDocument, decodeRevisionContent } from '../browser/flow-change-schema.js';
 export declare function canonicalJsonBytes(value: JsonValue): Uint8Array;
 export declare function digestBytes(bytes: Uint8Array): Promise<string>;
 export declare function canonicalPorts(value: readonly (InputPort | Port | Group)[]): JsonValue;
 export declare function canonicalOutputs(value: readonly (OutputMapping & Port)[]): JsonValue;
 export declare function canonicalGraph(value: Graph): JsonValue;
+export declare function canonicalRevisionGraph(content: RevisionContent, graph: Graph): JsonValue;
+export declare function canonicalRevisionOutputs(content: RevisionContent, value: readonly (OutputMapping & Port)[], graph: Graph): JsonValue;
 export declare function canonicalTask(task: FlowDocument['tasks'][string]): JsonValue;
+export declare function triggerRuntimeJson(trigger: TriggerNode): string;
 export declare function canonicalDocument(document: FlowDocument): JsonValue;
 export declare function canonicalModule(module: CodeModule): JsonValue;
 export declare function encodeRevision(content: RevisionContent): Uint8Array;
+export declare function decodeRevision(bytes: Uint8Array): RevisionContent;
+export type RevisionRepairKind = 'repair' | 'upgrade';
+export declare function revisionRepairKind(bytes: Uint8Array): RevisionRepairKind | undefined;
+export declare function repairRevision(bytes: Uint8Array): RevisionContent;
+export declare function legacyProjectFlowIds(value: unknown): readonly string[];
+export declare function convertProjectFlow(value: unknown, flowId: string): {
+    name: string;
+    revision: RevisionContent;
+    adjustments: readonly string[];
+};