@voltro/runtime 0.85.0 → 0.86.0

package/dist/workflowRuntime.js

@@ -0,0 +1,708 @@
+import { getRowFilter as e, resolveRowFilterScopeFor as t } from "./rowFilter.js";
+import { SYSTEM_SUBJECT as n } from "./systemSubject.js";
+import { makeEffectStoreLayer as r } from "./effectStore.js";
+import { Cause as i, Effect as a, Exit as o, Layer as s, Option as c, Schema as l, SchemaIssue as u } from "effect";
+import { SubjectService as d, WorkflowControlResultSchema as f, WorkflowQueuedCancellationResultSchema as p, WorkflowRestartCommandSchema as m, WorkflowRestartObservationSchema as h, WorkflowRestartResultSchema as g, WorkflowRestartTargetSchema as _, WorkflowRetryCommandSchema as v, WorkflowRetryObservationSchema as y, WorkflowRetryTargetSchema as b } from "@voltro/protocol";
+import { createLogger as x } from "@voltro/logger";
+import * as S from "effect/SchemaAST";
+import { executePreparedWorkflow as C, getCurrentWorkflowExecutionId as w, hasPreparedWorkflowExecution as T } from "@voltro/workflow";
+//#region src/workflowRuntime.ts
+var E = class extends l.TaggedError()("WorkflowStartNotExecuted", {
+	workflowName: l.String,
+	handleId: l.String,
+	reason: l.Literals([
+		"dropped",
+		"skipped",
+		"superseded",
+		"cancelled",
+		"abandoned",
+		"rejected"
+	]),
+	failureId: l.NullOr(l.String),
+	incumbentExecutionId: l.NullOr(l.String)
+}) {}, D = x({ scope: "voltro:workflow" }), O = /* @__PURE__ */ new Set(), k = 1e3, A = /* @__PURE__ */ new Set([
+	"succeeded",
+	"failed",
+	"cancelled"
+]), j = async (e, t) => {
+	try {
+		return (await e({
+			idPrefix: t,
+			limit: 5
+		})).find((e) => e.executionId === t && A.has(e.status));
+	} catch {
+		return;
+	}
+}, M = (e, t, n) => ({
+	id: t,
+	workflowName: e,
+	executionId: t,
+	status: n
+}), N = (e, t) => t.kind === "queued" ? {
+	id: t.receiptId,
+	workflowName: e,
+	executionId: null,
+	status: "queued",
+	deferral: {
+		mode: t.mode,
+		dueAt: t.dueAt,
+		retryAfterMs: null,
+		intentId: t.intentId
+	}
+} : t.kind === "dropped" ? {
+	id: `dropped:${e}`,
+	workflowName: e,
+	executionId: null,
+	status: "dropped",
+	deferral: {
+		mode: "rateLimit",
+		dueAt: null,
+		retryAfterMs: t.retryAfterMs,
+		intentId: null
+	}
+} : {
+	id: t.executionId,
+	workflowName: e,
+	executionId: t.executionId,
+	status: "skipped",
+	deferral: {
+		mode: "singleton",
+		dueAt: null,
+		retryAfterMs: null,
+		intentId: null
+	}
+}, P = class extends Error {
+	workflowName;
+	retryAfterMs;
+	constructor(e, t) {
+		super(`workflow '${e}' is over its declared rateLimit; this start was DROPPED and will not run. The window reopens in ${t}ms. Use throttle instead of rateLimit if the excess should be queued rather than discarded.`), this.name = "WorkflowRateLimitedError", this.workflowName = e, this.retryAfterMs = t;
+	}
+}, F = class extends Error {
+	workflowName;
+	executionId;
+	constructor(e, t) {
+		super(`workflow '${e}' holds its singleton key on run '${t}', and this workflow declares mode 'skip'. Nothing new was started. Wait on that run (ctx.workflows.wait('${e}', '${t}')) if its result is what you needed.`), this.name = "WorkflowSingletonHeldError", this.workflowName = e, this.executionId = t;
+	}
+}, I = { kind: "passthrough" }, L = M, R = (e) => {
+	let t = i.findErrorOption(e), n = t._tag === "Some" ? t.value : i.squash(e);
+	return {
+		tag: n && typeof n == "object" && "_tag" in n ? String(n._tag) : null,
+		message: n?.message ?? String(n)
+	};
+}, z = (e, t, n) => {
+	if (n === void 0) return {
+		id: t,
+		workflowName: e,
+		executionId: t,
+		status: "unknown"
+	};
+	if (typeof n == "object" && n && n._tag === "Suspended") return {
+		id: t,
+		workflowName: e,
+		executionId: t,
+		status: "suspended"
+	};
+	if (typeof n == "object" && n && n._tag === "Complete") {
+		let r = n.exit;
+		return o.isSuccess(r) ? {
+			id: t,
+			workflowName: e,
+			executionId: t,
+			status: "succeeded",
+			output: r.value
+		} : {
+			id: t,
+			workflowName: e,
+			executionId: t,
+			status: i.hasInterruptsOnly(r.cause) ? "cancelled" : "failed",
+			error: R(r.cause)
+		};
+	}
+	return {
+		id: t,
+		workflowName: e,
+		executionId: t,
+		status: "running"
+	};
+}, B = (e) => new Promise((t) => setTimeout(t, e)), V = class extends Error {
+	workflowName;
+	missingFields;
+	detail;
+	_tag = "WorkflowPayloadError";
+	constructor(e, t, n) {
+		let r = t.length > 0 ? ` missing required field(s): ${t.join(", ")}.` : "";
+		super(`Workflow "${e}" was started with an invalid payload.${r} ${n}`), this.workflowName = e, this.missingFields = t, this.detail = n, this.name = "WorkflowPayloadError";
+	}
+}, H = (e, t) => {
+	let n = e.ast, r = [], i = [];
+	return S.isObjects(n) && n.propertySignatures.forEach((e) => {
+		let n = e.name;
+		typeof n == "string" && (S.isOptional(e.type) ? t && i.push(n) : r.push(n));
+	}), {
+		required: r,
+		optional: i
+	};
+}, U = (e) => H(e, !0), W = (e) => H(e, !1).required, G = (e) => {
+	let t = new Map(e.workflows.map((e) => [e.definition.name, e.definition])), r = (e) => {
+		let n = t.get(e);
+		if (!n) {
+			let n = [...t.keys()].sort().join(", ");
+			throw Error(`Unknown workflow: ${e}. Registered workflows: ${n || "(none)"}.`);
+		}
+		return n;
+	}, i = (e, t, n = e.payloadSchema) => {
+		let r = l.decodeUnknownResult(l.make(S.toType(n.ast)))(t);
+		if (r._tag === "Success") return;
+		let i = new Set(typeof t == "object" && t ? Object.keys(t) : []), a = W(n).filter((e) => !i.has(e));
+		throw new V(e.name, a, u.makeFormatterDefault()(r.failure.issue));
+	}, a = (t) => e.startPayloadSchema?.(t.name) ?? t.payloadSchema, s = (e, t, n = !1) => {
+		let o = r(e);
+		return i(o, t, n ? o.payloadSchema : a(o)), o;
+	}, d = async (t, n) => {
+		let i = r(t);
+		return z(t, n, c.getOrUndefined(await e.runEffect(i.poll(n))));
+	}, x = async () => e.runEffect(w()), L = async (t, n, r) => {
+		if (e.resolveQueuedStart === void 0) throw Error(`Workflow '${t}' remains queued under receipt '${n}'; no receipt resolver is configured`);
+		let i = await e.resolveQueuedStart({
+			workflowName: t,
+			receiptId: n,
+			callerContext: r
+		});
+		if (i.kind === "pending") return;
+		if (i.kind === "accepted") {
+			if (i.executionId.length === 0) throw Error("Queued workflow acceptance has an empty execution identity");
+			return i.executionId;
+		}
+		let a = i.kind === "terminal" ? i.outcome : void 0;
+		throw new E({
+			workflowName: t,
+			handleId: n,
+			reason: a?.kind ?? "rejected",
+			failureId: i.kind === "rejected" ? i.failureId : a?.kind === "abandoned" ? a.failureId : null,
+			incumbentExecutionId: a?.kind === "skipped" ? a.executionId : null
+		});
+	}, R = async (t, n) => {
+		let i = r(t);
+		for (;;) {
+			let t = c.getOrUndefined(await e.runEffect(i.poll(n)));
+			if (typeof t == "object" && t && "_tag" in t && t._tag === "Complete") {
+				if (!("exit" in t) || !o.isExit(t.exit)) throw Error("Completed workflow observation has no valid Exit");
+				return e.runEffect(t.exit);
+			}
+			await B(500);
+		}
+	}, H = async (e, t, n) => {
+		let r;
+		for (; r === void 0;) r = await L(e, t, n), r === void 0 && await B(500);
+		return {
+			executionId: r,
+			value: await R(e, r)
+		};
+	}, U = (e, t, n) => {
+		let r = l.decodeUnknownSync(f)(t), i = n === "submit" && r.kind === "unknown" && r.requestId === null;
+		if (r.operation !== e.operation || r.snapshot.workflowName !== e.workflowName || r.snapshot.executionId !== e.executionId || e.requestId !== void 0 && r.requestId !== e.requestId && !i) throw Error("Workflow control response does not match the requested control target");
+		return r;
+	}, G = async (t, n, i, a) => {
+		let o = r(n), s = a?.requestId;
+		if (a !== void 0 && (typeof s != "string" || s.trim().length === 0)) throw Error("Workflow control requestId must be a non-empty string");
+		if (e.control !== void 0) {
+			let r = {
+				operation: t,
+				workflowName: n,
+				executionId: i,
+				...s === void 0 ? {} : { requestId: s },
+				...a?.cause === void 0 ? {} : { cause: a.cause }
+			};
+			return U(r, await e.control(r), "submit");
+		}
+		if (s !== void 0) throw Error("Workflow control requestId requires a resident control adapter");
+		let c = await d(n, i);
+		if (A.has(c.status)) return {
+			operation: t,
+			kind: "already-terminal",
+			requestId: null,
+			snapshot: c
+		};
+		try {
+			await e.runEffect(t === "cancel" ? o.interrupt(i) : o.resume(i));
+			let r = await d(n, i);
+			return {
+				operation: t,
+				kind: t === "cancel" && r.status === "cancelled" ? "confirmed" : "unknown",
+				requestId: null,
+				snapshot: r
+			};
+		} catch (e) {
+			return D.warn("workflow control outcome is unknown", {
+				workflowName: n,
+				executionId: i,
+				operation: t,
+				error: e
+			}), {
+				operation: t,
+				kind: "unknown",
+				requestId: null,
+				snapshot: {
+					id: i,
+					workflowName: n,
+					executionId: i,
+					status: "unknown"
+				}
+			};
+		}
+	}, q = async (t, n, r) => {
+		for (let e of [
+			n.workflowName,
+			n.receiptId,
+			n.requestId
+		]) if (typeof e != "string" || e.trim().length === 0) throw Error("Queued control requires non-empty workflow, receipt and request identities");
+		let i = t === "submit" ? e.cancelQueued : e.readQueuedCancellation;
+		if (i === void 0) throw Error("Queued cancellation requires a resident submit/read adapter");
+		let a = l.decodeUnknownSync(p)(await i({
+			workflowName: n.workflowName,
+			receiptId: n.receiptId,
+			requestId: n.requestId,
+			callerContext: r?.callerContext,
+			...t === "submit" && r?.cause !== void 0 ? { cause: r.cause } : {}
+		}));
+		if (a.workflowName !== n.workflowName || a.receiptId !== n.receiptId || a.requestId !== null && a.requestId !== n.requestId) throw Error("Queued cancellation response does not match the requested target");
+		return a;
+	}, J = async (t, r, i) => {
+		let o = i?.requestId;
+		if (o !== void 0 && (typeof o != "string" || o.trim().length === 0 || o.length > 64 || i?.at === void 0 || i?.admitted === !0 || i?.enqueueStart !== void 0)) throw Error("Workflow start requestId requires a non-empty identity of at most 64 characters and an explicit at instant, without admitted or transactional enqueue");
+		let c = i?.preparedExecutionId;
+		if (c !== void 0 && (c.length === 0 || i?.admitted !== !0 || i.wait === !0 || i.enqueueStart !== void 0 || i.at !== void 0)) throw Error("Prepared workflow execution requires a non-empty identity and admitted:true, without wait, enqueueStart or at");
+		let u = s(t, r, i?.admitted === !0);
+		if (i?.enqueueStart !== void 0) {
+			if (i.wait === !0 || i.admitted === !0) throw Error("A transactional workflow start cannot wait or bypass admission");
+			let e = i.at?.getTime() ?? Date.now();
+			if (!Number.isFinite(e)) throw Error(`ctx.workflows.start('${t}'): 'at' is not a valid Date`);
+			let n;
+			try {
+				n = l.encodeUnknownSync(a(u))(r);
+			} catch {
+				throw new V(t, [], "payload could not be encoded for the admission queue");
+			}
+			return N(t, {
+				kind: "queued",
+				mode: "transaction",
+				...await i.enqueueStart({
+					workflowName: t,
+					payload: n,
+					callerContext: i.callerContext,
+					at: e
+				})
+			});
+		}
+		if (i?.at !== void 0 && i.admitted !== !0) {
+			let n = i.at.getTime();
+			if (!Number.isFinite(n)) throw Error(`ctx.workflows.start('${t}', …, { at }): 'at' is not a valid Date`);
+			if (n > Date.now() || o !== void 0) {
+				if (e.parkDelayedStart === void 0) throw Error(`ctx.workflows.start('${t}', …, { at }): delayed starts are not configured in this runtime — the durable pending queue that fires them is wired by the framework boot (voltro dev / voltro serve).`);
+				let a = await e.parkDelayedStart({
+					...o === void 0 ? {} : { requestId: o },
+					workflowName: t,
+					payload: r,
+					callerContext: i.callerContext,
+					at: n
+				});
+				return i.wait === !0 ? M(t, (await H(t, a.receiptId, i.callerContext)).executionId, "succeeded") : {
+					id: a.receiptId,
+					workflowName: t,
+					executionId: null,
+					status: "queued",
+					deferral: {
+						mode: "delayed",
+						dueAt: a.dueAt,
+						retryAfterMs: null,
+						intentId: a.intentId
+					}
+				};
+			}
+		}
+		let d = i?.wait === !0, f = e.admitStart === void 0 || i?.admitted === !0 ? I : await e.admitStart({
+			workflowName: t,
+			payload: r,
+			callerContext: i?.callerContext,
+			waiting: d
+		});
+		if (f.kind === "queued" || f.kind === "dropped" || f.kind === "skipped") return d && f.kind === "queued" ? M(t, (await H(t, f.receiptId, i?.callerContext)).executionId, "succeeded") : N(t, f);
+		if (f.kind === "start") {
+			let n = await f.accept();
+			return typeof n == "string" ? (e.onEnqueue?.(), d && await R(t, n), M(t, n, d ? "succeeded" : "running")) : d ? M(t, (await H(t, n.receiptId, i?.callerContext)).executionId, "succeeded") : N(t, n);
+		}
+		let p = r;
+		if (e.listRuns !== void 0 && i?.admitted !== !0) {
+			let n = await e.runEffect(u.executionId(p)), r = await j(e.listRuns, n);
+			if (r !== void 0) return O.has(n) || (O.size >= k && O.clear(), O.add(n), D.warn("workflow start replayed — the idempotency key was already spent, nothing ran", {
+				workflow: t,
+				executionId: n,
+				runId: r.id,
+				status: r.status
+			})), d ? (await R(t, n), {
+				id: r.id,
+				workflowName: t,
+				executionId: n,
+				status: "succeeded"
+			}) : {
+				id: r.id,
+				workflowName: t,
+				executionId: n,
+				status: "replayed"
+			};
+		}
+		let m;
+		(e.rememberStartContext !== void 0 || i?.callerContext !== void 0) && (m = c ?? await e.runEffect(u.executionId(p)), await e.rememberStartContext?.(t, m, i?.callerContext ?? { subject: n }));
+		let h = c ?? (m !== void 0 && T(u) ? m : void 0);
+		if (d) return h === void 0 ? await e.runEffect(u.execute(p)) : await e.runEffect(C(u, p, h, { discard: !1 })), e.onEnqueue?.(), M(t, h ?? await e.runEffect(u.executionId(p)), "succeeded");
+		let g = await e.runEffect(h === void 0 ? u.execute(p, { discard: !0 }) : C(u, p, h));
+		return e.onEnqueue?.(), M(t, g, "running");
+	};
+	return {
+		start: J,
+		child: async (e, t, n) => {
+			let r = n?.callerContext?.parentExecutionId ?? await x();
+			if (r == null || r === "") throw Error("ctx.workflows.child(...) can only be used from inside a workflow execution; use ctx.workflows.start(...) for top-level starts.");
+			let i = n?.callerContext ?? {}, a = {
+				...i,
+				source: i.source ?? `workflow:${r}`,
+				parentExecutionId: r,
+				parentClosePolicy: n?.parentClosePolicy ?? i.parentClosePolicy ?? "cancel"
+			};
+			return J(e, t, {
+				...n?.wait === void 0 ? {} : { wait: n.wait },
+				...n?.enqueueStart === void 0 ? {} : { enqueueStart: n.enqueueStart },
+				callerContext: a
+			});
+		},
+		run: async (t, r, i) => {
+			let a = s(t, r);
+			if (e.admitStart !== void 0) {
+				let n = await e.admitStart({
+					workflowName: t,
+					payload: r,
+					callerContext: i?.callerContext,
+					waiting: !0
+				});
+				if (n.kind === "queued") return (await H(t, n.receiptId, i?.callerContext)).value;
+				if (n.kind === "dropped") throw new P(t, n.retryAfterMs);
+				if (n.kind === "skipped") throw new F(t, n.executionId);
+				if (n.kind === "start") {
+					let r = await n.accept();
+					return typeof r == "string" ? (e.onEnqueue?.(), await R(t, r)) : (await H(t, r.receiptId, i?.callerContext)).value;
+				}
+			}
+			if (e.rememberStartContext !== void 0 || i?.callerContext !== void 0) {
+				let o = await e.runEffect(a.executionId(r));
+				await e.rememberStartContext?.(t, o, i?.callerContext ?? { subject: n });
+			}
+			return await e.runEffect(a.execute(r));
+		},
+		executionId: async (t, n) => {
+			let r = s(t, n, !0);
+			return e.runEffect(r.executionId(n));
+		},
+		poll: async (e, t) => d(e, t),
+		query: async (e, t) => d(e, t),
+		wait: (async (t, n, r) => {
+			let i = typeof t == "string" ? t : t.workflowName, a = typeof t == "string" ? n : t.executionId, o = typeof t == "string" ? r : n, s = Date.now(), c = o?.pollIntervalMs ?? 500, l = typeof t == "string" ? void 0 : t;
+			if (l?.status === "dropped" || l?.status === "skipped") throw new E({
+				workflowName: i,
+				handleId: l.id,
+				reason: l.status,
+				failureId: null,
+				incumbentExecutionId: l.status === "skipped" ? l.executionId : null
+			});
+			for (;;) {
+				if (a == null) {
+					if (l?.status !== "queued" || e.resolveQueuedStart === void 0) throw Error(`Workflow '${i}' has no execution or configured receipt resolver`);
+					if (a = await L(i, l.id, o?.callerContext), a === void 0) {
+						if (o?.timeoutMs !== void 0 && Date.now() - s >= o.timeoutMs) throw Error(`Timed out waiting for workflow '${i}' start receipt '${l.id}'`);
+						await B(c);
+						continue;
+					}
+				}
+				let t = await d(i, a);
+				if (t.status === "succeeded" || t.status === "failed" || t.status === "cancelled") return t;
+				if (o?.timeoutMs !== void 0 && Date.now() - s >= o.timeoutMs) throw Error(`Timed out waiting for workflow '${i}' run '${a}'`);
+				await B(c);
+			}
+		}),
+		cancel: (e, t, n) => G("cancel", e, t, n),
+		cancelQueued: (e, t) => q("submit", e, t),
+		readQueuedCancellation: (e, t) => q("read", e, t),
+		readStart: async (t, n) => {
+			if (t.status === "dropped" || t.status === "skipped") return {
+				kind: "not-executed",
+				reason: t.status,
+				failureId: null,
+				incumbentExecutionId: t.status === "skipped" ? t.executionId : null
+			};
+			if (t.status === "queued") {
+				if (e.resolveQueuedStart === void 0) throw Error(`Workflow '${t.workflowName}' remains queued under receipt '${t.id}'; no receipt resolver is configured`);
+				let r = await e.resolveQueuedStart({
+					workflowName: t.workflowName,
+					receiptId: t.id,
+					callerContext: n?.callerContext
+				});
+				if (r.kind === "pending") return { kind: "pending" };
+				if (r.kind === "accepted") {
+					if (r.executionId.length === 0) throw Error("Queued workflow acceptance has an empty execution identity");
+					return {
+						kind: "accepted",
+						executionId: r.executionId
+					};
+				}
+				if (r.kind === "rejected") return {
+					kind: "not-executed",
+					reason: "rejected",
+					failureId: r.failureId,
+					incumbentExecutionId: null
+				};
+				let i = r.outcome;
+				return {
+					kind: "not-executed",
+					reason: i.kind,
+					failureId: i.kind === "abandoned" ? i.failureId : null,
+					incumbentExecutionId: i.kind === "skipped" ? i.executionId : null
+				};
+			}
+			if (t.executionId === null || t.executionId.length === 0) throw Error(`Workflow '${t.workflowName}' handle '${t.id}' is '${t.status}' but names no execution`);
+			return {
+				kind: "accepted",
+				executionId: t.executionId
+			};
+		},
+		resume: (e, t, n) => G("resume", e, t, n),
+		readControl: async (t) => {
+			if (typeof t.requestId != "string" || t.requestId.trim().length === 0) throw Error("Workflow control requestId must be a non-empty string");
+			if (e.readControl === void 0) throw Error("Workflow control observation requires a resident readControl adapter");
+			return U(t, await e.readControl(t), "read");
+		},
+		signal: async (t, n, r) => {
+			if (!e.signal) throw Error("Workflow signals are not configured in this runtime");
+			return e.signal(t, n, r);
+		},
+		update: async (t, n, r, i) => {
+			if (!e.update) throw Error("Workflow updates are not configured in this runtime");
+			return e.update(t, n, r, i);
+		},
+		listRuns: (async (t) => {
+			if (!e.listRuns) throw Error("Workflow run listing is not configured in this runtime");
+			return e.listRuns(t);
+		}),
+		readRetry: async (t, n) => {
+			if (!e.readRetry) throw Error("Workflow retry observation is not configured in this runtime");
+			l.decodeUnknownSync(b)({
+				runId: t,
+				requestId: n
+			});
+			let r = l.decodeUnknownSync(y)(await e.readRetry(t, n));
+			if (r.originalRunId !== t || r.requestId !== n) throw Error("Workflow retry observation belongs to another intent");
+			return r;
+		},
+		retry: async (t, n) => {
+			if (!e.retry) throw Error("Workflow retry is not configured in this runtime");
+			let r = l.decodeUnknownSync(v)({
+				...n,
+				runId: t
+			}), i = l.decodeUnknownSync(y)(await e.retry(t, r));
+			if (i.originalRunId !== t || i.requestId !== r.requestId) throw Error("Workflow retry observation belongs to another intent");
+			return i;
+		},
+		restart: async (t, n) => {
+			if (!e.restart) throw Error("Workflow restart is not configured in this runtime");
+			let r = l.decodeUnknownSync(m)({
+				...n,
+				runId: t
+			}), i = l.decodeUnknownSync(g)(await e.restart(r));
+			return K(r, i), i;
+		},
+		readRestart: async (t, n) => {
+			if (!e.readRestart) throw Error("Workflow restart observation is not configured in this runtime");
+			let r = l.decodeUnknownSync(_)({
+				runId: t,
+				requestId: n
+			}), i = l.decodeUnknownSync(h)(await e.readRestart(r));
+			return K(r, i), i;
+		},
+		withdrawRestart: async (t, n) => {
+			if (!e.withdrawRestart) throw Error("Workflow restart withdrawal is not configured in this runtime");
+			let r = l.decodeUnknownSync(m)({
+				...n,
+				runId: t
+			}), i = l.decodeUnknownSync(h)(await e.withdrawRestart(r));
+			if (K(r, i), i.kind === "not-found") throw Error("Workflow withdrawal has no durable outcome");
+			return i;
+		}
+	};
+}, K = (e, t) => {
+	if (t.runId !== e.runId || t.requestId !== e.requestId) throw Error("Workflow restart receipt belongs to another intent");
+	if (e.selection !== void 0 && "selection" in t && (t.selection.kind !== e.selection.kind || t.selection.kind === "from-step" && e.selection.kind === "from-step" && t.selection.stepName !== e.selection.stepName)) throw Error("Workflow restart receipt changed the saved selection");
+}, q = (e, t) => ({
+	...e,
+	startsDeferredUntilCommit: !0,
+	start: async (n, r, i) => {
+		if (i?.wait) throw Error("ctx.workflows.start(..., { wait: true }) is not allowed inside a mutation transaction; start the workflow and wait after commit.");
+		return e.start(n, r, {
+			...i,
+			enqueueStart: t
+		});
+	},
+	child: async (n, r, i) => {
+		if (i?.wait) throw Error("ctx.workflows.child(..., { wait: true }) is not allowed inside a mutation transaction; start the child workflow and wait after commit.");
+		return e.child(n, r, {
+			...i,
+			enqueueStart: t
+		});
+	},
+	run: async () => {
+		throw Error("ctx.workflows.run(...) is not allowed inside a mutation transaction; use ctx.workflows.start(...) so the workflow starts after commit.");
+	},
+	wait: async () => {
+		throw Error("ctx.workflows.wait(...) is not allowed inside a mutation transaction; wait after commit.");
+	},
+	restart: async () => {
+		throw Error("Restart workflows after the mutation transaction commits");
+	},
+	readRestart: async () => {
+		throw Error("Observe workflow restart after the mutation transaction commits");
+	},
+	withdrawRestart: async () => {
+		throw Error("Withdraw workflow restart after the mutation transaction commits");
+	},
+	cancelQueued: async () => {
+		throw Error("Cancel queued workflows after the mutation transaction commits");
+	},
+	readQueuedCancellation: async () => {
+		throw Error("Observe queued cancellation after the mutation transaction commits");
+	},
+	readStart: async () => {
+		throw Error("Observe a start after the mutation transaction commits; its receipt is provisional until then");
+	}
+}), J = (e, t) => ({
+	...e,
+	cancelQueued: (n, r) => e.cancelQueued(n, {
+		...r,
+		callerContext: t
+	}),
+	readQueuedCancellation: (n, r) => e.readQueuedCancellation(n, {
+		...r,
+		callerContext: t
+	}),
+	readStart: (n, r) => e.readStart(n, {
+		...r,
+		callerContext: t
+	}),
+	start: (n, r, i) => e.start(n, r, {
+		...i,
+		callerContext: t
+	}),
+	child: (n, r, i) => e.child(n, r, {
+		...i,
+		callerContext: t
+	}),
+	run: (n, r, i) => e.run(n, r, {
+		...i,
+		callerContext: t
+	}),
+	wait: ((n, r, i) => typeof n == "string" ? e.wait(n, r, {
+		...i,
+		callerContext: t
+	}) : e.wait(n, {
+		...r,
+		callerContext: t
+	}))
+}), Y = (e) => {
+	let t = () => {
+		let t = e();
+		if (!t) throw Error("Workflow runtime is not ready yet");
+		return t;
+	};
+	return {
+		start: (e, n, r) => t().start(e, n, r),
+		child: (e, n, r) => t().child(e, n, r),
+		run: (e, n, r) => t().run(e, n, r),
+		executionId: (e, n) => t().executionId(e, n),
+		poll: (e, n) => t().poll(e, n),
+		query: (e, n) => t().query(e, n),
+		wait: ((e, n, r) => typeof e == "string" ? t().wait(e, n, r) : t().wait(e, n)),
+		cancel: (e, n, r) => t().cancel(e, n, r),
+		resume: (e, n, r) => t().resume(e, n, r),
+		readControl: (e) => t().readControl(e),
+		cancelQueued: (e, n) => t().cancelQueued(e, n),
+		readQueuedCancellation: (e, n) => t().readQueuedCancellation(e, n),
+		readStart: (e, n) => t().readStart(e, n),
+		signal: (e, n, r) => t().signal(e, n, r),
+		update: (e, n, r, i) => t().update(e, n, r, i),
+		listRuns: ((e) => t().listRuns(e)),
+		readRetry: (e, n) => t().readRetry(e, n),
+		retry: (e, n) => t().retry(e, n),
+		restart: (e, n) => t().restart(e, n),
+		readRestart: (e, n) => t().readRestart(e, n),
+		withdrawRestart: (e, n) => t().withdrawRestart(e, n)
+	};
+}, X = (e, t) => {
+	let n = {};
+	for (let r of e) n[r.definition.name] = (e) => (t ? a.promise(() => t.start(r.definition.name, e)) : r.definition.execute(e, { discard: !0 }).pipe(a.map((e) => M(r.definition.name, e, "running")))).pipe(a.withSpan(`workflow.${r.definition.name}`, { attributes: { "framework.kind": "workflow" } }));
+	return n;
+}, Z = (o, c, l) => o.map((o) => o.definition.toLayer(((u, f) => {
+	let p, m = a.suspend(() => {
+		let e = c.resolveStartContext?.(o.definition.name, f);
+		return e === void 0 ? a.succeed(void 0) : a.promise(() => Promise.resolve(e));
+	}), h = (e) => c.reportExecutionRefusal?.({
+		workflowName: o.definition.name,
+		executionId: f,
+		reason: e
+	});
+	return m.pipe(a.flatMap((e) => {
+		p = e;
+		let t = e?.subject;
+		return c.resolveStartContext !== void 0 && t == null ? a.die(/* @__PURE__ */ Error("workflow start context is missing its caller identity; execution refused")) : typeof t == "object" && t && "type" in t && t.type === "system" ? n.type === "system" ? a.succeed({
+			callerContext: e,
+			subject: {
+				...t,
+				scopes: n.scopes
+			}
+		}) : a.die(/* @__PURE__ */ Error("workflow system authority is invalid; execution refused")) : t == null || c.resolveAuthority === void 0 ? a.succeed({
+			callerContext: e,
+			subject: t ?? n
+		}) : a.tryPromise({
+			try: () => c.resolveAuthority(t),
+			catch: (e) => e
+		}).pipe(a.map((t) => ({
+			callerContext: e,
+			subject: t
+		})));
+	}), a.flatMap(({ callerContext: n, subject: r }) => t(e(), r).pipe(a.map((e) => ({
+		callerContext: n,
+		subject: r,
+		rowFilter: e
+	})))), a.catchCause((e) => a.sync(() => h(i.pretty(e))).pipe(a.andThen(a.suspend(() => p?.subject == null || c.onExecutionRefusal === void 0 ? a.failCause(e) : c.onExecutionRefusal({
+		workflowName: o.definition.name,
+		executionId: f,
+		payload: u,
+		cause: e,
+		callerContext: p
+	}).pipe(a.andThen(a.failCause(e))))))), a.flatMap(({ callerContext: e, subject: t, rowFilter: n }) => {
+		let i = {
+			...e,
+			subject: t,
+			traceId: e?.traceId ?? "workflow-bootstrap",
+			rowFilter: n
+		}, p = (t, n, s) => a.suspend(() => {
+			let l = c.buildContext(i, {
+				workflowName: o.definition.name,
+				executionId: n,
+				...s === void 0 ? {} : { generation: s },
+				parentExecutionId: e?.parentExecutionId ?? null,
+				parentGeneration: e?.parentGeneration ?? null,
+				parentClosePolicy: e?.parentClosePolicy ?? null
+			}), u = o.buildExecute(l)(t, n), d = l?.store;
+			return d === void 0 ? u : a.provide(u, r(d));
+		}), m = (l?.(o, p, i) ?? p)(u, f), h = s.succeed(d, i.subject);
+		return a.provide(m, h);
+	}));
+})));
+//#endregion
+export { V as WorkflowPayloadError, P as WorkflowRateLimitedError, F as WorkflowSingletonHeldError, E as WorkflowStartNotExecuted, Y as makeLazyWorkflowFacade, q as makeTransactionalWorkflowFacade, G as makeWorkflowFacade, J as makeWorkflowFacadeWithCallerContext, X as makeWorkflowHandlers, Z as makeWorkflowLayers, L as makeWorkflowRunHandle, U as payloadPropertyNames };