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

package/dist/common/scheduler.js

@@ -1,16 +1,26 @@
+import * as e from "effect/Effect";
+import * as t from "effect/Exit";
+import * as n from "effect/FiberSet";
+//#region ../../node_modules/.bun/nanoid@6.0.1/node_modules/nanoid/url-alphabet/index.js
+var r = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict", i = (e = 21) => {
+	let t = "", n = crypto.getRandomValues(new Uint8Array(e |= 0));
+	for (; e--;) t += r[n[e] & 63];
+	return t;
+};
+//#endregion
 //#region src/flow/common/change.ts
-function e(e) {
-	return Object.fromEntries(e.map((e) => [e.handle, e]));
+function a(e) {
+	return Object.fromEntries(e.flatMap((e) => "handle" in e ? [[e.handle, e]] : []));
 }
 //#endregion
 //#region src/execution/common/scheduler.ts
-function t(e, t) {
+function o(e, t) {
 	return t?.(e) ?? {
 		code: "node.failed",
 		message: e instanceof Error ? e.message : String(e)
 	};
 }
-var n = class {
+var s = class {
 	#e = [];
 	#t = 0;
 	get length() {
@@ -23,14 +33,19 @@ var n = class {
 		let e = this.#e[this.#t];
 		return this.#t += 1, this.#t >= 64 && this.#t * 2 >= this.#e.length && (this.#e.splice(0, this.#t), this.#t = 0), e;
 	}
-}, r = class {
+	restore(e) {
+		this.#e.push(...e);
+	}
+	snapshot() {
+		return this.#e.slice(this.#t);
+	}
+}, c = class {
 	#e;
-	#t = new n();
+	#t = new s();
 	#n;
 	#r;
-	constructor(e, t, n) {
-		let r = e.inputs[t];
-		this.#e = r?.kind == "sources", this.#n = !this.#e && (r?.kind == "value" || Object.hasOwn(n, "value")), this.#r = r?.kind == "value" ? r.value : n.value ?? null;
+	constructor(e, t) {
+		this.#e = e?.kind == "sources", this.#n = !this.#e && (e?.kind == "value" || Object.hasOwn(t, "value")), this.#r = e?.kind == "value" ? e.value : t.value ?? null;
 	}
 	get ready() {
 		return this.#t.length > 0 || this.#n;
@@ -47,13 +62,26 @@ var n = class {
 	take() {
 		return this.#t.length > 0 ? this.#t.shift() : this.#r;
 	}
-}, i = class {
+	restore(e) {
+		this.#n = e.provided, this.#r = e.value, this.#t.restore(e.queue);
+	}
+	snapshot() {
+		return {
+			provided: this.#n,
+			queue: this.#t.snapshot(),
+			value: this.#r
+		};
+	}
+}, l = class {
 	#e;
 	#t;
 	#n;
 	#r = !1;
-	constructor(e, t, n) {
-		this.#t = e, this.#n = new Map(Object.entries(n).map(([e, n]) => [e, new r(t, e, n)])), this.#e = [...this.#n.values()].some((e) => e.dynamic);
+	constructor(e, t, n, r) {
+		this.#t = e, this.#n = new Map(Object.entries(n).map(([e, n]) => {
+			let i = new c(t[e], n), a = r?.slots[e];
+			return a != null && i.restore(a), [e, i];
+		})), this.#e = [...this.#n.values()].some((e) => e.dynamic), this.#r = r?.staticTaken ?? !1;
 	}
 	get ready() {
 		return (!this.#r || this.#e) && [...this.#n.values()].every((e) => e.ready);
@@ -71,36 +99,59 @@ var n = class {
 		if (!this.ready) throw Error(`Node "${this.#t}" inputs are not ready.`);
 		return this.#e || (this.#r = !0), Object.fromEntries([...this.#n].map(([e, t]) => [e, t.take()]));
 	}
-};
-function a(t, n) {
-	switch (n.kind) {
-		case "condition": return { [n.input.handle]: n.input };
+	snapshot() {
+		return {
+			slots: Object.fromEntries([...this.#n].map(([e, t]) => [e, t.snapshot()])),
+			staticTaken: this.#r
+		};
+	}
+}, u = "notification:";
+function d(e) {
+	return `${u}${e}`;
+}
+function f(e) {
+	return e.kind != "wait" || e.notification == null ? e.inputs : {
+		...e.inputs,
+		...Object.fromEntries(Object.entries(e.notification.inputs).map(([e, t]) => [d(e), t]))
+	};
+}
+function p(e, t) {
+	switch (t.kind) {
+		case "condition": return { [t.input.handle]: t.input };
 		case "value": return {};
-		case "subflow": return e(t.subflows[n.subflowId].inputs);
-		case "task": return e(n.task == null ? t.tasks[n.taskId].inputs : n.task.inputs);
+		case "subflow": return a(e.subflows[t.subflowId].inputs);
+		case "task": return a([...t.task == null ? e.tasks[t.taskId].inputs : t.task.inputs, ...t.additionalInputs ?? []]);
+		case "wait": {
+			let n = t.notification, r = n == null ? void 0 : e.tasks[n.taskId];
+			return {
+				[t.input.handle]: t.input,
+				...n == null || r == null ? {} : Object.fromEntries(r.inputs.flatMap((e) => "handle" in e && e.handle != n.messageHandle ? [[d(e.handle), e]] : []))
+			};
+		}
 	}
 }
-function o(e, t) {
+function m(e, t) {
 	if (t.name != null) return t.name;
 	switch (t.kind) {
 		case "condition": return;
 		case "value": return "Value";
 		case "subflow": return e.subflows[t.subflowId].name;
 		case "task": return t.task == null ? e.tasks[t.taskId].name : t.task.name;
+		case "wait": return "Wait";
 	}
 }
-function s(e, t) {
+function h(e, t) {
 	return t.kind == "task" ? t.task == null ? e.tasks[t.taskId].executor.kind : "javascript" : t.kind;
 }
-function c(e, t, n, r) {
+function g(e, t, n, r) {
 	let i = e.get(t) ?? /* @__PURE__ */ new Map(), a = i.get(n) ?? [];
 	a.push(r), i.set(n, a), e.set(t, i);
 }
-function l(e, t, n) {
+function _(e, t, n) {
 	return e.get(t)?.get(n) ?? [];
 }
-function u(e) {
-	let t = new Map(Object.entries(e.nodes).map(([t, n]) => [t, new Set(Object.values(n.inputs).flatMap((t) => t.kind == "sources" ? t.sources.flatMap((t) => t.kind == "node" && e.nodes[t.nodeId] != null ? [t.nodeId] : []) : []))])), n = [];
+function v(e) {
+	let t = new Map(Object.entries(e.nodes).map(([t, n]) => [t, new Set(Object.values(f(n)).flatMap((t) => t.kind == "sources" ? t.sources.flatMap((t) => t.kind == "node" && e.nodes[t.nodeId] != null ? [t.nodeId] : []) : []))])), n = [];
 	for (; t.size > 0;) {
 		let e = [...t].filter(([, e]) => e.size == 0).map(([e]) => e).toSorted();
 		if (e.length == 0) throw Error("Prepared graph contains a dependency cycle.");
@@ -109,18 +160,124 @@ function u(e) {
 	}
 	return n;
 }
-function d(e, t) {
+function y(e, t) {
+	let n = new Set(Object.values(e.nodes).flatMap((e) => Object.values(f(e)).flatMap((e) => e.kind == "sources" ? e.sources.filter((e) => e.kind == "node").map((e) => e.nodeId) : [])));
+	return t.filter((e) => !n.has(e));
+}
+function b(e, t) {
+	if (typeof e != "object" || !e || Array.isArray(e)) throw Error(`${t} must be an object.`);
+	return e;
+}
+function x(e, t, n) {
+	let r = Object.keys(e);
+	if (r.length != t.length || r.some((e) => !t.includes(e))) throw Error(`${n} contains unsupported fields.`);
+}
+function S(e, t) {
+	if (typeof e != "string" || e.length == 0) throw Error(`${t} must be a non-empty string.`);
+	return e;
+}
+function C(e, t) {
+	if (!Number.isSafeInteger(e) || Number(e) < 0) throw Error(`${t} must be a non-negative integer.`);
+	return Number(e);
+}
+function w(e, t, n = 0) {
+	if (n > 64) throw Error(`${t} exceeds the maximum JSON depth.`);
+	if (e === null || typeof e == "boolean" || typeof e == "string" || typeof e == "number" && Number.isFinite(e)) return e;
+	if (Array.isArray(e)) return e.map((e) => w(e, t, n + 1));
+	let r = b(e, t);
+	return Object.fromEntries(Object.entries(r).map(([e, r]) => [e, w(r, t, n + 1)]));
+}
+function T(e) {
+	let t = b(e, "Flow Run checkpoint");
+	if (x(t, [
+		"bindingValues",
+		"buffers",
+		"completedNodes",
+		"nextJobs",
+		"outputs",
+		"results",
+		"version",
+		"wait"
+	], "Flow Run checkpoint"), t.version != 1) throw Error("Flow Run checkpoint version is unsupported.");
+	let n = b(t.bindingValues, "Flow Run checkpoint bindings"), r = Object.fromEntries(Object.entries(n).map(([e, t]) => {
+		if (typeof t != "string") throw Error(`Flow Run checkpoint binding "${e}" must be a string.`);
+		return [e, t];
+	})), i = b(t.buffers, "Flow Run checkpoint buffers"), a = Object.fromEntries(Object.entries(i).map(([e, t]) => {
+		let n = b(t, `Flow Run checkpoint buffer "${e}"`);
+		if (x(n, ["slots", "staticTaken"], `Flow Run checkpoint buffer "${e}"`), typeof n.staticTaken != "boolean") throw Error(`Flow Run checkpoint buffer "${e}" staticTaken must be boolean.`);
+		let r = b(n.slots, `Flow Run checkpoint buffer "${e}" slots`);
+		return [e, {
+			slots: Object.fromEntries(Object.entries(r).map(([t, n]) => {
+				let r = b(n, `Flow Run checkpoint slot "${e}/${t}"`);
+				if (x(r, [
+					"provided",
+					"queue",
+					"value"
+				], `Flow Run checkpoint slot "${e}/${t}"`), typeof r.provided != "boolean" || !Array.isArray(r.queue)) throw Error(`Flow Run checkpoint slot "${e}/${t}" is invalid.`);
+				return [t, {
+					provided: r.provided,
+					queue: r.queue.map((n) => w(n, `Flow Run checkpoint slot "${e}/${t}" queue`)),
+					value: w(r.value, `Flow Run checkpoint slot "${e}/${t}" value`)
+				}];
+			})),
+			staticTaken: n.staticTaken
+		}];
+	}));
+	if (!Array.isArray(t.completedNodes) || !Array.isArray(t.results)) throw Error("Flow Run checkpoint result state is invalid.");
+	let o = t.completedNodes.map((e) => S(e, "Flow Run checkpoint completed node")), s = Object.fromEntries(Object.entries(b(t.nextJobs, "Flow Run checkpoint next jobs")).map(([e, t]) => [e, C(t, `Flow Run checkpoint next job "${e}"`)])), c = Object.fromEntries(Object.entries(b(t.outputs, "Flow Run checkpoint outputs")).map(([e, t]) => [e, w(t, `Flow Run checkpoint output "${e}"`)])), l = t.results.map((e, t) => {
+		let n = b(e, `Flow Run checkpoint result ${t}`);
+		if (x(n, ["jobs", "nodeId"], `Flow Run checkpoint result ${t}`), !Array.isArray(n.jobs)) throw Error(`Flow Run checkpoint result ${t} jobs must be an array.`);
+		return {
+			jobs: n.jobs.map((e, n) => {
+				let r = b(e, `Flow Run checkpoint result ${t} job ${n}`);
+				return x(r, [
+					"jobId",
+					"order",
+					"outputs"
+				], `Flow Run checkpoint result ${t} job ${n}`), {
+					jobId: S(r.jobId, `Flow Run checkpoint result ${t} job ${n} ID`),
+					order: C(r.order, `Flow Run checkpoint result ${t} job ${n} order`),
+					outputs: Object.fromEntries(Object.entries(b(r.outputs, `Flow Run checkpoint result ${t} job ${n} outputs`)).map(([e, r]) => [e, w(r, `Flow Run checkpoint result ${t} job ${n} output "${e}"`)]))
+				};
+			}),
+			nodeId: S(n.nodeId, `Flow Run checkpoint result ${t} node ID`)
+		};
+	}), u = b(t.wait, "Flow Run checkpoint wait");
+	return x(u, [
+		"jobId",
+		"nodeId",
+		"order",
+		"value",
+		"waitId"
+	], "Flow Run checkpoint wait"), {
+		bindingValues: r,
+		buffers: a,
+		completedNodes: o,
+		nextJobs: s,
+		outputs: c,
+		results: l,
+		version: 1,
+		wait: {
+			jobId: S(u.jobId, "Flow Run checkpoint wait job ID"),
+			nodeId: S(u.nodeId, "Flow Run checkpoint wait node ID"),
+			order: C(u.order, "Flow Run checkpoint wait order"),
+			value: w(u.value, "Flow Run checkpoint wait value"),
+			waitId: S(u.waitId, "Flow Run checkpoint wait ID")
+		}
+	};
+}
+function E(e, t) {
 	if (e === t) return !0;
 	if (e == null || t == null || typeof e != "object" || typeof t != "object") return !1;
-	if (Array.isArray(e) || Array.isArray(t)) return Array.isArray(e) && Array.isArray(t) && e.length == t.length && e.every((e, n) => d(e, t[n]));
+	if (Array.isArray(e) || Array.isArray(t)) return Array.isArray(e) && Array.isArray(t) && e.length == t.length && e.every((e, n) => E(e, t[n]));
 	let n = Object.entries(e), r = Object.entries(t), i = t;
-	return n.length == r.length && n.every(([e, t]) => Object.hasOwn(i, e) && d(t, i[e]));
+	return n.length == r.length && n.every(([e, t]) => Object.hasOwn(i, e) && E(t, i[e]));
 }
-function f(e, t, n) {
+function D(e, t, n) {
 	let r = Object.hasOwn(n, t.input) ? n[t.input] : null, i = t.value;
 	switch (t.operator) {
-		case "==": return i !== void 0 && d(r, i);
-		case "!=": return i !== void 0 && !d(r, i);
+		case "==": return i !== void 0 && E(r, i);
+		case "!=": return i !== void 0 && !E(r, i);
 		case ">": return typeof r == "number" && typeof i == "number" && r > i;
 		case ">=": return typeof r == "number" && typeof i == "number" && r >= i;
 		case "<": return typeof r == "number" && typeof i == "number" && r < i;
@@ -128,7 +285,7 @@ function f(e, t, n) {
 		case "contains":
 		case "notContains": {
 			let e;
-			return typeof r == "string" && typeof i == "string" ? e = r.includes(i) : Array.isArray(r) && i !== void 0 && (e = r.some((e) => d(e, i))), e == null ? !1 : t.operator == "contains" ? e : !e;
+			return typeof r == "string" && typeof i == "string" ? e = r.includes(i) : Array.isArray(r) && i !== void 0 && (e = r.some((e) => E(e, i))), e == null ? !1 : t.operator == "contains" ? e : !e;
 		}
 		case "startsWith": return typeof r == "string" && typeof i == "string" && r.startsWith(i);
 		case "endsWith": return typeof r == "string" && typeof i == "string" && r.endsWith(i);
@@ -141,7 +298,7 @@ function f(e, t, n) {
 		case "hasValue":
 		case "notHasValue": {
 			if (r == null || Array.isArray(r) || typeof r != "object" || i === void 0) return !1;
-			let e = Object.values(r).some((e) => d(e, i));
+			let e = Object.values(r).some((e) => E(e, i));
 			return t.operator == "hasValue" ? e : !e;
 		}
 		case "isEmpty":
@@ -155,230 +312,361 @@ function f(e, t, n) {
 		case "isFalse": return r === !1;
 	}
 }
-function p(e, t) {
+function O(e, t) {
+	if (e === void 0) return {};
 	if (typeof e != "object" || !e || Array.isArray(e)) throw Error(`Node "${t}" must return an object.`);
 	return e;
 }
-function m(e) {
-	return e.reason instanceof Error ? e.reason : /* @__PURE__ */ Error("Run canceled.");
-}
-function h(e, t) {
-	return new Promise((n, r) => {
-		let i = () => {
-			t.removeEventListener("abort", i), r(m(t));
-		};
-		e.then((e) => {
-			t.removeEventListener("abort", i), n(e);
-		}, (e) => {
-			t.removeEventListener("abort", i), r(e);
-		}), t.aborted ? i() : t.addEventListener("abort", i, { once: !0 });
-	});
-}
-async function g(n, r, d, m, _, y, b = {}, x, S) {
-	_.throwIfAborted(), await n.emit({
-		flowId: r.flowId,
-		...y == null ? {} : {
-			parentJobId: y.jobId,
-			parentRunId: y.runId
-		},
-		runId: d,
-		type: "run.started"
-	});
-	let C = u(r.graph), w = C.length, T = new Map(Object.entries(r.graph.nodes).map(([e, t]) => [e, new i(e, t, a(n.prepared, t))])), E = /* @__PURE__ */ new Map(), D = /* @__PURE__ */ new Map(), O = /* @__PURE__ */ new Map();
-	for (let [e, t] of Object.entries(r.graph.nodes)) for (let [n, r] of Object.entries(t.inputs)) if (r.kind == "sources") for (let t of r.sources) if (t.kind == "flow") {
-		let r = E.get(t.input) ?? [];
-		r.push({
+function k(r, s, c, d, b, x = {}, S, C, w) {
+	return e.scoped(e.gen(function* () {
+		w ?? (yield* r.emit({
+			flowId: s.flowId,
+			...b == null ? {} : {
+				parentJobId: b.jobId,
+				parentRunId: b.runId
+			},
+			runId: c,
+			type: "run.started"
+		}));
+		let E = v(s.graph), A = y(s.graph, E), M = E.length, N = new Map(Object.entries(s.graph.nodes).map(([e, t]) => [e, new l(e, f(t), p(r.prepared, t), w?.checkpoint.buffers[e])]));
+		if (w != null) {
+			let t = Object.keys(w.checkpoint.buffers).toSorted();
+			if (t.length != E.length || t.some((e, t) => e != [...E].toSorted()[t])) return yield* e.fail(/* @__PURE__ */ Error("Flow Run checkpoint buffers do not match the prepared graph."));
+			for (let [t, n] of Object.entries(s.graph.nodes)) {
+				let i = Object.keys(p(r.prepared, n)).toSorted(), a = Object.keys(w.checkpoint.buffers[t].slots).toSorted();
+				if (i.length != a.length || i.some((e, t) => e != a[t])) return yield* e.fail(/* @__PURE__ */ Error(`Flow Run checkpoint inputs do not match node "${t}".`));
+			}
+		}
+		let P = /* @__PURE__ */ new Map(), F = /* @__PURE__ */ new Map(), I = /* @__PURE__ */ new Map(), L = /* @__PURE__ */ new Map();
+		for (let [e, t] of Object.entries(s.graph.nodes)) for (let [n, r] of Object.entries(f(t))) if (r.kind == "sources") for (let t of r.sources) if (t.kind == "binding") {
+			let r = F.get(t.bindingId) ?? [];
+			r.push({
+				handle: n,
+				nodeId: e
+			}), F.set(t.bindingId, r);
+		} else if (t.kind == "flow") {
+			let r = P.get(t.input) ?? [];
+			r.push({
+				handle: n,
+				nodeId: e
+			}), P.set(t.input, r);
+		} else t.kind == "node" && g(I, t.nodeId, t.output, {
 			handle: n,
 			nodeId: e
-		}), E.set(t.input, r);
-	} else t.kind == "node" && c(D, t.nodeId, t.output, {
-		handle: n,
-		nodeId: e
-	});
-	for (let [e, t] of Object.entries(r.outputs)) for (let n of t.sources) n.kind == "node" && c(O, n.nodeId, n.output, e);
-	let k = /* @__PURE__ */ new Map(), A = /* @__PURE__ */ new Set(), j = /* @__PURE__ */ new Map(), M = /* @__PURE__ */ new Map(), N = /* @__PURE__ */ new Map(), P = /* @__PURE__ */ new Set(), F = new AbortController(), I = AbortSignal.any([_, F.signal]), L, R = !1, z, B = (e, t) => {
-		F.signal.aborted || (T.get(e.nodeId).push(e.handle, t), z(e.nodeId));
-	}, V = async (e, t, r, i) => {
-		await n.emit({
-			handle: r,
-			jobId: t,
-			nodeId: e,
-			runId: d,
-			type: "node.output",
-			value: i
 		});
-		for (let t of l(D, e, r)) B(t, i);
-		for (let t of l(O, e, r)) N.set(t, i), await x?.(t, i);
-	}, H = async (t, r, i, a) => {
-		let c = s(n.prepared, r), l = o(n.prepared, r);
-		await n.emit({
-			inputs: a,
-			jobId: i,
-			nodeId: t,
-			nodeKind: c,
-			...l == null ? {} : { nodeTitle: l },
-			runId: d,
-			type: "node.started"
-		});
-		let u = r.timeoutMs == null ? void 0 : new AbortController(), m = u == null ? void 0 : setTimeout(() => u.abort(/* @__PURE__ */ Error(`Node "${t}" timed out.`)), r.timeoutMs), _ = u == null ? I : AbortSignal.any([I, u.signal]);
-		try {
-			let o;
-			switch (r.kind) {
-				case "condition": {
-					let e = r.cases.find((e) => {
-						if (e.expressions.length == 0) return !1;
-						let t = e.expressions.map((e) => f(r, e, a));
-						return e.relation == "all" ? t.every(Boolean) : t.some(Boolean);
-					})?.output ?? r.defaultOutput;
-					o = e == null ? {} : { [e]: a[r.input.handle] ?? null }, e != null && await V(t, i, e, o[e]);
-					break;
+		for (let [e, t] of Object.entries(s.outputs)) for (let n of t.sources) n.kind == "node" && g(L, n.nodeId, n.output, e);
+		let R = /* @__PURE__ */ new Map(), z = yield* n.make(), B = yield* n.runtime(z)(), V = new Map(w?.checkpoint.results.map((e) => [e.nodeId, [...e.jobs]]) ?? []), H = new Map(Object.entries(w?.checkpoint.nextJobs ?? {})), U = new Map(Object.entries(w?.checkpoint.outputs ?? {})), W = new Set(w?.checkpoint.completedNodes ?? []), G, K, q = w != null, J, Y, X = (e, t) => {
+			G ?? (N.get(e.nodeId).push(e.handle, t), Y(e.nodeId));
+		}, Z = (t, n, i, a) => e.gen(function* () {
+			yield* r.emit({
+				handle: i,
+				jobId: n,
+				nodeId: t,
+				runId: c,
+				type: "node.output",
+				value: a
+			});
+			for (let e of _(I, t, i)) X(e, a);
+			for (let e of _(L, t, i)) U.set(e, a), S != null && (yield* S(e, a));
+		}), ee = (t, n, i, o) => {
+			let l = e.gen(function* () {
+				let l = h(r.prepared, n), u = m(r.prepared, n), d = Object.fromEntries(Object.entries(o).filter(([e]) => {
+					if (n.kind == "wait") return e == n.input.handle;
+					let t = n.inputs[e];
+					return t?.kind != "sources" || t.sources.every((e) => e.kind != "binding");
+				}));
+				yield* r.emit({
+					inputs: d,
+					jobId: i,
+					nodeId: t,
+					nodeKind: l,
+					...u == null ? {} : { nodeTitle: u },
+					runId: c,
+					type: "node.started"
+				});
+				let f;
+				switch (n.kind) {
+					case "condition": {
+						let e = n.cases.find((e) => {
+							if (e.expressions.length == 0) return !1;
+							let t = e.expressions.map((e) => D(n, e, o));
+							return e.relation == "all" ? t.every(Boolean) : t.some(Boolean);
+						})?.output ?? n.defaultOutput;
+						f = e == null ? {} : { [e]: o[n.input.handle] ?? null }, e != null && (yield* Z(t, i, e, f[e]));
+						break;
+					}
+					case "value":
+						f = Object.fromEntries(n.values.map((e) => [e.handle, e.value ?? null]));
+						for (let [e, n] of Object.entries(f)) yield* Z(t, i, e, n);
+						break;
+					case "subflow": {
+						let e = r.prepared.subflows[n.subflowId];
+						f = yield* k(r, {
+							flowId: n.subflowId,
+							graph: j(e.graph),
+							inputs: a(e.inputs),
+							kind: "subflow",
+							outputs: a(e.outputs)
+						}, r.createId(), o, {
+							jobId: i,
+							runId: c
+						}, {}, (e, n) => Z(t, i, e, n));
+						break;
+					}
+					case "task": {
+						let a = new Set((n.additionalInputs ?? []).map((e) => e.handle)), l = /* @__PURE__ */ new Map(), u = (n) => e.gen(function* () {
+							let r = yield* e.try({
+								try: () => O(n, t),
+								catch: (e) => e instanceof Error ? e : Error(String(e))
+							});
+							for (let [e, n] of Object.entries(r)) yield* Z(t, i, e, n), l.set(e, n);
+						});
+						yield* u(yield* r.invokeTask({
+							additionalInputs: Object.fromEntries(Object.entries(o).filter(([e]) => a.has(e))),
+							blockId: n.task == null ? n.taskId : n.task.moduleId,
+							flowId: s.flowId,
+							input: Object.fromEntries(Object.entries(o).filter(([e]) => !a.has(e))),
+							invocationId: r.createId(),
+							jobId: i,
+							nodeId: t,
+							runId: c,
+							...n.task == null ? { taskId: n.taskId } : {
+								capabilities: n.task.capabilities ?? [],
+								moduleId: n.task.moduleId
+							}
+						}, u)), f = Object.fromEntries(l);
+						break;
+					}
+					case "wait": return yield* e.fail(/* @__PURE__ */ Error("Wait jobs are handled by the Scheduler suspension boundary."));
 				}
-				case "value":
-					o = Object.fromEntries(r.values.map((e) => [e.handle, e.value ?? null]));
-					for (let [e, n] of Object.entries(o)) await V(t, i, e, n);
-					break;
-				case "subflow": {
-					let s = n.prepared.subflows[r.subflowId];
-					o = await h(g(n, {
-						flowId: r.subflowId,
-						graph: v(s.graph),
-						inputs: e(s.inputs),
-						kind: "subflow",
-						outputs: e(s.outputs)
-					}, n.createId(), a, _, {
-						jobId: i,
-						runId: d
-					}, {}, (e, n) => V(t, i, e, n)), _);
-					break;
+				return yield* r.emit({
+					jobId: i,
+					nodeId: t,
+					runId: c,
+					type: "node.completed"
+				}), f;
+			});
+			return n.timeoutMs == null ? l : l.pipe(e.timeoutOrElse({
+				duration: n.timeoutMs,
+				orElse: () => e.fail(/* @__PURE__ */ Error(`Node "${t}" timed out.`))
+			}));
+		}, te = (t) => {
+			let n = s.graph.nodes[t], a = N.get(t).take(), l = r.createId(), d = H.get(t) ?? 0;
+			if (H.set(t, d + 1), n.kind == "wait") {
+				q = !0, J = {
+					actions: n.actions,
+					jobId: l,
+					nodeId: t,
+					...n.notification == null ? {} : { notification: {
+						input: Object.fromEntries(Object.entries(a).flatMap(([e, t]) => e.startsWith(u) ? [[e.slice(13), t]] : [])),
+						messageHandle: n.notification.messageHandle,
+						taskId: n.notification.taskId
+					} },
+					order: d,
+					value: a[n.input.handle] ?? null,
+					waitId: i()
+				};
+				let e = n.inputs[n.input.handle], o = e?.kind == "sources" && e.sources.some((e) => e.kind == "binding") ? {} : { [n.input.handle]: a[n.input.handle] ?? null };
+				B(r.emit({
+					inputs: o,
+					jobId: l,
+					nodeId: t,
+					nodeKind: "wait",
+					...n.name == null ? {} : { nodeTitle: n.name },
+					runId: c,
+					type: "node.started"
+				}));
+				return;
+			}
+			R.set(t, (R.get(t) ?? 0) + 1), B(ee(t, n, l, a).pipe(e.tap((n) => e.gen(function* () {
+				let e = V.get(t) ?? [];
+				e.push({
+					jobId: l,
+					order: d,
+					outputs: n
+				}), V.set(t, e), W.has(t) || (W.add(t), yield* r.emit({
+					...b == null ? {} : {
+						parentJobId: b.jobId,
+						parentRunId: b.runId
+					},
+					progress: W.size / M * 100,
+					runId: c,
+					type: "run.progress"
+				}));
+			})), e.tapError((n) => e.gen(function* () {
+				G ?? (K ??= n);
+				let i = o(n, r.projectFailure);
+				yield* r.emit({
+					...i,
+					jobId: l,
+					nodeId: t,
+					runId: c,
+					type: "node.failed"
+				}).pipe(e.ignore);
+			})), e.tapCause((t) => e.sync(() => {
+				G ??= t;
+			})), e.ensuring(e.sync(() => {
+				R.set(t, (R.get(t) ?? 1) - 1), Y(t);
+			}))));
+		};
+		if (Y = (e) => {
+			if (G != null || q) return;
+			let t = s.graph.nodes[e], n = N.get(e);
+			for (; n.ready && (R.get(e) ?? 0) < t.concurrency;) if (te(e), q) return;
+		}, w == null) {
+			for (let [e, t] of Object.entries(x)) {
+				let n = N.get(e);
+				if (n != null) for (let [e, r] of Object.entries(t)) n.launch(e, r);
+			}
+			for (let [t, n] of F) {
+				if (!Object.hasOwn(r.bindingValues, t)) return yield* e.fail(/* @__PURE__ */ Error(`Variable binding "${t}" is unresolved.`));
+				for (let e of n) X(e, r.bindingValues[t]);
+			}
+			for (let [e, t] of Object.entries(s.inputs)) {
+				let n = Object.hasOwn(d, e) ? d[e] : t.value;
+				if (n !== void 0) {
+					for (let t of Object.entries(s.outputs)) t[1].sources.some((t) => t.kind == "flow" && t.input == e) && (U.set(t[0], n), S != null && (yield* S(t[0], n)));
+					for (let t of P.get(e) ?? []) X(t, n);
 				}
-				case "task":
-					o = p(await h(n.invokeTask({
-						input: a,
-						invocationId: n.createId(),
-						jobId: i,
-						nodeId: t,
-						runId: d,
-						signal: _,
-						...r.task == null ? { taskId: r.taskId } : {
-							capabilities: r.task.capabilities ?? [],
-							moduleId: r.task.moduleId
-						}
-					}), _), t);
-					for (let [e, n] of Object.entries(o)) await V(t, i, e, n);
 			}
-			return await n.emit({
-				jobId: i,
-				nodeId: t,
-				runId: d,
+			if (C != null) for (let e of _(I, C.nodeId, "payload")) X(e, C.payload);
+		} else {
+			let t = w.checkpoint.wait, n = s.graph.nodes[t.nodeId];
+			if (n?.kind != "wait" || !n.actions.some((e) => e == w.action)) return yield* e.fail(/* @__PURE__ */ Error("Flow Run checkpoint resolution does not match the prepared Wait node."));
+			if (Object.keys(w.checkpoint.nextJobs).some((e) => s.graph.nodes[e] == null)) return yield* e.fail(/* @__PURE__ */ Error("Flow Run checkpoint job state does not match the prepared graph."));
+			let i = { [w.action]: t.value };
+			yield* Z(t.nodeId, t.jobId, w.action, t.value);
+			let a = V.get(t.nodeId) ?? [];
+			a.push({
+				jobId: t.jobId,
+				order: t.order,
+				outputs: i
+			}), V.set(t.nodeId, a), W.has(t.nodeId) || (W.add(t.nodeId), yield* r.emit({
+				progress: W.size / M * 100,
+				runId: c,
+				type: "run.progress"
+			})), yield* r.emit({
+				jobId: t.jobId,
+				nodeId: t.nodeId,
+				runId: c,
 				type: "node.completed"
-			}), o;
-		} finally {
-			m != null && clearTimeout(m);
+			}), q = !1;
 		}
-	}, U = (e) => {
-		let i = r.graph.nodes[e], a = T.get(e).take(), o = n.createId(), s = M.get(e) ?? 0;
-		M.set(e, s + 1), k.set(e, (k.get(e) ?? 0) + 1);
-		let c = Promise.resolve();
-		c = H(e, i, o, a).then(async (t) => {
-			let r = j.get(e) ?? [];
-			r.push({
-				jobId: o,
-				order: s,
-				outputs: t
-			}), j.set(e, r), P.has(e) || (P.add(e), await n.emit({
-				...y == null ? {} : {
-					parentJobId: y.jobId,
-					parentRunId: y.runId
+		for (let e of E) Y(e);
+		let Q = yield* e.raceFirst(n.awaitEmpty(z), n.join(z)).pipe(e.exit);
+		if (K != null) return yield* n.clear(z), yield* r.emit({
+			message: K.message,
+			runId: c,
+			type: "run.failed"
+		}).pipe(e.ignore), yield* e.fail(K);
+		if (G != null) return yield* n.clear(z), yield* e.failCause(G);
+		if (t.isFailure(Q)) return yield* e.failCause(Q.cause);
+		if (J != null) {
+			if (s.kind != "flow") return yield* e.fail(/* @__PURE__ */ Error("Subflow Wait is not supported."));
+			let t = {
+				bindingValues: r.bindingValues,
+				buffers: Object.fromEntries([...N].map(([e, t]) => [e, t.snapshot()])),
+				completedNodes: [...W].toSorted(),
+				nextJobs: Object.fromEntries(H),
+				outputs: Object.fromEntries(U),
+				results: A.map((e) => ({
+					jobs: (V.get(e) ?? []).toSorted((e, t) => e.order - t.order),
+					nodeId: e
+				})),
+				version: 1,
+				wait: {
+					jobId: J.jobId,
+					nodeId: J.nodeId,
+					order: J.order,
+					value: J.value,
+					waitId: J.waitId
+				}
+			}, n = JSON.stringify(t);
+			if (new TextEncoder().encode(n).byteLength > 16777216) {
+				let t = "Flow Run checkpoint exceeds 16 MiB.";
+				return yield* r.emit({
+					code: "run.checkpoint-too-large",
+					jobId: J.jobId,
+					message: t,
+					nodeId: J.nodeId,
+					runId: c,
+					type: "node.failed"
+				}), yield* r.emit({
+					message: t,
+					runId: c,
+					type: "run.failed"
+				}), yield* e.fail(/* @__PURE__ */ Error(`run.checkpoint-too-large: ${t}`));
+			}
+			return {
+				checkpoint: T(JSON.parse(n)),
+				kind: "waiting",
+				...J.notification == null ? {} : { notification: J.notification },
+				wait: {
+					actions: J.actions,
+					jobId: J.jobId,
+					nodeId: J.nodeId,
+					order: J.order,
+					waitId: J.waitId
+				}
+			};
+		}
+		if (s.kind == "subflow") {
+			let e = Object.fromEntries(U);
+			return yield* r.emit({
+				result: {
+					kind: "function-outputs",
+					outputs: e,
+					target: "subflow"
 				},
-				progress: P.size / w * 100,
-				runId: d,
-				type: "run.progress"
-			}));
-		}).catch(async (r) => {
-			R || (R = !0, L = r, F.abort(r));
-			let i = t(r, n.projectFailure);
-			await n.emit({
-				...i,
-				jobId: o,
-				nodeId: e,
-				runId: d,
-				type: "node.failed"
-			}).catch(() => void 0);
-		}).finally(() => {
-			A.delete(c), k.set(e, (k.get(e) ?? 1) - 1), z(e);
-		}), A.add(c);
-	};
-	z = (e) => {
-		if (F.signal.aborted) return;
-		let t = r.graph.nodes[e], n = T.get(e);
-		for (; n.ready && (k.get(e) ?? 0) < t.concurrency;) U(e);
-	};
-	for (let [e, t] of Object.entries(b)) {
-		let n = T.get(e);
-		if (n != null) for (let [e, r] of Object.entries(t)) n.launch(e, r);
-	}
-	for (let [e, t] of Object.entries(r.inputs)) {
-		let n = Object.hasOwn(m, e) ? m[e] : t.value;
-		if (n !== void 0) {
-			for (let t of Object.entries(r.outputs)) t[1].sources.some((t) => t.kind == "flow" && t.input == e) && (N.set(t[0], n), await x?.(t[0], n));
-			for (let t of E.get(e) ?? []) B(t, n);
+				runId: c,
+				type: "run.completed"
+			}), e;
 		}
-	}
-	if (S != null) for (let e of l(D, S.nodeId, "payload")) B(e, S.payload);
-	for (let e of C) z(e);
-	for (; A.size > 0;) await Promise.race(A);
-	if (R) throw await n.emit({
-		message: L instanceof Error ? L.message : String(L),
-		runId: d,
-		type: "run.failed"
-	}).catch(() => void 0), L;
-	if (I.throwIfAborted(), r.kind == "subflow") {
-		let e = Object.fromEntries(N);
-		return await n.emit({
-			result: {
-				kind: "function-outputs",
-				outputs: e,
-				target: "subflow"
-			},
-			runId: d,
+		let $ = {
+			kind: "node-results",
+			nodes: A.map((e) => ({
+				jobs: (V.get(e) ?? []).toSorted((e, t) => e.order - t.order).map(({ jobId: e, outputs: t }) => ({
+					jobId: e,
+					outputs: t
+				})),
+				nodeId: e
+			}))
+		};
+		return yield* r.emit({
+			result: $,
+			runId: c,
 			type: "run.completed"
-		}), e;
-	}
-	let W = new Set(Object.values(r.graph.nodes).flatMap((e) => Object.values(e.inputs).flatMap((e) => e.kind == "sources" ? e.sources.filter((e) => e.kind == "node").map((e) => e.nodeId) : []))), G = {
-		kind: "node-results",
-		nodes: C.filter((e) => !W.has(e)).map((e) => ({
-			jobs: (j.get(e) ?? []).toSorted((e, t) => e.order - t.order).map(({ jobId: e, outputs: t }) => ({
-				jobId: e,
-				outputs: t
-			})),
-			nodeId: e
-		}))
-	};
-	return await n.emit({
-		result: G,
-		runId: d,
-		type: "run.completed"
-	}), G;
+		}), $;
+	}));
 }
-async function _(e, t) {
-	let n = async (e) => await t.emit?.(e), r = t.signal ?? new AbortController().signal, i = t.trigger == null ? void 0 : e.graph.nodes[t.trigger.nodeId];
-	if (t.trigger != null && (i == null || "inputs" in i)) throw Error(`Node "${t.trigger.nodeId}" is not a TriggerNode in Flow "${t.flowId}".`);
-	return await g({
-		createId: t.createId,
-		emit: n,
-		invokeTask: t.invokeTask,
-		prepared: e,
-		projectFailure: t.projectFailure
-	}, {
-		flowId: t.flowId,
-		graph: v(e.graph),
-		inputs: {},
-		kind: "flow",
-		outputs: {}
-	}, t.runId, {}, r, void 0, t.inputs, void 0, t.trigger);
+function A(t, n) {
+	let r = n.emit ?? (() => e.void);
+	return e.gen(function* () {
+		if (n.resume != null && (n.inputs != null || n.trigger != null)) return yield* e.fail(/* @__PURE__ */ Error("A resumed Flow Run cannot accept launch inputs or a Trigger seed."));
+		let i = n.resume == null ? void 0 : T(n.resume.checkpoint);
+		if (i != null && new TextEncoder().encode(JSON.stringify(i)).byteLength > 16777216) return yield* e.fail(/* @__PURE__ */ Error("Flow Run checkpoint exceeds 16 MiB."));
+		let a = n.trigger == null ? void 0 : t.graph.nodes[n.trigger.nodeId];
+		return n.trigger != null && (a == null || "inputs" in a) ? yield* e.fail(/* @__PURE__ */ Error(`Node "${n.trigger.nodeId}" is not a TriggerNode in Flow "${n.flowId}".`)) : yield* k({
+			bindingValues: i?.bindingValues ?? n.bindingValues ?? {},
+			createId: n.createId,
+			emit: r,
+			invokeTask: n.invokeTask,
+			prepared: t,
+			projectFailure: n.projectFailure
+		}, {
+			flowId: n.flowId,
+			graph: j(t.graph),
+			inputs: {},
+			kind: "flow",
+			outputs: {}
+		}, n.runId, {}, void 0, n.inputs, void 0, n.trigger, i == null ? void 0 : {
+			action: n.resume.action,
+			checkpoint: i
+		});
+	});
 }
-function v(e) {
+function j(e) {
 	return { nodes: Object.fromEntries(Object.entries(e.nodes).filter((e) => "inputs" in e[1])) };
 }
 //#endregion
-export { _ as runFlow };
+export { T as decodeFlowRunCheckpoint, A as runFlow };