@temelj/workflow 0.0.0-alpha.2 → 0.0.0-alpha.4

package/dist/engine/state.mjs

@@ -1,13 +1,17 @@
+import { applyAttributePatch } from "../attributes.mjs";
+import { WorkflowErrorCode } from "../errors/codes.mjs";
 import { WorkflowStateError } from "../errors/base.mjs";
 import { WorkflowRunCanceledError, WorkflowRunCancellationError, WorkflowRunDeadlineExceededError, WorkflowRunMismatchError } from "../errors/run.mjs";
-import { getRequiredRun, isPositiveSafeInteger } from "../utility.mjs";
-import { applyWorkflowAttributePatch } from "../attributes.mjs";
-import "./retry-policy.mjs";
+import { History } from "../history/replay.mjs";
+import { isPositiveSafeInteger } from "../values.mjs";
+import { CLEARED_LEASE, CLEARED_RETRY, UNFINISHED } from "../run-status.mjs";
+import { getRequiredRun } from "../store/query.mjs";
 import { serializeError } from "./serialization.mjs";
-import { WorkflowHistory } from "../history/mod.mjs";
-import { enforceWorkflowEventHistoryNextLimit } from "./retry.mjs";
+import { enforceEventHistoryNextLimit } from "./retry.mjs";
+import { StaleExecutionError } from "./signals.mjs";
 import { readRunResult } from "./run-utils.mjs";
 //#region src/engine/state.ts
+const MAX_RUN_UPDATE_ATTEMPTS = 16;
 function requireDefinitionMatchesRun(definition, run) {
 	if (definition.name !== run.workflowName) WorkflowRunMismatchError.mismatch({
 		runId: run.id,
@@ -24,17 +28,27 @@ async function appendEventIfCurrentExecution(store, history, event, executionOwn
 	let appendedEvents;
 	await history.append(async () => {
 		beforeAppend?.();
-		enforceWorkflowEventHistoryNextLimit(history.events, limits);
-		const events = await store.appendEventIfRunCurrent(executionOwner, event);
-		if (events === void 0) WorkflowStaleExecutionError.stale(executionOwner.id);
-		appendedEvents = events;
-		return events;
+		enforceEventHistoryNextLimit(history.events, limits);
+		for (let attempt = 0; attempt < 16; attempt++) {
+			const current = await store.getRun(executionOwner.id);
+			if (current === void 0 || !isCurrentExecutionOwner(current, executionOwner)) StaleExecutionError.stale(executionOwner.id);
+			const events = await store.appendEventIfRunCurrent(current, event);
+			if (events !== void 0) {
+				appendedEvents = events;
+				return events;
+			}
+		}
+		StaleExecutionError.stale(executionOwner.id);
 	});
 	if (appendedEvents !== void 0) afterAppend?.(event, appendedEvents);
 }
-async function requireCurrentExecutionOwner(store, runId, executionOwner) {
-	const current = await store.getRun(runId);
-	if (current === void 0 || !isCurrentExecutionOwner(current, executionOwner)) WorkflowStaleExecutionError.stale(runId);
+async function requireCurrentExecutionOwner(store, executionOwner) {
+	if (await currentExecution(store, executionOwner) === void 0) StaleExecutionError.stale(executionOwner.id);
+}
+/** The stored run, while `executionOwner` still holds its lease; otherwise `undefined`. */
+async function currentExecution(store, executionOwner) {
+	const current = await store.getRun(executionOwner.id);
+	return current !== void 0 && isCurrentExecutionOwner(current, executionOwner) ? current : void 0;
 }
 async function patchRun(store, current, patch) {
 	const next = {
@@ -50,266 +64,155 @@ async function patchRunIfCurrent(store, current, patch) {
 	});
 }
 async function updateRunMetadataIfCurrent(store, runId, metadata, timestamp) {
-	for (let attempt = 0; attempt < 16; attempt++) {
-		const updated = await patchRunIfCurrent(store, await getRequiredRun(store, runId), {
-			metadata,
-			updatedAt: timestamp
-		});
-		if (updated !== void 0) return updated;
-	}
-	WorkflowStateError.failedRunMetadataUpdate(runId);
+	return await patchRunWithRetry(store, runId, () => ({
+		metadata,
+		updatedAt: timestamp
+	}), `Failed to update workflow run metadata for run ${runId}`, WorkflowErrorCode.STATE_RUN_METADATA_UPDATE_FAILED);
 }
 async function setRunAttributesIfCurrent(store, runId, attributes, timestamp) {
+	return await patchRunWithRetry(store, runId, (current) => attributesPatch(current, attributes, timestamp), `Failed to update workflow run attributes for run ${runId}`, WorkflowErrorCode.STATE_RUN_ATTRIBUTES_UPDATE_FAILED);
+}
+/** Patches a run, retrying when another writer updates the run first. */
+async function patchRunWithRetry(store, runId, patch, failureMessage, failureCode) {
 	for (let attempt = 0; attempt < 16; attempt++) {
 		const current = await getRequiredRun(store, runId);
-		const updated = await patchRunIfCurrent(store, current, {
-			attributes: applyWorkflowAttributePatch(current.attributes, attributes),
-			updatedAt: timestamp
-		});
+		const updated = await patchRunIfCurrent(store, current, patch(current));
 		if (updated !== void 0) return updated;
 	}
-	WorkflowStateError.failedRunAttributesUpdate(runId);
+	throw new WorkflowStateError(failureMessage, {
+		code: failureCode,
+		details: { runId }
+	});
+}
+function attributesPatch(current, attributes, timestamp) {
+	return {
+		attributes: applyAttributePatch(current.attributes, attributes),
+		updatedAt: timestamp
+	};
 }
 async function patchCurrentExecutionRun(store, executionOwner, patch) {
-	const current = await store.getRun(executionOwner.id);
-	if (current === void 0 || !isCurrentExecutionOwner(current, executionOwner)) return;
+	const current = await currentExecution(store, executionOwner);
+	if (current === void 0) return;
 	return await patchRunIfCurrent(store, current, patch);
 }
 async function patchCurrentExecutionRunAttributes(store, executionOwner, attributes, timestamp) {
-	const current = await store.getRun(executionOwner.id);
-	if (current === void 0 || !isCurrentExecutionOwner(current, executionOwner)) return;
-	return await patchRunIfCurrent(store, current, {
-		attributes: applyWorkflowAttributePatch(current.attributes, attributes),
-		updatedAt: timestamp
-	});
+	const current = await currentExecution(store, executionOwner);
+	if (current === void 0) return;
+	return await patchRunIfCurrent(store, current, attributesPatch(current, attributes, timestamp));
 }
-function transitionRunToMissingImplementationWait(run, error, timestamp, availableAt, retryAttempt) {
+/** The run with the transition stamped on it; every transition starts here. */
+function moved(run, timestamp, reason) {
 	return {
 		...run,
-		status: "waiting",
-		error,
 		updatedAt: timestamp,
 		lastTransitionAt: timestamp,
-		lastTransitionReason: "missing_implementation",
-		availableAt,
-		retryAt: availableAt,
-		retryReason: "missing_implementation",
-		retryAttempt,
-		retryStepId: void 0,
-		retryStepName: void 0,
-		workerId: void 0,
-		leaseExpiresAt: void 0,
-		deadlineAt: run.deadlineAt,
-		output: void 0,
-		finishedAt: void 0
+		lastTransitionReason: reason
 	};
 }
-function transitionRunToFailed(run, error, timestamp, lastTransitionReason, deadlineAt) {
+/** A terminal run: no lease, no retry, nothing left to schedule. */
+function finished(run, timestamp, status, reason, result) {
 	return {
-		...run,
-		status: "failed",
-		error,
-		updatedAt: timestamp,
-		lastTransitionAt: timestamp,
-		lastTransitionReason,
+		...moved(run, timestamp, reason),
+		status,
+		output: result.output,
+		error: result.error,
 		finishedAt: timestamp,
-		output: void 0,
 		availableAt: void 0,
-		retryAt: void 0,
-		retryReason: void 0,
-		retryAttempt: void 0,
-		retryStepId: void 0,
-		retryStepName: void 0,
-		workerId: void 0,
-		leaseExpiresAt: void 0,
-		deadlineAt: deadlineAt ?? run.deadlineAt
+		...CLEARED_LEASE,
+		...CLEARED_RETRY
 	};
 }
 function transitionRunToRunning(run, timestamp, attempts) {
 	return {
-		...run,
+		...moved(run, timestamp, "started"),
+		...UNFINISHED,
+		...CLEARED_RETRY,
 		status: "running",
 		attempts,
-		updatedAt: timestamp,
-		lastTransitionAt: timestamp,
-		lastTransitionReason: "started",
 		startedAt: run.startedAt ?? timestamp,
-		availableAt: void 0,
-		error: void 0,
-		output: void 0,
-		finishedAt: void 0,
-		retryAt: void 0,
-		retryReason: void 0,
-		retryAttempt: void 0,
-		retryStepId: void 0,
-		retryStepName: void 0
+		availableAt: void 0
 	};
 }
 function transitionRunToCompleted(run, output, timestamp) {
+	return finished(run, timestamp, "completed", "completed", { output });
+}
+function transitionRunToFailed(run, error, timestamp, reason, deadlineAt) {
 	return {
-		...run,
-		status: "completed",
-		...output === void 0 ? { output: void 0 } : { output },
-		error: void 0,
-		updatedAt: timestamp,
-		lastTransitionAt: timestamp,
-		lastTransitionReason: "completed",
-		finishedAt: timestamp,
-		availableAt: void 0,
-		workerId: void 0,
-		leaseExpiresAt: void 0,
-		retryAt: void 0,
-		retryReason: void 0,
-		retryAttempt: void 0,
-		retryStepId: void 0,
-		retryStepName: void 0
+		...finished(run, timestamp, "failed", reason, { error }),
+		deadlineAt: deadlineAt ?? run.deadlineAt
 	};
 }
-function transitionRunToExecutionWait(run, timestamp, availableAt, options = {}) {
+function transitionRunToCanceled(run, error, timestamp) {
+	return finished(run, timestamp, "canceled", "canceled", { error });
+}
+function transitionRunToWaiting(run, timestamp, availableAt) {
 	return {
-		...run,
+		...moved(run, timestamp, "waiting"),
+		...UNFINISHED,
+		...CLEARED_LEASE,
 		status: "waiting",
-		availableAt,
-		updatedAt: timestamp,
-		lastTransitionAt: timestamp,
+		availableAt
+	};
+}
+/** Waits after an execution suspended, optionally to retry a failed step or workflow. */
+function transitionRunToExecutionWait(run, timestamp, availableAt, options = {}) {
+	return {
+		...transitionRunToWaiting(run, timestamp, availableAt),
 		lastTransitionReason: options.retryReason === void 0 ? "waiting" : "retry",
-		workerId: void 0,
-		leaseExpiresAt: void 0,
 		retryAt: options.retryAt,
 		retryReason: options.retryReason,
 		retryAttempt: options.retryAttempt,
 		retryStepId: options.retryStepId,
 		retryStepName: options.retryStepName,
-		error: options.error,
-		output: void 0,
-		finishedAt: void 0
+		error: options.error
 	};
 }
-function transitionRunToWaiting(run, timestamp, availableAt) {
+function transitionRunToMissingImplementationWait(run, error, timestamp, availableAt, retryAttempt) {
 	return {
-		...run,
-		status: "waiting",
-		availableAt,
-		updatedAt: timestamp,
-		lastTransitionAt: timestamp,
-		lastTransitionReason: "waiting",
-		deadlineAt: run.deadlineAt,
-		workerId: void 0,
-		leaseExpiresAt: void 0,
-		error: void 0,
-		output: void 0,
-		finishedAt: void 0
+		...transitionRunToWaiting(run, timestamp, availableAt),
+		...CLEARED_RETRY,
+		lastTransitionReason: "missing_implementation",
+		retryAt: availableAt,
+		retryReason: "missing_implementation",
+		retryAttempt,
+		error
 	};
 }
-function transitionRunToRescheduled(run, timestamp, availableAt) {
+function transitionRunAfterStaleLeaseRelease(run, timestamp, availableAt) {
 	return {
-		...run,
-		availableAt,
-		updatedAt: timestamp,
-		lastTransitionAt: timestamp,
-		lastTransitionReason: "rescheduled",
-		deadlineAt: run.deadlineAt,
-		leaseExpiresAt: void 0,
-		workerId: void 0,
-		retryAt: run.retryReason === void 0 ? void 0 : availableAt,
-		retryReason: run.retryReason,
-		retryAttempt: run.retryAttempt,
-		retryStepId: run.retryStepId,
-		retryStepName: run.retryStepName,
-		error: void 0,
-		output: void 0,
-		finishedAt: void 0
+		...transitionRunToWaiting(run, timestamp, availableAt),
+		...CLEARED_RETRY,
+		lastTransitionReason: "lease_released"
 	};
 }
-function transitionRunAfterStaleLeaseRelease(run, timestamp, availableAt) {
+/** Moves the run's next attempt to `availableAt`, keeping its status and retry details. */
+function transitionRunToRescheduled(run, timestamp, availableAt) {
 	return {
-		...transitionRunToWaiting(run, timestamp, availableAt),
-		lastTransitionReason: "lease_released",
-		retryAt: void 0,
-		retryReason: void 0,
-		retryAttempt: void 0,
-		retryStepId: void 0,
-		retryStepName: void 0,
-		deadlineAt: run.deadlineAt,
-		updatedAt: timestamp,
-		lastTransitionAt: timestamp
+		...moved(run, timestamp, "rescheduled"),
+		...UNFINISHED,
+		...CLEARED_LEASE,
+		availableAt,
+		retryAt: run.retryReason === void 0 ? void 0 : availableAt
 	};
 }
 function transitionRunToManualRetry(run, timestamp, availableAt, retryAttempt) {
 	return {
-		...run,
+		...moved(run, timestamp, "manual_retry"),
+		...UNFINISHED,
+		...CLEARED_LEASE,
 		status: "pending",
 		availableAt,
-		updatedAt: timestamp,
-		lastTransitionAt: timestamp,
-		lastTransitionReason: "manual_retry",
-		deadlineAt: run.deadlineAt,
-		workerId: void 0,
-		leaseExpiresAt: void 0,
 		retryAt: availableAt,
 		retryReason: run.retryReason ?? "workflow",
-		retryAttempt,
-		retryStepId: run.retryStepId,
-		retryStepName: run.retryStepName,
-		error: void 0,
-		output: void 0,
-		finishedAt: void 0
-	};
-}
-function transitionRunToPermanentFailure(run, error, timestamp) {
-	return {
-		...run,
-		status: "failed",
-		error,
-		output: void 0,
-		availableAt: void 0,
-		updatedAt: timestamp,
-		lastTransitionAt: timestamp,
-		lastTransitionReason: "permanent_failure",
-		deadlineAt: run.deadlineAt,
-		workerId: void 0,
-		leaseExpiresAt: void 0,
-		retryAt: void 0,
-		retryReason: void 0,
-		retryAttempt: void 0,
-		retryStepId: void 0,
-		retryStepName: void 0,
-		finishedAt: timestamp
-	};
-}
-function transitionRunToCanceled(run, error, timestamp) {
-	return {
-		...run,
-		status: "canceled",
-		error,
-		updatedAt: timestamp,
-		lastTransitionAt: timestamp,
-		lastTransitionReason: "canceled",
-		finishedAt: timestamp,
-		availableAt: void 0,
-		output: void 0,
-		workerId: void 0,
-		leaseExpiresAt: void 0,
-		retryAt: void 0,
-		retryReason: void 0,
-		retryAttempt: void 0,
-		retryStepId: void 0,
-		retryStepName: void 0
+		retryAttempt
 	};
 }
 function transitionRunAfterParentWake(run, timestamp) {
 	return {
-		...run,
+		...moved(run, timestamp, "waiting"),
+		...UNFINISHED,
 		availableAt: timestamp,
-		updatedAt: timestamp,
-		lastTransitionAt: timestamp,
-		lastTransitionReason: "waiting",
-		deadlineAt: run.deadlineAt,
-		retryAt: run.retryAt,
-		startedAt: run.startedAt ?? timestamp,
-		error: void 0,
-		output: void 0,
-		finishedAt: void 0
+		startedAt: run.startedAt ?? timestamp
 	};
 }
 function isCurrentExecutionOwner(current, execution) {
@@ -319,7 +222,7 @@ async function cancelRunWithChildren(store, runId, canceledAt) {
 	const run = await getRequiredRun(store, runId);
 	if (run.status === "completed" || run.status === "failed") WorkflowRunCancellationError.cannotCancel(runId, run.status);
 	if (run.status === "canceled") return run;
-	const canceledRun = await patchRunIfCurrent(store, run, transitionRunToCanceled(run, serializeError(WorkflowRunCanceledError.create(runId)), canceledAt));
+	const canceledRun = await patchRunIfCurrent(store, run, transitionRunToCanceled(run, serializeError(new WorkflowRunCanceledError(runId)), canceledAt));
 	if (canceledRun === void 0) {
 		const latest = await getRequiredRun(store, runId);
 		if (latest.status === "completed" || latest.status === "failed") WorkflowRunCancellationError.cannotCancel(runId, latest.status);
@@ -328,7 +231,7 @@ async function cancelRunWithChildren(store, runId, canceledAt) {
 	}
 	await releaseLocksForRun(store, run.id, canceledAt);
 	await cancelActiveChildRuns(store, run.id, canceledAt);
-	await wakeParentRunForTerminalChild(store, canceledRun, canceledAt);
+	await wakeParentRun(store, canceledRun, canceledAt);
 	return canceledRun;
 }
 async function cancelActiveChildRuns(store, parentRunId, canceledAt) {
@@ -346,23 +249,14 @@ async function cancelActiveChildRuns(store, parentRunId, canceledAt) {
 		await cancelRunWithChildren(store, child.id, canceledAt);
 	}
 }
-async function wakeParentRunForTerminalChild(store, childRun, timestamp) {
-	if (childRun.parentRunId === void 0) return;
-	const parentRun = await store.getRun(childRun.parentRunId);
-	if (parentRun === void 0 || parentRun.status !== "waiting") return;
-	if (!await parentHasActiveChildWorkflowAttemptForRun(store, parentRun.id, childRun)) return;
-	const wakeAt = timestamp;
-	if (parentRun.availableAt !== void 0 && Temporal.Instant.compare(parentRun.availableAt, wakeAt) <= 0) return;
-	await patchRun(store, parentRun, transitionRunAfterParentWake(parentRun, timestamp));
-}
-async function wakeParentRunForWaitingChild(store, childRun, availableAt) {
+/** Makes a waiting parent run available by `at` when one of its child workflow steps changes. */
+async function wakeParentRun(store, childRun, at) {
 	if (childRun.parentRunId === void 0) return;
 	const parentRun = await store.getRun(childRun.parentRunId);
 	if (parentRun === void 0 || parentRun.status !== "waiting") return;
 	if (!await parentHasActiveChildWorkflowAttemptForRun(store, parentRun.id, childRun)) return;
-	const wakeAt = availableAt;
-	if (parentRun.availableAt !== void 0 && Temporal.Instant.compare(parentRun.availableAt, wakeAt) <= 0) return;
-	await patchRun(store, parentRun, transitionRunAfterParentWake(parentRun, availableAt));
+	if (parentRun.availableAt !== void 0 && Temporal.Instant.compare(parentRun.availableAt, at) <= 0) return;
+	await patchRun(store, parentRun, transitionRunAfterParentWake(parentRun, at));
 }
 async function parentHasActiveChildWorkflowAttemptForRun(store, parentRunId, childRun) {
 	if (childRun.parentRunId !== parentRunId) return false;
@@ -377,26 +271,26 @@ async function parentHasActiveChildWorkflowAttemptForRun(store, parentRunId, chi
 async function parentHasActiveChildWorkflowEventForAttempt(store, parentRunId, attempt) {
 	if (attempt.childRunId === void 0) return false;
 	const events = await store.getEvents(parentRunId);
-	const lifecycle = new WorkflowHistory(events).childWorkflowLifecycleForAttempt(attempt);
+	const lifecycle = new History(events).childWorkflowLifecycleForAttempt(attempt);
 	if (lifecycle.started === void 0) return false;
 	if (!isPositiveSafeInteger(lifecycle.started.attempt)) return false;
 	return !lifecycle.hasTerminalAfterStarted;
 }
-async function failRunForDeadline(store, run, deadlineAt, failedAt, executionOwner) {
-	const serialized = serializeError(WorkflowRunDeadlineExceededError.create(run.id, deadlineAt));
+async function failRunForDeadline(store, definition, run, deadlineAt, failedAt, executionOwner) {
+	const serialized = serializeError(new WorkflowRunDeadlineExceededError(run.id, deadlineAt));
 	if (executionOwner !== void 0) {
 		const current = await store.getRun(run.id);
-		if (current === void 0 || !isCurrentExecutionOwner(current, executionOwner)) return await readRunResult(store, run.id, failedAt);
+		if (current === void 0 || !isCurrentExecutionOwner(current, executionOwner)) return await readRunResult(store, definition, run.id, failedAt);
 	}
 	await cancelActiveChildRuns(store, run.id, failedAt);
 	const failedRun = executionOwner === void 0 ? await patchRun(store, run, transitionRunToFailed(run, serialized, failedAt, "deadline")) : await patchCurrentExecutionRun(store, executionOwner, transitionRunToFailed(executionOwner, serialized, failedAt, "deadline"));
-	if (failedRun === void 0) return await readRunResult(store, run.id, failedAt);
+	if (failedRun === void 0) return await readRunResult(store, definition, run.id, failedAt);
 	if (await store.appendEventIfRunCurrent(failedRun, {
 		kind: "workflow_failed",
 		timestamp: failedAt
-	}) === void 0) return await readRunResult(store, run.id, failedAt);
+	}) === void 0) return await readRunResult(store, definition, run.id, failedAt);
 	await releaseLocksForRun(store, run.id, failedAt);
-	await wakeParentRunForTerminalChild(store, failedRun, failedAt);
+	await wakeParentRun(store, failedRun, failedAt);
 	return {
 		kind: "failed",
 		run: failedRun,
@@ -404,62 +298,13 @@ async function failRunForDeadline(store, run, deadlineAt, failedAt, executionOwn
 	};
 }
 async function releaseLocksForRun(store, runId, releasedAt) {
-	const timestamp = releasedAt;
 	const locks = await store.listLocks();
 	await Promise.all(locks.filter((lock) => lock.releasedAt === void 0 && lock.holderRunId === runId).map(async (lock) => {
 		await store.updateLockIfCurrent(lock, {
 			...lock,
-			releasedAt: timestamp
+			releasedAt
 		});
 	}));
 }
-var WorkflowSuspended = class WorkflowSuspended extends Error {
-	availableAt;
-	retryAt;
-	retryReason;
-	retryAttempt;
-	retryStep;
-	constructor(availableAt, context) {
-		super(`Workflow suspended until ${availableAt.toString()}`);
-		this.name = "WorkflowSuspended";
-		this.availableAt = availableAt;
-		if (Error.captureStackTrace !== void 0) Error.captureStackTrace(this, context ?? this.constructor);
-	}
-	static until(availableAt) {
-		throw new WorkflowSuspended(availableAt, WorkflowSuspended.until);
-	}
-	static forStepRetry(retryAt, retryStep, retryAttempt) {
-		const suspended = new WorkflowSuspended(retryAt, WorkflowSuspended.forStepRetry);
-		Object.defineProperties(suspended, {
-			retryAt: {
-				value: retryAt,
-				enumerable: true
-			},
-			retryReason: {
-				value: "step",
-				enumerable: true
-			},
-			retryAttempt: {
-				value: retryAttempt,
-				enumerable: true
-			},
-			retryStep: {
-				value: retryStep,
-				enumerable: true
-			}
-		});
-		throw suspended;
-	}
-};
-var WorkflowStaleExecutionError = class WorkflowStaleExecutionError extends Error {
-	constructor(runId, context) {
-		super(`Workflow execution no longer owns run: ${runId}`);
-		this.name = "WorkflowStaleExecutionError";
-		if (Error.captureStackTrace !== void 0) Error.captureStackTrace(this, context ?? this.constructor);
-	}
-	static stale(runId) {
-		throw new WorkflowStaleExecutionError(runId, WorkflowStaleExecutionError.stale);
-	}
-};
 //#endregion
-export { WorkflowStaleExecutionError, WorkflowSuspended, appendEventIfCurrentExecution, cancelActiveChildRuns, cancelRunWithChildren, failRunForDeadline, getRequiredRun, isCurrentExecutionOwner, parentHasActiveChildWorkflowAttemptForRun, parentHasActiveChildWorkflowEventForAttempt, patchCurrentExecutionRun, patchCurrentExecutionRunAttributes, patchRun, patchRunIfCurrent, releaseLocksForRun, requireCurrentExecutionOwner, requireDefinitionMatchesRun, setRunAttributesIfCurrent, transitionRunAfterParentWake, transitionRunAfterStaleLeaseRelease, transitionRunToCanceled, transitionRunToCompleted, transitionRunToExecutionWait, transitionRunToFailed, transitionRunToManualRetry, transitionRunToMissingImplementationWait, transitionRunToPermanentFailure, transitionRunToRescheduled, transitionRunToRunning, transitionRunToWaiting, updateRunMetadataIfCurrent, wakeParentRunForTerminalChild, wakeParentRunForWaitingChild };
+export { MAX_RUN_UPDATE_ATTEMPTS, appendEventIfCurrentExecution, cancelRunWithChildren, failRunForDeadline, isCurrentExecutionOwner, patchCurrentExecutionRun, patchCurrentExecutionRunAttributes, patchRun, patchRunIfCurrent, releaseLocksForRun, requireCurrentExecutionOwner, requireDefinitionMatchesRun, setRunAttributesIfCurrent, transitionRunAfterStaleLeaseRelease, transitionRunToCanceled, transitionRunToCompleted, transitionRunToExecutionWait, transitionRunToFailed, transitionRunToManualRetry, transitionRunToMissingImplementationWait, transitionRunToRescheduled, transitionRunToRunning, transitionRunToWaiting, updateRunMetadataIfCurrent, wakeParentRun };

package/dist/engine/step-api.d.mts

@@ -1,9 +1,6 @@
-import { WorkflowDeterministicApi, WorkflowStepApi } from "../types/step.mjs";
-import { WorkflowExecutionEnvironment } from "../types/engine.mjs";
-import { WorkflowChildWorkflowEngine } from "./child-workflow.mjs";
-import { WorkflowStepLockEngine } from "./lock.mjs";
+import { DeterministicApi, StepApi } from "../types/step.mjs";
+import { WorkflowEngine } from "./create.mjs";
+import { ExecutionEnvironment } from "../types/engine.mjs";
 //#region src/engine/step-api.d.ts
-type WorkflowStepRuntime = WorkflowChildWorkflowEngine & WorkflowStepLockEngine;
-declare function createStepApi(environment: WorkflowExecutionEnvironment, engine: WorkflowStepRuntime, executionSignal: AbortSignal, deterministic: WorkflowDeterministicApi): WorkflowStepApi;
-//#endregion
-export { createStepApi };
+export declare function createStepApi(environment: ExecutionEnvironment, engine: WorkflowEngine, executionSignal: AbortSignal, deterministic: DeterministicApi): StepApi;
+//#endregion

package/dist/engine/step-api.mjs

@@ -1,24 +1,24 @@
-import { createWorkflowStepWorkflowApi } from "./child-workflow.mjs";
-import { createWorkflowStepMessageApi } from "./message.mjs";
-import { createWorkflowStepHookApi } from "./hooks.mjs";
-import { createWorkflowStepLockApi } from "./lock.mjs";
-import { createWorkflowRunDataApi } from "./run-data.mjs";
-import { createWorkflowStepStreamApi } from "./stream.mjs";
-import { createWorkflowStepTaskApi } from "./task.mjs";
+import { createStepStreamApi } from "./stream.mjs";
+import { createStepMessageApi } from "./message.mjs";
+import { createStepHookApi } from "./hooks.mjs";
+import { createStepLockApi } from "./lock.mjs";
+import { createStepWorkflowApi } from "./child-workflow.mjs";
+import { createRunDataApi } from "./run-data.mjs";
+import { createStepTaskApi } from "./task.mjs";
 //#region src/engine/step-api.ts
 function createStepApi(environment, engine, executionSignal, deterministic) {
-	const task = createWorkflowStepTaskApi(environment, executionSignal);
-	const runTask = async (config, callback) => await task.run(config, callback);
+	const task = createStepTaskApi(environment, executionSignal);
+	const runTask = (config, callback) => task.run(config, callback);
 	return {
 		log: environment.logger,
-		task,
-		workflow: createWorkflowStepWorkflowApi(environment, engine),
-		message: createWorkflowStepMessageApi(environment),
-		lock: createWorkflowStepLockApi(environment, engine, runTask),
-		runData: createWorkflowRunDataApi(environment),
+		...task,
+		workflow: createStepWorkflowApi(environment, engine),
+		message: createStepMessageApi(environment),
+		lock: createStepLockApi(environment, engine, runTask),
+		runData: createRunDataApi(environment),
 		deterministic,
-		stream: createWorkflowStepStreamApi(environment),
-		hook: createWorkflowStepHookApi(environment)
+		stream: createStepStreamApi(environment),
+		hook: createStepHookApi(environment)
 	};
 }
 //#endregion

package/dist/engine/stream-reader.d.mts

@@ -0,0 +1,12 @@
+import { RunId, StreamIdOrName } from "../types/ids.mjs";
+import { FollowStreamOptions, ReadStreamOptions, StreamChunk, StreamInfo, StreamState, StreamUpdate, WaitStreamOptions } from "../types/stream.mjs";
+import { EngineContext } from "./context.mjs";
+import "temporal-polyfill/global";
+//#region src/engine/stream-reader.d.ts
+export declare function getStreamInfo(context: EngineContext, runId: RunId, streamIdOrName: StreamIdOrName): Promise<StreamInfo>;
+export declare function readStream(context: EngineContext, runId: RunId, streamIdOrName: StreamIdOrName, readOptions?: ReadStreamOptions): Promise<StreamState>;
+export declare function followStream(context: EngineContext, runId: RunId, streamIdOrName: StreamIdOrName, followOptions?: FollowStreamOptions): AsyncIterable<StreamUpdate>;
+export declare function waitForStream(context: EngineContext, runId: RunId, streamIdOrName: StreamIdOrName, waitOptions?: WaitStreamOptions): Promise<StreamInfo | undefined>;
+export declare function waitForStreamChunk(context: EngineContext, runId: RunId, streamIdOrName: StreamIdOrName, afterIndex: number, waitOptions?: WaitStreamOptions): Promise<StreamChunk | undefined>;
+export declare function waitForStreamTerminal(context: EngineContext, runId: RunId, streamIdOrName: StreamIdOrName, waitOptions?: WaitStreamOptions): Promise<StreamInfo | undefined>;
+//#endregion