@oomol-lab/open-flow 0.1.0-alpha.9 → 0.1.0-beta.10

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

@@ -48,6 +48,7 @@ export interface IntegrationReconcileContext {
     readonly config: Readonly<Record<string, JsonValue>>;
     readonly connector: ConnectorProxy;
     readonly endpointUrl: string;
+    readonly idempotencyKey: string;
     readonly now: Date;
     readonly signal?: AbortSignal;
     readonly state?: IntegrationStateContext;

package/dist/common/licenses.md

@@ -1,27 +1,3 @@
 # Licenses
 
-The app bundles dependencies which contain the following licenses:
-
-## dequal - 2.0.3 (MIT)
-
-The MIT License (MIT)
-
-Copyright (c) Luke Edwards <luke.edwards05@gmail.com> (lukeed.com)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
+The app does not bundle any dependencies with licenses.

package/dist/common/localization.d.ts

@@ -0,0 +1,21 @@
+export declare const uiLanguages: readonly ['en', 'zh-CN', 'zh-TW', 'ja', 'ko', 'ru', 'fr'];
+export type UiLanguage = (typeof uiLanguages)[number];
+export declare const defaultUiLanguage: UiLanguage;
+/** Endonyms, shown in language pickers regardless of the current UI language. */
+export declare const uiLanguageNames: Readonly<Record<UiLanguage, string>>;
+export declare function isUiLanguage(value: unknown): value is UiLanguage;
+/**
+ * BCP 47 aware resolution over candidates such as `navigator.languages`: an exact tag match
+ * (case-insensitive) wins; for zh an explicit script subtag beats the region (zh-Hant-* to zh-TW,
+ * zh-Hans-* to zh-CN), then zh-TW, zh-HK and zh-MO map to zh-TW and any other zh* to zh-CN; en, ja,
+ * ko, ru and fr also match on their primary subtag (fr-CA to fr, ja-JP to ja).
+ */
+export declare function resolveUiLanguage(candidates: Iterable<string | null | undefined>, fallback?: UiLanguage): UiLanguage;
+/** Languages written with CJK scripts: zh-CN, zh-TW, ja and ko. */
+export declare function isCjkLanguage(language: string): boolean;
+/**
+ * Lookup order for package-author locale files (`oo-locales/<lang>.json`), which only exist for en
+ * and zh-CN today. Traditional Chinese readers prefer Simplified Chinese over English; every other
+ * language falls back to English first. The chain never repeats a locale.
+ */
+export declare function userLocaleFallbackChain(language: string): readonly string[];

package/dist/common/localization.js

@@ -0,0 +1,62 @@
+//#region src/localization/common/languages.ts
+var e = [
+	"en",
+	"zh-CN",
+	"zh-TW",
+	"ja",
+	"ko",
+	"ru",
+	"fr"
+], t = "en", n = {
+	en: "English",
+	"zh-CN": "简体中文",
+	"zh-TW": "繁體中文",
+	ja: "日本語",
+	ko: "한국어",
+	ru: "Русский",
+	fr: "Français"
+}, r = new Map(e.map((e) => [e.toLowerCase(), e])), i = /* @__PURE__ */ new Set([
+	"hk",
+	"mo",
+	"tw"
+]), a = /* @__PURE__ */ new Set([
+	"zh-CN",
+	"zh-TW",
+	"ja",
+	"ko"
+]);
+function o(e) {
+	return typeof e == "string" && r.get(e.toLowerCase()) == e;
+}
+function s(e, t = "en") {
+	for (let t of e) {
+		let e = t == null ? void 0 : u(t);
+		if (e != null) return e;
+	}
+	return t;
+}
+function c(e) {
+	let t = u(e);
+	return t != null && a.has(t);
+}
+function l(e) {
+	return e == "zh-TW" ? [
+		"zh-TW",
+		"zh-CN",
+		"en"
+	] : e == "zh-CN" ? ["zh-CN", "en"] : e == "en" ? ["en", "zh-CN"] : [
+		e,
+		"en",
+		"zh-CN"
+	];
+}
+function u(e) {
+	let t = e.trim().toLowerCase();
+	if (t.length == 0) return;
+	let n = r.get(t);
+	if (n != null) return n;
+	let a = t.split("-");
+	return a[0] == "zh" ? a.includes("hant") ? "zh-TW" : a.includes("hans") ? "zh-CN" : a.some((e) => i.has(e)) ? "zh-TW" : "zh-CN" : r.get(a[0]);
+}
+//#endregion
+export { t as defaultUiLanguage, c as isCjkLanguage, o as isUiLanguage, s as resolveUiLanguage, n as uiLanguageNames, e as uiLanguages, l as userLocaleFallbackChain };

package/dist/common/provider-triggers.js

@@ -3923,7 +3923,10 @@ var ci = 300, H = "/v1/webhook_endpoints", li = { "Content-Type": "application/x
 			let t = await U(e, "endpoint create", {
 				body: fi(e.endpointUrl, n),
 				endpoint: H,
-				headers: li,
+				headers: {
+					...li,
+					"Idempotency-Key": e.idempotencyKey
+				},
 				method: "POST"
 			});
 			W(t, "endpoint create");

package/dist/common/run-events.js

@@ -5,7 +5,8 @@ var e = new TextEncoder(), t = /* @__PURE__ */ new Set([
 	"javascript",
 	"llm",
 	"subflow",
-	"value"
+	"value",
+	"wait"
 ]);
 function n(e, t) {
 	if (typeof e != "object" || !e || Array.isArray(e)) throw TypeError(`${t} must be an object.`);

package/dist/common/run-lifecycle.d.ts

@@ -1,11 +1,15 @@
 export declare const runTerminalStatuses: readonly ['canceled', 'completed', 'failed', 'indeterminate'];
-export declare const runStatuses: readonly ["canceled", "completed", "failed", "indeterminate", "queued", "running", "starting"];
+export declare const runStatuses: readonly ["canceled", "completed", "failed", "indeterminate", "queued", "running", "starting", "waiting"];
 export type RunStatus = (typeof runStatuses)[number];
 export type RunTerminalStatus = (typeof runTerminalStatuses)[number];
 export type RunOperation = {
     readonly kind: 'claim';
 } | {
     readonly kind: 'start';
+} | {
+    readonly kind: 'wait';
+} | {
+    readonly kind: 'resolve';
 } | {
     readonly kind: 'commit';
     readonly status: RunTerminalStatus;
@@ -16,6 +20,9 @@ export type RunTransition = {
 } | {
     readonly kind: 'running';
     readonly status: 'running';
+} | {
+    readonly kind: 'waiting';
+    readonly status: 'waiting';
 } | {
     readonly kind: 'terminal';
     readonly status: RunTerminalStatus;
@@ -28,12 +35,18 @@ export type RunTransition = {
 } | {
     readonly kind: 'committed';
     readonly status: RunTerminalStatus;
+} | {
+    readonly kind: 'waited';
+    readonly status: 'waiting';
+} | {
+    readonly kind: 'resolved';
+    readonly status: 'queued';
 } | {
     readonly kind: 'stale';
     readonly status: RunStatus;
 };
 export type RunClaim = Extract<RunTransition, {
-    readonly kind: 'ready' | 'running' | 'terminal';
+    readonly kind: 'ready' | 'running' | 'terminal' | 'waiting';
 }>;
 export type RunStart = Extract<RunTransition, {
     readonly kind: 'already-started' | 'started' | 'stale';
@@ -60,7 +73,9 @@ export interface RunLifecycleHarness {
     claim(runId: string): Promise<RunClaim>;
     commit(runId: string, status: RunTerminalStatus): Promise<boolean>;
     observe(runId: string): Promise<RunObservation>;
+    resolve(runId: string): Promise<boolean>;
     start(runId: string): Promise<RunStart>;
+    wait(runId: string): Promise<boolean>;
 }
 export interface RunLifecycleConformanceCase {
     readonly name: string;

package/dist/common/run-lifecycle.js

@@ -28,7 +28,8 @@ var n = [
 	...n,
 	"queued",
 	"running",
-	"starting"
+	"starting",
+	"waiting"
 ];
 function i(e) {
 	return e == "canceled" || e == "completed" || e == "failed" || e == "indeterminate";
@@ -45,6 +46,10 @@ function a(e, t) {
 				kind: "running",
 				status: e
 			};
+			case "waiting": return {
+				kind: "waiting",
+				status: e
+			};
 			case "canceled":
 			case "completed":
 			case "failed":
@@ -63,6 +68,7 @@ function a(e, t) {
 				status: e
 			};
 			case "queued":
+			case "waiting":
 			case "canceled":
 			case "completed":
 			case "failed":
@@ -71,10 +77,24 @@ function a(e, t) {
 				status: e
 			};
 		}
+		case "wait": return e == "running" ? {
+			kind: "waited",
+			status: "waiting"
+		} : {
+			kind: "stale",
+			status: e
+		};
+		case "resolve": return e == "waiting" ? {
+			kind: "resolved",
+			status: "queued"
+		} : {
+			kind: "stale",
+			status: e
+		};
 		case "commit": return i(e) ? {
 			kind: "stale",
 			status: e
-		} : t.status == "canceled" || e == "running" ? {
+		} : t.status == "canceled" || e == "running" || t.status == "failed" && e == "waiting" ? {
 			kind: "committed",
 			status: t.status
 		} : {
@@ -95,6 +115,37 @@ async function s(e, t = "request", n = "request-a") {
 	return r.runId;
 }
 var c = [
+	{
+		name: "pauses and resumes the same Run through the ordinary start barrier",
+		async verify(e) {
+			let t = await s(e), n = await e.claim(t);
+			if (n.kind != "ready") throw Error("Initial Run claim was not ready.");
+			o(await e.start(t), a(n.status, { kind: "start" }), "Initial start"), o(await e.wait(t), !0, "Wait commit"), o(await e.observe(t), {
+				status: "waiting",
+				terminalEvents: []
+			}, "Waiting Run observation"), o(await e.claim(t), a("waiting", { kind: "claim" }), "Claim while waiting"), o(await e.resolve(t), !0, "Wait resolution"), o(await e.resolve(t), !1, "Repeated Wait resolution");
+			let r = await e.claim(t);
+			if (r.kind != "ready") throw Error("Resolved Run claim was not ready.");
+			o(await e.start(t), a(r.status, { kind: "start" }), "Resume start"), o(await e.commit(t, "completed"), !0, "Completion after resume"), o(await e.observe(t), {
+				status: "completed",
+				terminalEvents: ["completed"]
+			}, "Resumed Run observation");
+		}
+	},
+	{
+		name: "allows cancellation and expiry failure while waiting",
+		async verify(e) {
+			let t = await s(e, "cancel-wait");
+			if ((await e.claim(t)).kind != "ready") throw Error("Canceled Run claim was not ready.");
+			await e.start(t), o(await e.wait(t), !0, "Canceled Run Wait commit"), o(await e.commit(t, "canceled"), !0, "Waiting cancellation"), o(await e.resolve(t), !1, "Resolution after cancellation");
+			let n = await s(e, "expire-wait");
+			if ((await e.claim(n)).kind != "ready") throw Error("Expired Run claim was not ready.");
+			await e.start(n), o(await e.wait(n), !0, "Expired Run Wait commit"), o(await e.commit(n, "failed"), !0, "Waiting expiry failure"), o(await e.observe(n), {
+				status: "failed",
+				terminalEvents: ["failed"]
+			}, "Expired Run observation");
+		}
+	},
 	{
 		name: "replays idempotent acceptance and rejects a conflicting request",
 		async verify(e) {

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

@@ -44,7 +44,7 @@ export interface RuntimeInvocation {
 }
 export interface RuntimeHarness {
     readonly engineDigest: string;
-    invoke(invocation: RuntimeInvocation): Promise<JsonValue>;
+    invoke(invocation: RuntimeInvocation): Promise<JsonValue | undefined>;
 }
 export interface RuntimeConformanceCase {
     readonly name: string;

package/dist/common/runtime-contract.js

@@ -129,6 +129,33 @@ var c = [
 			}], "Capability request");
 		}
 	},
+	{
+		name: "submits Task outputs and accepts a void result",
+		async verify(e) {
+			let t = [];
+			o(await e.invoke({
+				capability: async (e) => (t.push(e), {
+					body: null,
+					status: 200
+				}),
+				input: null,
+				invocationId: "task-outputs",
+				program: a(e, "export default async (_input, context) => {\n  await context.outputs({ first: 1 })\n  await context.outputs({ second: 2 })\n}")
+			}), void 0, "Void Task result"), o(t.map(({ invocationId: e, kind: t, payload: n }) => ({
+				invocationId: e,
+				kind: t,
+				payload: n
+			})), [{
+				invocationId: "task-outputs",
+				kind: "outputs",
+				payload: { first: 1 }
+			}, {
+				invocationId: "task-outputs",
+				kind: "outputs",
+				payload: { second: 2 }
+			}], "Task outputs request");
+		}
+	},
 	{
 		name: "cancels a pending Capability and the user invocation",
 		async verify(e) {

package/dist/common/scheduler.d.ts

@@ -1,5 +1,6 @@
-import type { ConnectorCapability, JsonValue } from '../browser/flow-change.js';
+import type { ConnectorCapability, JsonValue, WaitAction } from '../browser/flow-change.js';
 import type { PreparedFlow } from './flow-semantics.js';
+import * as Effect from 'effect/Effect';
 export type SchedulerEvent = {
     readonly flowId: string;
     readonly parentJobId?: string;
@@ -16,7 +17,7 @@ export type SchedulerEvent = {
     readonly inputs: Readonly<Record<string, JsonValue>>;
     readonly jobId: string;
     readonly nodeId: string;
-    readonly nodeKind: 'condition' | 'connector' | 'javascript' | 'llm' | 'subflow' | 'value';
+    readonly nodeKind: 'condition' | 'connector' | 'javascript' | 'llm' | 'subflow' | 'value' | 'wait';
     readonly nodeTitle?: string;
     readonly runId: string;
     readonly type: 'node.started';
@@ -39,6 +40,13 @@ export type SchedulerEvent = {
     readonly nodeId: string;
     readonly runId: string;
     readonly type: 'node.failed';
+} | {
+    readonly jobId: string;
+    readonly level: 'debug' | 'error' | 'info' | 'warn';
+    readonly message: string;
+    readonly nodeId: string;
+    readonly runId: string;
+    readonly type: 'node.log';
 } | {
     readonly result: FlowRunResult | SubflowRunResult;
     readonly runId: string;
@@ -58,18 +66,66 @@ export interface FlowRunResult {
         readonly nodeId: string;
     }[];
 }
+export interface FlowRunCheckpoint {
+    readonly bindingValues: Readonly<Record<string, string>>;
+    readonly buffers: Readonly<Record<string, {
+        readonly slots: Readonly<Record<string, {
+            readonly provided: boolean;
+            readonly queue: readonly JsonValue[];
+            readonly value: JsonValue;
+        }>>;
+        readonly staticTaken: boolean;
+    }>>;
+    readonly completedNodes: readonly string[];
+    readonly nextJobs: Readonly<Record<string, number>>;
+    readonly outputs: Readonly<Record<string, JsonValue>>;
+    readonly results: readonly {
+        readonly jobs: readonly {
+            readonly jobId: string;
+            readonly order: number;
+            readonly outputs: Readonly<Record<string, JsonValue>>;
+        }[];
+        readonly nodeId: string;
+    }[];
+    readonly version: 1;
+    readonly wait: {
+        readonly jobId: string;
+        readonly nodeId: string;
+        readonly order: number;
+        readonly value: JsonValue;
+        readonly waitId: string;
+    };
+}
+export type FlowRunOutcome = FlowRunResult | {
+    readonly checkpoint: FlowRunCheckpoint;
+    readonly kind: 'waiting';
+    readonly notification?: {
+        readonly input: Readonly<Record<string, JsonValue>>;
+        readonly messageHandle: string;
+        readonly taskId: string;
+    };
+    readonly wait: {
+        readonly actions: readonly ['continue'] | readonly ['approve', 'reject'];
+        readonly jobId: string;
+        readonly nodeId: string;
+        readonly order: number;
+        readonly waitId: string;
+    };
+};
 export interface SubflowRunResult {
     readonly kind: 'function-outputs';
     readonly outputs: Readonly<Record<string, JsonValue>>;
     readonly target: 'subflow';
 }
 interface TaskInvocationBase {
+    readonly additionalInputs: Readonly<Record<string, JsonValue>>;
+    readonly blockId: string;
+    readonly flowId: string;
     readonly input: Readonly<Record<string, JsonValue>>;
     readonly invocationId: string;
     readonly jobId: string;
     readonly nodeId: string;
     readonly runId: string;
-    readonly signal: AbortSignal;
 }
 export type TaskInvocation = TaskInvocationBase & ({
     readonly capabilities: readonly ConnectorCapability[];
@@ -86,15 +142,20 @@ export interface SchedulerFailure {
     readonly message: string;
 }
 export interface FlowRunOptions {
+    readonly bindingValues?: Readonly<Record<string, string>>;
     readonly createId: () => string;
-    readonly emit?: (event: SchedulerEvent) => void | Promise<void>;
+    readonly emit?: (event: SchedulerEvent) => Effect.Effect<void, Error>;
     readonly flowId: string;
     readonly inputs?: Readonly<Record<string, Readonly<Record<string, JsonValue>>>>;
-    readonly invokeTask: (invocation: TaskInvocation) => Promise<unknown>;
+    readonly invokeTask: (invocation: TaskInvocation, outputs: (value: unknown) => Effect.Effect<void, Error>) => Effect.Effect<unknown, Error>;
     readonly projectFailure?: (error: unknown) => SchedulerFailure;
+    readonly resume?: {
+        readonly action: WaitAction;
+        readonly checkpoint: unknown;
+    };
     readonly runId: string;
-    readonly signal?: AbortSignal;
     readonly trigger?: TriggerSeed;
 }
-export declare function runFlow(prepared: PreparedFlow, options: FlowRunOptions): Promise<FlowRunResult>;
+export declare function decodeFlowRunCheckpoint(value: unknown): FlowRunCheckpoint;
+export declare function runFlow(prepared: PreparedFlow, options: FlowRunOptions): Effect.Effect<FlowRunOutcome, Error>;
 export {};