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

package/dist/engine/summary/step-attempts.d.mts

@@ -1,11 +1,6 @@
-import { WorkflowStepAttemptRecord, WorkflowStepAttemptSummary } from "../../types/step-attempts.mjs";
-import { WorkflowRunRecord } from "../../types/run.mjs";
+import { StepAttemptRecord, StepAttemptSummary } from "../../types/step-attempts.mjs";
+import { RunRecord } from "../../types/run.mjs";
 //#region src/engine/summary/step-attempts.d.ts
-interface WorkflowStepAttemptSummaryReducer {
-  addAttempt(attempt: WorkflowStepAttemptRecord): void;
-  finish(): WorkflowStepAttemptSummary;
-}
-/** Creates a reducer for materialized step attempts and active child workflow records. */
-declare function createWorkflowStepAttemptSummaryReducer(childRuns?: readonly WorkflowRunRecord[]): WorkflowStepAttemptSummaryReducer;
-//#endregion
-export { WorkflowStepAttemptSummaryReducer, createWorkflowStepAttemptSummaryReducer };
+/** Summarizes one run's step attempts, with the child runs its workflow steps started. */
+export declare function summarizeStepAttempts(attempts: readonly StepAttemptRecord[], childRuns?: readonly RunRecord[]): StepAttemptSummary;
+//#endregion

package/dist/engine/summary/step-attempts.mjs

@@ -1,43 +1,164 @@
-import { makeWorkflowStepAttemptKey } from "../../history/attempt-key.mjs";
-import { createWorkflowStepAttemptActiveChildWorkflowSummaryReducer } from "./step-attempt-active-child-workflows.mjs";
-import { createWorkflowStepAttemptActiveMessageWaitSummaryReducer } from "./step-attempt-active-message-waits.mjs";
-import { createWorkflowStepAttemptActiveSleepSummaryReducer } from "./step-attempt-active-sleeps.mjs";
-import { createWorkflowStepAttemptBucketSummaryReducer } from "./step-attempt-buckets.mjs";
-import { createWorkflowStepAttemptFailureSummaryReducer } from "./step-attempt-failure.mjs";
-import { createWorkflowStepAttemptLifecycleSummaryReducer } from "./step-attempt-lifecycle.mjs";
+import { earliestOptionalTimestamp, latestOptionalTimestamp } from "../../temporal.mjs";
+import { stepAttemptKey } from "../../store-keys.mjs";
+import { Earliest, WaitTally, sorted } from "./tally.mjs";
+import { summarizeChildRuns } from "./runs.mjs";
 //#region src/engine/summary/step-attempts.ts
-/** Creates a reducer for materialized step attempts and active child workflow records. */
-function createWorkflowStepAttemptSummaryReducer(childRuns = []) {
-	const buckets = createWorkflowStepAttemptBucketSummaryReducer();
-	const lifecycle = createWorkflowStepAttemptLifecycleSummaryReducer();
-	const failure = createWorkflowStepAttemptFailureSummaryReducer();
-	const sleep = createWorkflowStepAttemptActiveSleepSummaryReducer();
-	const childWorkflow = createWorkflowStepAttemptActiveChildWorkflowSummaryReducer();
-	const messageWait = createWorkflowStepAttemptActiveMessageWaitSummaryReducer();
-	let total = 0;
+const STEP_ATTEMPT_STATUSES = [
+	"running",
+	"completed",
+	"failed",
+	"abandoned"
+];
+const STEP_TYPES = [
+	"run",
+	"sleep",
+	"workflow",
+	"message-send",
+	"message-wait",
+	"stream",
+	"deterministic"
+];
+/** Summarizes one run's step attempts, with the child runs its workflow steps started. */
+function summarizeStepAttempts(attempts, childRuns = []) {
+	const byStatus = new Buckets(STEP_ATTEMPT_STATUSES);
+	const byKind = new Buckets(STEP_TYPES);
+	const failure = new StepFailureTally();
+	const sleeps = {
+		stepIds: /* @__PURE__ */ new Set(),
+		attemptKeys: /* @__PURE__ */ new Set()
+	};
+	const nextSleep = new Earliest();
+	const messageWaits = new WaitTally();
+	const messages = /* @__PURE__ */ new Set();
+	const childWaits = new WaitTally();
+	const childRunIds = /* @__PURE__ */ new Set();
+	const workflows = /* @__PURE__ */ new Set();
+	let oldestRunningAt;
+	let latestFinishedAt;
+	for (const attempt of attempts) {
+		const attemptKey = stepAttemptKey(attempt.stepId, attempt.attempt);
+		byStatus.add(attempt.status, attempt.stepId, attemptKey);
+		byKind.add(attempt.kind, attempt.stepId, attemptKey);
+		failure.add(attempt, attemptKey);
+		latestFinishedAt = latestOptionalTimestamp(latestFinishedAt, attempt.finishedAt);
+		if (attempt.status !== "running") continue;
+		oldestRunningAt = earliestOptionalTimestamp(oldestRunningAt, attempt.startedAt);
+		const next = {
+			stepId: attempt.stepId,
+			attemptKey
+		};
+		if (attempt.kind === "sleep") {
+			sleeps.stepIds.add(attempt.stepId);
+			sleeps.attemptKeys.add(attemptKey);
+			nextSleep.offer(attempt.until, {
+				...next,
+				duration: attempt.duration instanceof Temporal.Duration ? attempt.duration : void 0
+			});
+		} else if (attempt.kind === "message-wait") {
+			messageWaits.add(attempt.stepId, attemptKey, attempt.startedAt);
+			messageWaits.next.offer(attempt.timeoutAt, next);
+			if (attempt.messageId !== void 0) messages.add(attempt.messageId);
+		} else if (attempt.kind === "workflow") {
+			childWaits.add(attempt.stepId, attemptKey, attempt.startedAt);
+			childWaits.next.offer(attempt.timeoutAt, next);
+			if (attempt.childRunId !== void 0) childRunIds.add(attempt.childRunId);
+			if (attempt.workflowName !== void 0) workflows.add(attempt.workflowVersion === void 0 ? attempt.workflowName : `${attempt.workflowName}@${attempt.workflowVersion}`);
+		}
+	}
 	return {
-		addAttempt(attempt) {
-			total++;
-			const attemptKey = makeWorkflowStepAttemptKey(attempt.stepId, attempt.attempt);
-			buckets.addAttempt(attempt, attemptKey);
-			lifecycle.addAttempt(attempt);
-			failure.addAttempt(attempt, attemptKey);
-			sleep.addAttempt(attempt, attemptKey);
-			childWorkflow.addAttempt(attempt, attemptKey);
-			messageWait.addAttempt(attempt, attemptKey);
+		total: attempts.length,
+		statusStepIds: byStatus.stepIds(),
+		statusAttemptKeys: byStatus.attemptKeys(),
+		kindStepIds: byKind.stepIds(),
+		kindAttemptKeys: byKind.attemptKeys(),
+		failure: failure.finish(),
+		oldestRunningAt,
+		latestFinishedAt,
+		sleep: sleeps.stepIds.size === 0 ? void 0 : {
+			stepIds: sorted(sleeps.stepIds),
+			attemptKeys: sorted(sleeps.attemptKeys),
+			next: nextSleep.next
 		},
-		finish() {
-			return {
-				total,
-				...buckets.finish(),
-				...lifecycle.finish(),
-				...failure.finish(),
-				...sleep.finish(),
-				...childWorkflow.finish(childRuns),
-				...messageWait.finish()
-			};
+		childWorkflow: childWaits.total === 0 ? void 0 : {
+			stepIds: sorted(childWaits.stepIds),
+			attemptKeys: sorted(childWaits.attemptKeys),
+			childRunIds: sorted(childRunIds),
+			workflows: sorted(workflows),
+			...summarizeChildRuns(childRuns.filter((run) => childRunIds.has(run.id))),
+			oldestStartedAt: childWaits.oldestStartedAt,
+			next: childWaits.next.next
+		},
+		message: messageWaits.total === 0 ? void 0 : {
+			stepIds: sorted(messageWaits.stepIds),
+			attemptKeys: sorted(messageWaits.attemptKeys),
+			messages: sorted(messages),
+			oldestStartedAt: messageWaits.oldestStartedAt,
+			next: messageWaits.next.next
 		}
 	};
 }
+/** Step IDs and attempt keys grouped by status or by kind. */
+var Buckets = class {
+	#keys;
+	#stepIds = /* @__PURE__ */ new Map();
+	#attemptKeys = /* @__PURE__ */ new Map();
+	constructor(keys) {
+		this.#keys = keys;
+	}
+	add(key, stepId, attemptKey) {
+		push(this.#stepIds, key, stepId);
+		push(this.#attemptKeys, key, attemptKey);
+	}
+	stepIds() {
+		return this.#sorted(this.#stepIds);
+	}
+	attemptKeys() {
+		return this.#sorted(this.#attemptKeys);
+	}
+	#sorted(lists) {
+		return Object.fromEntries(this.#keys.map((key) => [key, sorted(lists.get(key) ?? [])]));
+	}
+};
+function push(lists, key, value) {
+	const list = lists.get(key);
+	if (list === void 0) lists.set(key, [value]);
+	else list.push(value);
+}
+/** Failed step attempts grouped by error name. */
+var StepFailureTally = class {
+	#latestFailedAt;
+	#failedStepIds = /* @__PURE__ */ new Set();
+	#failedAttemptKeys = /* @__PURE__ */ new Set();
+	#errors = /* @__PURE__ */ new Map();
+	add(attempt, attemptKey) {
+		if (attempt.status !== "failed") return;
+		this.#failedStepIds.add(attempt.stepId);
+		this.#failedAttemptKeys.add(attemptKey);
+		this.#latestFailedAt = latestOptionalTimestamp(this.#latestFailedAt, attempt.finishedAt);
+		const name = attempt.error?.name ?? "Error";
+		const error = this.#errors.get(name) ?? {
+			failedStepIds: /* @__PURE__ */ new Set(),
+			failedAttemptKeys: /* @__PURE__ */ new Set()
+		};
+		error.failedStepIds.add(attempt.stepId);
+		error.failedAttemptKeys.add(attemptKey);
+		error.latestFailedAt = latestOptionalTimestamp(error.latestFailedAt, attempt.finishedAt);
+		this.#errors.set(name, error);
+	}
+	finish() {
+		if (this.#failedAttemptKeys.size === 0) return;
+		return {
+			stepIds: sorted(this.#failedStepIds),
+			attemptKeys: sorted(this.#failedAttemptKeys),
+			errors: [...this.#errors.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([name, error]) => ({
+				name,
+				stepIds: sorted(error.failedStepIds),
+				attemptKeys: sorted(error.failedAttemptKeys),
+				latestFailedAt: error.latestFailedAt
+			})),
+			latestFailedAt: this.#latestFailedAt
+		};
+	}
+};
 //#endregion
-export { createWorkflowStepAttemptSummaryReducer };
+export { summarizeStepAttempts };

package/dist/engine/summary/tally.d.mts

@@ -0,0 +1,44 @@
+import { RunFailureSummary, RunRetrySummary } from "../../types/summary.mjs";
+import { RunRecord } from "../../types/run.mjs";
+//#region src/engine/summary/tally.d.ts
+export declare const RUN_STATUSES: readonly ["pending", "running", "waiting", "completed", "failed", "canceled"];
+export declare const TERMINAL_RUN_STATUSES: readonly ["completed", "failed", "canceled"];
+export declare const RUN_TRANSITION_REASONS: readonly ["created", "claimed", "reclaimed", "started", "waiting", "rescheduled", "lease_released", "manual_retry", "permanent_failure", "retry", "missing_implementation", "completed", "failed", "deadline", "canceled"];
+/** Keeps the entry with the earliest instant. Ties keep the first entry. */
+export declare class Earliest<T extends object> {
+  #private;
+  get at(): Temporal.Instant | undefined;
+  get next(): (T & {
+    readonly at: Temporal.Instant;
+  }) | undefined;
+  offer(at: Temporal.Instant | undefined, value: T): void;
+}
+export declare function sorted(values: Iterable<string>): readonly string[];
+/** Sorted values, or `undefined` when there are none. */
+export declare function sortedOrUndefined(values: ReadonlySet<string>): readonly string[] | undefined;
+export declare function counts<const TKey extends string>(keys: readonly TKey[]): Record<TKey, number>;
+/** Runs scheduled for a retry: why, which steps, and which retry comes next. */
+export declare class RetryTally {
+  #private;
+  get total(): number;
+  add(run: RunRecord): void;
+  runIds(): readonly string[] | undefined;
+  finish(): RunRetrySummary;
+}
+/** Failed runs grouped by error name. */
+export declare class FailureTally {
+  #private;
+  get total(): number;
+  add(run: RunRecord): void;
+  finish(): RunFailureSummary;
+}
+/** Waits of one kind across runs: who waits, since when, and which wait ends first. */
+export declare class WaitTally<TNext extends object> {
+  total: number;
+  oldestStartedAt: Temporal.Instant | undefined;
+  readonly next: Earliest<TNext>;
+  readonly stepIds: Set<string>;
+  readonly attemptKeys: Set<string>;
+  add(stepId: string, attemptKey: string | undefined, startedAt: Temporal.Instant | undefined): void;
+}
+//#endregion

package/dist/engine/summary/tally.mjs

@@ -0,0 +1,142 @@
+import { earliestOptionalTimestamp, latestOptionalTimestamp } from "../../temporal.mjs";
+import { greatestOptionalNumber } from "../../values.mjs";
+import { isScheduledRunStatus } from "../../run-status.mjs";
+//#region src/engine/summary/tally.ts
+const RUN_STATUSES = [
+	"pending",
+	"running",
+	"waiting",
+	"completed",
+	"failed",
+	"canceled"
+];
+const TERMINAL_RUN_STATUSES = [
+	"completed",
+	"failed",
+	"canceled"
+];
+const RUN_TRANSITION_REASONS = [
+	"created",
+	"claimed",
+	"reclaimed",
+	"started",
+	"waiting",
+	"rescheduled",
+	"lease_released",
+	"manual_retry",
+	"permanent_failure",
+	"retry",
+	"missing_implementation",
+	"completed",
+	"failed",
+	"deadline",
+	"canceled"
+];
+const RUN_RETRY_REASONS = [
+	"workflow",
+	"step",
+	"missing_implementation"
+];
+/** Keeps the entry with the earliest instant. Ties keep the first entry. */
+var Earliest = class {
+	#next;
+	get at() {
+		return this.#next?.at;
+	}
+	get next() {
+		return this.#next;
+	}
+	offer(at, value) {
+		if (at !== void 0 && (this.#next === void 0 || Temporal.Instant.compare(at, this.#next.at) < 0)) this.#next = {
+			...value,
+			at
+		};
+	}
+};
+function sorted(values) {
+	return [...values].sort();
+}
+/** Sorted values, or `undefined` when there are none. */
+function sortedOrUndefined(values) {
+	return values.size === 0 ? void 0 : sorted(values);
+}
+function counts(keys) {
+	return Object.fromEntries(keys.map((key) => [key, 0]));
+}
+/** Runs scheduled for a retry: why, which steps, and which retry comes next. */
+var RetryTally = class {
+	#highestAttempt;
+	#next = new Earliest();
+	#reason = counts(RUN_RETRY_REASONS);
+	#runIds = /* @__PURE__ */ new Set();
+	#stepNames = /* @__PURE__ */ new Set();
+	get total() {
+		return this.#runIds.size;
+	}
+	add(run) {
+		if (!isScheduledRunStatus(run.status) || run.retryReason === void 0) return;
+		this.#runIds.add(run.id);
+		this.#reason[run.retryReason]++;
+		if (run.retryStepName !== void 0) this.#stepNames.add(run.retryStepName);
+		this.#highestAttempt = greatestOptionalNumber(this.#highestAttempt, run.retryAttempt);
+		this.#next.offer(run.retryAt, { runId: run.id });
+	}
+	runIds() {
+		return sortedOrUndefined(this.#runIds);
+	}
+	finish() {
+		return {
+			count: this.#runIds.size,
+			stepNames: sorted(this.#stepNames),
+			reason: this.#reason,
+			highestAttempt: this.#highestAttempt,
+			next: this.#next.next
+		};
+	}
+};
+/** Failed runs grouped by error name. */
+var FailureTally = class {
+	#latestFailedAt;
+	#failedRunIds = /* @__PURE__ */ new Set();
+	#errors = /* @__PURE__ */ new Map();
+	get total() {
+		return this.#failedRunIds.size;
+	}
+	add(run) {
+		if (run.status !== "failed") return;
+		this.#failedRunIds.add(run.id);
+		this.#latestFailedAt = latestOptionalTimestamp(this.#latestFailedAt, run.finishedAt);
+		const name = run.error?.name ?? "Error";
+		const error = this.#errors.get(name) ?? { failedRunIds: /* @__PURE__ */ new Set() };
+		error.failedRunIds.add(run.id);
+		error.latestFailedAt = latestOptionalTimestamp(error.latestFailedAt, run.finishedAt);
+		this.#errors.set(name, error);
+	}
+	finish() {
+		return {
+			count: this.#failedRunIds.size,
+			errors: [...this.#errors.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([name, error]) => ({
+				name,
+				count: error.failedRunIds.size,
+				latestFailedAt: error.latestFailedAt
+			})),
+			latestFailedAt: this.#latestFailedAt
+		};
+	}
+};
+/** Waits of one kind across runs: who waits, since when, and which wait ends first. */
+var WaitTally = class {
+	total = 0;
+	oldestStartedAt;
+	next = new Earliest();
+	stepIds = /* @__PURE__ */ new Set();
+	attemptKeys = /* @__PURE__ */ new Set();
+	add(stepId, attemptKey, startedAt) {
+		this.total++;
+		this.stepIds.add(stepId);
+		if (attemptKey !== void 0) this.attemptKeys.add(attemptKey);
+		this.oldestStartedAt = earliestOptionalTimestamp(this.oldestStartedAt, startedAt);
+	}
+};
+//#endregion
+export { Earliest, FailureTally, RUN_STATUSES, RUN_TRANSITION_REASONS, RetryTally, TERMINAL_RUN_STATUSES, WaitTally, counts, sorted, sortedOrUndefined };

package/dist/engine/task.d.mts

@@ -1,6 +1,5 @@
-import { WorkflowStepTaskApi } from "../types/step.mjs";
-import { WorkflowExecutionEnvironment } from "../types/engine.mjs";
+import { StepTaskApi } from "../types/step.mjs";
+import { ExecutionEnvironment } from "../types/engine.mjs";
 //#region src/engine/task.d.ts
-declare function createWorkflowStepTaskApi(environment: WorkflowExecutionEnvironment, executionSignal: AbortSignal): WorkflowStepTaskApi;
-//#endregion
-export { createWorkflowStepTaskApi };
+export declare function createStepTaskApi(environment: ExecutionEnvironment, executionSignal: AbortSignal): StepTaskApi;
+//#endregion

package/dist/engine/task.mjs

@@ -1,22 +1,22 @@
 import { WorkflowDurationError, WorkflowNonRetryableError } from "../errors/failures.mjs";
-import { isAbortError, safeDuration } from "../utility.mjs";
 import { WorkflowStepExecutionError, WorkflowStepRetryLimitError, WorkflowStepTimeoutError } from "../errors/step.mjs";
 import "../errors/mod.mjs";
-import { WORKFLOW_ATTRIBUTES, withStepTelemetry } from "../telemetry.mjs";
+import { isAbortError, safeDuration } from "../values.mjs";
 import { serializeError, toOptionalPersistedValue } from "./serialization.mjs";
-import { nextRetryAt, resolveWorkflowRetryConfig, retryClassificationRetryAt } from "./retry.mjs";
-import { WorkflowSuspended } from "./state.mjs";
-import { resolveWorkflowCommandIdentityFromCandidates } from "./command-identity.mjs";
-import { appendDurableStepStartedEvent, appendDurableStepTerminalEvent } from "./durable-command.mjs";
-import { isRunStepTerminalForStartedAttempt, recordedStepCompletionTimestamp, requireRecordedDurableStepStarted, requireRunStepReplayTimeoutMatches, sleepUntil } from "./replay.mjs";
+import { nextRetryAt, resolveRetryConfig, retryClassificationRetryAt } from "./retry.mjs";
+import { Suspended } from "./signals.mjs";
+import { resolveCommandIdentityFromCandidates } from "./command-identity.mjs";
+import { appendDurableEvent, appendDurableStepStartedEvent } from "./durable-command.mjs";
+import { WORKFLOW_ATTRIBUTES, withStepTelemetry } from "../telemetry.mjs";
+import { isRunStepTerminalForStartedAttempt, recordedInstant, requireRecordedDurableStepStarted, requireRunStepReplayTimeoutMatches, sleepUntil } from "./replay.mjs";
 //#region src/engine/task.ts
-function createWorkflowStepTaskApi(environment, executionSignal) {
+function createStepTaskApi(environment, executionSignal) {
 	const { runId, history, now, limits, executionOwner, telemetry } = environment;
 	const run = async (config, callback) => {
-		const identity = resolveWorkflowCommandIdentityFromCandidates(history, "run", [config.commandId, config.name], "Workflow step name or commandId");
+		const identity = resolveCommandIdentityFromCandidates(history, "run", [config.commandId, config.name], "Workflow step name or commandId");
 		const timeout = config.timeout === void 0 ? void 0 : (() => {
 			const value = safeDuration(config.timeout.total({ unit: "millisecond" }), "Workflow step timeout");
-			if (value <= 0) WorkflowDurationError.stepTimeoutPositive();
+			if (value <= 0) throw new WorkflowDurationError("Workflow step timeout must be greater than zero");
 			return value;
 		})();
 		const started = history.startedStep(identity.id);
@@ -24,41 +24,41 @@ function createWorkflowStepTaskApi(environment, executionSignal) {
 		if (completed !== void 0 && (started === void 0 || isRunStepTerminalForStartedAttempt(completed, started))) {
 			requireRecordedDurableStepStarted(identity, history.hasStartedEventBeforeTerminalEvent(completed));
 			requireRunStepReplayTimeoutMatches(identity, started, config);
-			recordedStepCompletionTimestamp(identity, completed.timestamp);
+			recordedInstant("run", identity, "completion", completed.timestamp);
 			return completed.result;
 		}
 		if (history.unstartedFailedStep(identity.id) !== void 0) requireRecordedDurableStepStarted(identity, false);
-		const retry = resolveWorkflowRetryConfig(config.retry, {
+		const retry = resolveRetryConfig(config.retry, {
 			maximumAttempts: 10,
 			backoffCoefficient: 2
 		}, "Workflow step retry");
 		let attempt = history.nextStepAttempt(identity.id);
 		while (retry.maximumAttempts === 0 || attempt <= retry.maximumAttempts) {
 			const startedAt = now();
-			const timestamp = startedAt;
 			const timeoutAt = timeout === void 0 ? void 0 : startedAt.add(Temporal.Duration.from({ milliseconds: timeout }));
-			await appendDurableStepStartedEvent(environment, {
+			const startedEvent = {
 				kind: "step_started",
-				timestamp,
+				timestamp: startedAt,
 				stepId: identity.id,
 				stepName: identity.name,
 				count: identity.count,
 				attempt,
-				...timeoutAt === void 0 ? {} : { timeoutAt }
-			});
+				timeoutAt
+			};
+			await appendDurableStepStartedEvent(environment, startedEvent);
+			const telemetryContext = {
+				run: executionOwner,
+				step: {
+					id: identity.id,
+					name: identity.name,
+					count: identity.count,
+					kind: "run"
+				},
+				attempt,
+				retry,
+				timeoutAt
+			};
 			try {
-				const telemetryContext = {
-					run: executionOwner,
-					step: {
-						id: identity.id,
-						name: identity.name,
-						count: identity.count,
-						kind: "run"
-					},
-					attempt,
-					retry,
-					...timeoutAt === void 0 ? {} : { timeoutAt }
-				};
 				const result = await withStepTelemetry(telemetry, telemetryContext, async () => {
 					return await runStepCallbackWithTimeout(callback, createStepContext(identity, attempt, retry, executionSignal, environment.logger.child({
 						[WORKFLOW_ATTRIBUTES.stepId]: identity.id,
@@ -79,34 +79,26 @@ function createWorkflowStepTaskApi(environment, executionSignal) {
 					telemetry?.recordStepExecution?.(telemetryContext);
 				} catch {}
 				const persistedResult = toOptionalPersistedValue(result, "step result", limits);
-				await appendDurableStepTerminalEvent(environment, {
+				const completedEvent = {
 					kind: "step_completed",
 					timestamp: now(),
 					stepId: identity.id,
 					stepName: identity.name,
 					attempt,
-					...persistedResult === void 0 ? {} : { result: persistedResult }
-				});
+					result: persistedResult
+				};
+				await appendDurableEvent(environment, completedEvent);
 				return result;
 			} catch (error) {
 				if (executionSignal.aborted && isAbortError(error)) throw error;
 				try {
 					telemetry?.recordStepExecution?.({
-						run: executionOwner,
-						step: {
-							id: identity.id,
-							name: identity.name,
-							count: identity.count,
-							kind: "run"
-						},
-						attempt,
-						retry,
-						...timeoutAt === void 0 ? {} : { timeoutAt },
+						...telemetryContext,
 						error
 					});
 				} catch {}
 				const failedAt = now();
-				await appendDurableStepTerminalEvent(environment, {
+				await appendDurableEvent(environment, {
 					kind: "step_failed",
 					timestamp: failedAt,
 					stepId: identity.id,
@@ -121,7 +113,7 @@ function createWorkflowStepTaskApi(environment, executionSignal) {
 					cause: error
 				});
 				const retryAt = retryClassificationRetryAt(failedAt, error, "Workflow step retry classification") ?? nextRetryAt(failedAt, retry, attempt, "Workflow step retry delay");
-				if (retryAt !== void 0) WorkflowSuspended.forStepRetry(retryAt, identity, attempt + 1);
+				if (retryAt !== void 0) Suspended.forStepRetry(retryAt, identity, attempt + 1);
 				attempt++;
 			}
 		}
@@ -129,7 +121,7 @@ function createWorkflowStepTaskApi(environment, executionSignal) {
 			stepId: identity.id,
 			stepName: identity.name,
 			attempt,
-			cause: WorkflowStepRetryLimitError.create({
+			cause: new WorkflowStepRetryLimitError({
 				stepId: identity.id,
 				stepName: identity.name,
 				attempt
@@ -140,7 +132,7 @@ function createWorkflowStepTaskApi(environment, executionSignal) {
 		run,
 		async call(definition, ...args) {
 			return await run(definition.config, async (context) => {
-				return await definition.handler(...args, context);
+				return await definition.handler(context, ...args);
 			});
 		},
 		async sleep(commandId, duration) {
@@ -183,7 +175,7 @@ async function runStepCallbackWithTimeout(callback, context, timeout) {
 	let timeoutHandle;
 	const timeoutPromise = new Promise((_resolve, reject) => {
 		timeoutHandle = setTimeout(() => {
-			const error = WorkflowStepTimeoutError.create({
+			const error = new WorkflowStepTimeoutError({
 				runId: timeout.runId,
 				stepId: timeout.stepId,
 				stepName: timeout.stepName,
@@ -205,4 +197,4 @@ async function runStepCallbackWithTimeout(callback, context, timeout) {
 	}
 }
 //#endregion
-export { createWorkflowStepTaskApi };
+export { createStepTaskApi };