@voltro/workflow 0.85.0 → 0.87.0

package/dist/submissionRecovery.js

@@ -0,0 +1,122 @@
+import { loggableCause as e } from "./journalEncryption.js";
+import { readResidentExecutionEvidence as t } from "./residentExecutionEvidence.js";
+import { acknowledgeAdmissionSubmissionInTransaction as n, beginAdmissionSubmissionDispatchInTransaction as r, decodeAdmissionSubmission as i, noteAdmissionSubmissionFailure as a, readPendingAdmissionSubmissionRows as o, rejectAdmissionSubmissionInTransaction as s } from "./admissionSubmission.js";
+import { decodePendingPayload as c, releaseLease as l, retryBackoffMs as u } from "./admissionStore.js";
+import { prepareSubmissionDispatch as d } from "./prepareSubmissionDispatch.js";
+import { Schema as f } from "effect";
+//#region src/submissionRecovery.ts
+var p = /* @__PURE__ */ new WeakMap(), m = async (m, h, g, _) => {
+	let v = p.get(m), y = await o(m.store, g, v?.afterId), b = 0, x = 0, S = 0, C = 0, w = v?.nextDueAt, T = (e) => {
+		w = Math.min(w ?? e, e);
+	};
+	for (let o of y) {
+		let p;
+		try {
+			p = i(o);
+		} catch {
+			b++, S++, T(h + u(1)), m.log?.warn?.("workflow submission metadata is invalid", { submissionId: typeof o.id == "string" ? o.id : null });
+			continue;
+		}
+		b++;
+		let g = p.dispatchAttempts === 0 ? 0 : void 0, v = p.retry.recovery?.attempts ?? 0;
+		try {
+			let e = p.preparedExecutionId, i = e === null || p.dispatchAttempts === 0 ? void 0 : await m.transaction(async (n) => {
+				let r = await t(n, p.workflowName, e);
+				return r === void 0 ? void 0 : {
+					executionId: e,
+					runId: r.runId
+				};
+			});
+			if (i === void 0 && p.retry.stoppedAt !== null) {
+				b--;
+				continue;
+			}
+			if (i === void 0 && p.retry.after > h) {
+				b--, T(p.retry.after);
+				continue;
+			}
+			if (i === void 0 && m.acquireSubmissionCapacity !== void 0 && !await m.acquireSubmissionCapacity(p)) {
+				T(h + 1e3);
+				continue;
+			}
+			let a = i ?? await (async () => {
+				let e = m.controls.get(p.workflowName)?.batch === void 0 ? c(m.store, p.workflowName, p.payload) : { items: f.decodeUnknownSync(f.Struct({ items: f.Array(f.Unknown) }))(p.payload).items.map((e) => c(m.store, p.workflowName, e)) }, t = await d(m, p, e), n = await m.transaction((e) => r(e, p.id, m.now?.() ?? Date.now()));
+				if (n === null) return;
+				v = n.retry.recovery?.attempts ?? 0, g = n.dispatchAttempts === 1 ? 1 : void 0;
+				let i = await m.startAdmitted(p.workflowName, e, p.callerContext, t);
+				if (g = void 0, i.executionId !== t) throw Error("Engine returned a different prepared execution identity");
+				return i;
+			})();
+			if (a === void 0) continue;
+			g = void 0, p.eviction !== null && (await m.cancelRun({
+				workflowName: p.workflowName,
+				...p.eviction,
+				reason: "cancelled to make room for a newer start (singleton mode 'cancel')",
+				detail: {
+					source: "flow-control",
+					mode: "singleton"
+				}
+			}), await l(m.store, p.eviction.executionId, h)), await m.transaction((e) => n(e, p.id, {
+				executionId: a.executionId,
+				runId: a.runId ?? null
+			})), x++;
+		} catch (t) {
+			S++;
+			let n;
+			try {
+				if (g !== void 0 && m.isPermanentStartError?.(t) === !0) {
+					let e = g, n = await m.transaction((n) => s(n, p.id, e, {
+						handler: m.controls.get(p.workflowName)?.onFailure ?? null,
+						errorMessage: String(t),
+						now: h
+					}, v));
+					if (n !== void 0) {
+						C++, m.log?.warn?.("workflow submission rejected; failure report retained", {
+							workflow: p.workflowName,
+							submissionId: p.id,
+							failureId: n.id
+						});
+						continue;
+					}
+				}
+				n = await m.transaction((e) => a(e, p.id, String(t), h, _, v));
+			} catch (n) {
+				T(h), m.log?.warn?.("workflow submission retry state could not be recorded", {
+					workflow: p.workflowName,
+					submissionId: p.id,
+					cause: e(p.workflowName, t),
+					recordingCause: String(n)
+				});
+				continue;
+			}
+			n.retry.stoppedAt === null && T(n.retry.after), m.log?.warn?.("workflow submission remains unacknowledged", {
+				workflow: p.workflowName,
+				submissionId: p.id,
+				cause: e(p.workflowName, t),
+				retryStoppedAt: n.retry.stoppedAt,
+				acceptance: "unknown"
+			});
+		}
+	}
+	let E = y.at(-1);
+	return y.length === g && E !== void 0 && typeof E.id == "string" ? (p.set(m, {
+		afterId: E.id,
+		nextDueAt: w
+	}), {
+		scanned: b,
+		admitted: x,
+		failed: S,
+		rejected: C,
+		nextDueAt: h,
+		examined: !0
+	}) : (p.delete(m), {
+		scanned: b,
+		admitted: x,
+		failed: S,
+		rejected: C,
+		nextDueAt: w,
+		examined: y.length > 0
+	});
+};
+//#endregion
+export { m as recoverAdmissionSubmissions };

package/dist/submissionRejection.js

@@ -0,0 +1,10 @@
+import { readWorkflowFailureRecord as e } from "./failureReportStore.js";
+//#region src/submissionRejection.ts
+var t = async (t, n) => {
+	if (n.failureId === null) throw Error("Workflow submission has no rejection marker");
+	let r = await e(t, n.failureId);
+	if (n.executionId !== null || n.dispatchAttempts > 1 || r === void 0 || r.sourceKind !== "submission" || r.sourceId !== n.id || r.workflowName !== n.workflowName || r.tenantId !== n.tenantId || r.report.executionId !== null || r.report.runId !== null) throw Error("Workflow start rejection has contradictory ownership or execution evidence");
+	return r.id;
+};
+//#endregion
+export { t as readProvenSubmissionRejection };

package/dist/submissionRetry.js

@@ -0,0 +1,71 @@
+import { readAdmissionSubmission as e } from "./admissionSubmission.js";
+import { ADMISSIONS_TABLE as t } from "./admissionStore.js";
+import { eq as n } from "@voltro/database";
+//#region src/submissionRetry.ts
+var r = (e, t) => ({
+	kind: "refused",
+	submissionId: e,
+	reason: t
+}), i = async (i, a) => {
+	let o = await e(i, a);
+	if (o === void 0) return r(a, "missing-submission");
+	if (!o.receiptsBound) return r(a, "incomplete-transfer");
+	if (o.executionId !== null || o.runId !== null) return r(a, "accepted");
+	if (o.failureId !== null) return r(a, "rejected");
+	if (o.dispatchAttempts !== 0) return r(a, "dispatch-attempted");
+	if (o.preparedExecutionId !== null) return r(a, "prepared-execution");
+	let [s] = await i.query({
+		table: t,
+		predicate: n("id", o.ledgerId),
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	return s === void 0 ? r(a, "missing-lease") : s.workflowName !== o.workflowName || s.tenantId !== o.tenantId || s.outcome !== "admitted" ? r(a, "foreign-lease") : s.releasedAt === null ? s.executionId !== null || s.runId !== null ? r(a, "bound-lease") : {
+		kind: "owner",
+		submission: o
+	} : r(a, "released-lease");
+}, a = (e) => e.retry.stoppedAt === null ? void 0 : {
+	attempts: e.retry.attempts,
+	stoppedAt: e.retry.stoppedAt
+}, o = async (e, t) => {
+	let n = await i(e, t);
+	if (n.kind === "refused") return n;
+	let o = a(n.submission);
+	return o === void 0 ? r(t, "not-stopped") : {
+		kind: "eligible",
+		submissionId: t,
+		expected: o
+	};
+}, s = async (t, n, o, s) => {
+	if (!Number.isSafeInteger(o.attempts) || o.attempts < 1 || !Number.isFinite(o.stoppedAt) || !Number.isFinite(s)) throw Error("Submission recovery requires a valid stopped retry token and time");
+	let c = (await e(t, n))?.retry.recovery;
+	if (c?.attempts === o.attempts && c.stoppedAt === o.stoppedAt) return {
+		kind: "already-retried",
+		submissionId: n,
+		expected: o
+	};
+	let l = await i(t, n);
+	if (l.kind === "refused") return l;
+	let u = a(l.submission);
+	if (u === void 0) return r(n, "not-stopped");
+	if (u.attempts !== o.attempts || u.stoppedAt !== o.stoppedAt) return r(n, "changed-retry");
+	let d = {
+		...l.submission.retry,
+		after: s,
+		stoppedAt: null,
+		recovery: {
+			...u,
+			retriedAt: s
+		}
+	};
+	if (await t.update("_voltro_workflow_submissions", n, { retry: d }) === null) throw Error("Admission submission disappeared during stopped retry recovery");
+	return {
+		kind: "retried",
+		submissionId: n,
+		expected: o
+	};
+};
+//#endregion
+export { o as inspectAdmissionSubmissionRetry, s as retryAdmissionSubmissionInTransaction };

package/dist/suspensionUnavailable.js

@@ -0,0 +1,9 @@
+import { Context as e } from "effect";
+//#region src/suspensionUnavailable.ts
+var t = e.Reference("@voltro/workflow/SuspensionUnavailable", { defaultValue: () => void 0 }), n = class extends Error {
+	constructor(e, t) {
+		super(`${e} cannot wait for a durable result here: ${t}`), this.name = "WorkflowCannotPark";
+	}
+};
+//#endregion
+export { t as SuspensionUnavailable, n as WorkflowCannotPark };

package/dist/updates.js

@@ -0,0 +1,87 @@
+import { failureMessage as e } from "./failureMessage.js";
+import { encryptionAwareActivity as t, openEventPayload as n } from "./journalEncryption.js";
+import { CurrentWorkflowRunId as r, WorkflowRunRecorder as i } from "./recorder.js";
+import { terminalUpdates as a } from "./workflowReadSelections.js";
+import { Cause as o, Effect as s, Schema as c } from "effect";
+import { eq as l } from "@voltro/database";
+//#region src/updates.ts
+var u = async (e, t) => {
+	if (e) try {
+		await e.recordEvent(t);
+	} catch {}
+}, d = (t) => {
+	let n = o.findErrorOption(t), r = t.reasons.filter(o.isDieReason).map((e) => e.defect), i = n._tag === "Some" ? n.value : r[0] ?? o.squash(t);
+	return {
+		errorTag: i && typeof i == "object" && "_tag" in i ? String(i._tag) : null,
+		errorMessage: e(i)
+	};
+}, f = (e, o) => {
+	let f = s.gen(function* () {
+		let t = o.pollIntervalMs ?? 200, f = o.maxPollIntervalMs ?? 5e3, p = o.timeoutMs ?? 3e4, m = yield* r, h = yield* s.serviceOption(i), g = h._tag === "Some" ? h.value : void 0;
+		if (m === void 0) return yield* s.die(/* @__PURE__ */ Error("awaitUpdate: no active workflow run id in scope"));
+		let _ = m, v = Date.now(), y = t;
+		for (;;) {
+			let t = Date.now() - v;
+			if (t > p) return yield* s.die(/* @__PURE__ */ Error(`awaitUpdate('${o.name}') timed out after ${t}ms`));
+			let r = {
+				table: "_voltro_workflow_run_events",
+				order: [{
+					column: "occurredAt",
+					direction: "asc"
+				}],
+				predicate: l("runId", _),
+				projection: void 0,
+				skip: void 0,
+				take: 1e3
+			}, i = yield* s.tryPromise({
+				try: () => e.store.query(r),
+				catch: (e) => e
+			}), m = a(i), h = i.find((e) => e.eventType === "update-requested" && e.payload?.updateName === o.name && typeof e.payload.updateId == "string" && !m.has(e.payload.updateId));
+			if (h !== void 0) {
+				let e = h.payload.updateId;
+				yield* s.promise(() => u(g, {
+					runId: _,
+					eventType: "update-received",
+					payload: {
+						updateId: e,
+						updateName: o.name
+					}
+				}));
+				let t = yield* c.decodeUnknownEffect(o.schema)(n(h.payload)?.value).pipe(s.tapCause((t) => s.promise(() => u(g, {
+					runId: _,
+					eventType: "update-failed",
+					payload: {
+						updateId: e,
+						updateName: o.name,
+						...d(t)
+					}
+				})))), r = yield* (o.handle ? o.handle(t) : s.succeed(t)).pipe(s.flatMap((e) => o.success ? c.decodeUnknownEffect(o.success)(e) : s.succeed(e))).pipe(s.tapCause((t) => s.promise(() => u(g, {
+					runId: _,
+					eventType: "update-failed",
+					payload: {
+						updateId: e,
+						updateName: o.name,
+						...d(t)
+					}
+				}))));
+				return yield* s.promise(() => u(g, {
+					runId: _,
+					eventType: "update-completed",
+					payload: {
+						updateId: e,
+						updateName: o.name,
+						result: r
+					}
+				})), r;
+			}
+			yield* s.sleep(`${y} millis`), y = Math.min(y * 2, f);
+		}
+	});
+	return t({
+		name: `await-update:${o.name}`,
+		success: o.success ?? o.schema,
+		execute: f
+	});
+};
+//#endregion
+export { f as awaitUpdate };

package/dist/watermarkTable.js

@@ -0,0 +1,9 @@
+import { id as e, table as t, timestamp as n } from "@voltro/database";
+//#region src/watermarkTable.ts
+var r = t("_voltro_workflow_watermarks", {
+	id: e({ prefix: "wfwm" }),
+	positionAt: n(),
+	updatedAt: n().default("now")
+});
+//#endregion
+export { r as _voltroWorkflowWatermarksTable };

package/dist/webCrypto.js

@@ -0,0 +1,17 @@
+import { Crypto as e, Effect as t, Layer as n, PlatformError as r } from "effect";
+//#region src/webCrypto.ts
+var i = e.make({
+	randomBytes: (e) => globalThis.crypto.getRandomValues(new Uint8Array(e)),
+	digest: (e, n) => t.tryPromise({
+		try: async () => new Uint8Array(await globalThis.crypto.subtle.digest(e, new Uint8Array(n).buffer)),
+		catch: (t) => r.systemError({
+			_tag: "Unknown",
+			module: "Crypto",
+			method: "digest",
+			description: `digest ${e} failed`,
+			cause: t
+		})
+	})
+}), a = n.succeed(e.Crypto, i);
+//#endregion
+export { i as webCrypto, a as webCryptoLayer };

package/dist/workflowDelivery.js

@@ -0,0 +1,24 @@
+import { Context as e, Effect as t } from "effect";
+//#region src/workflowDelivery.ts
+var n = "voltro-workflow-restart", r = class extends e.Service()("voltro/CurrentWorkflowDelivery") {}, i = (e) => ({
+	...e,
+	registerEntity: (n, i, a) => e.registerEntity(n, n.type.startsWith("Workflow/") ? i.pipe(t.map((e) => {
+		let n = e.run;
+		if (typeof n != "function") throw Error("Workflow entity is missing its run handler");
+		return {
+			...e,
+			run: (e) => {
+				let i = {
+					requestId: String(e.requestId),
+					restartToken: e.headers["voltro-workflow-restart"] ?? null
+				};
+				return t.suspend(() => {
+					let r = n(e);
+					return t.isEffect(r) ? r : t.die(/* @__PURE__ */ Error("Workflow run handler must return an Effect"));
+				}).pipe(t.provideService(r, i));
+			}
+		};
+	})) : i, a)
+});
+//#endregion
+export { r as CurrentWorkflowDelivery, n as WORKFLOW_RESTART_HEADER, i as withWorkflowDelivery };

package/dist/workflowExecutorRouting.js

@@ -0,0 +1,33 @@
+import { journalExecutorGroups as e } from "./journalRoutingLayout.js";
+import { WorkflowEngine as t } from "effect/workflow";
+import { Context as n, Effect as r, Layer as i, Option as a } from "effect";
+//#region src/workflowExecutorRouting.ts
+var o = n.Service("@voltro/workflow/WorkflowExecutorRouting"), s = (e, t, r, i, a) => n.add(e, o, Object.freeze({
+	engine: t,
+	mode: r,
+	state: i,
+	groups: a ?? Object.freeze({
+		available: Object.freeze(["default"]),
+		assigned: Object.freeze(r === "client" ? [] : ["default"])
+	})
+})), c = (n, s) => {
+	let c = Object.freeze({
+		workflows: s.workflows,
+		schedules: s.schedules,
+		webhooks: s.webhooks
+	});
+	if (Object.values(c).some((e) => typeof e != "boolean")) throw Error("Explicit executor selection is required");
+	let l = Object.values(c).every(Boolean), u = Object.values(c).some(Boolean), d = r.gen(function* () {
+		let n = yield* r.serviceOption(t.WorkflowEngine);
+		if (a.isNone(n)) return yield* r.die(/* @__PURE__ */ Error("Executor registration requires a workflow engine"));
+		let i = yield* r.serviceOption(o);
+		if (a.isNone(i)) return l ? void 0 : yield* r.die(/* @__PURE__ */ Error("Selected executor roles require an engine routing contract"));
+		let s = i.value;
+		if (s.engine !== n.value || s.mode !== (u ? "worker" : "client")) return yield* r.die(/* @__PURE__ */ Error("Executor roles do not match the provided workflow engine"));
+		let d = yield* r.sync(() => e(s.state?.layout ?? "default", c)), f = (e, t) => e.length === t.length && e.every((e) => t.includes(e));
+		if (!f(s.groups.available, d.available) || !f(s.groups.assigned, d.assigned)) return yield* r.die(/* @__PURE__ */ Error("Executor roles do not match the engine shard ownership"));
+	});
+	return i.effectDiscard(d).pipe(i.provideMerge(n));
+};
+//#endregion
+export { s as recordWorkflowExecutorRouting, c as withWorkflowExecutorSelection };

package/dist/workflowJournal.js

@@ -0,0 +1,124 @@
+import { latestExitReply as e } from "./workflowReadSelections.js";
+import { Context as t, Effect as n, Option as r, Schema as i } from "effect";
+import { ClusterSchema as a, EntityAddress as o, EntityId as s, EntityType as c, MessageStorage as l, Sharding as u } from "effect/cluster";
+//#region src/workflowJournal.ts
+var d = (e, t) => `${e}/${t}`, f = (e, n, r) => {
+	let i = s.make(n), l = t.get(e.annotations, a.ShardGroup)(i);
+	return new o.EntityAddress({
+		entityType: c.EntityType.make(`Workflow/${e._tag}`),
+		entityId: i,
+		shardId: r.getShardId(i, l)
+	});
+}, p = (t, i) => n.gen(function* () {
+	let n = yield* u.Sharding, a = yield* l.MessageStorage, o = yield* a.requestIdForPrimaryKey({
+		address: f(t, i, n),
+		tag: "run",
+		id: ""
+	});
+	if (r.isNone(o)) return { kind: "not-found" };
+	let s = String(o.value), c = yield* a.repliesForUnfiltered([o.value]), d = e(c);
+	return d === void 0 ? {
+		kind: "pending",
+		requestId: s
+	} : {
+		kind: "reply",
+		requestId: s,
+		replyId: String(d.id),
+		exit: d.exit
+	};
+}), m = i.Union([i.Struct({
+	_tag: i.Literal("Success"),
+	value: i.Unknown
+}), i.Struct({
+	_tag: i.Literal("Failure"),
+	cause: i.Array(i.Union([
+		i.Struct({
+			_tag: i.Literal("Fail"),
+			error: i.Unknown
+		}),
+		i.Struct({
+			_tag: i.Literal("Die"),
+			defect: i.Unknown
+		}),
+		i.Struct({
+			_tag: i.Literal("Interrupt"),
+			fiberId: i.optional(i.NullOr(i.Number))
+		})
+	]))
+})]), h = i.decodeUnknownOption(m), g = (e) => {
+	let t = (e) => e && typeof e == "object" && "_tag" in e && typeof e._tag == "string" ? e._tag : void 0, n = h(e);
+	if (r.isNone(n)) return "unrecognized-reply";
+	if (n.value._tag === "Failure") return "failed";
+	let i = n.value.value, a = t(i);
+	if (a === "Suspended") return "suspended";
+	if (a === "Complete") {
+		let e = i.exit, t = h(e);
+		return r.isNone(t) ? "unrecognized-reply" : t.value._tag === "Success" ? "succeeded" : "failed";
+	}
+	return "unrecognized-reply";
+}, _ = (e) => y(e.workflow, e.executionId, e.failedActivities), v = (e) => y(e.workflow, e.executionId, e.resetActivities), y = (t, i, a) => n.gen(function* () {
+	let o = yield* u.Sharding, s = yield* l.MessageStorage, c = f(t, i, o), p = yield* s.requestIdForPrimaryKey({
+		address: c,
+		tag: "run",
+		id: ""
+	}).pipe(n.orDie);
+	if (r.isNone(p)) return {
+		redriven: !1,
+		runReplyCleared: !1,
+		activitiesReset: 0,
+		reason: "no-journal"
+	};
+	let m = yield* s.repliesForUnfiltered([p.value]).pipe(n.orDie), h = e(m);
+	if (h === void 0) return {
+		redriven: !1,
+		runReplyCleared: !1,
+		activitiesReset: 0,
+		reason: "no-reply"
+	};
+	let _ = g(h.exit);
+	if (_ !== "failed") return {
+		redriven: !1,
+		runReplyCleared: !1,
+		activitiesReset: 0,
+		reason: _
+	};
+	let v = /* @__PURE__ */ new Set();
+	for (let e of a) {
+		let t = yield* s.requestIdForPrimaryKey({
+			address: c,
+			tag: "activity",
+			id: d(e.name, e.attempt)
+		}).pipe(n.orDie);
+		if (r.isNone(t)) return {
+			redriven: !1,
+			runReplyCleared: !1,
+			activitiesReset: 0,
+			reason: "activity-not-found"
+		};
+		v.add(t.value);
+	}
+	let y = 0;
+	for (let e of v) {
+		if (!(yield* o.reset(e))) return {
+			redriven: !1,
+			runReplyCleared: !1,
+			activitiesReset: y,
+			reason: "activity-reset-unconfirmed"
+		};
+		y++;
+	}
+	let b = yield* o.reset(p.value);
+	return b ? (yield* o.pollStorage, {
+		redriven: !0,
+		runReplyCleared: b,
+		activitiesReset: y,
+		reason: null
+	}) : {
+		redriven: !1,
+		runReplyCleared: !1,
+		activitiesReset: y,
+		reason: "run-reset-unconfirmed"
+	};
+});
+//#endregion
+export { m as JournalExit, d as activityPrimaryKey, g as classifyRunReply, p as readWorkflowRunReply, _ as redriveFailedRun, v as resumeRunFromStep, f as runEntityAddress };

package/dist/workflowJournalReset.js

@@ -0,0 +1,111 @@
+import { WORKFLOW_RESTART_HEADER as e } from "./workflowDelivery.js";
+import { Effect as t, Schema as n } from "effect";
+import { SqlClient as r } from "effect/sql";
+//#region src/workflowJournalReset.ts
+var i = n.fromJsonString(n.Struct({
+	_tag: n.Literal("Success"),
+	value: n.Struct({ _tag: n.Literal("Suspended") })
+})), a = n.fromJsonString(n.Record(n.String, n.String)), o = (e) => t.gen(function* () {
+	if (!/^[1-9]\d*$/.test(e.requestId) || e.workflowName.length === 0 || e.executionId.length === 0) return yield* t.die(/* @__PURE__ */ Error("Suspension observation requires an exact engine delivery owner"));
+	let [o] = yield* (yield* r.SqlClient).withoutTransforms()`
+      SELECT m.entity_type, m.entity_id, m.tag, m.headers, r.id AS reply_id, r.payload
+      FROM cluster_messages m LEFT JOIN cluster_replies r
+        ON r.id = m.last_reply_id AND r.request_id = m.id AND r.kind = 0
+      WHERE m.id = ${e.requestId} AND m.kind = 0`;
+	if (o === void 0) return;
+	if (o.entity_type !== `Workflow/${e.workflowName}` || o.entity_id !== e.executionId || o.tag !== "run") return yield* t.die(/* @__PURE__ */ Error("Suspension observation belongs to another execution or procedure"));
+	if (((yield* t.sync(() => n.decodeUnknownSync(a)(o.headers)))["voltro-workflow-restart"] ?? null) !== e.restartToken || o.reply_id === null || n.decodeUnknownOption(i)(o.payload)._tag === "None") return;
+	let s = String(o.reply_id);
+	return /^[1-9]\d*$/.test(s) ? {
+		...e,
+		replyId: s
+	} : yield* t.die(/* @__PURE__ */ Error("Suspension reply has an invalid identity"));
+}).pipe(t.provideService(r.SafeIntegers, !0)), s = (a, o) => t.gen(function* () {
+	let { restart: s, suspension: c } = o, l = /* @__PURE__ */ new Map();
+	for (let e of a) {
+		if (!/^[1-9]\d*$/.test(e.requestId) || !/^[1-9]\d*$/.test(e.replyId)) return yield* t.die(/* @__PURE__ */ Error("Journal reset requires positive decimal request and reply identities"));
+		let n = l.get(e.requestId);
+		if (n !== void 0 && n !== e.replyId) return yield* t.die(/* @__PURE__ */ Error("Journal reset contains conflicting observations for one request"));
+		l.set(e.requestId, e.replyId);
+	}
+	if (s !== void 0 && (!l.has(s.requestId) || s.token.length === 0 || s.token === s.previousToken || s.workflowName.length === 0 || s.executionId.length === 0)) return yield* t.die(/* @__PURE__ */ Error("Journal restart requires a selected request, new token and execution owner"));
+	if (l.size === 0) return {
+		kind: "reset",
+		count: 0
+	};
+	let u = [...l].sort(([e], [t]) => e < t ? -1 : +(e > t)), d = (yield* r.SqlClient).withoutTransforms(), f = d("cluster_messages"), p = d("cluster_replies"), m = d.onDialectOrElse({
+		pg: () => d.literal("FALSE"),
+		orElse: () => d.literal("0")
+	});
+	return yield* t.gen(function* () {
+		let r = /* @__PURE__ */ new Map();
+		for (let [e] of u) {
+			let n = yield* d.onDialectOrElse({
+				mssql: () => d`
+            SELECT last_reply_id FROM ${f} WITH (UPDLOCK, HOLDLOCK)
+            WHERE id = ${e} AND kind = 0`,
+				sqlite: () => d`
+            SELECT last_reply_id FROM ${f} WHERE id = ${e} AND kind = 0`,
+				orElse: () => d`
+            SELECT last_reply_id FROM ${f} WHERE id = ${e} AND kind = 0 FOR UPDATE`
+			});
+			if (n.length !== 1) return {
+				kind: "changed",
+				requestId: e
+			};
+			if (r.set(e, String(n[0]?.last_reply_id)), s !== void 0) {
+				let [n] = yield* d`
+            SELECT entity_type, entity_id, tag FROM ${f} WHERE id = ${e}`;
+				if (n?.entity_type !== `Workflow/${s.workflowName}` || n.entity_id !== s.executionId || n.tag !== (e === s.requestId ? "run" : "activity")) return yield* t.die(/* @__PURE__ */ Error("Journal restart selection belongs to another execution or procedure"));
+			}
+		}
+		let a;
+		if (c !== void 0) {
+			let [e] = yield* d`
+          SELECT entity_type, entity_id, tag, headers FROM ${f} WHERE id = ${c.requestId}`;
+			if (e?.entity_type !== `Workflow/${c.workflowName}` || e.entity_id !== c.executionId || e.tag !== "run" || c.workflowName.length === 0 || c.executionId.length === 0) return yield* t.die(/* @__PURE__ */ Error("Journal resume selection belongs to another execution or procedure"));
+			if (((yield* t.sync(() => n.decodeUnknownSync(n.fromJsonString(n.Record(n.String, n.String)))(e.headers)))["voltro-workflow-restart"] ?? null) !== c.restartToken) return {
+				kind: "changed",
+				requestId: c.requestId
+			};
+		}
+		if (s !== void 0) {
+			let [e] = yield* d`
+          SELECT tag, entity_type, headers FROM ${f} WHERE id = ${s.requestId}`;
+			if (e?.tag !== "run" || !e.entity_type.startsWith("Workflow/")) return yield* t.die(/* @__PURE__ */ Error("Journal restart marker can only target a workflow run"));
+			if (a = yield* t.sync(() => n.decodeUnknownSync(n.fromJsonString(n.Record(n.String, n.String)))(e.headers)), a["voltro-workflow-restart"] === s.token) return {
+				kind: "already-reset",
+				count: u.length
+			};
+			if ((a["voltro-workflow-restart"] ?? null) !== s.previousToken) return {
+				kind: "changed",
+				requestId: s.requestId
+			};
+		}
+		for (let [e, t] of u) {
+			if (r.get(e) !== t) return {
+				kind: "changed",
+				requestId: e
+			};
+			let a = yield* d`SELECT payload FROM ${p}
+          WHERE id = ${t} AND request_id = ${e} AND kind = 0`;
+			if (a.length !== 1 || c !== void 0 && n.decodeUnknownOption(i)(a[0]?.payload)._tag === "None") return {
+				kind: "changed",
+				requestId: e
+			};
+		}
+		s !== void 0 && (yield* d`UPDATE ${f} SET headers = ${JSON.stringify({
+			...a,
+			[e]: s.token
+		})}
+          WHERE id = ${s.requestId}`);
+		for (let [e] of u) yield* d`DELETE FROM ${p} WHERE request_id = ${e} AND kind = 0`, yield* d`DELETE FROM ${f} WHERE request_id = ${e} AND kind = 2`, yield* d`UPDATE ${f} SET processed = ${m}, last_reply_id = NULL,
+          last_read = NULL WHERE request_id = ${e}`;
+		return {
+			kind: "reset",
+			count: u.length
+		};
+	}).pipe(d.withTransaction, t.provideService(r.SafeIntegers, !0));
+}), c = (e, t) => s(e, t === void 0 ? {} : { restart: t }), l = (e) => s([e], { suspension: e });
+//#endregion
+export { o as observeWorkflowSuspension, c as resetExpectedWorkflowReplies, l as resetExpectedWorkflowSuspension };

package/dist/workflowReadSelections.js

@@ -0,0 +1,12 @@
+//#region src/workflowReadSelections.ts
+var e = (e) => e.findLast((e, t, n) => t in n && e._tag === "WithExit"), t = (e) => {
+	let t = /* @__PURE__ */ new Set();
+	for (let n of e) {
+		if (n.eventType !== "update-completed" && n.eventType !== "update-failed") continue;
+		let e = n.payload?.updateId;
+		typeof e == "string" && e.length > 0 && t.add(e);
+	}
+	return t;
+};
+//#endregion
+export { e as latestExitReply, t as terminalUpdates };

package/dist/workflowRestartDispatch.js

@@ -0,0 +1,35 @@
+import { JournalRoutingGuard as e, protectJournalRoutingEffect as t, tryOwnedJournalRoutingPromise as n } from "./journalRoutingGuard.js";
+import { resetReservedWorkflowJournal as r } from "./workflowRestartReservation.js";
+import { JournalRoutingLayout as i, routeJournalWorkflow as a } from "./journalRoutingRuntime.js";
+import { prepareWorkflowRestartCommand as o } from "./workflowRestartPreparation.js";
+import { observeWorkflowRestartReplies as s } from "./workflowRestartObservation.js";
+import { Context as c, Effect as l, Option as u } from "effect";
+import { SqlClient as d } from "effect/sql";
+import { MessageStorage as f, Sharding as p } from "effect/cluster";
+//#region src/workflowRestartDispatch.ts
+var m = (e) => l.gen(function* () {
+	let t = yield* r(e);
+	return t.kind === "waiting-capacity" ? t : (yield* (yield* p.Sharding).pollStorage, {
+		kind: "attempted",
+		journal: t
+	});
+}), h = class extends c.Service()("@voltro/workflow/WorkflowRestartDispatcher") {}, g = l.gen(function* () {
+	let r = u.getOrUndefined(yield* l.serviceOption(e)), c = u.getOrUndefined(yield* l.serviceOption(i)), g = yield* d.SqlClient, _ = yield* p.Sharding, v = yield* f.MessageStorage, y = (e) => t(r, s(c === void 0 ? e : {
+		...e,
+		workflow: a(e.workflow, c)
+	})).pipe(l.provideService(d.SqlClient, g), l.provideService(p.Sharding, _), l.provideService(f.MessageStorage, v));
+	return h.of({
+		prepare: (e) => t(r, n((t) => o({
+			...e,
+			transaction: (n) => {
+				if (t.throwIfAborted(), r?.isClosed()) throw Error("Journal routing admission is closed");
+				return e.transaction(n);
+			},
+			observe: (e) => l.runPromise(y(e), { signal: t })
+		}))),
+		observe: y,
+		dispatch: (e) => t(r, m(e)).pipe(l.provideService(d.SqlClient, g), l.provideService(p.Sharding, _))
+	});
+});
+//#endregion
+export { h as WorkflowRestartDispatcher, m as dispatchWorkflowRestart, g as makeWorkflowRestartDispatcher };