@voltro/workflow 0.33.0 → 0.34.0

package/dist/index.js

@@ -1,3 +1,3 @@
-import { A as e, C as t, D as n, E as r, F as i, M as a, N as o, O as s, P as c, S as l, _ as u, a as d, b as f, c as p, d as m, f as h, g, h as _, i as v, j as y, k as b, l as x, m as S, n as C, o as w, p as T, r as E, s as D, t as O, u as k, v as A, w as j, x as M, y as N } from "./primitives-Bp98_F5L.js";
-import { $ as P, A as F, B as I, C as L, D as R, E as z, F as B, G as V, H, I as U, J as W, K as G, L as K, M as q, N as J, O as Y, P as X, Q as Z, R as Q, S as $, T as ee, U as te, V as ne, W as re, X as ie, Y as ae, Z as oe, _ as se, a as ce, at as le, b as ue, c as de, ct as fe, d as pe, dt as me, et as he, f as ge, ft as _e, g as ve, h as ye, i as be, it as xe, j as Se, k as Ce, l as we, lt as Te, m as Ee, mt as De, n as Oe, nt as ke, o as Ae, ot as je, p as Me, pt as Ne, q as Pe, r as Fe, rt as Ie, s as Le, st as Re, t as ze, tt as Be, u as Ve, ut as He, v as Ue, w as We, x as Ge, y as Ke, z as qe } from "./src-CP61KZ9V.js";
-export { J as ADMISSIONS_TABLE, ue as CANCEL_ON_WATERMARK, t as CurrentWorkflowExecutionId, j as CurrentWorkflowRunId, Ge as DEFAULT_COLD_LOOKBACK_MS, Ue as DEFAULT_DRAIN_BATCH, $ as DEFAULT_EVENT_BATCH, X as DEFAULT_LEASE_MS, e as DEFERRING_CONTROLS, L as EVENTS_TABLE, P as FlowControlKeyError, B as PAUSES_TABLE, U as PENDING_TABLE, We as WATERMARKS_TABLE, O as WorkflowFlowControlProperty, C as WorkflowMessagesProperty, r as WorkflowRunRecorder, n as WorkflowStepInterceptorTag, E as WorkflowVersionTypeId, v as WorkflowWorkerLayerTypeId, Re as _voltroWorkflowAdmissionsTable, fe as _voltroWorkflowPausesTable, Te as _voltroWorkflowPendingTable, me as _voltroWorkflowRunEventsTable, _e as _voltroWorkflowRunStepsTable, Ne as _voltroWorkflowRunsTable, He as _voltroWorkflowStartContextsTable, F as _voltroWorkflowWatermarksTable, Se as admitStart, K as allIntents, y as assertConsistentPools, ve as awaitEvent, se as awaitSignal, we as awaitSignalSuspending, de as awaitUpdate, Fe as closeWorkflowChildrenForParent, he as comparePendingOrder, Ve as completeSuspendingSignal, Be as decideAdmission, a as deferringControlsOf, Q as deleteIntent, qe as discardIntent, Ke as drainTick, I as dueIntents, d as durableClock, w as durableQueue, D as durableQueueModule, p as durableRateLimiterModule, ne as evaluateAdmission, s as getCurrentWorkflowExecutionId, b as getCurrentWorkflowRunId, x as getWorkflowFlowControl, k as getWorkflowVersionMetadata, o as hasCancelOn, c as hasFlowControl, De as inMemoryWorkflowEngineLayer, Oe as inspectWorkflow, ke as isFinishExpired, Ie as isStartExpired, m as isWorkflowWorkerLayer, q as linkExecution, ze as makeInMemoryRecorder, be as makeWorkflowRunRecorder, ge as makeWorkflowUpdateId, Y as newestEventAt, xe as nextSlotAt, H as noteIntentAttempt, te as pauseWorkflow, re as pendingSlotId, V as pendingWindow, G as persistDefer, Ce as planCancellations, le as pooledConcurrencyKey, h as processQueue, Pe as pruneAdmissions, T as queueWorker, S as rateLimit, W as readAdmissionState, ae as readPausedWorkflows, ee as readWatermark, ie as recordAdmission, oe as releaseLease, je as resolveAdmissionKeys, Me as resolveWorkflowMessageRun, Z as resumeWorkflow, Ee as sendWorkflowSignal, ye as sendWorkflowUpdate, ce as serialiseWorkflowRowForWire, _ as sleep, g as sleepUntil, u as step, A as stepIdempotencyKey, N as stepModule, pe as suspendingSignalDeferredName, z as sweepCancelOn, Ae as truncateWorkflowValue, i as validateFlowControl, f as withCompensation, M as workflow, l as workflowModule, Le as wrapWorkflowExecuteWithRunRecording, R as writeWatermark };
+import { A as e, B as t, C as n, D as r, E as i, F as a, I as o, L as s, M as c, N as l, O as u, P as d, R as f, S as p, T as m, V as h, _ as g, a as _, b as v, c as y, d as b, f as x, g as S, h as C, i as w, k as T, l as E, m as D, n as O, o as k, p as A, r as j, s as M, t as N, u as P, v as F, w as I, x as L, y as R, z } from "./primitives-oLKOTbvJ.js";
+import { $ as B, A as V, At as H, B as U, C as W, Ct as G, D as K, Dt as q, E as J, Et as Y, F as X, G as Z, H as Q, I as $, J as ee, K as te, L as ne, M as re, Mt as ie, N as ae, Nt as oe, O as se, Ot as ce, P as le, Q as ue, R as de, S as fe, St as pe, T as me, Tt as he, U as ge, V as _e, W as ve, X as ye, Y as be, Z as xe, _ as Se, _t as Ce, a as we, at as Te, b as Ee, bt as De, c as Oe, ct as ke, d as Ae, dt as je, et as Me, f as Ne, ft as Pe, g as Fe, gt as Ie, h as Le, ht as Re, i as ze, it as Be, j as Ve, jt as He, k as Ue, kt as We, l as Ge, lt as Ke, m as qe, mt as Je, n as Ye, nt as Xe, o as Ze, ot as Qe, p as $e, pt as et, q as tt, r as nt, rt, s as it, st as at, t as ot, tt as st, u as ct, ut as lt, v as ut, vt as dt, w as ft, wt as pt, x as mt, xt as ht, y as gt, yt as _t, z as vt } from "./src-BXObaqb-.js";
+export { ue as ADMISSIONS_TABLE, $e as BUDGET_HOLDS_TABLE, qe as BudgetHoldExpired, vt as CANCEL_ON_WATERMARK, u as CurrentWorkflowExecutionId, T as CurrentWorkflowPatches, I as CurrentWorkflowReplayShape, e as CurrentWorkflowRunId, Le as DEFAULT_BUDGET_HOLD_TIMEOUT_MS, U as DEFAULT_COLD_LOOKBACK_MS, ae as DEFAULT_DRAIN_BATCH, _e as DEFAULT_EVENT_BATCH, B as DEFAULT_LEASE_MS, ze as DEFAULT_MAX_RUN_RECLAIMS, we as DEFAULT_REPLAY_SHAPE_LIMIT, X as DEFAULT_STALL_AFTER_MS, $ as DEFAULT_STALL_EVENT_LOOKBACK, ne as DEFAULT_STALL_RUN_PAGE, o as DEFERRING_CONTROLS, Q as EVENTS_TABLE, dt as FlowControlKeyError, Me as PAUSES_TABLE, st as PENDING_TABLE, ge as WATERMARKS_TABLE, N as WorkflowFlowControlProperty, O as WorkflowMessagesProperty, c as WorkflowRunRecorder, l as WorkflowStepInterceptorTag, j as WorkflowVersionTypeId, w as WorkflowWorkerLayerTypeId, Fe as _voltroBudgetHoldsTable, Y as _voltroWorkflowAdmissionsTable, q as _voltroWorkflowPausesTable, ce as _voltroWorkflowPendingTable, H as _voltroWorkflowRunEventsTable, He as _voltroWorkflowRunStepsTable, ie as _voltroWorkflowRunsTable, We as _voltroWorkflowStartContextsTable, be as _voltroWorkflowWatermarksTable, ye as admitStart, Xe as allIntents, s as assertConsistentPools, Ve as awaitEvent, re as awaitSignal, ft as awaitSignalSuspending, Ne as awaitUpdate, Se as budgetHoldGeneration, ut as budgetHoldKey, gt as budgetHoldSignalName, nt as closeWorkflowChildrenForParent, _t as comparePendingOrder, me as completeSuspendingSignal, De as decideAdmission, f as deferringControlsOf, rt as deleteIntent, Be as discardIntent, le as drainTick, Te as dueIntents, _ as durableClock, k as durableQueue, M as durableQueueModule, y as durableRateLimiterModule, Qe as evaluateAdmission, d as getCurrentWorkflowExecutionId, a as getCurrentWorkflowRunId, E as getWorkflowFlowControl, P as getWorkflowVersionMetadata, z as hasCancelOn, t as hasFlowControl, Ee as heldBudgets, oe as inMemoryWorkflowEngineLayer, Ye as inspectWorkflow, ht as isFinishExpired, pe as isStartExpired, b as isWorkflowWorkerLayer, xe as linkExecution, ot as makeInMemoryRecorder, m as makeReplayShapeTracker, Ze as makeWorkflowRunRecorder, K as makeWorkflowUpdateId, tt as newestEventAt, G as nextSlotAt, i as nondeterminismEventPayload, it as normaliseWorkflowPatches, at as noteIntentAttempt, x as patch, ke as pauseWorkflow, mt as pendingBudgetHolds, Ke as pendingSlotId, lt as pendingWindow, je as persistDefer, ee as planCancellations, pt as pooledConcurrencyKey, A as processQueue, Pe as pruneAdmissions, D as queueWorker, C as rateLimit, et as readAdmissionState, Je as readPausedWorkflows, ve as readWatermark, Re as recordAdmission, fe as releaseBudgetHolds, Ie as releaseLease, r as reportNondeterminism, he as resolveAdmissionKeys, Oe as resolveRunGuardTuning, se as resolveWorkflowMessageRun, Ce as resumeWorkflow, Ue as sendWorkflowSignal, V as sendWorkflowUpdate, Ge as serialiseWorkflowRowForWire, S as sleep, g as sleepUntil, F as step, R as stepIdempotencyKey, v as stepModule, W as suspendForBudget, J as suspendingSignalDeferredName, Z as sweepCancelOn, de as sweepStalledRuns, ct as truncateWorkflowValue, h as validateFlowControl, L as withCompensation, p as workflow, n as workflowModule, Ae as wrapWorkflowExecuteWithRunRecording, te as writeWatermark };

package/dist/{primitives-Bp98_F5L.js → primitives-oLKOTbvJ.js}

@@ -1,16 +1,16 @@
 import { Activity as e, Activity as t, DurableClock as n, DurableClock as r, DurableQueue as i, DurableQueue as a, DurableRateLimiter as o, DurableRateLimiter as s, Workflow as c, Workflow as l } from "@effect/workflow";
-import { Cause as u, Context as d, Duration as f, Effect as p, Exit as m, FiberRef as h, Option as g, Schedule as _, Schema as v } from "effect";
+import { Cause as u, Context as d, Duration as f, Effect as p, Exit as m, FiberRef as h, Option as ee, Schedule as g, Schema as _ } from "effect";
 //#region src/flowControl.ts
-var y = (e) => e !== void 0 && (e.debounce !== void 0 || e.singleton !== void 0 || e.concurrency !== void 0 || e.throttle !== void 0 || e.rateLimit !== void 0 || e.batch !== void 0 || e.timeouts?.startMs !== void 0 || e.timeouts?.finishMs !== void 0), b = (e) => e?.cancelOn !== void 0 && e.cancelOn.length > 0, x = [
+var v = (e) => e !== void 0 && (e.debounce !== void 0 || e.singleton !== void 0 || e.concurrency !== void 0 || e.throttle !== void 0 || e.rateLimit !== void 0 || e.batch !== void 0 || e.timeouts?.startMs !== void 0 || e.timeouts?.finishMs !== void 0), y = (e) => e?.cancelOn !== void 0 && e.cancelOn.length > 0, b = [
 	"debounce",
 	"batch",
 	"throttle",
 	"concurrency"
-], S = (e) => {
+], x = (e) => {
 	if (e === void 0) return [];
 	let t = [];
 	return e.debounce !== void 0 && t.push("debounce"), e.batch !== void 0 && t.push("batch"), e.throttle !== void 0 && t.push("throttle"), e.concurrency !== void 0 && t.push("concurrency"), t;
-}, C = (e, t, n) => {
+}, S = (e, t, n) => {
 	let r;
 	try {
 		r = f.toMillis(f.decode(e));
@@ -19,26 +19,26 @@ var y = (e) => e !== void 0 && (e.debounce !== void 0 || e.singleton !== void 0
 	}
 	if (!Number.isFinite(r) || r <= 0) throw Error(`workflow '${n}': ${t} must be a positive finite duration, got ${String(e)}`);
 	return r;
-}, w = (e, t, n) => {
+}, C = (e, t, n) => {
 	if (!Number.isInteger(e) || e <= 0) throw Error(`workflow '${n}': ${t} must be a positive integer, got ${String(e)}`);
 	return e;
-}, T = (e, t, n) => {
+}, w = (e, t, n) => {
 	if (typeof e != "function") throw Error(`workflow '${n}': ${t} must be a function of the payload`);
 	return e;
-}, E = (e) => {
+}, T = (e) => {
 	let t = e?.ast?.propertySignatures;
 	if (!Array.isArray(t)) return !1;
 	let n = t.find((e) => e.name === "items");
 	return n !== void 0 && n.type?._tag === "TupleType";
-}, D = (e) => {
+}, E = (e) => {
 	let { workflowName: t, control: n } = e;
 	if (n === void 0) return;
 	let r = { workflowName: t };
 	if (n.debounce !== void 0) {
-		let e = n.debounce, i = C(e.period, "debounce.period", t), a = e.timeout === void 0 ? void 0 : C(e.timeout, "debounce.timeout", t);
+		let e = n.debounce, i = S(e.period, "debounce.period", t), a = e.timeout === void 0 ? void 0 : S(e.timeout, "debounce.timeout", t);
 		if (a !== void 0 && a < i) throw Error(`workflow '${t}': debounce.timeout (${a}ms) is shorter than debounce.period (${i}ms), so the burst can never be collapsed — the run would be admitted before the quiet period could ever elapse. Raise the timeout or lower the period.`);
 		r.debounce = {
-			key: T(e.key, "debounce.key", t),
+			key: w(e.key, "debounce.key", t),
 			periodMs: i,
 			...a === void 0 ? {} : { timeoutMs: a }
 		};
@@ -47,7 +47,7 @@ var y = (e) => e !== void 0 && (e.debounce !== void 0 || e.singleton !== void 0
 		let e = n.singleton;
 		if (e.mode !== "skip" && e.mode !== "cancel") throw Error(`workflow '${t}': singleton.mode must be 'skip' or 'cancel'. There is no default — 'skip' discards the incoming request and 'cancel' discards the running one, and choosing for you would silently throw away work either way.`);
 		r.singleton = {
-			key: T(e.key, "singleton.key", t),
+			key: w(e.key, "singleton.key", t),
 			mode: e.mode
 		};
 	}
@@ -55,34 +55,34 @@ var y = (e) => e !== void 0 && (e.debounce !== void 0 || e.singleton !== void 0
 		let e = n.concurrency;
 		if (e.pool !== void 0 && (typeof e.pool != "string" || e.pool.trim() === "")) throw Error(`workflow '${t}': concurrency.pool must be a non-empty name — it is the identity other workflows declare to share this budget, and an empty one would silently merge every empty-named pool in the deployment into one.`);
 		r.concurrency = {
-			limit: w(e.limit, "concurrency.limit", t),
-			...e.key === void 0 ? {} : { key: T(e.key, "concurrency.key", t) },
+			limit: C(e.limit, "concurrency.limit", t),
+			...e.key === void 0 ? {} : { key: w(e.key, "concurrency.key", t) },
 			...e.pool === void 0 ? {} : { pool: e.pool.trim() }
 		};
 	}
 	if (n.throttle !== void 0) {
 		let e = n.throttle;
 		r.throttle = {
-			limit: w(e.limit, "throttle.limit", t),
-			periodMs: C(e.period, "throttle.period", t),
-			...e.key === void 0 ? {} : { key: T(e.key, "throttle.key", t) }
+			limit: C(e.limit, "throttle.limit", t),
+			periodMs: S(e.period, "throttle.period", t),
+			...e.key === void 0 ? {} : { key: w(e.key, "throttle.key", t) }
 		};
 	}
 	if (n.rateLimit !== void 0) {
 		let e = n.rateLimit;
 		r.rateLimit = {
-			limit: w(e.limit, "rateLimit.limit", t),
-			periodMs: C(e.period, "rateLimit.period", t),
-			...e.key === void 0 ? {} : { key: T(e.key, "rateLimit.key", t) }
+			limit: C(e.limit, "rateLimit.limit", t),
+			periodMs: S(e.period, "rateLimit.period", t),
+			...e.key === void 0 ? {} : { key: w(e.key, "rateLimit.key", t) }
 		};
 	}
 	if (n.batch !== void 0) {
 		let i = n.batch;
-		if (e.payloadSchema !== void 0 && !E(e.payloadSchema)) throw Error(`workflow '${t}': batch is declared, so the workflow's own \`payload\` must be the BATCH shape — \`Schema.Struct({ items: Schema.Array(Item) })\` — while callers start it with a SINGLE item. Declare the item's schema as \`batch.item\`. Checked here rather than at admission because a decode failure on the batching replica is a failure nobody is watching.`);
+		if (e.payloadSchema !== void 0 && !T(e.payloadSchema)) throw Error(`workflow '${t}': batch is declared, so the workflow's own \`payload\` must be the BATCH shape — \`Schema.Struct({ items: Schema.Array(Item) })\` — while callers start it with a SINGLE item. Declare the item's schema as \`batch.item\`. Checked here rather than at admission because a decode failure on the batching replica is a failure nobody is watching.`);
 		r.batch = {
-			...i.key === void 0 ? {} : { key: T(i.key, "batch.key", t) },
-			maxSize: w(i.maxSize, "batch.maxSize", t),
-			timeoutMs: C(i.timeout, "batch.timeout", t),
+			...i.key === void 0 ? {} : { key: w(i.key, "batch.key", t) },
+			maxSize: C(i.maxSize, "batch.maxSize", t),
+			timeoutMs: S(i.timeout, "batch.timeout", t),
 			...i.item === void 0 ? {} : { item: i.item }
 		};
 	}
@@ -91,7 +91,7 @@ var y = (e) => e !== void 0 && (e.debounce !== void 0 || e.singleton !== void 0
 		r.priority = n.priority;
 	}
 	if (n.timeouts !== void 0) {
-		let e = n.timeouts, i = e.start === void 0 ? void 0 : C(e.start, "timeouts.start", t), a = e.finish === void 0 ? void 0 : C(e.finish, "timeouts.finish", t);
+		let e = n.timeouts, i = e.start === void 0 ? void 0 : S(e.start, "timeouts.start", t), a = e.finish === void 0 ? void 0 : S(e.finish, "timeouts.finish", t);
 		(i !== void 0 || a !== void 0) && (r.timeouts = {
 			...i === void 0 ? {} : { startMs: i },
 			...a === void 0 ? {} : { finishMs: a }
@@ -111,7 +111,7 @@ var y = (e) => e !== void 0 && (e.debounce !== void 0 || e.singleton !== void 0
 			if (typeof e?.event != "string" || e.event.length === 0) throw Error(`workflow '${t}': ${r}.event must be a non-empty event name, exactly as ctx.events.publish writes it.`);
 			if (e.schema === void 0 || typeof e.schema.ast != "object") throw Error(`workflow '${t}': ${r}.schema must be a Schema for the event payload. It is decoded before \`match\` runs, so the predicate reads the domain type rather than raw JSON.`);
 			if (typeof e.match != "function") throw Error(`workflow '${t}': ${r}.match is required. Omitting it would mean "cancel every live run of this workflow whenever '${e.event}' is published" — write \`match: () => true\` if that is what you mean, so it is visible in review.`);
-			let i = e.within === void 0 ? void 0 : C(e.within, `${r}.within`, t);
+			let i = e.within === void 0 ? void 0 : S(e.within, `${r}.within`, t);
 			return {
 				event: e.event,
 				schema: e.schema,
@@ -122,9 +122,9 @@ var y = (e) => e !== void 0 && (e.debounce !== void 0 || e.singleton !== void 0
 		});
 		e.length > 0 && (r.cancelOn = e);
 	}
-	if (r.timeouts?.startMs !== void 0 && S(r).length === 0) throw Error(`workflow '${t}': timeouts.start bounds how long a run may sit in the ADMISSION queue, but this workflow declares no control that can defer one (debounce, batch, throttle, concurrency). It would never fire. Use timeouts.finish to bound the run itself.`);
+	if (r.timeouts?.startMs !== void 0 && x(r).length === 0) throw Error(`workflow '${t}': timeouts.start bounds how long a run may sit in the ADMISSION queue, but this workflow declares no control that can defer one (debounce, batch, throttle, concurrency). It would never fire. Use timeouts.finish to bound the run itself.`);
 	return r;
-}, ee = (e) => {
+}, D = (e) => {
 	let t = /* @__PURE__ */ new Map();
 	for (let n of e) {
 		let e = n?.concurrency;
@@ -137,99 +137,143 @@ var y = (e) => e !== void 0 && (e.debounce !== void 0 || e.singleton !== void 0
 		else if (r.limit !== e.limit) throw Error(`concurrency pool '${e.pool}': '${n.workflowName}' declares limit ${e.limit}, but ${r.workflows.map((e) => `'${e}'`).join(", ")} declare${r.workflows.length === 1 ? "s" : ""} limit ${r.limit}. A pool is ONE budget — every member must declare the same number, or the enforced limit would depend on which workflow's start arrived first. Align the limits, or give the workflows different pool names if they were never meant to share.`);
 		else r.workflows.push(n.workflowName);
 	}
-}, O = class extends d.Tag("@voltro/WorkflowRunRecorder")() {}, k = h.unsafeMake(void 0), A = h.unsafeMake(void 0), j = h.unsafeMake(void 0), M = () => h.get(k), N = () => h.get(A), P = class extends d.Tag("@voltro/WorkflowStepInterceptor")() {}, F = (e) => {
+}, O = class extends d.Tag("@voltro/WorkflowRunRecorder")() {}, k = h.unsafeMake(void 0), A = h.unsafeMake(void 0), j = h.unsafeMake(void 0), M = h.unsafeMake([]), N = () => h.get(k), P = () => h.get(A), F = class extends d.Tag("@voltro/WorkflowStepInterceptor")() {}, I = (e) => {
+	let t = /* @__PURE__ */ new Map();
+	for (let n of e) t.set(n.stepName, (t.get(n.stepName) ?? 0) + 1);
+	let n = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Set(), i = (e) => r.has(e) ? !1 : (r.add(e), !0);
+	return {
+		reach: (e) => {
+			let r = (n.get(e) ?? 0) + 1;
+			n.set(e, r);
+			let a = t.get(e) ?? 0;
+			if (a !== 0 && !(r <= a) && i(`extra:${e}`)) return {
+				kind: "extra-step-occurrence",
+				stepName: e,
+				recorded: a,
+				reached: r,
+				detail: `step '${e}' was reached ${r} time(s) on this attempt but this run only ever recorded ${a} — the body may have changed how often it runs this step (a loop bound), so the journal replays a result for an iteration the code no longer means.`
+			};
+		},
+		settle: () => {
+			let e = [];
+			for (let [r, a] of t) (n.get(r) ?? 0) > 0 || i(`unreached:${r}`) && e.push({
+				kind: "unreached-step",
+				stepName: r,
+				recorded: a,
+				reached: 0,
+				detail: `step '${r}' ran on an earlier attempt of this run but the current code never reaches it — the step was renamed, removed, or moved behind a branch, so its journaled result is orphaned and any step that replaced it executed fresh.`
+			});
+			return e;
+		}
+	};
+}, L = h.unsafeMake(void 0), R = (e) => ({
+	kind: e.kind,
+	stepName: e.stepName,
+	recorded: e.recorded,
+	reached: e.reached,
+	detail: e.detail
+}), z = (e) => p.gen(function* () {
+	if (e.length === 0) return;
+	let t = yield* h.get(k), n = yield* p.serviceOption(O);
+	if (t === void 0 || n._tag !== "Some") return;
+	let r = n.value;
+	for (let n of e) yield* p.promise(() => r.recordEvent({
+		runId: t,
+		eventType: "nondeterminism-suspected",
+		payload: R(n)
+	}).then(() => void 0).catch(() => void 0));
+}), B = (e) => {
 	if (typeof e != "object" || !e) return;
 	let t = e.retryAfterMillis;
 	if (typeof t == "number" && Number.isFinite(t) && t >= 0) return f.millis(t);
 	let n = e.retryAfter;
 	if (typeof n == "number" && Number.isFinite(n) && n >= 0) return f.seconds(n);
-}, I = (e) => f.decode(e), L = (e) => typeof e == "object" && e && "_tag" in e ? String(e._tag) : void 0, R = (e) => e !== void 0 && (e.maxAttempts ?? 3) > 1, z = (e) => {
+}, V = (e) => f.decode(e), H = (e) => typeof e == "object" && e && "_tag" in e ? String(e._tag) : void 0, U = (e) => e !== void 0 && (e.maxAttempts ?? 3) > 1, W = (e) => {
 	if (e.retryable) return e.retryable;
 	if (e.retryableErrors && e.retryableErrors.length > 0) {
 		let t = new Set(e.retryableErrors);
 		return (e) => {
-			let n = L(e);
+			let n = H(e);
 			return n !== void 0 && t.has(n);
 		};
 	}
 	return () => !0;
-}, B = (e) => {
-	let t = e.baseDelay ?? "200 millis", n = e.strategy ?? "exponential", r = e.maxAttempts ?? 3, i = n === "linear" ? _.linear(I(e.step ?? t)) : n === "fixed" ? _.spaced(I(t)) : _.exponential(I(t), e.factor ?? 2);
+}, G = (e) => {
+	let t = e.baseDelay ?? "200 millis", n = e.strategy ?? "exponential", r = e.maxAttempts ?? 3, i = n === "linear" ? g.linear(V(e.step ?? t)) : n === "fixed" ? g.spaced(V(t)) : g.exponential(V(t), e.factor ?? 2);
 	if (e.maxDelay !== void 0) {
-		let t = I(e.maxDelay);
-		i = _.modifyDelay(i, (e, n) => f.min(n, t));
+		let t = V(e.maxDelay);
+		i = g.modifyDelay(i, (e, n) => f.min(n, t));
 	}
-	(e.jitter ?? !0) === !0 && (i = _.jittered(i));
-	let a = _.intersect(i, _.recurs(Math.max(0, r - 1)));
-	return e.maxElapsed !== void 0 && (a = _.upTo(I(e.maxElapsed))(a)), a;
-}, V = (e, t) => {
-	let n = f.toMillis(I(e.baseDelay ?? "200 millis")), r = e.strategy ?? "exponential", i = r === "fixed" ? n : r === "linear" ? n + f.toMillis(I(e.step ?? e.baseDelay ?? "200 millis")) * (t - 1) : n * (e.factor ?? 2) ** (t - 1);
-	return e.maxDelay !== void 0 && (i = Math.min(i, f.toMillis(I(e.maxDelay)))), (e.jitter ?? !0) === !0 && (i *= Math.random()), i;
-}, H = (e, t, n, r) => p.gen(function* () {
-	let i = t.maxAttempts ?? 3, a = t.maxElapsed === void 0 ? Infinity : f.toMillis(I(t.maxElapsed)), o = yield* p.sync(() => Date.now()), s = 0;
+	(e.jitter ?? !0) === !0 && (i = g.jittered(i));
+	let a = g.intersect(i, g.recurs(Math.max(0, r - 1)));
+	return e.maxElapsed !== void 0 && (a = g.upTo(V(e.maxElapsed))(a)), a;
+}, K = (e, t) => {
+	let n = f.toMillis(V(e.baseDelay ?? "200 millis")), r = e.strategy ?? "exponential", i = r === "fixed" ? n : r === "linear" ? n + f.toMillis(V(e.step ?? e.baseDelay ?? "200 millis")) * (t - 1) : n * (e.factor ?? 2) ** (t - 1);
+	return e.maxDelay !== void 0 && (i = Math.min(i, f.toMillis(V(e.maxDelay)))), (e.jitter ?? !0) === !0 && (i *= Math.random()), i;
+}, q = (e, t, n, r) => p.gen(function* () {
+	let i = t.maxAttempts ?? 3, a = t.maxElapsed === void 0 ? Infinity : f.toMillis(V(t.maxElapsed)), o = yield* p.sync(() => Date.now()), s = 0;
 	for (;;) {
 		let c = yield* p.exit(e);
 		if (m.isSuccess(c)) return c.value;
-		let l = c.cause, d = u.failureOption(l), h = g.isSome(d) ? d.value : u.squash(l);
+		let l = c.cause, d = u.failureOption(l), h = ee.isSome(d) ? d.value : u.squash(l);
 		s += 1;
-		let _ = (yield* p.sync(() => Date.now())) - o;
-		if (s >= i || !n(h) || _ >= a) return yield* p.failCause(l);
+		let g = (yield* p.sync(() => Date.now())) - o;
+		if (s >= i || !n(h) || g >= a) return yield* p.failCause(l);
 		r?.(h);
-		let v = F(h), y = v === void 0 ? V(t, s) : f.toMillis(v);
-		yield* p.sleep(f.millis(y));
+		let _ = B(h), v = _ === void 0 ? K(t, s) : f.toMillis(_);
+		yield* p.sleep(f.millis(v));
 	}
-}), U = (e, t, n) => {
-	if (!R(t)) return e;
-	let r = z(t);
-	if (t.respectRetryAfter === !0) return H(e, t, r, n);
-	let i = B(t), a = n ? p.tapError(e, (e) => p.sync(() => {
+}), J = (e, t, n) => {
+	if (!U(t)) return e;
+	let r = W(t);
+	if (t.respectRetryAfter === !0) return q(e, t, r, n);
+	let i = G(t), a = n ? p.tapError(e, (e) => p.sync(() => {
 		r(e) && n(e);
 	})) : e;
 	return p.retry(a, {
 		schedule: i,
 		while: r
 	});
-}, W = Symbol.for("voltro.workflow.workerLayer"), G = Symbol.for("voltro.workflow.version"), K = "__voltroWorkflowMessages", q = "__voltroWorkflowFlowControl", J = (e) => typeof e == "object" && !!e && e[W] === !0, Y = (e) => typeof e == "object" && e && e[G] !== void 0 ? e[G] : {
+}, Y = Symbol.for("voltro.workflow.workerLayer"), X = Symbol.for("voltro.workflow.version"), Z = "__voltroWorkflowMessages", Q = "__voltroWorkflowFlowControl", te = (e) => typeof e == "object" && !!e && e[Y] === !0, ne = (e) => typeof e == "object" && e && e[X] !== void 0 ? e[X] : {
 	version: "1",
 	compatibleWith: ["1"],
 	patches: []
-}, X = ((e) => {
+}, re = ((e) => {
 	let t = c.make(e), n = e.suspendOnFailure === !0 ? t.annotate(c.SuspendOnFailure, !0) : t, r = String(e.version ?? "1"), i = {
 		version: r,
 		compatibleWith: (e.compatibleWith ?? [r]).map(String),
 		patches: [...e.patches ?? []]
 	}, a = {
 		signals: { ...e.messages?.signals ?? {} },
-		updates: { ...e.messages?.updates ?? {} },
-		queries: { ...e.messages?.queries ?? {} }
+		updates: { ...e.messages?.updates ?? {} }
 	};
-	Object.defineProperty(n, G, {
+	Object.defineProperty(n, X, {
 		value: i,
 		enumerable: !1
-	}), Object.defineProperty(n, K, {
+	}), Object.defineProperty(n, Z, {
 		value: a,
 		enumerable: !1
 	});
-	let o = D({
+	let o = E({
 		workflowName: e.name,
 		payloadSchema: e.payload,
 		control: e
 	});
-	return o !== void 0 && Object.defineProperty(n, q, {
+	return o !== void 0 && Object.defineProperty(n, Q, {
 		value: o,
 		enumerable: !1
 	}), n;
-}), Z = (e) => {
+}), ie = (e) => {
 	if (typeof e != "object" || !e) return;
-	let t = e[q];
+	let t = e[Q];
 	return t === void 0 ? void 0 : t;
-}, Q = i.make, te = i.process, ne = ((...e) => {
+}, ae = i.make, oe = i.process, se = ((...e) => {
 	let t = i.worker(...e);
-	return Object.defineProperty(t, W, {
+	return Object.defineProperty(t, Y, {
 		value: !0,
 		enumerable: !1
 	}), t;
-}), re = o.rateLimit, $ = (e) => p.gen(function* () {
+}), ce = o.rateLimit, $ = (e) => p.gen(function* () {
 	let t = yield* k, r = yield* p.serviceOption(O), i = f.toMillis(f.decode(e.duration));
 	if (t !== void 0 && r._tag === "Some") {
 		let a = r.value, o = new Date(Date.now() + i).toISOString(), s = yield* j;
@@ -256,18 +300,18 @@ var y = (e) => e !== void 0 && (e.debounce !== void 0 || e.singleton !== void 0
 		return;
 	}
 	yield* n.sleep(e);
-}), ie = (t) => p.gen(function* () {
+}), le = (t) => p.gen(function* () {
 	let n = (yield* e.make({
 		name: `sleepUntil:${t.name}`,
-		success: v.Number,
+		success: _.Number,
 		execute: p.sync(() => t.until instanceof Date ? t.until.getTime() : t.until)
 	})) - Date.now();
 	n <= 0 || (yield* $({
 		name: t.name,
 		duration: `${n} millis`
 	}));
-}), ae = (t, n, r, i) => p.gen(function* () {
-	let a = yield* k, o = yield* e.CurrentAttempt, s = yield* p.serviceOption(O), c = yield* p.serviceOption(P), l = c._tag === "Some" ? c.value.interceptor(n, {
+}), ue = (t, n, r, i) => p.gen(function* () {
+	let a = yield* k, o = yield* e.CurrentAttempt, s = yield* p.serviceOption(O), c = yield* p.serviceOption(F), l = c._tag === "Some" ? c.value.interceptor(n, {
 		runId: a ?? "unrecorded",
 		stepName: t,
 		attempt: o
@@ -288,7 +332,7 @@ var y = (e) => e !== void 0 && (e.debounce !== void 0 || e.singleton !== void 0
 		}
 	}
 	let m = Date.now();
-	return yield* U(l, i).pipe(p.tap((e) => d && f ? p.promise(async () => {
+	return yield* J(l, i).pipe(p.tap((e) => d && f ? p.promise(async () => {
 		try {
 			await f.endStepSuccess({
 				stepRecordId: d,
@@ -312,12 +356,23 @@ var y = (e) => e !== void 0 && (e.debounce !== void 0 || e.singleton !== void 0
 			});
 		} catch {}
 	}) : p.void));
-}), oe = (t) => {
+}), de = (e) => p.gen(function* () {
+	let t = yield* h.get(L);
+	if (t === void 0) return;
+	let n = t.reach(e);
+	n !== void 0 && (yield* z([n]));
+}), fe = (e, t) => {
+	let n = e;
+	return {
+		...e,
+		commit: () => p.zipRight(de(t), n)
+	};
+}, pe = (t) => {
 	let { input: n, retry: r, ...i } = t;
-	return e.make({
+	return fe(e.make({
 		...i,
-		execute: ae(i.name, i.execute, n, r)
-	});
-}, se = c.withCompensation, ce = e.idempotencyKey;
+		execute: ue(i.name, i.execute, n, r)
+	}), i.name);
+}, me = (e) => p.map(h.get(M), (t) => t.includes(e)), he = c.withCompensation, ge = e.idempotencyKey;
 //#endregion
-export { x as A, A as C, P as D, O as E, D as F, S as M, b as N, N as O, y as P, l as S, j as T, oe as _, r as a, se as b, s as c, J as d, te as f, ie as g, $ as h, W as i, ee as j, M as k, Z as l, re as m, K as n, Q as o, ne as p, G as r, a as s, q as t, Y as u, ce as v, k as w, X as x, t as y };
+export { k as A, v as B, l as C, z as D, R as E, N as F, b as I, D as L, O as M, F as N, A as O, P, x as R, re as S, I as T, E as V, le as _, r as a, t as b, s as c, te as d, me as f, $ as g, ce as h, Y as i, j, M as k, ie as l, se as m, Z as n, ae as o, oe as p, X as r, a as s, Q as t, ne as u, pe as v, L as w, he as x, ge as y, y as z };

package/dist/primitives.d.ts

@@ -3,6 +3,7 @@ import { DurableQueue as durableQueueModule } from '@effect/workflow';
 import { DurableRateLimiter as durableRateLimiterModule } from '@effect/workflow';
 import { Duration } from 'effect';
 import { Effect } from 'effect';
+import { FiberRef } from 'effect';
 import { Schema } from 'effect';
 import { Activity as stepModule } from '@effect/workflow';
 import { Workflow as workflowModule } from '@effect/workflow';
@@ -24,6 +25,16 @@ import { Workflow as workflowModule } from '@effect/workflow';
  */
 export declare const assertConsistentPools: (controls: ReadonlyArray<ResolvedFlowControl | undefined>) => void;
 
+/**
+ * The tracker for the CURRENT body entry, or `undefined` when there is nothing
+ * to compare against.
+ *
+ * Installed by `wrapWorkflowExecuteWithRunRecording` ONLY on a re-entry (a run
+ * whose row already exists). A first entry has no prior shape, so the whole
+ * mechanism costs one `FiberRef` read per step and nothing else.
+ */
+export declare const CurrentWorkflowReplayShape: FiberRef.FiberRef<ReplayShapeTracker | undefined>;
+
 /** The DECODED payload type. Mirrors `Workflow.make`'s own `idempotencyKey`
  *  parameter, so the two never disagree about what a payload is. */
 declare type DecodedPayload<P> = P extends Schema.Struct.Fields ? Schema.Struct.Type<P> : P extends {
@@ -84,6 +95,34 @@ export declare const hasFlowControl: (control: ResolvedFlowControl | undefined)
 
 export declare const isWorkflowWorkerLayer: (value: unknown) => value is WorkflowWorkerLayerBrand;
 
+/**
+ * Build a tracker from the step rows this run recorded on EARLIER body entries.
+ *
+ * Pass the rows as they are: one row per step ATTEMPT, so a step that retried
+ * three times contributes three. Counting rows rather than distinct names is
+ * what makes the per-name sequence rule work, and the asymmetry is deliberate —
+ * only reaching a name MORE often than recorded is a finding. Fewer is normal
+ * (a crash mid-step records two rows for one logical reach).
+ */
+export declare const makeReplayShapeTracker: (recordedRows: ReadonlyArray<RecordedStepShape>) => ReplayShapeTracker;
+
+/** The `nondeterminism-suspected` event body. Kept here so the two emit sites
+ *  (the step wrapper, and the run wrapper's `settle`) cannot drift. */
+export declare const nondeterminismEventPayload: (finding: NondeterminismFinding) => Record<string, unknown>;
+
+export declare interface NondeterminismFinding {
+    readonly kind: NondeterminismKind;
+    readonly stepName: string;
+    /** How many rows this run recorded for `stepName` on EARLIER body entries. */
+    readonly recorded: number;
+    /** How many times the CURRENT body entry reached it. */
+    readonly reached: number;
+    /** One sentence an operator can act on, without opening the code. */
+    readonly detail: string;
+}
+
+export declare type NondeterminismKind = 'unreached-step' | 'extra-step-occurrence';
+
 declare type NormaliseWorkflowMessages<M extends WorkflowMessageSchemas | undefined> = {
     readonly signals: M extends {
         readonly signals: infer Signals;
@@ -91,11 +130,60 @@ declare type NormaliseWorkflowMessages<M extends WorkflowMessageSchemas | undefi
     readonly updates: M extends {
         readonly updates: infer Updates;
     } ? NonNullable<Updates> & Readonly<Record<string, WorkflowMessagePairSchemas>> : {};
-    readonly queries: M extends {
-        readonly queries: infer Queries;
-    } ? NonNullable<Queries> & Readonly<Record<string, WorkflowMessagePairSchemas>> : {};
 };
 
+/**
+ * Is a named change marker in effect for the run currently executing?
+ *
+ * This is the escape valve for the versioning trap. `compatibleWith` is
+ * all-or-nothing: leave an old version out and every in-flight run on it is
+ * terminally failed; leave it in and the old runs replay against the new body
+ * with no detection. `patch` is the third option — the body itself branches, so
+ * runs that started BEFORE the change keep taking the old path to completion
+ * while new runs take the new one.
+ *
+ * ```ts
+ * export const Charge = workflow({
+ *   name: 'billing.charge',
+ *   payload: { orderId: Schema.String },
+ *   idempotencyKey: ({ orderId }) => `billing.charge:${orderId}`,
+ *   patches: ['split-tax-calculation'],       // ← declare it
+ * })
+ *
+ * // inside the body:
+ * if (yield* patch('split-tax-calculation')) {
+ *   const net = yield* step({ name: 'net-total', execute })
+ *   const tax = yield* step({ name: 'tax', execute })
+ *   return net + tax
+ * }
+ * return yield* step({ name: 'total', execute })   // the pre-patch path
+ * ```
+ *
+ * ── The answer is pinned to the RUN, not to the code ────────────────────────
+ *
+ * `patches` is stamped onto `_voltro_workflow_runs.workflowPatches` when the
+ * run starts and read back from that row on every resume. So a run started
+ * before you added the marker answers `false` for the rest of its life,
+ * however many times it replays and whatever the deployed code says — which is
+ * the property that makes the branch deterministic across a redeploy.
+ *
+ * Under `@effect/workflow` the naive implementation does the opposite: an
+ * activity that is ABSENT from an old run's journal EXECUTES on replay (the
+ * journal is keyed name/attempt), so a marker journaled by an activity would
+ * answer `true` for exactly the old runs it must answer `false` for. Reading
+ * the run row sidesteps that entirely.
+ *
+ * ── Retiring a patch ───────────────────────────────────────────────────────
+ *
+ * Once no run predating the marker can still be in flight, delete the old
+ * branch and the entry from `patches`. Runs that stamped it keep the marker on
+ * their row for the audit trail; `patch()` simply stops being called.
+ *
+ * Outside a recorded workflow body (a unit test, a bare `step()` call) this is
+ * `false` — the pre-patch branch, which is the safe direction.
+ */
+export declare const patch: (id: string) => Effect.Effect<boolean>;
+
 /** The SCHEMA a payload input denotes — `Fields` lifted into a `Struct`. */
 declare type PayloadSchemaOf<P> = P extends Schema.Struct.Fields ? Schema.Struct<P> : P;
 
@@ -114,6 +202,39 @@ export declare const queueWorker: typeof durableQueueModule.worker;
 /** Durable rate limiter activity. Delays through the workflow clock. */
 export declare const rateLimit: typeof durableRateLimiterModule.rateLimit;
 
+/** The slice of a `_voltro_workflow_run_steps` row this needs. */
+export declare interface RecordedStepShape {
+    readonly stepName: string;
+}
+
+export declare interface ReplayShapeTracker {
+    /**
+     * The body reached `stepName`. Returns a finding the FIRST time that reach
+     * is anomalous, `undefined` otherwise — so a step in a hot loop reports once
+     * rather than once per iteration.
+     */
+    readonly reach: (stepName: string) => NondeterminismFinding | undefined;
+    /**
+     * The body ran to a COMPLETE outcome. Returns the set-membership findings —
+     * recorded names the body never reached.
+     *
+     * Call this ONLY on success/failure, never on a suspend: a suspended body
+     * stopped partway through on purpose, so everything after the suspension
+     * point is legitimately unreached.
+     */
+    readonly settle: () => ReadonlyArray<NondeterminismFinding>;
+}
+
+/**
+ * Emit findings from INSIDE the workflow body, where the run id and the
+ * recorder are only reachable through the fiber context.
+ *
+ * Best-effort in the strongest sense: no recorder, no run id, or a rejecting
+ * write all resolve to "nothing happened". A tripwire that can break the run it
+ * is watching is not a tripwire.
+ */
+export declare const reportNondeterminism: (findings: ReadonlyArray<NondeterminismFinding>) => Effect.Effect<void>;
+
 /** One resolved `cancelOn` entry. The schema is kept (not pre-compiled into a
  *  decoder) so the sweeper can report a decode failure naming the event, which
  *  is the difference between "the predicate said no" and "we could not read the
@@ -742,16 +863,24 @@ export declare interface WorkflowMessagesCarrier<M extends WorkflowMessagesMetad
     readonly [WorkflowMessagesProperty]: M;
 }
 
+/**
+ * The message channels a workflow declares.
+ *
+ * TWO, not three. `queries` used to sit here as a third channel and there was
+ * never a send path for it — no `sendWorkflowQuery`, no `awaitQuery`, nothing
+ * to receive one. It was normalised into metadata, projected into the generated
+ * rpcGroup and carried on the client's `WorkflowState`, so a user got a fully
+ * typed record they could not invoke from anywhere. Signals (fire-and-forget)
+ * and updates (synchronous, with a result) are the channels that exist.
+ */
 export declare interface WorkflowMessageSchemas {
     readonly signals?: Readonly<Record<string, Schema.Schema.Any>>;
     readonly updates?: Readonly<Record<string, WorkflowMessagePairSchemas>>;
-    readonly queries?: Readonly<Record<string, WorkflowMessagePairSchemas>>;
 }
 
 export declare interface WorkflowMessagesMetadata {
     readonly signals: Readonly<Record<string, Schema.Schema.Any>>;
     readonly updates: Readonly<Record<string, WorkflowMessagePairSchemas>>;
-    readonly queries: Readonly<Record<string, WorkflowMessagePairSchemas>>;
 }
 
 export declare const WorkflowMessagesProperty = "__voltroWorkflowMessages";
@@ -841,6 +970,17 @@ export declare interface WorkflowVersionMetadata {
 export declare interface WorkflowVersionOptions {
     readonly version?: string | number;
     readonly compatibleWith?: ReadonlyArray<string | number>;
+    /**
+     * Named change markers this workflow's body may branch on, via
+     * {@link patch}. Declaring one here is what makes `yield* patch('id')`
+     * answer `true` for runs started from now on and `false` for runs that were
+     * already in flight — see {@link patch} for the semantics and the worked
+     * example.
+     *
+     * The declared set is stamped onto `_voltro_workflow_runs.workflowPatches`
+     * at run start and read back from THERE on every resume, so the answer is
+     * pinned to the run and cannot change under a redeploy.
+     */
     readonly patches?: ReadonlyArray<string>;
     /**
      * When `true`, a workflow whose top-level body FAILS does not become a

package/dist/primitives.js

@@ -1,2 +1,2 @@
-import { A as e, F as t, M as n, N as r, P as i, S as a, _ as o, a as s, b as c, c as l, d as u, f as d, g as f, h as p, i as m, j as h, l as g, m as _, n as v, o as y, p as b, r as x, s as S, t as C, u as w, v as T, x as E, y as D } from "./primitives-Bp98_F5L.js";
-export { e as DEFERRING_CONTROLS, C as WorkflowFlowControlProperty, v as WorkflowMessagesProperty, x as WorkflowVersionTypeId, m as WorkflowWorkerLayerTypeId, h as assertConsistentPools, n as deferringControlsOf, s as durableClock, y as durableQueue, S as durableQueueModule, l as durableRateLimiterModule, g as getWorkflowFlowControl, w as getWorkflowVersionMetadata, r as hasCancelOn, i as hasFlowControl, u as isWorkflowWorkerLayer, d as processQueue, b as queueWorker, _ as rateLimit, p as sleep, f as sleepUntil, o as step, T as stepIdempotencyKey, D as stepModule, t as validateFlowControl, c as withCompensation, E as workflow, a as workflowModule };
+import { B as e, C as t, D as n, E as r, I as i, L as a, R as o, S as s, T as c, V as l, _ as u, a as d, b as f, c as p, d as m, f as h, g, h as _, i as v, l as y, m as b, n as x, o as S, p as C, r as w, s as T, t as E, u as D, v as O, w as k, x as A, y as j, z as M } from "./primitives-oLKOTbvJ.js";
+export { k as CurrentWorkflowReplayShape, i as DEFERRING_CONTROLS, E as WorkflowFlowControlProperty, x as WorkflowMessagesProperty, w as WorkflowVersionTypeId, v as WorkflowWorkerLayerTypeId, a as assertConsistentPools, o as deferringControlsOf, d as durableClock, S as durableQueue, T as durableQueueModule, p as durableRateLimiterModule, y as getWorkflowFlowControl, D as getWorkflowVersionMetadata, M as hasCancelOn, e as hasFlowControl, m as isWorkflowWorkerLayer, c as makeReplayShapeTracker, r as nondeterminismEventPayload, h as patch, C as processQueue, b as queueWorker, _ as rateLimit, n as reportNondeterminism, g as sleep, u as sleepUntil, O as step, j as stepIdempotencyKey, f as stepModule, l as validateFlowControl, A as withCompensation, s as workflow, t as workflowModule };