@fragno-dev/workflows 0.0.1 → 0.0.3

package/dist/node/runner/step.js

@@ -1,415 +1,465 @@
-import { isTerminalStatus } from "./status.js";
-import { getStepSnapshot, queueEventUpdate, queueLogCreate, queueStepCreate, queueStepUpdate } from "./state.js";
-import { NonRetryableError } from "../workflow.js";
+import { WaitForEventTimeoutError } from "../workflow.js";
+import { isMutateOnlyTx, isNonRetryableError, toError } from "./utils.js";
+import { isSystemEventActor } from "../system-events.js";
 import { parseDurationMs } from "../utils.js";
-import { computeRetryDelayMs, normalizeRetryConfig, normalizeWaitTimeoutMs } from "./utils.js";
 
 //#region src/runner/step.ts
-var WorkflowSuspend = class extends Error {
-	constructor(kind, runAt) {
-		super("WORKFLOW_SUSPEND");
-		this.kind = kind;
-		this.runAt = runAt;
+var RunnerStepSuspended = class extends Error {
+	reason;
+	constructor(reason) {
+		super("WORKFLOW_STEP_SUSPENDED");
+		this.name = "RunnerStepSuspended";
+		this.reason = reason;
 	}
 };
-var WorkflowPause = class extends Error {
-	constructor() {
-		super("WORKFLOW_PAUSE");
+var RunnerStepReplayStopped = class extends Error {
+	stepKey;
+	constructor(stepKey) {
+		super("WORKFLOW_REPLAY_STOPPED");
+		this.name = "RunnerStepReplayStopped";
+		this.stepKey = stepKey;
 	}
 };
-var WorkflowAbort = class extends Error {
-	constructor() {
-		super("WORKFLOW_ABORT");
+/**
+* Build a deterministic step key from type, name, and optional occurrence.
+* Bigger picture: stable step keys are the identity for replayable workflow steps.
+*/
+function buildStepKey(type, name, occurrence) {
+	const base = `${type}:${name}`;
+	if (occurrence === void 0 || occurrence === 0) return base;
+	return `${base}#${occurrence}`;
+}
+/**
+* Normalize timestamps to a Date instance.
+* Bigger picture: step scheduling uses consistent Date objects for comparisons.
+*/
+function coerceTimestamp(timestamp) {
+	return timestamp instanceof Date ? timestamp : new Date(timestamp);
+}
+/**
+* Strip delay-only fields from persisted snapshots.
+* Bigger picture: runner state stores the durable fields, not scheduling hints.
+*/
+function stripDelayFields(data) {
+	const { nextRetryDelayMs, wakeDelayMs,...rest } = data;
+	return rest;
+}
+/**
+* Treat both \"complete\" and \"completed\" as terminal step statuses.
+* Bigger picture: keeps runner compatible with existing persisted values.
+*/
+function isCompletedStatus(status) {
+	return status === "completed" || status === "complete";
+}
+/**
+* Compute retry delay based on the configured backoff strategy.
+* Bigger picture: centralizes retry timing so scheduling is deterministic.
+*/
+function computeBackoffDelayMs(retries, attempt) {
+	const baseDelay = parseDurationMs(retries.delay);
+	switch (retries.backoff) {
+		case "linear": return baseDelay * Math.max(attempt, 1);
+		case "exponential": return baseDelay * Math.pow(2, Math.max(attempt - 1, 0));
+		default: return baseDelay;
 	}
-};
-var WaitForEventTimeoutError = class extends Error {
-	constructor() {
-		super("WAIT_FOR_EVENT_TIMEOUT");
-		this.name = "WaitForEventTimeoutError";
-	}
-};
-const coerceDate = (timestamp) => timestamp instanceof Date ? timestamp : new Date(timestamp);
-const coerceEventTimestamp = (timestamp) => {
-	if (timestamp instanceof Date) return timestamp;
-	if (typeof timestamp === "string" || typeof timestamp === "number") return new Date(timestamp);
-	return /* @__PURE__ */ new Date(NaN);
-};
+}
 var RunnerStep = class {
-	log;
 	#state;
-	#workflowName;
-	#instanceRef;
-	#instanceId;
-	#runNumber;
-	#inFlightSteps = /* @__PURE__ */ new Set();
-	#maxSteps;
-	#stepCount = 0;
-	#time;
-	#getDbNow;
-	#activeStepKey = null;
-	#activeAttempt = null;
+	#taskKind;
+	#mode;
+	#stepOccurrences = /* @__PURE__ */ new Map();
 	constructor(options) {
 		this.#state = options.state;
-		this.#workflowName = options.workflowName;
-		this.#instanceRef = options.instanceRef;
-		this.#instanceId = options.instanceId;
-		this.#runNumber = options.runNumber;
-		this.#maxSteps = options.maxSteps;
-		this.#time = options.time;
-		this.#getDbNow = options.getDbNow;
-		this.log = {
-			debug: (message, data, opts) => this.#writeLog("debug", message, data, opts),
-			info: (message, data, opts) => this.#writeLog("info", message, data, opts),
-			warn: (message, data, opts) => this.#writeLog("warn", message, data, opts),
-			error: (message, data, opts) => this.#writeLog("error", message, data, opts)
-		};
+		this.#taskKind = options.taskKind;
+		this.#mode = options.mode ?? "execute";
 	}
 	async do(name, configOrCallback, maybeCallback) {
-		const { config, callback } = typeof configOrCallback === "function" ? {
-			config: void 0,
-			callback: configOrCallback
-		} : {
-			config: configOrCallback,
-			callback: maybeCallback
-		};
-		if (!callback) throw new Error("Missing step callback");
-		this.#beginStep(name);
-		const now = this.#time.now();
-		const dbNow = await this.#getDbNow();
+		const config = typeof configOrCallback === "function" ? void 0 : configOrCallback;
+		const callback = typeof configOrCallback === "function" ? configOrCallback : maybeCallback;
+		if (!callback) throw new Error("WORKFLOW_STEP_CALLBACK_REQUIRED");
+		const stepKey = this.#nextStepKey("do", name);
+		const snapshot = this.#state.stepsByKey.get(stepKey);
+		if (snapshot && isCompletedStatus(snapshot.status)) return snapshot.result;
+		if (this.#mode === "restore") throw new RunnerStepReplayStopped(stepKey);
+		if (snapshot?.status === "errored") {
+			const error = new Error(snapshot.errorMessage ?? "STEP_FAILED");
+			error.name = snapshot.errorName ?? "Error";
+			throw error;
+		}
+		if (snapshot?.status === "waiting" && snapshot.nextRetryAt) {
+			if (this.#taskKind !== "retry") throw new RunnerStepSuspended({
+				type: "retry",
+				stepKey,
+				delayMs: null
+			});
+		}
+		const attempt = (snapshot?.attempts ?? 0) + 1;
+		const maxAttempts = config?.retries ? config.retries.limit + 1 : 1;
+		const timeoutMs = snapshot?.timeoutMs ?? null;
+		const txQueue = this.#createStepTxQueue();
 		try {
-			const existing = getStepSnapshot(this.#state, name);
-			if (existing && existing.type !== "do") throw new Error("STEP_TYPE_MISMATCH");
-			if (existing?.status === "completed") {
-				await this.#throwIfPauseRequested();
-				return existing.result;
-			}
-			if (existing?.status === "waiting" && existing.nextRetryAt) {
-				if (existing.nextRetryAt > dbNow) {
-					await this.#throwIfPauseRequested();
-					throw new WorkflowSuspend("retry", existing.nextRetryAt);
-				}
-			}
-			if (existing?.status === "errored") {
-				const err = new Error(existing.errorMessage ?? "STEP_FAILED");
-				err.name = existing.errorName ?? "Error";
-				throw err;
-			}
-			const { maxAttempts, delayMs, backoff } = normalizeRetryConfig(config);
-			const timeoutMs = config?.timeout ? parseDurationMs(config.timeout) : null;
-			if (existing && (existing.attempts ?? 0) >= maxAttempts) {
-				if (existing.id) queueStepUpdate(this.#state, name, existing.id, {
-					status: "errored",
-					errorName: "StepMaxAttemptsExceeded",
-					errorMessage: "STEP_MAX_ATTEMPTS_EXCEEDED",
-					updatedAt: now
-				});
-				throw new NonRetryableError("STEP_MAX_ATTEMPTS_EXCEEDED", "StepMaxAttemptsExceeded");
-			}
-			const attempt = (existing?.attempts ?? 0) + 1;
-			const startUpdate = {
-				status: "running",
-				attempts: attempt,
-				maxAttempts,
-				timeoutMs,
-				nextRetryAt: null,
-				errorName: null,
-				errorMessage: null,
-				updatedAt: now
-			};
-			if (existing?.id) queueStepUpdate(this.#state, name, existing.id, startUpdate);
-			else queueStepCreate(this.#state, name, {
-				instanceRef: this.#instanceRef,
-				workflowName: this.#workflowName,
-				instanceId: this.#instanceId,
-				runNumber: this.#runNumber,
-				stepKey: name,
+			const result = await callback(txQueue.tx);
+			txQueue.commitSuccess();
+			this.#upsertStep(stepKey, {
 				name,
 				type: "do",
-				status: "running",
+				status: "completed",
 				attempts: attempt,
 				maxAttempts,
 				timeoutMs,
-				nextRetryAt: null,
-				wakeAt: null,
-				waitEventType: null,
-				result: null,
+				result,
 				errorName: null,
 				errorMessage: null,
-				createdAt: now,
-				updatedAt: now
+				nextRetryAt: null,
+				wakeAt: null,
+				waitEventType: null
 			});
-			this.#setStepContext(name, attempt);
-			try {
-				const result = await this.#runWithTimeout(callback, timeoutMs);
-				const completionUpdate = {
-					status: "completed",
-					result,
-					updatedAt: this.#time.now()
-				};
-				const snapshot = getStepSnapshot(this.#state, name);
-				queueStepUpdate(this.#state, name, snapshot?.id, completionUpdate);
-				await this.#throwIfPauseRequested();
-				return result;
-			} catch (err) {
-				if (err instanceof WorkflowSuspend || err instanceof WorkflowPause || err instanceof WorkflowAbort) throw err;
-				const error = err;
-				const shouldRetry = !(error instanceof NonRetryableError) && attempt < maxAttempts;
-				let nextRetryAt = null;
-				if (shouldRetry) {
-					let retryBase;
-					try {
-						retryBase = await this.#getDbNow();
-					} catch {
-						retryBase = this.#time.now();
-					}
-					nextRetryAt = new Date(retryBase.getTime() + computeRetryDelayMs(attempt, delayMs, backoff));
-				}
-				const failureUpdate = {
-					status: shouldRetry ? "waiting" : "errored",
+			return result;
+		} catch (err) {
+			const error = toError(err);
+			const nonRetryable = isNonRetryableError(error);
+			const retries = config?.retries;
+			const canRetry = !nonRetryable && Boolean(retries && attempt <= retries.limit);
+			if (nonRetryable) {
+				txQueue.commitTerminalError();
+				this.#upsertStep(stepKey, {
+					name,
+					type: "do",
+					status: "errored",
+					attempts: attempt,
+					maxAttempts,
+					timeoutMs,
 					errorName: error.name,
 					errorMessage: error.message,
-					nextRetryAt,
-					updatedAt: this.#time.now()
-				};
-				const snapshot = getStepSnapshot(this.#state, name);
-				queueStepUpdate(this.#state, name, snapshot?.id, failureUpdate);
-				if (shouldRetry && nextRetryAt) {
-					await this.#throwIfPauseRequested();
-					throw new WorkflowSuspend("retry", nextRetryAt);
-				}
+					nextRetryAt: null,
+					wakeAt: null,
+					waitEventType: null
+				});
 				throw error;
 			}
-		} finally {
-			this.#endStep(name);
-		}
-	}
-	async sleep(name, duration) {
-		const dbNow = await this.#getDbNow();
-		const wakeAt = new Date(dbNow.getTime() + parseDurationMs(duration));
-		return this.#sleepUntil(name, wakeAt);
-	}
-	async sleepUntil(name, timestamp) {
-		const wakeAt = coerceDate(timestamp);
-		return this.#sleepUntil(name, wakeAt);
-	}
-	async waitForEvent(name, options) {
-		this.#beginStep(name);
-		this.#setStepContext(name, null);
-		const now = this.#time.now();
-		const dbNow = await this.#getDbNow();
-		try {
-			const existing = getStepSnapshot(this.#state, name);
-			if (existing && existing.type !== "waitForEvent") throw new Error("STEP_TYPE_MISMATCH");
-			if (existing?.status === "completed" && existing.result) {
-				await this.#throwIfPauseRequested();
-				const result = existing.result;
-				return {
-					...result,
-					timestamp: coerceEventTimestamp(result.timestamp)
-				};
-			}
-			if (existing?.status === "errored") throw new WaitForEventTimeoutError();
-			const timeoutMs = existing?.timeoutMs ?? normalizeWaitTimeoutMs(options.timeout);
-			const wakeAt = existing?.wakeAt ?? new Date(dbNow.getTime() + timeoutMs);
-			const event = this.#state.events.find((candidate) => {
-				if (candidate.type !== options.type || candidate.deliveredAt !== null) return false;
-				const createdAt = coerceEventTimestamp(candidate.createdAt);
-				if (Number.isNaN(createdAt.getTime())) return false;
-				return createdAt <= wakeAt;
-			});
-			if (event) {
-				const eventTimestamp = coerceEventTimestamp(event.createdAt);
-				const result = {
-					type: event.type,
-					payload: event.payload,
-					timestamp: eventTimestamp
-				};
-				queueEventUpdate(this.#state, event, {
-					deliveredAt: now,
-					consumedByStepKey: name
-				});
-				if (existing?.id) queueStepUpdate(this.#state, name, existing.id, {
-					status: "completed",
-					result,
-					updatedAt: now
-				});
-				else queueStepCreate(this.#state, name, {
-					instanceRef: this.#instanceRef,
-					workflowName: this.#workflowName,
-					instanceId: this.#instanceId,
-					runNumber: this.#runNumber,
-					stepKey: name,
+			if (canRetry && retries) {
+				const delayMs = computeBackoffDelayMs(retries, attempt);
+				this.#upsertStep(stepKey, {
 					name,
-					type: "waitForEvent",
-					status: "completed",
-					attempts: 1,
-					maxAttempts: 1,
-					timeoutMs: normalizeWaitTimeoutMs(options.timeout),
+					type: "do",
+					status: "waiting",
+					attempts: attempt,
+					maxAttempts: retries.limit + 1,
+					timeoutMs,
+					errorName: error.name,
+					errorMessage: error.message,
+					nextRetryDelayMs: delayMs,
 					nextRetryAt: null,
 					wakeAt: null,
-					waitEventType: options.type,
-					result,
-					errorName: null,
-					errorMessage: null,
-					createdAt: now,
-					updatedAt: now
+					waitEventType: null
 				});
-				await this.#throwIfPauseRequested();
-				return {
-					...result,
-					timestamp: coerceEventTimestamp(result.timestamp)
-				};
-			}
-			if (wakeAt <= dbNow) {
-				if (existing?.id) queueStepUpdate(this.#state, name, existing.id, {
-					status: "errored",
-					errorName: "WaitForEventTimeoutError",
-					errorMessage: "WAIT_FOR_EVENT_TIMEOUT",
-					updatedAt: now
+				throw new RunnerStepSuspended({
+					type: "retry",
+					stepKey,
+					delayMs
 				});
-				throw new WaitForEventTimeoutError();
 			}
-			if (existing?.id) queueStepUpdate(this.#state, name, existing.id, {
-				status: "waiting",
-				wakeAt,
-				waitEventType: options.type,
-				timeoutMs,
-				updatedAt: now
-			});
-			else queueStepCreate(this.#state, name, {
-				instanceRef: this.#instanceRef,
-				workflowName: this.#workflowName,
-				instanceId: this.#instanceId,
-				runNumber: this.#runNumber,
-				stepKey: name,
+			txQueue.commitTerminalError();
+			this.#upsertStep(stepKey, {
 				name,
-				type: "waitForEvent",
-				status: "waiting",
-				attempts: 0,
-				maxAttempts: 1,
+				type: "do",
+				status: "errored",
+				attempts: attempt,
+				maxAttempts,
 				timeoutMs,
+				errorName: error.name,
+				errorMessage: error.message,
 				nextRetryAt: null,
-				wakeAt,
-				waitEventType: options.type,
-				result: null,
-				errorName: null,
-				errorMessage: null,
-				createdAt: now,
-				updatedAt: now
+				wakeAt: null,
+				waitEventType: null
 			});
-			await this.#throwIfPauseRequested();
-			throw new WorkflowSuspend("wake", wakeAt);
-		} finally {
-			this.#endStep(name);
+			throw error;
 		}
 	}
-	async #sleepUntil(name, wakeAt) {
-		this.#beginStep(name);
-		this.#setStepContext(name, null);
-		const now = this.#time.now();
-		const dbNow = await this.#getDbNow();
-		try {
-			const existing = getStepSnapshot(this.#state, name);
-			if (existing && existing.type !== "sleep") throw new Error("STEP_TYPE_MISMATCH");
-			if (existing?.status === "completed") {
-				await this.#throwIfPauseRequested();
-				return;
-			}
-			if (existing?.wakeAt && existing.wakeAt <= dbNow) {
-				if (existing.id) queueStepUpdate(this.#state, name, existing.id, {
-					status: "completed",
-					updatedAt: now
-				});
-				await this.#throwIfPauseRequested();
-				return;
-			}
-			if (existing?.id) queueStepUpdate(this.#state, name, existing.id, {
-				status: "waiting",
-				wakeAt: existing.wakeAt ?? wakeAt,
-				updatedAt: now
+	async sleep(name, duration) {
+		const delayMs = parseDurationMs(duration);
+		const stepKey = this.#nextStepKey("sleep", name);
+		const snapshot = this.#state.stepsByKey.get(stepKey);
+		if (isCompletedStatus(snapshot?.status)) return;
+		if (this.#mode === "restore") throw new RunnerStepReplayStopped(stepKey);
+		if (this.#taskKind === "wake" && snapshot?.status === "waiting") {
+			this.#upsertStep(stepKey, {
+				name,
+				type: "sleep",
+				status: "completed",
+				attempts: snapshot?.attempts ?? 0,
+				maxAttempts: snapshot?.maxAttempts ?? 1,
+				timeoutMs: snapshot?.timeoutMs ?? null,
+				wakeAt: null,
+				waitEventType: null,
+				nextRetryAt: null
 			});
-			else queueStepCreate(this.#state, name, {
-				instanceRef: this.#instanceRef,
-				workflowName: this.#workflowName,
-				instanceId: this.#instanceId,
-				runNumber: this.#runNumber,
-				stepKey: name,
+			return;
+		}
+		if (snapshot?.status === "waiting") throw new RunnerStepSuspended({
+			type: "sleep",
+			stepKey,
+			delayMs: null
+		});
+		if (!snapshot) this.#upsertStep(stepKey, {
+			name,
+			type: "sleep",
+			status: "waiting",
+			attempts: 0,
+			maxAttempts: 1,
+			timeoutMs: null,
+			wakeDelayMs: delayMs,
+			wakeAt: null,
+			waitEventType: null,
+			nextRetryAt: null
+		});
+		throw new RunnerStepSuspended({
+			type: "sleep",
+			stepKey,
+			delayMs
+		});
+	}
+	async sleepUntil(name, timestamp) {
+		const stepKey = this.#nextStepKey("sleep", name);
+		const target = coerceTimestamp(timestamp);
+		const snapshot = this.#state.stepsByKey.get(stepKey);
+		if (isCompletedStatus(snapshot?.status)) return;
+		if (this.#mode === "restore") throw new RunnerStepReplayStopped(stepKey);
+		if (this.#taskKind === "wake" && snapshot?.status === "waiting") {
+			this.#upsertStep(stepKey, {
 				name,
 				type: "sleep",
-				status: "waiting",
-				attempts: 0,
-				maxAttempts: 1,
-				timeoutMs: null,
-				nextRetryAt: null,
-				wakeAt,
+				status: "completed",
+				attempts: snapshot?.attempts ?? 0,
+				maxAttempts: snapshot?.maxAttempts ?? 1,
+				timeoutMs: snapshot?.timeoutMs ?? null,
+				wakeAt: null,
 				waitEventType: null,
-				result: null,
+				nextRetryAt: null
+			});
+			return;
+		}
+		if (snapshot?.status === "waiting") throw new RunnerStepSuspended({
+			type: "sleep",
+			stepKey,
+			delayMs: null
+		});
+		if (!snapshot) this.#upsertStep(stepKey, {
+			name,
+			type: "sleep",
+			status: "waiting",
+			attempts: 0,
+			maxAttempts: 1,
+			timeoutMs: null,
+			wakeAt: target,
+			waitEventType: null,
+			nextRetryAt: null
+		});
+		throw new RunnerStepSuspended({
+			type: "sleep",
+			stepKey,
+			runAt: target
+		});
+	}
+	async waitForEvent(name, options) {
+		const stepKey = this.#nextStepKey("waitForEvent", name);
+		const snapshot = this.#state.stepsByKey.get(stepKey);
+		if (snapshot && isCompletedStatus(snapshot.status)) return snapshot.result;
+		if (this.#mode === "restore") throw new RunnerStepReplayStopped(stepKey);
+		const event = this.#findPendingEvent(options.type, snapshot?.wakeAt ?? null);
+		if (event) {
+			this.#queueEventUpdate(event, { consumedByStepKey: stepKey });
+			event.consumedByStepKey = stepKey;
+			const result = {
+				type: event.type,
+				payload: event.payload ?? null,
+				timestamp: event.createdAt
+			};
+			this.#upsertStep(stepKey, {
+				name,
+				type: "waitForEvent",
+				status: "completed",
+				attempts: snapshot?.attempts ?? 0,
+				maxAttempts: snapshot?.maxAttempts ?? 1,
+				timeoutMs: snapshot?.timeoutMs ?? null,
+				result,
+				waitEventType: options.type,
 				errorName: null,
 				errorMessage: null,
-				createdAt: now,
-				updatedAt: now
+				nextRetryAt: null,
+				wakeAt: null
+			});
+			return result;
+		}
+		const timeoutMs = options.timeout ? parseDurationMs(options.timeout) : null;
+		if (snapshot?.status === "waiting") {
+			if (this.#taskKind !== "wake") throw new RunnerStepSuspended({
+				type: "waitForEvent",
+				stepKey,
+				eventType: options.type,
+				delayMs: null
+			});
+			if (!snapshot.wakeAt) throw new RunnerStepSuspended({
+				type: "waitForEvent",
+				stepKey,
+				eventType: options.type,
+				delayMs: null
 			});
-			await this.#throwIfPauseRequested();
-			throw new WorkflowSuspend("wake", wakeAt);
-		} finally {
-			this.#endStep(name);
+			const error = new WaitForEventTimeoutError();
+			this.#upsertStep(stepKey, {
+				name,
+				type: "waitForEvent",
+				status: "errored",
+				attempts: snapshot?.attempts ?? 0,
+				maxAttempts: snapshot?.maxAttempts ?? 1,
+				timeoutMs: snapshot?.timeoutMs ?? null,
+				errorName: error.name,
+				errorMessage: error.message,
+				waitEventType: options.type,
+				nextRetryAt: null,
+				wakeAt: null
+			});
+			throw error;
 		}
+		if (!snapshot) this.#upsertStep(stepKey, {
+			name,
+			type: "waitForEvent",
+			status: "waiting",
+			attempts: 0,
+			maxAttempts: 1,
+			timeoutMs,
+			wakeDelayMs: timeoutMs ?? void 0,
+			waitEventType: options.type,
+			nextRetryAt: null,
+			wakeAt: null
+		});
+		throw new RunnerStepSuspended({
+			type: "waitForEvent",
+			stepKey,
+			eventType: options.type,
+			delayMs: timeoutMs ?? null
+		});
 	}
-	#beginStep(stepKey) {
-		if (this.#inFlightSteps.has(stepKey)) throw new Error("DUPLICATE_STEP_KEY");
-		this.#inFlightSteps.add(stepKey);
-		this.#stepCount += 1;
-		if (this.#stepCount > this.#maxSteps) throw new Error("MAX_STEPS_EXCEEDED");
+	#createStepTxQueue() {
+		const pendingMutations = [];
+		const pendingServiceCalls = [];
+		const pendingTerminalErrorMutations = [];
+		return {
+			tx: {
+				mutate: (fn) => {
+					pendingMutations.push(fn);
+				},
+				onTerminalError: { mutate: (fn) => {
+					pendingTerminalErrorMutations.push(fn);
+				} },
+				serviceCalls: (factory) => {
+					let calls;
+					try {
+						calls = factory();
+					} catch (error) {
+						const err = toError(error);
+						if (err.message.startsWith("Cannot add retrieval operation in state")) throw new Error("WORKFLOW_STEP_TX_RETRIEVE_NOT_SUPPORTED");
+						throw err;
+					}
+					for (const call of calls) {
+						if (!isMutateOnlyTx(call)) throw new Error("WORKFLOW_STEP_TX_RETRIEVE_NOT_SUPPORTED");
+						pendingServiceCalls.push(call);
+					}
+				}
+			},
+			commitSuccess: () => {
+				this.#state.mutations.txMutations.push(...pendingMutations);
+				this.#state.mutations.txServiceCalls.push(...pendingServiceCalls);
+			},
+			commitTerminalError: () => {
+				this.#state.mutations.txMutations.push(...pendingTerminalErrorMutations);
+			}
+		};
 	}
-	#endStep(stepKey) {
-		this.#inFlightSteps.delete(stepKey);
-		if (this.#activeStepKey === stepKey) {
-			this.#activeStepKey = null;
-			this.#activeAttempt = null;
-		}
+	#findPendingEvent(type, wakeAt) {
+		return this.#state.events.find((event) => !isSystemEventActor(event.actor) && event.type === type && !event.consumedByStepKey && (!wakeAt || event.createdAt <= wakeAt));
 	}
-	#setStepContext(stepKey, attempt) {
-		this.#activeStepKey = stepKey;
-		this.#activeAttempt = attempt;
+	#nextStepKey(type, name) {
+		const baseKey = buildStepKey(type, name);
+		const occurrence = this.#stepOccurrences.get(baseKey) ?? 0;
+		this.#stepOccurrences.set(baseKey, occurrence + 1);
+		return buildStepKey(type, name, occurrence);
 	}
-	async #throwIfPauseRequested() {
-		if (this.#state.remoteStateRefresh) await this.#state.remoteStateRefresh();
-		const remote = this.#state.remoteState;
-		if (remote.missing) return;
-		if (remote.runNumber !== this.#runNumber || isTerminalStatus(remote.status)) throw new WorkflowAbort();
-		if (remote.pauseRequested || remote.status === "waitingForPause" || remote.status === "paused") throw new WorkflowPause();
+	#queueEventUpdate(event, data) {
+		const key = event.id.toString();
+		const existing = this.#state.mutations.eventUpdates.get(key);
+		if (existing) {
+			this.#state.mutations.eventUpdates.set(key, {
+				id: existing.id,
+				data: {
+					...existing.data,
+					...data
+				}
+			});
+			return;
+		}
+		this.#state.mutations.eventUpdates.set(key, {
+			id: event.id,
+			data
+		});
 	}
-	async #runWithTimeout(callback, timeoutMs) {
-		if (!timeoutMs) return await callback();
-		let timer = null;
-		try {
-			return await Promise.race([Promise.resolve().then(callback), new Promise((_, reject) => {
-				timer = setTimeout(() => {
-					reject(/* @__PURE__ */ new Error("STEP_TIMEOUT"));
-				}, timeoutMs);
-			})]);
-		} finally {
-			if (timer) clearTimeout(timer);
+	#upsertStep(stepKey, data) {
+		const snapshot = this.#state.stepsByKey.get(stepKey);
+		const existingCreate = this.#state.mutations.stepCreates.get(stepKey);
+		if (existingCreate) this.#state.mutations.stepCreates.set(stepKey, {
+			...existingCreate,
+			...data
+		});
+		else if (snapshot?.id) {
+			const existingUpdate = this.#state.mutations.stepUpdates.get(stepKey);
+			if (existingUpdate) this.#state.mutations.stepUpdates.set(stepKey, {
+				id: existingUpdate.id,
+				data: {
+					...existingUpdate.data,
+					...data
+				}
+			});
+			else this.#state.mutations.stepUpdates.set(stepKey, {
+				id: snapshot.id,
+				data
+			});
+		} else {
+			const createBase = this.#buildStepCreateBase(stepKey, data);
+			this.#state.mutations.stepCreates.set(stepKey, {
+				...createBase,
+				...data
+			});
 		}
+		const nextSnapshot = {
+			...snapshot,
+			...existingCreate && stripDelayFields(existingCreate),
+			...stripDelayFields(data)
+		};
+		this.#state.stepsByKey.set(stepKey, nextSnapshot);
 	}
-	async #writeLog(level, message, data, options) {
-		const log = {
-			instanceRef: this.#instanceRef,
-			workflowName: this.#workflowName,
-			instanceId: this.#instanceId,
-			runNumber: this.#runNumber,
-			stepKey: this.#activeStepKey,
-			attempt: this.#activeAttempt,
-			level,
-			category: options?.category ?? "workflow",
-			message,
-			data: data ?? null,
-			createdAt: this.#time.now()
+	#buildStepCreateBase(stepKey, data) {
+		return {
+			instanceRef: this.#state.instance.id,
+			runNumber: this.#state.instance.runNumber,
+			stepKey,
+			name: data.name ?? stepKey,
+			type: data.type ?? "do",
+			status: data.status ?? "waiting",
+			attempts: data.attempts ?? 0,
+			maxAttempts: data.maxAttempts ?? 1,
+			timeoutMs: data.timeoutMs ?? null,
+			nextRetryAt: data.nextRetryAt ?? null,
+			wakeAt: data.wakeAt ?? null,
+			waitEventType: data.waitEventType ?? null,
+			result: data.result ?? null,
+			errorName: data.errorName ?? null,
+			errorMessage: data.errorMessage ?? null,
+			nextRetryDelayMs: data.nextRetryDelayMs,
+			wakeDelayMs: data.wakeDelayMs
 		};
-		queueLogCreate(this.#state, log);
 	}
 };
 
 //#endregion
-export { RunnerStep, WorkflowAbort, WorkflowPause, WorkflowSuspend };
+export { RunnerStep, RunnerStepReplayStopped, RunnerStepSuspended };
 //# sourceMappingURL=step.js.map