@voltro/workflow 0.85.0 → 0.86.0

package/dist/parentClosure.js

@@ -0,0 +1,141 @@
+import { acceptWorkflowControlInTransaction as e, hasUnsettledParentClosureControls as t, readWorkflowControlInTransaction as n } from "./controlRequest.js";
+import { cancelSuspendedWorkflowRunInTransaction as r } from "./runGeneration.js";
+import { Schema as i } from "effect";
+import { and as a, derivedRowId as o, eq as s, gt as c } from "@voltro/database";
+//#region src/parentClosure.ts
+var l = "_voltro_workflow_parent_closures", u = i.NonEmptyString, d = i.Struct({
+	id: u,
+	runId: u,
+	workflowName: u,
+	executionId: u,
+	generation: u,
+	parentStatus: i.Literals([
+		"succeeded",
+		"failed",
+		"cancelled"
+	]),
+	closedAt: i.Date,
+	afterChildId: i.NullOr(u),
+	scanHasOpenChildren: i.Boolean,
+	completedAt: i.NullOr(i.Date)
+}), f = i.Struct({
+	id: u,
+	tag: u,
+	executionId: u,
+	status: i.Literals([
+		"running",
+		"suspended",
+		"succeeded",
+		"failed",
+		"cancelled"
+	]),
+	runnerGeneration: i.optional(i.NullOr(u)),
+	parentGeneration: i.optional(i.NullOr(u)),
+	parentClosePolicy: i.NullOr(i.Literals([
+		"cancel",
+		"terminate",
+		"abandon"
+	]))
+}), p = async (t, r, c) => {
+	if (r.parentClosePolicy !== "cancel" && r.parentClosePolicy !== "terminate") return !1;
+	if (typeof r.parentExecutionId != "string" || r.parentExecutionId.length === 0 || typeof r.parentGeneration != "string" || r.parentGeneration.length === 0) throw Error("Child entry requires its original parent execution and generation");
+	let u = c ?? (await t.query({
+		table: l,
+		predicate: a(s("executionId", r.parentExecutionId), s("generation", r.parentGeneration)),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	}))[0];
+	if (u === void 0) return !1;
+	let p = i.decodeUnknownSync(d)(u);
+	if (p.executionId !== r.parentExecutionId || p.generation !== r.parentGeneration) return !1;
+	let m = i.decodeUnknownSync(f)(r), h = o("wfctl", JSON.stringify([
+		"parent-close",
+		p.id,
+		m.id
+	])), g = await n(t, h);
+	if (g !== void 0) {
+		if (g.runId !== m.id || g.workflowName !== m.tag || g.executionId !== m.executionId || g.operation === "resume" || g.cause?.reason !== "parent-close" || g.cause.detail?.closureId !== p.id) throw Error("Parent closure receipt belongs to another child");
+	} else {
+		if (m.status !== "running" && m.status !== "suspended") return !1;
+		if (m.runnerGeneration === void 0 || m.runnerGeneration === null) throw Error("Child entry requires its own generation");
+		await e(t, {
+			id: h,
+			runId: m.id,
+			workflowName: m.tag,
+			executionId: m.executionId,
+			generation: m.runnerGeneration,
+			operation: r.parentClosePolicy,
+			requestedAt: p.closedAt.getTime(),
+			cause: {
+				reason: "parent-close",
+				detail: {
+					closureId: p.id,
+					parentRunId: p.runId,
+					parentExecutionId: p.executionId,
+					parentGeneration: p.generation,
+					parentStatus: p.parentStatus,
+					parentClosePolicy: r.parentClosePolicy
+				}
+			}
+		});
+	}
+	return !0;
+}, m = async (e, n, o = Date.now()) => {
+	let [u] = await e.query({
+		table: l,
+		predicate: s("id", n),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (u === void 0) throw Error("Parent closure is missing");
+	let m = i.decodeUnknownSync(d)(u);
+	if (m.completedAt !== null) return {
+		scanned: 0,
+		controls: 0,
+		wrapped: !1
+	};
+	if (!Number.isFinite(o)) throw Error("Parent closure requires a finite completion timestamp");
+	let h = await e.query({
+		table: "_voltro_workflow_runs",
+		predicate: a(s("parentExecutionId", m.executionId), ...m.afterChildId === null ? [] : [c("id", m.afterChildId)]),
+		lock: "update",
+		order: [{
+			column: "id",
+			direction: "asc"
+		}],
+		take: 100,
+		skip: void 0,
+		projection: void 0
+	}), g = 0, _ = m.scanHasOpenChildren, v = null;
+	for (let t of h) {
+		let n = i.decodeUnknownSync(f)(t);
+		if (v = n.id, n.parentClosePolicy !== null && n.parentClosePolicy !== "abandon") {
+			if (n.parentGeneration === void 0 || n.parentGeneration === null) throw Error("Parent closure cannot attribute a child without its parent generation");
+			n.parentGeneration === m.generation && ((n.status === "running" || n.status === "suspended") && (_ = !0), await p(e, t, m) && (g++, n.status === "suspended" && typeof n.runnerGeneration == "string" && await r(e, {
+				runId: n.id,
+				workflowName: n.tag,
+				executionId: n.executionId,
+				generation: n.runnerGeneration
+			}, o)));
+		}
+	}
+	let y = h.length < 100, b = y && !_ && !await t(e, m.id);
+	if (await e.update(l, m.id, {
+		afterChildId: y ? null : v,
+		scanHasOpenChildren: !y && _,
+		completedAt: b ? new Date(o) : null
+	}) === null) throw Error("Parent closure disappeared before saving its cursor");
+	return {
+		scanned: h.length,
+		controls: g,
+		wrapped: y
+	};
+};
+//#endregion
+export { p as stageParentClosureAtChildEntry, m as stageWorkflowParentClosureInTransaction };

package/dist/parentClosureRecovery.js

@@ -0,0 +1,54 @@
+import { stageWorkflowParentClosureInTransaction as e } from "./parentClosure.js";
+import { and as t, eq as n, gt as r, isNull as i } from "@voltro/database";
+//#region src/parentClosureRecovery.ts
+var a = "_voltro_workflow_parent_closures", o = /* @__PURE__ */ new WeakMap(), s = async (s, c, l) => {
+	let u = o.get(s), d = await s.store.query({
+		table: a,
+		predicate: t(i("completedAt"), ...u === void 0 ? [] : [r("id", u.afterId)]),
+		order: [{
+			column: "id",
+			direction: "asc"
+		}],
+		take: l,
+		skip: void 0,
+		projection: void 0
+	}), f = 0, p = u?.nextDueAt, m = () => {
+		p = Math.min(p ?? c + 1e3, c + 1e3);
+	};
+	for (let t of d) try {
+		if (typeof t.id != "string" || t.id.length === 0) throw Error("Parent closure has no identity");
+		let r = t.id;
+		await s.transaction(async (t) => {
+			await e(t, r, c);
+			let [i] = await t.query({
+				table: a,
+				predicate: n("id", r),
+				order: [],
+				take: 1,
+				skip: void 0,
+				projection: ["completedAt"]
+			});
+			if (i === void 0) throw Error("Parent closure disappeared");
+			return i.completedAt instanceof Date && Number.isFinite(i.completedAt.getTime());
+		}) || m();
+	} catch {
+		f++, m(), s.log?.warn?.("workflow parent closure could not be reconciled", { closureId: typeof t.id == "string" ? t.id : null });
+	}
+	let h = d.at(-1);
+	return d.length === l && typeof h?.id == "string" ? (o.set(s, {
+		afterId: h.id,
+		nextDueAt: p
+	}), {
+		scanned: d.length,
+		failed: f,
+		nextDueAt: c,
+		examined: !0
+	}) : (o.delete(s), {
+		scanned: d.length,
+		failed: f,
+		nextDueAt: p,
+		examined: d.length > 0
+	});
+};
+//#endregion
+export { s as recoverWorkflowParentClosures };

package/dist/pendingSubmission.js

@@ -0,0 +1,85 @@
+import { withAdmissionTransaction as e } from "./admissionTransaction.js";
+import { persistReservedSubmission as t, readAdmissionSubmission as n, reserveAdmissionSubmissionInTransaction as r } from "./admissionSubmission.js";
+import { bindWorkflowStartReceipts as i } from "./startReceipt.js";
+import { PENDING_TABLE as a, toPendingIntent as o } from "./admissionStore.js";
+import { eq as s } from "@voltro/database";
+//#region src/pendingSubmission.ts
+var c = async (e, r) => {
+	if (new Set(r.intentIds).size !== r.intentIds.length) throw Error("Admitted transfer requires distinct pending identities");
+	let c = await n(e, r.id);
+	if (c !== void 0) {
+		if (c.workflowName !== r.workflowName || c.tenantId !== r.tenantId || c.ledgerId !== r.ledgerId || !c.receiptsBound) throw Error("Admitted transfer contradicts its existing submission");
+		return c;
+	}
+	for (let t of r.intentIds) {
+		let n = await e.query({
+			table: a,
+			predicate: s("id", t),
+			order: [],
+			take: 1,
+			skip: void 0,
+			projection: void 0,
+			lock: "update"
+		});
+		if (n[0] === void 0) throw Error("Admitted transfer lost a selected input");
+		let i = o(n[0]);
+		if (i.workflowName !== r.workflowName || i.tenantId !== r.tenantId || i.deadLetteredAt !== void 0) throw Error("Admitted transfer selected a foreign or dead-lettered input");
+	}
+	let l = await t(e, r);
+	await i(e, l.id);
+	for (let t of l.intentIds) if (!await e.delete("_voltro_workflow_pending", t)) throw Error("Admitted input disappeared during submission transfer");
+	return {
+		...l,
+		receiptsBound: !0
+	};
+}, l = async (t, n) => e(t, (e) => u(e, n)), u = async (e, t) => {
+	if (t.id.length === 0 || t.intentIds.length === 0 || new Set(t.intentIds).size !== t.intentIds.length) throw Error("Queue transfer requires a submission identity and distinct pending identities");
+	let c = await n(e, t.id);
+	if (c !== void 0) {
+		if (c.workflowName !== t.workflowName || c.tenantId !== t.tenantId) throw Error("Admission submission identity belongs to a different workflow or tenant");
+		if (!c.receiptsBound) throw Error("Submission exists without completed queue transfer");
+		return {
+			kind: "reserved",
+			submission: c,
+			reused: !0
+		};
+	}
+	let l = [];
+	for (let n of t.intentIds) {
+		let r = await e.query({
+			table: a,
+			predicate: s("id", n),
+			order: [],
+			take: 1,
+			skip: void 0,
+			projection: void 0,
+			lock: "update"
+		});
+		if (r[0] === void 0) return { kind: "selection-unavailable" };
+		let i = o(r[0]);
+		if (i.workflowName !== t.workflowName || i.tenantId !== t.tenantId) throw Error("Selected pending start belongs to a different workflow or tenant");
+		if (i.deadLetteredAt !== void 0 || i.dueAt > t.now) return { kind: "selection-unavailable" };
+		l.push(i);
+	}
+	let u = t.prepare(l);
+	if (u.control.workflowName !== t.workflowName) throw Error("Prepared submission belongs to a different workflow");
+	let d = await r(e, {
+		...u,
+		id: t.id,
+		tenantId: t.tenantId,
+		intentIds: t.intentIds,
+		now: t.now
+	});
+	if (d.kind !== "reserved") return d;
+	await i(e, t.id);
+	for (let t of l) if (!await e.delete("_voltro_workflow_pending", t.id)) throw Error("Pending start disappeared during queue transfer");
+	return {
+		...d,
+		submission: {
+			...d.submission,
+			receiptsBound: !0
+		}
+	};
+};
+//#endregion
+export { c as takeAdmittedSubmissionInTransaction, l as takePendingAdmissionSubmission, u as takePendingAdmissionSubmissionInTransaction };

package/dist/prepareSubmissionDispatch.js

@@ -0,0 +1,17 @@
+import { prepareAdmissionSubmissionExecutionInTransaction as e, readAdmissionSubmission as t } from "./admissionSubmission.js";
+//#region src/prepareSubmissionDispatch.ts
+var n = async (n, r, i) => {
+	let a = await n.transaction((e) => t(e, r.id));
+	if (a === void 0 || a.workflowName !== r.workflowName || a.tenantId !== r.tenantId || a.ledgerId !== r.ledgerId) throw Error("Submission dispatch lost its resident owner");
+	if (!a.receiptsBound || a.failureId !== null) throw Error("Cannot dispatch an incomplete or rejected submission");
+	if (a.preparedExecutionId !== null) {
+		if (a.executionId !== null && a.executionId !== a.preparedExecutionId) throw Error("Submission acceptance contradicts its prepared identity");
+		return a.preparedExecutionId;
+	}
+	if (a.dispatchAttempts !== 0 || a.executionId !== null) throw Error("Submission has an unbound prior dispatch; reconciliation required");
+	let o = await n.resolveExecutionId(r.workflowName, i), s = await n.transaction((t) => e(t, r.id, o));
+	if (s.preparedExecutionId === null) throw Error("Submission preparation returned no execution identity");
+	return s.preparedExecutionId;
+};
+//#endregion
+export { n as prepareSubmissionDispatch };

package/dist/preparedExecution.js

@@ -0,0 +1,14 @@
+import { Effect as e } from "effect";
+//#region src/preparedExecution.ts
+var t = Symbol.for("@voltro/workflow/PreparedExecution"), n = (e, n) => {
+	Object.defineProperty(e, t, {
+		value: n,
+		enumerable: !0
+	});
+}, r = (e) => (typeof e == "object" || typeof e == "function") && e !== null && typeof e[t] == "function", i = (n, r, i, a) => e.suspend(() => {
+	if (i.length === 0) return e.die(/* @__PURE__ */ Error("Prepared workflow execution requires a non-empty identity"));
+	let o = n[t];
+	return typeof o == "function" ? o(r, i, a?.discard ?? !0) : e.die(/* @__PURE__ */ Error("Workflow definition has no prepared-execution capability"));
+});
+//#endregion
+export { n as attachPreparedWorkflowExecution, i as executePreparedWorkflow, r as hasPreparedWorkflowExecution };

package/dist/primitives.js

@@ -1,2 +1,225 @@
-import { A as e, C as t, D as n, E as r, G as i, J as a, K as o, O as s, S as c, T as l, U as u, W as d, _ as f, a as p, b as m, c as h, d as g, f as _, g as v, h as y, i as b, j as x, k as S, l as C, m as w, n as T, o as E, p as D, q as O, r as k, s as A, t as j, u as M, v as N, w as P, x as F, y as I } from "./primitives-DX04WTWh.js";
-export { P as CurrentWorkflowReplayShape, s as DEFAULT_WORKFLOW_SCHEDULE_MAX_RUNTIME_MS, u as DEFERRING_CONTROLS, j as WorkflowFlowControlProperty, T as WorkflowMessagesProperty, S as WorkflowScheduleProperty, k as WorkflowVersionTypeId, b as WorkflowWorkerLayerTypeId, d as assertConsistentPools, i as deferringControlsOf, p as durableClock, E as durableQueue, A as durableQueueModule, h as getWorkflowFlowControl, e as getWorkflowSchedule, C as getWorkflowVersionMetadata, o as hasCancelOn, O as hasFlowControl, M as isCarrier, g as isWorkflowWorkerLayer, l as makeReplayShapeTracker, r as nondeterminismEventPayload, _ as patch, D as processQueue, w as queueWorker, y as rateLimit, n as reportNondeterminism, v as sleep, f as sleepUntil, N as step, I as stepIdempotencyKey, m as stepModule, a as validateFlowControl, x as validateWorkflowSchedule, F as withCompensation, c as workflow, t as workflowModule };
+import { failureMessage as e } from "./failureMessage.js";
+import { attachPreparedWorkflowExecution as t } from "./preparedExecution.js";
+import { CurrentWorkflowEncrypted as n, isQueueEncrypted as r, markQueueEncrypted as i, markWorkflowEncrypted as a, openDefect as o, sealDefect as s, sealedPayloadFields as c, sealedSchema as l } from "./journalEncryption.js";
+import { DEFERRING_CONTROLS as u, assertConsistentPools as d, deferringControlsOf as f, hasCancelOn as p, hasFlowControl as m, validateFlowControl as h } from "./flowControl.js";
+import { CurrentWorkflowPatches as g, CurrentWorkflowRunId as _, CurrentWorkflowStep as v, CurrentWorkflowWakeTenant as ee, WorkflowRunRecorder as y, WorkflowStepInterceptorTag as b } from "./recorder.js";
+import { DEFAULT_WORKFLOW_SCHEDULE_MAX_RUNTIME_MS as x, WorkflowScheduleProperty as S, getWorkflowSchedule as C, validateWorkflowSchedule as w } from "./scheduleDeclaration.js";
+import { CurrentWorkflowReplayShape as T, makeReplayShapeTracker as E, nondeterminismEventPayload as D, reportNondeterminism as O } from "./nondeterminism.js";
+import { applyRetryPolicy as k } from "./retryPolicy.js";
+import { Activity as A, Activity as j, DurableClock as M, DurableClock as N, DurableQueue as P, DurableQueue as te, Workflow as F, Workflow as ne, WorkflowEngine as I } from "effect/workflow";
+import { RateLimiter as L } from "effect/persistence";
+import { Cause as R, Duration as z, Effect as B, Effectable as V, Schema as H } from "effect";
+import { attachWorkflowAccess as U, resolveWorkflowAccess as W } from "@voltro/protocol";
+//#region src/primitives.ts
+var G = Symbol.for("voltro.workflow.workerLayer"), K = Symbol.for("voltro.workflow.version"), q = "__voltroWorkflowMessages", J = "__voltroWorkflowFlowControl", Y = (e) => typeof e == "object" && !!e && e[G] === !0, X = (e) => (typeof e == "object" || typeof e == "function") && e !== null, re = (e) => X(e) && e[K] !== void 0 ? e[K] : {
+	version: "1",
+	compatibleWith: ["1"],
+	patches: []
+}, Z = (e) => {
+	let t = e, r = `workflow '${e.name}' defect`;
+	return Object.assign(Object.create(Object.getPrototypeOf(e)), e, {
+		toLayer: (e) => t.toLayer((t, i) => B.provideService(e(t, i), n, !0).pipe(B.catchDefect((e) => B.die(s(e, r))))),
+		execute: (...e) => t.execute(...e).pipe(B.catchDefect((e) => B.die(o(e, r)))),
+		annotate: (...e) => Z(t.annotate(...e)),
+		annotateContext: (...e) => Z(t.annotateContext(...e))
+	});
+}, ie = ((e) => {
+	let n = e.encrypted === !0, r = F.make(e.name, n ? {
+		...e,
+		payload: c(e.name, e.payload),
+		...e.success === void 0 ? {} : { success: l(e.success, `workflow '${e.name}' result`) },
+		...e.error === void 0 ? {} : { error: l(e.error, `workflow '${e.name}' failure`) }
+	} : e);
+	n && a(e.name);
+	let i = e.suspendOnFailure === !0 ? r.annotate(F.SuspendOnFailure, !0) : r, o = n ? Z(i) : i;
+	Object.defineProperty(o, "name", {
+		value: e.name,
+		enumerable: !0
+	}), t(o, (t, n, r) => B.gen(function* () {
+		let i = o.payloadSchema.make(t), a = yield* I.WorkflowEngine;
+		return yield* B.annotateCurrentSpan({ executionId: n }), yield* a.execute(o, {
+			executionId: n,
+			payload: i,
+			discard: r,
+			suspendedRetrySchedule: e.suspendedRetrySchedule
+		});
+	}).pipe(B.withSpan(`${e.name}.execute`)));
+	let s = String(e.version ?? "1"), u = {
+		version: s,
+		compatibleWith: (e.compatibleWith ?? [s]).map(String),
+		patches: [...e.patches ?? []]
+	}, d = {
+		signals: { ...e.messages?.signals ?? {} },
+		updates: { ...e.messages?.updates ?? {} }
+	};
+	Object.defineProperty(o, K, {
+		value: u,
+		enumerable: !1
+	}), Object.defineProperty(o, q, {
+		value: d,
+		enumerable: !1
+	}), U(o, W(e.name, e));
+	let f = h({
+		workflowName: e.name,
+		payloadSchema: H.isSchema(e.payload) ? e.payload : H.Struct(e.payload),
+		control: e
+	});
+	f !== void 0 && Object.defineProperty(o, J, {
+		value: f,
+		enumerable: !1
+	});
+	let p = w(e.name, e.schedule);
+	return p !== void 0 && Object.defineProperty(o, S, {
+		value: p,
+		enumerable: !1
+	}), o;
+}), ae = (e) => {
+	if (!X(e)) return;
+	let t = e[J];
+	return t === void 0 ? void 0 : t;
+}, oe = (e) => {
+	if (e.encrypted !== !0) return P.make(e);
+	i(e.name);
+	let t = H.isSchema(e.payload) ? e.payload : H.Struct(e.payload);
+	return P.make({
+		...e,
+		payload: l(t, `queue '${e.name}' payload`),
+		success: l(e.success ?? H.Void, `queue '${e.name}' result`),
+		error: l(e.error ?? H.Never, `queue '${e.name}' failure`)
+	});
+}, se = ((e, ...t) => B.flatMap(n, (n) => n && !r(e.name) ? B.die(/* @__PURE__ */ Error(`an encrypted workflow enqueued into durable queue '${e.name}', which is not encrypted: the queue's journal would hold the value in plaintext. Declare \`durableQueue({ …, encrypted: true })\`.`)) : P.process(e, ...t))), Q = ((...e) => {
+	let t = P.worker(...e);
+	return Object.defineProperty(t, G, {
+		value: !0,
+		enumerable: !1
+	}), t;
+}), ce = (e) => B.gen(function* () {
+	let t = yield* A.make({
+		name: `${e.name}/rateLimit`,
+		success: H.Number,
+		error: L.RateLimiterError,
+		execute: B.gen(function* () {
+			let t = yield* (yield* L.RateLimiter).consume({
+				...e,
+				onExceeded: "delay"
+			});
+			return z.toMillis(t.delay);
+		})
+	});
+	t > 0 && (yield* M.sleep({
+		name: `${e.name}/rateLimit`,
+		duration: z.millis(t)
+	}));
+}), $ = (e) => B.gen(function* () {
+	let t = yield* _, n = yield* B.serviceOption(y), r = z.toMillis(z.fromInputUnsafe(e.duration));
+	if (t !== void 0 && n._tag === "Some") {
+		let i = n.value, a = new Date(Date.now() + r).toISOString(), o = yield* ee;
+		yield* B.promise(() => i.recordEvent({
+			runId: t,
+			eventType: "timer-set",
+			payload: {
+				name: e.name,
+				durationMs: r,
+				scheduledWakeAt: a,
+				...o === void 0 ? {} : { tenantId: o }
+			}
+		}).catch(() => {}));
+		let s = Date.now();
+		yield* M.sleep(e), yield* B.promise(() => i.recordEvent({
+			runId: t,
+			eventType: "timer-fired",
+			payload: {
+				name: e.name,
+				actualDurationMs: Date.now() - s,
+				...o === void 0 ? {} : { tenantId: o }
+			}
+		}).catch(() => {}));
+	} else yield* M.sleep(e);
+}), le = (e) => B.gen(function* () {
+	let t = (yield* A.make({
+		name: `sleepUntil:${e.name}`,
+		success: H.Number,
+		execute: B.sync(() => e.until instanceof Date ? e.until.getTime() : e.until)
+	})) - Date.now();
+	t <= 0 || (yield* $({
+		name: e.name,
+		duration: `${t} millis`
+	}));
+}), ue = (t, r, i, a) => B.gen(function* () {
+	let o = yield* _, s = yield* A.CurrentAttempt, c = yield* B.serviceOption(y), l = yield* B.serviceOption(b), u = l._tag === "Some" ? l.value.interceptor(r, {
+		runId: o ?? "unrecorded",
+		stepName: t,
+		attempt: s
+	}) : r, d, f, p = !1;
+	if (o !== void 0 && c._tag === "Some") {
+		f = c.value;
+		let e = a === void 0 ? void 0 : (({ retryable: e, ...t }) => t)(a);
+		p = yield* n;
+		try {
+			d = yield* B.promise(() => f.startStep({
+				runId: o,
+				stepName: t,
+				attempt: s,
+				stepInput: i,
+				sealed: p,
+				...e === void 0 ? {} : { retryPolicy: e }
+			}));
+		} catch {
+			d = void 0;
+		}
+	}
+	let m = Date.now();
+	return yield* B.provideService(k(u, a), v, t).pipe(B.tap((e) => d && f ? B.promise(async () => {
+		try {
+			await f.endStepSuccess({
+				stepRecordId: d,
+				sealed: p,
+				output: e,
+				durationMs: Date.now() - m
+			});
+		} catch {}
+	}) : B.void), B.tapCause((t) => d && f && !R.hasInterruptsOnly(t) ? B.promise(async () => {
+		try {
+			let n = R.findErrorOption(t), r = t.reasons.filter(R.isFailReason).map((e) => e.error), i = t.reasons.filter(R.isDieReason).map((e) => e.defect), a = n._tag === "Some" ? n.value : i[0] ?? R.squash(t), o = e(a), s = a && typeof a == "object" && "_tag" in a ? String(a._tag) : null;
+			await f.endStepFailure({
+				stepRecordId: d,
+				sealed: p,
+				errorTag: s,
+				errorMessage: o,
+				errorCause: {
+					pretty: R.pretty(t),
+					failures: r,
+					defects: i
+				},
+				durationMs: Date.now() - m
+			});
+		} catch {}
+	}) : B.void));
+}), de = (e) => B.gen(function* () {
+	let t = yield* T;
+	if (t === void 0) return;
+	let n = t.reach(e);
+	n !== void 0 && (yield* O([n]));
+}), fe = (e, t, r) => {
+	let i = e;
+	return {
+		...e,
+		...V.Prototype({
+			label: "Activity",
+			evaluate: () => B.andThen(de(t), r === void 0 ? i : B.flatMap(n, (e) => e ? r().pipe(B.catchDefect((e) => B.die(o(e, `step '${t}' defect`)))) : i))
+		})
+	};
+}, pe = (e) => {
+	let { input: t, retry: n, ...r } = e, i = ue(r.name, r.execute, t, n), a = A.make({
+		...r,
+		execute: i
+	}), o, c = `step '${r.name}' defect`;
+	return fe(a, r.name, () => o ??= A.make({
+		...r,
+		success: l(r.success ?? H.Void, `step '${r.name}' result`),
+		error: l(r.error ?? H.Never, `step '${r.name}' failure`),
+		execute: i.pipe(B.catchDefect((e) => B.die(s(e, c))))
+	}));
+}, me = (e) => B.map(g, (t) => t.includes(e)), he = F.withCompensation, ge = A.idempotencyKey;
+//#endregion
+export { T as CurrentWorkflowReplayShape, x as DEFAULT_WORKFLOW_SCHEDULE_MAX_RUNTIME_MS, u as DEFERRING_CONTROLS, J as WorkflowFlowControlProperty, q as WorkflowMessagesProperty, S as WorkflowScheduleProperty, K as WorkflowVersionTypeId, G as WorkflowWorkerLayerTypeId, d as assertConsistentPools, f as deferringControlsOf, N as durableClock, oe as durableQueue, te as durableQueueModule, ae as getWorkflowFlowControl, C as getWorkflowSchedule, re as getWorkflowVersionMetadata, p as hasCancelOn, m as hasFlowControl, X as isCarrier, Y as isWorkflowWorkerLayer, E as makeReplayShapeTracker, D as nondeterminismEventPayload, me as patch, se as processQueue, Q as queueWorker, ce as rateLimit, O as reportNondeterminism, $ as sleep, le as sleepUntil, pe as step, ge as stepIdempotencyKey, j as stepModule, h as validateFlowControl, w as validateWorkflowSchedule, he as withCompensation, ie as workflow, ne as workflowModule };