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

package/dist/worker/error.d.mts

@@ -1,12 +1,5 @@
-import { WorkflowResolvedMissingImplementationRetryConfig } from "../types/retry.mjs";
-import { WorkflowRunRecord } from "../types/run.mjs";
 import { WorkflowErrorRecord } from "../types/error.mjs";
 import "temporal-polyfill/global";
 //#region src/worker/error.d.ts
-declare const DEFAULT_MISSING_IMPLEMENTATION_RETRY_INTERVAL: Temporal.Duration;
-declare function makeMissingImplementationNotFoundErrorRecord(run: WorkflowRunRecord): WorkflowErrorRecord;
-declare function makeMissingImplementationDeadlineErrorRecord(run: WorkflowRunRecord, deadlineAt: Temporal.Instant): WorkflowErrorRecord;
-declare function missingImplementationRetryDelay(retry: WorkflowResolvedMissingImplementationRetryConfig, retryAttempt: number): Temporal.Duration;
-declare function toWorkflowWorkerErrorRecord(error: unknown): WorkflowErrorRecord;
-//#endregion
-export { DEFAULT_MISSING_IMPLEMENTATION_RETRY_INTERVAL, makeMissingImplementationDeadlineErrorRecord, makeMissingImplementationNotFoundErrorRecord, missingImplementationRetryDelay, toWorkflowWorkerErrorRecord };
+export declare function toWorkerErrorRecord(cause: unknown): WorkflowErrorRecord;
+//#endregion

package/dist/worker/error.mjs

@@ -1,41 +1,29 @@
-import { WorkflowOptionsError } from "../errors/base.mjs";
-import { WorkflowRunDeadlineExceededError } from "../errors/run.mjs";
-import { durationTotal, isPositiveSafeInteger, safeDuration } from "../utility.mjs";
 import { WorkflowImplementationNotFoundError } from "../errors/implementation.mjs";
+import { WorkflowRunDeadlineExceededError } from "../errors/run.mjs";
 import "temporal-polyfill/global";
 //#region src/worker/error.ts
-const DEFAULT_MISSING_IMPLEMENTATION_RETRY_INTERVAL = Temporal.Duration.from({ seconds: 30 });
-function makeMissingImplementationNotFoundErrorRecord(run) {
-	return toWorkflowWorkerErrorRecord(WorkflowImplementationNotFoundError.create(run.workflowName, run.workflowVersion));
-}
-function makeMissingImplementationDeadlineErrorRecord(run, deadlineAt) {
-	return toWorkflowWorkerErrorRecord(WorkflowRunDeadlineExceededError.create(run.id, deadlineAt));
-}
-function missingImplementationRetryDelay(retry, retryAttempt) {
-	if (!isPositiveSafeInteger(retryAttempt)) WorkflowOptionsError.missingImplementationRetryAttemptPositiveSafeInteger();
-	const exponentialDelay = durationTotal(retry.initialInterval) * retry.backoffCoefficient ** Math.max(0, retryAttempt - 1);
-	const delay = retry.maximumInterval === void 0 ? exponentialDelay : Math.min(exponentialDelay, durationTotal(retry.maximumInterval));
-	safeDuration(delay, "Workflow missing implementation retry delay");
-	return Temporal.Duration.from({ milliseconds: delay });
-}
-function toWorkflowWorkerErrorRecord(error) {
-	if (!(error instanceof Error)) return {
+function toWorkerErrorRecord(cause) {
+	if (!(cause instanceof Error)) return {
 		name: "WorkflowNonErrorThrow",
-		message: String(error)
+		message: String(cause)
 	};
 	return {
-		name: error.name,
-		message: error.message,
-		...error.stack === void 0 ? {} : { stack: error.stack },
-		...error instanceof WorkflowRunDeadlineExceededError ? { details: {
-			runId: error.runId,
-			deadlineAt: error.deadlineAt.toString()
-		} } : {},
-		...error instanceof WorkflowImplementationNotFoundError ? { details: {
-			workflowName: error.workflowName,
-			...error.workflowVersion === void 0 ? {} : { workflowVersion: error.workflowVersion }
-		} } : {}
+		name: cause.name,
+		message: cause.message,
+		stack: cause.stack,
+		details: errorRecordDetails(cause)
+	};
+}
+function errorRecordDetails(cause) {
+	if (cause instanceof WorkflowRunDeadlineExceededError) return {
+		runId: cause.runId,
+		deadlineAt: cause.deadlineAt.toString()
 	};
+	if (cause instanceof WorkflowImplementationNotFoundError) {
+		const details = { workflowName: cause.workflowName };
+		if (cause.workflowVersion !== void 0) details.workflowVersion = cause.workflowVersion;
+		return details;
+	}
 }
 //#endregion
-export { DEFAULT_MISSING_IMPLEMENTATION_RETRY_INTERVAL, makeMissingImplementationDeadlineErrorRecord, makeMissingImplementationNotFoundErrorRecord, missingImplementationRetryDelay, toWorkflowWorkerErrorRecord };
+export { toWorkerErrorRecord };

package/dist/worker/missing-implementation.d.mts

@@ -0,0 +1,19 @@
+import { RunId } from "../types/ids.mjs";
+import { ResolvedMissingImplementationRetryConfig } from "../types/retry.mjs";
+import { ExecutionResult } from "../types/result.mjs";
+import { RunRecord } from "../types/run.mjs";
+import { WorkflowStore } from "../types/store.mjs";
+import "temporal-polyfill/global";
+//#region src/worker/missing-implementation.d.ts
+interface MissingImplementationContext {
+  readonly store: WorkflowStore;
+  readonly now: () => Temporal.Instant;
+  readonly retry: ResolvedMissingImplementationRetryConfig;
+  readonly readResult: (runId: RunId) => Promise<ExecutionResult<unknown>>;
+}
+/** Retries a run whose implementation is not registered, or fails it once retries or its deadline run out. */
+export declare function handleMissingImplementation(context: MissingImplementationContext, run: RunRecord): Promise<ExecutionResult<unknown>>;
+export declare const DEFAULT_RETRY_INTERVAL: Temporal.Duration;
+export declare function retryDelay(retry: ResolvedMissingImplementationRetryConfig, retryAttempt: number): Temporal.Duration;
+//#endregion
+export {};

package/dist/worker/missing-implementation.mjs

@@ -0,0 +1,62 @@
+import { durationTotal } from "../temporal.mjs";
+import { WorkflowErrorCode } from "../errors/codes.mjs";
+import { WorkflowOptionsError } from "../errors/base.mjs";
+import { WorkflowImplementationNotFoundError } from "../errors/implementation.mjs";
+import { WorkflowRunDeadlineExceededError } from "../errors/run.mjs";
+import { isPositiveSafeInteger, safeDuration } from "../values.mjs";
+import { patchRunIfCurrent, transitionRunToFailed, transitionRunToMissingImplementationWait, wakeParentRun } from "../engine/state.mjs";
+import { nonNegativeTimerDelay } from "../timer.mjs";
+import { toWorkerErrorRecord } from "./error.mjs";
+import "temporal-polyfill/global";
+//#region src/worker/missing-implementation.ts
+/** Retries a run whose implementation is not registered, or fails it once retries or its deadline run out. */
+async function handleMissingImplementation(context, run) {
+	const timestamp = context.now();
+	const retryAttempt = run.attempts ?? (run.retryAttempt ?? 0) + 1;
+	const errorRecord = toWorkerErrorRecord(new WorkflowImplementationNotFoundError(run.workflowName, run.workflowVersion));
+	const deadlineAt = run.deadlineAt;
+	if (deadlineAt !== void 0 && Temporal.Instant.compare(deadlineAt, timestamp) <= 0) return await fail(context, run, deadlineErrorRecord(run, deadlineAt), timestamp, "deadline", deadlineAt);
+	if (context.retry.maximumAttempts > 0 && retryAttempt >= context.retry.maximumAttempts) return await fail(context, run, errorRecord, timestamp, "failed");
+	let availableAt;
+	try {
+		availableAt = timestamp.add(Temporal.Duration.from({ milliseconds: nonNegativeTimerDelay(retryDelay(context.retry, retryAttempt), "Workflow missing implementation retry delay").clampedDelay }));
+	} catch (retryError) {
+		return await fail(context, run, toWorkerErrorRecord(retryError), timestamp, "failed");
+	}
+	if (deadlineAt !== void 0 && Temporal.Instant.compare(deadlineAt, availableAt) <= 0) return await fail(context, run, deadlineErrorRecord(run, deadlineAt), timestamp, "deadline", deadlineAt);
+	const waitingRun = await patchRunIfCurrent(context.store, run, transitionRunToMissingImplementationWait(run, errorRecord, timestamp, availableAt, retryAttempt));
+	if (waitingRun === void 0) return await context.readResult(run.id);
+	await wakeParentRun(context.store, waitingRun, availableAt);
+	return {
+		kind: "waiting",
+		run: waitingRun,
+		availableAt
+	};
+}
+async function fail(context, run, errorRecord, timestamp, reason, deadlineAt) {
+	const failedRun = await patchRunIfCurrent(context.store, run, transitionRunToFailed(run, errorRecord, timestamp, reason, deadlineAt));
+	if (failedRun === void 0) return await context.readResult(run.id);
+	if (await context.store.appendEventIfRunCurrent(failedRun, {
+		kind: "workflow_failed",
+		timestamp
+	}) === void 0) return await context.readResult(run.id);
+	await wakeParentRun(context.store, failedRun, timestamp);
+	return {
+		kind: "failed",
+		run: failedRun,
+		error: errorRecord
+	};
+}
+const DEFAULT_RETRY_INTERVAL = Temporal.Duration.from({ seconds: 30 });
+function deadlineErrorRecord(run, deadlineAt) {
+	return toWorkerErrorRecord(new WorkflowRunDeadlineExceededError(run.id, deadlineAt));
+}
+function retryDelay(retry, retryAttempt) {
+	if (!isPositiveSafeInteger(retryAttempt)) throw new WorkflowOptionsError("Workflow missing implementation retry delay attempt must be a positive safe integer", { code: WorkflowErrorCode.OPTIONS_MISSING_IMPLEMENTATION_RETRY_ATTEMPT_INVALID });
+	const exponentialDelay = durationTotal(retry.initialInterval) * retry.backoffCoefficient ** Math.max(0, retryAttempt - 1);
+	const delay = retry.maximumInterval === void 0 ? exponentialDelay : Math.min(exponentialDelay, durationTotal(retry.maximumInterval));
+	safeDuration(delay, "Workflow missing implementation retry delay");
+	return Temporal.Duration.from({ milliseconds: delay });
+}
+//#endregion
+export { DEFAULT_RETRY_INTERVAL, handleMissingImplementation, retryDelay };

package/dist/worker/worker.d.mts

@@ -0,0 +1,18 @@
+import { RunId } from "../types/ids.mjs";
+import { ExecutionResult } from "../types/result.mjs";
+import { RunRecord } from "../types/run.mjs";
+import { CreateWorkflowWorkerOptions, WorkerLeaseOptions, WorkerRunFilterOptions, WorkerRunOptions, WorkerRunResult, WorkflowWorker as WorkflowWorker$1 } from "../types/worker.mjs";
+import "temporal-polyfill/global";
+//#region src/worker/worker.d.ts
+/** Storage-backed workflow worker implementation. */
+export declare class WorkflowWorker implements WorkflowWorker$1 {
+  #private;
+  constructor(options: CreateWorkflowWorkerOptions);
+  processRun(runId: RunId): Promise<ExecutionResult<unknown>>;
+  processNextRun(options?: WorkerRunFilterOptions): Promise<ExecutionResult<unknown> | undefined>;
+  extendLease(runId: RunId, options?: WorkerLeaseOptions): Promise<RunRecord | undefined>;
+  releaseLease(runId: RunId, options?: WorkerLeaseOptions): Promise<RunRecord | undefined>;
+  run(options?: WorkerRunOptions): Promise<WorkerRunResult>;
+  stop(): Promise<void>;
+}
+//#endregion

package/dist/{worker.mjs → worker/worker.mjs}

@@ -1,15 +1,17 @@
-import { WorkflowStateError } from "./errors/base.mjs";
-import { WorkflowRunNotFoundError } from "./errors/run.mjs";
-import { createDefaultWorkerId, isPositiveSafeInteger, resolvePositiveSafeIntegerOption } from "./utility.mjs";
-import { WorkflowCapabilityError } from "./errors/capability.mjs";
-import { durationBetween } from "./temporal.mjs";
-import { MAX_TIMER_DELAY, nonNegativeTimerDelay, positiveTimerDelay } from "./timer.mjs";
-import { resolveMissingImplementationRetryConfig } from "./engine/retry.mjs";
-import { patchRunIfCurrent, transitionRunToFailed, transitionRunToMissingImplementationWait, wakeParentRunForTerminalChild, wakeParentRunForWaitingChild } from "./engine/state.mjs";
-import { requireWorkflowStoreCapabilities } from "./store/capabilities.mjs";
-import { DEFAULT_MISSING_IMPLEMENTATION_RETRY_INTERVAL, makeMissingImplementationDeadlineErrorRecord, makeMissingImplementationNotFoundErrorRecord, missingImplementationRetryDelay, toWorkflowWorkerErrorRecord } from "./worker/error.mjs";
+import { durationBetween, earliestOptionalTimestamp } from "../temporal.mjs";
+import { WorkflowErrorCode } from "../errors/codes.mjs";
+import { WorkflowStateError } from "../errors/base.mjs";
+import { WorkflowCapabilityError } from "../errors/capability.mjs";
+import { createDefaultWorkerId } from "../ids.mjs";
+import { isPositiveSafeInteger, resolvePositiveSafeIntegerOption } from "../values.mjs";
+import { requireStoreCapabilities } from "../store/capabilities.mjs";
+import { getRequiredRun } from "../store/query.mjs";
+import { resolveMissingImplementationRetryConfig } from "../engine/retry.mjs";
+import { unfinishedRunResult } from "../engine/run-utils.mjs";
+import { MAX_TIMER_DELAY, nonNegativeTimerDelay, positiveTimerDelay } from "../timer.mjs";
+import { DEFAULT_RETRY_INTERVAL, handleMissingImplementation } from "./missing-implementation.mjs";
 import "temporal-polyfill/global";
-//#region src/worker.ts
+//#region src/worker/worker.ts
 const DEFAULT_WORKER_LEASE_DURATION = Temporal.Duration.from({ seconds: 30 });
 const DEFAULT_WORKER_POLL_INTERVAL = Temporal.Duration.from({ milliseconds: 100 });
 const DEFAULT_WORKER_STOP_DRAIN_TIMEOUT = Temporal.Duration.from({ seconds: 30 });
@@ -32,14 +34,14 @@ var WorkflowWorker = class {
 	#activeExecutionRuns = /* @__PURE__ */ new Map();
 	constructor(options) {
 		const store = options.engine.store;
-		requireWorkflowStoreCapabilities(store, {
-			conditionalRunClaims: "workflow worker conditional run claims",
-			conditionalRunUpdates: "workflow worker conditional run updates",
-			conditionalRunLeaseExtensions: "workflow worker conditional lease extensions",
-			conditionalRunLeaseReleases: "workflow worker conditional lease releases",
-			conditionalEventAppends: "workflow worker conditional event appends",
-			reconcilesStepAttemptsFromEvents: "workflow worker step-attempt reconciliation"
-		});
+		requireStoreCapabilities(store, [
+			["conditionalRunClaims", "workflow worker conditional run claims"],
+			["conditionalRunUpdates", "workflow worker conditional run updates"],
+			["conditionalRunLeaseExtensions", "workflow worker conditional lease extensions"],
+			["conditionalRunLeaseReleases", "workflow worker conditional lease releases"],
+			["conditionalEventAppends", "workflow worker conditional event appends"],
+			["reconcilesStepAttemptsFromEvents", "workflow worker step-attempt reconciliation"]
+		]);
 		this.#engine = options.engine;
 		this.#store = store;
 		this.#registry = options.registry;
@@ -50,7 +52,7 @@ var WorkflowWorker = class {
 		this.#stopDrainTimeout = nonNegativeTimerDelay(options.stopDrainTimeout ?? DEFAULT_WORKER_STOP_DRAIN_TIMEOUT, "Workflow worker stopDrainTimeout").clampedDelay;
 		this.#defaultPollInterval = nonNegativeTimerDelay(options.pollInterval ?? DEFAULT_WORKER_POLL_INTERVAL, "Workflow worker pollInterval").clampedDelay;
 		this.#missingImplementationRetry = resolveMissingImplementationRetryConfig(options.missingImplementationRetry, {
-			initialInterval: DEFAULT_MISSING_IMPLEMENTATION_RETRY_INTERVAL,
+			initialInterval: DEFAULT_RETRY_INTERVAL,
 			backoffCoefficient: 2,
 			maximumAttempts: 0
 		}, "Workflow missing implementation retry options");
@@ -59,10 +61,16 @@ var WorkflowWorker = class {
 	async processRun(runId) {
 		this.#stopRequested = false;
 		const run = await this.#claimRun({ runId });
-		if (run === void 0) WorkflowStateError.runNotClaimable(runId);
+		if (run === void 0) throw new WorkflowStateError(`Workflow run is not claimable: ${runId}`, {
+			code: WorkflowErrorCode.STATE_RUN_NOT_CLAIMABLE,
+			details: { runId }
+		});
 		if (this.#stopRequested) {
 			await this.#releaseLease(run.id, run.attempts);
-			WorkflowStateError.workerStoppedBeforeRun(runId);
+			throw new WorkflowStateError(`Workflow worker stopped before executing run: ${runId}`, {
+				code: WorkflowErrorCode.STATE_WORKER_STOPPED_BEFORE_RUN,
+				details: { runId }
+			});
 		}
 		return await this.#executeClaimedRun(run);
 	}
@@ -92,8 +100,8 @@ var WorkflowWorker = class {
 				execution = this.#processNextRun(options ?? {}, options?.signal).then((result) => ({
 					execution,
 					result
-				}), (error) => ({
-					error,
+				}), (cause) => ({
+					error: cause,
 					execution
 				}));
 				activeRuns.add(execution);
@@ -131,7 +139,7 @@ var WorkflowWorker = class {
 		for (const controller of this.#activeExecutionAborts) controller.abort();
 		for (const wakeup of this.#pollWakeups) wakeup();
 		if (!await this.#waitForActiveExecutions(activeExecutions)) return;
-		await Promise.all(releaseRuns.map(async ([runId, attempts]) => await this.#releaseLease(runId, attempts)));
+		await Promise.all(releaseRuns.map(([runId, attempts]) => this.#releaseLease(runId, attempts)));
 	}
 	async #waitForActiveExecutions(activeExecutions) {
 		if (activeExecutions.length === 0) return true;
@@ -170,15 +178,14 @@ var WorkflowWorker = class {
 	async #processNextRun(options, signal) {
 		const timestamp = this.#now();
 		const run = await this.#claimRun(options);
-		this.#observeWorkerOperation({
+		const observation = {
 			operation: "poll",
 			status: run === void 0 ? "empty" : "claimed",
 			timestamp,
-			...run === void 0 ? {} : {
-				runId: run.id,
-				run
-			}
-		});
+			runId: run?.id,
+			run
+		};
+		this.#observeWorkerOperation(observation);
 		if (run === void 0) return;
 		if (this.#stopRequested || signal?.aborted === true) {
 			await this.#releaseLease(run.id, run.attempts);
@@ -192,82 +199,22 @@ var WorkflowWorker = class {
 	}
 	async #executeClaimedRun(run, signal) {
 		const definition = this.#registry.getByName(run.workflowName, run.workflowVersion);
-		if (definition === void 0) return await this.#rescheduleMissingImplementation(run);
+		if (definition === void 0) return await handleMissingImplementation({
+			store: this.#store,
+			now: this.#now,
+			retry: this.#missingImplementationRetry,
+			readResult: (runId) => this.#readRunExecutionResult(runId)
+		}, run);
 		const attempts = run.attempts !== void 0 && isPositiveSafeInteger(run.attempts) ? run.attempts : void 0;
-		return await this.#withHeartbeat(run.id, attempts, signal, async (executionSignal) => await this.#engine.resumeWorkflow(definition, run.id, { signal: executionSignal }));
-	}
-	async #rescheduleMissingImplementation(run) {
-		const timestamp = this.#now();
-		const retryAttempt = run.attempts ?? (run.retryAttempt ?? 0) + 1;
-		const errorRecord = makeMissingImplementationNotFoundErrorRecord(run);
-		const deadlineAt = run.deadlineAt;
-		if (deadlineAt !== void 0 && Temporal.Instant.compare(deadlineAt, timestamp) <= 0) return await this.#failMissingImplementationForDeadline(run, deadlineAt, timestamp);
-		if (this.#missingImplementationRetry.maximumAttempts > 0 && retryAttempt >= this.#missingImplementationRetry.maximumAttempts) return await this.#failMissingImplementationRun(run, errorRecord, timestamp);
-		let availableAt;
-		try {
-			availableAt = timestamp.add(Temporal.Duration.from({ milliseconds: nonNegativeTimerDelay(missingImplementationRetryDelay(this.#missingImplementationRetry, retryAttempt), "Workflow missing implementation retry delay").clampedDelay }));
-		} catch (retryError) {
-			return await this.#failMissingImplementationRun(run, toWorkflowWorkerErrorRecord(retryError), timestamp);
-		}
-		if (deadlineAt !== void 0 && Temporal.Instant.compare(deadlineAt, availableAt) <= 0) return await this.#failMissingImplementationForDeadline(run, deadlineAt, timestamp);
-		const waitingRun = await patchRunIfCurrent(this.#store, run, transitionRunToMissingImplementationWait(run, errorRecord, timestamp, availableAt, retryAttempt));
-		if (waitingRun === void 0) return await this.#readRunExecutionResult(run.id);
-		await wakeParentRunForWaitingChild(this.#store, waitingRun, availableAt);
-		return {
-			kind: "waiting",
-			run: waitingRun,
-			availableAt
-		};
-	}
-	async #failMissingImplementationRun(run, errorRecord, timestamp) {
-		return await this.#failClaimedMissingImplementationRun(run, errorRecord, timestamp, "failed");
-	}
-	async #failMissingImplementationForDeadline(run, deadlineAt, timestamp) {
-		return await this.#failClaimedMissingImplementationRun(run, makeMissingImplementationDeadlineErrorRecord(run, deadlineAt), timestamp, "deadline", deadlineAt);
-	}
-	async #failClaimedMissingImplementationRun(run, errorRecord, timestamp, reason, deadlineAt) {
-		const failedRun = await patchRunIfCurrent(this.#store, run, transitionRunToFailed(run, errorRecord, timestamp, reason, deadlineAt));
-		if (failedRun === void 0) return await this.#readRunExecutionResult(run.id);
-		if (await this.#store.appendEventIfRunCurrent(failedRun, {
-			kind: "workflow_failed",
-			timestamp
-		}) === void 0) return await this.#readRunExecutionResult(run.id);
-		await wakeParentRunForTerminalChild(this.#store, failedRun, timestamp);
-		return {
-			kind: "failed",
-			run: failedRun,
-			error: errorRecord
-		};
+		return await this.#withHeartbeat(run.id, attempts, signal, (executionSignal) => this.#engine.resumeWorkflow(definition, run.id, { signal: executionSignal }));
 	}
 	async #readRunExecutionResult(runId) {
-		const current = await this.#engine.getRun(runId);
-		if (current === void 0) WorkflowRunNotFoundError.notFound(runId);
-		if (current.status === "completed") return {
+		const current = await getRequiredRun(this.#engine.store, runId);
+		return current.status === "completed" ? {
 			kind: "completed",
 			run: current,
 			output: current.output
-		};
-		if (current.status === "failed") return {
-			kind: "failed",
-			run: current,
-			error: current.error ?? {
-				name: "WorkflowError",
-				message: `Workflow run failed: ${runId}`
-			}
-		};
-		if (current.status === "canceled") return {
-			kind: "failed",
-			run: current,
-			error: current.error ?? {
-				name: "WorkflowRunCanceledError",
-				message: `Workflow run was canceled: ${runId}`
-			}
-		};
-		return {
-			kind: "waiting",
-			run: current,
-			availableAt: current.availableAt ?? this.#now()
-		};
+		} : unfinishedRunResult(current, this.#now());
 	}
 	async #extendLease(runId, attempts) {
 		const timestamp = this.#now();
@@ -278,13 +225,14 @@ var WorkflowWorker = class {
 			leaseDuration: this.#leaseDuration,
 			now: timestamp
 		});
-		this.#observeWorkerOperation({
+		const observation = {
 			operation: "lease_extension",
 			status: run === void 0 ? "failure" : "success",
 			timestamp,
 			runId,
-			...run === void 0 ? {} : { run }
-		});
+			run
+		};
+		this.#observeWorkerOperation(observation);
 		return run;
 	}
 	async #releaseLease(runId, attempts) {
@@ -295,13 +243,14 @@ var WorkflowWorker = class {
 			attempts,
 			now: timestamp
 		});
-		this.#observeWorkerOperation({
+		const observation = {
 			operation: "lease_release",
 			status: run === void 0 ? "failure" : "success",
 			timestamp,
 			runId,
-			...run === void 0 ? {} : { run }
-		});
+			run
+		};
+		this.#observeWorkerOperation(observation);
 		return run;
 	}
 	async #withHeartbeat(runId, attempts, signal, callback) {
@@ -332,21 +281,21 @@ var WorkflowWorker = class {
 					});
 					executionAbort.abort();
 				}
-			}).catch((error) => {
+			}).catch((cause) => {
 				executionAbort.abort();
-				heartbeatError ??= error;
+				heartbeatError ??= cause;
 				this.#observeWorkerOperation({
 					operation: "heartbeat",
 					status: "failure",
 					timestamp: this.#now(),
 					runId,
-					error
+					error: cause
 				});
 			}).finally(() => {
 				heartbeatPending = false;
 			});
 		}, this.#heartbeatInterval);
-		const execution = (async () => await callback(executionAbort.signal))();
+		const execution = (() => callback(executionAbort.signal))();
 		this.#activeExecutions.add(execution);
 		let executionOutcome;
 		try {
@@ -374,7 +323,7 @@ var WorkflowWorker = class {
 	}
 	#observeWorkerOperation(event) {
 		try {
-			this.#engine.observeWorkerOperation?.({
+			this.#engine.observation.emitWorkerOperation({
 				workerId: this.#workerId,
 				...event
 			});
@@ -410,8 +359,8 @@ var WorkflowWorker = class {
 		return Math.min(pollInterval, nonNegativeTimerDelay(durationBetween(timestamp, nextWakeAt), "Workflow idle poll delay").clampedDelay);
 	}
 	async #nextScheduleWakeAt() {
-		if (this.#engine.listSchedules === void 0) return;
-		return (await this.#engine.listSchedules({
+		if (this.#engine.store.listSchedules === void 0) return;
+		return (await this.#engine.store.listSchedules({
 			status: "active",
 			limit: 1
 		}))[0]?.nextFireAt;
@@ -419,10 +368,7 @@ var WorkflowWorker = class {
 };
 function earliestSummaryWakeAt(summary, timestamp) {
 	if (summary.lease.expired > 0) return timestamp;
-	const nextAt = summary.nextAvailableAt === void 0 ? summary.retry.nextRetryAt : summary.retry.nextRetryAt === void 0 || Temporal.Instant.compare(summary.nextAvailableAt, summary.retry.nextRetryAt) <= 0 ? summary.nextAvailableAt : summary.retry.nextRetryAt;
-	if (nextAt === void 0) return summary.lease.nextExpiresAt;
-	if (summary.lease.nextExpiresAt === void 0) return nextAt;
-	return Temporal.Instant.compare(summary.lease.nextExpiresAt, nextAt) < 0 ? summary.lease.nextExpiresAt : nextAt;
+	return earliestOptionalTimestamp(earliestOptionalTimestamp(summary.nextAvailableAt, summary.retry.next?.at), summary.lease.next?.at);
 }
 //#endregion
 export { WorkflowWorker };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@temelj/workflow",
-  "version": "0.0.0-alpha.2",
+  "version": "0.0.0-alpha.4",
   "description": "Durable, vendor-agnostic, extendible workflows.",
   "license": "MIT",
   "repository": {
@@ -17,29 +17,17 @@
       "types": "./dist/mod.d.mts",
       "import": "./dist/mod.mjs"
     },
-    "./engine": {
-      "types": "./dist/engine/mod.d.mts",
-      "import": "./dist/engine/mod.mjs"
+    "./compiled": {
+      "types": "./dist/compiled.d.mts",
+      "import": "./dist/compiled.mjs"
     },
     "./esbuild": {
       "types": "./dist/esbuild.d.mts",
       "import": "./dist/esbuild.mjs"
     },
-    "./events": {
-      "types": "./dist/events/mod.d.mts",
-      "import": "./dist/events/mod.mjs"
-    },
-    "./inspection": {
-      "types": "./dist/inspection/mod.d.mts",
-      "import": "./dist/inspection/mod.mjs"
-    },
     "./otel": {
-      "types": "./dist/otel.d.mts",
-      "import": "./dist/otel.mjs"
-    },
-    "./registry": {
-      "types": "./dist/registry.d.mts",
-      "import": "./dist/registry.mjs"
+      "types": "./dist/otel/mod.d.mts",
+      "import": "./dist/otel/mod.mjs"
     },
     "./rolldown": {
       "types": "./dist/rolldown.d.mts",
@@ -53,10 +41,6 @@
       "types": "./dist/rspack.d.mts",
       "import": "./dist/rspack.mjs"
     },
-    "./telemetry": {
-      "types": "./dist/telemetry.d.mts",
-      "import": "./dist/telemetry.mjs"
-    },
     "./store": {
       "types": "./dist/store/mod.d.mts",
       "import": "./dist/store/mod.mjs"
@@ -69,10 +53,6 @@
       "types": "./dist/webpack.d.mts",
       "import": "./dist/webpack.mjs"
     },
-    "./worker": {
-      "types": "./dist/worker.d.mts",
-      "import": "./dist/worker.mjs"
-    },
     "./cloudflare": {
       "types": "./dist/cloudflare/mod.d.mts",
       "import": "./dist/cloudflare/mod.mjs"
@@ -80,43 +60,47 @@
   },
   "dependencies": {
     "@opentelemetry/api": "^1.9.1",
-    "oxc-parser": "0.144.0",
-    "temporal-polyfill": "^1.0.4",
-    "unplugin": "^3.3.0",
-    "zod": "^4.4.3",
     "@temelj/event": "0.1.0",
     "@temelj/log": "0.1.0",
+    "@temelj/standard-schema": "0.1.0",
     "@temelj/storage": "0.4.0",
-    "@temelj/string": "0.14.0",
-    "@temelj/value": "0.14.0",
-    "@temelj/standard-schema": "0.1.0"
+    "@temelj/string": "0.15.0",
+    "@temelj/value": "0.15.0",
+    "oxc-parser": "0.154.0",
+    "temporal-polyfill": "^1.0.6",
+    "unplugin": "^3.4.0"
   },
   "devDependencies": {
-    "@opentelemetry/sdk-metrics": "^2.10.0",
-    "@opentelemetry/sdk-trace-base": "^2.10.0",
-    "@rspack/core": "^2.1.10",
-    "@types/node": "26.1.1",
+    "@cloudflare/workers-types": "5.20261014.1",
+    "@opentelemetry/sdk-metrics": "^2.12.0",
+    "@opentelemetry/sdk-trace-base": "^2.12.0",
+    "@rspack/core": "^2.2.9",
+    "@types/node": "26.6.5",
     "esbuild": "^0.28.2",
-    "rolldown": "^1.2.4",
-    "rollup": "^4.62.4",
+    "rolldown": "^1.2.14",
+    "rollup": "^4.64.6",
     "shx": "^0.4.0",
-    "tsdown": "^0.22.14",
+    "tsdown": "^0.23.1",
     "typedoc": "^0.28.20",
     "typescript": "^7.0.2",
-    "vite": "^8.2.1",
-    "vitest": "^4.1.10",
-    "webpack": "^5.109.2"
+    "vite": "^8.3.4",
+    "vitest": "^5.0.4",
+    "webpack": "^5.111.1",
+    "zod": "^4.6.7"
   },
   "peerDependencies": {
+    "@cloudflare/workers-types": "^4.0.0 || ^5.0.0",
     "@rspack/core": "^2.0.0",
     "esbuild": "^0.28.0",
     "rolldown": "^1.0.0",
     "rollup": "^4.0.0",
-    "typescript": "^6.0.0",
     "vite": "^8.0.0",
     "webpack": "^5.0.0"
   },
   "peerDependenciesMeta": {
+    "@cloudflare/workers-types": {
+      "optional": true
+    },
     "@rspack/core": {
       "optional": true
     },
@@ -129,9 +113,6 @@
     "rollup": {
       "optional": true
     },
-    "typescript": {
-      "optional": true
-    },
     "vite": {
       "optional": true
     },