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

package/dist/store-keys.d.mts

@@ -1,50 +1,38 @@
-import { RunId } from "./types/run-id.mjs";
+import { RunId, StepId } from "./types/ids.mjs";
 import { ScheduleId } from "./types/schedule.mjs";
-import "./types/run.mjs";
-import { WorkflowIdempotencyKeyOptions } from "./types/store.mjs";
+import { StepAttemptRecord } from "./types/step-attempts.mjs";
+import { IdempotencyKeyOptions } from "./types/store.mjs";
 //#region src/store-keys.d.ts
-type WorkflowIdempotencyKey = `workflow:${string}:idempotency:${string}:${string}`;
-type MessageIdempotencyKey = `workflow:${string}:message-idempotency:${string}:${string}`;
-type WorkflowRunKey = `workflow:${string}:run:${string}`;
-type WorkflowEventsKey = `workflow:${string}:events:${string}`;
-type WorkflowStepAttemptKey = `workflow:${string}:step-attempt:${string}:${string}`;
-type WorkflowScheduleKey = `workflow:${string}:schedule:${string}`;
-type WorkflowLockKey = `workflow:${string}:lock:${string}`;
-type WorkflowCleanupMarkerKey = `workflow:${string}:cleanup:${string}`;
-type WorkflowNamespacePrefix = `workflow:${string}:`;
-type WorkflowRunKeyPrefix = `workflow:${string}:run:`;
-type WorkflowStepAttemptKeyPrefix = `workflow:${string}:step-attempt:${string}:`;
-type WorkflowScheduleKeyPrefix = `workflow:${string}:schedule:`;
-type WorkflowLockKeyPrefix = `workflow:${string}:lock:`;
-type WorkflowCleanupMarkerKeyPrefix = `workflow:${string}:cleanup:`;
-/** Builds a validated workflow idempotency storage key. */
-declare function makeWorkflowIdempotencyKey(namespace: string, options: WorkflowIdempotencyKeyOptions): WorkflowIdempotencyKey;
-/** Builds a workflow run storage key. */
-declare function makeRunKey(namespace: string, runId: RunId): WorkflowRunKey;
-/** Builds a workflow event-history storage key. */
-declare function makeEventsKey(namespace: string, runId: RunId): WorkflowEventsKey;
-/** Builds a workflow step-attempt storage key. */
-declare function makeStepAttemptKey(namespace: string, runId: RunId, attemptKey: string): WorkflowStepAttemptKey;
-/** Builds a workflow step-attempt storage key prefix. */
-declare function makeStepAttemptKeyPrefix(namespace: string, runId: RunId): WorkflowStepAttemptKeyPrefix;
-declare function isStepAttemptKey(key: string, namespace: string, runId: RunId): boolean;
-/** Builds a workflow message idempotency storage key. */
-declare function makeMessageIdempotencyKey(namespace: string, runId: RunId, idempotencyKey: string): MessageIdempotencyKey;
-/** Builds a workflow schedule storage key. */
-declare function makeScheduleKey(namespace: string, scheduleId: ScheduleId): WorkflowScheduleKey;
-/** Builds a workflow schedule storage key prefix. */
-declare function makeScheduleKeyPrefix(namespace: string): WorkflowScheduleKeyPrefix;
-/** Builds a workflow lock storage key. */
-declare function makeLockKey(namespace: string, key: string): WorkflowLockKey;
-/** Builds a workflow cleanup marker storage key. */
-declare function makeCleanupMarkerKey(namespace: string, runId: RunId): WorkflowCleanupMarkerKey;
-/** Builds a workflow cleanup marker storage key prefix. */
-declare function makeCleanupMarkerKeyPrefix(namespace: string): WorkflowCleanupMarkerKeyPrefix;
-/** Builds a workflow lock storage key prefix. */
-declare function makeLockKeyPrefix(namespace: string): WorkflowLockKeyPrefix;
-/** Builds a workflow idempotency storage key. */
-declare function makeIdempotencyKey(namespace: string, options: WorkflowIdempotencyKeyOptions): WorkflowIdempotencyKey;
-/** Builds a workflow run storage key prefix. */
-declare function makeRunKeyPrefix(namespace: string): WorkflowRunKeyPrefix;
+/** The key of one step attempt within a run, such as `run:step_1:2`. */
+export declare function stepAttemptKey(stepId: StepId, attempt: number): string;
+export type IdempotencyKey = `workflow:${string}:idempotency:${string}:${string}`;
+export type MessageIdempotencyKey = `workflow:${string}:message-idempotency:${string}:${string}`;
+type RunKey = `workflow:${string}:run:${string}`;
+export type EventsKey = `workflow:${string}:events:${string}`;
+type StepAttemptKey = `workflow:${string}:step-attempt:${string}:${string}`;
+type ScheduleKey = `workflow:${string}:schedule:${string}`;
+type LockKey = `workflow:${string}:lock:${string}`;
+type CleanupMarkerKey = `workflow:${string}:cleanup:${string}`;
+type RunKeyPrefix = `workflow:${string}:run:`;
+type StepAttemptKeyPrefix = `workflow:${string}:step-attempt:${string}:`;
+type ScheduleKeyPrefix = `workflow:${string}:schedule:`;
+type LockKeyPrefix = `workflow:${string}:lock:`;
+type CleanupMarkerKeyPrefix = `workflow:${string}:cleanup:`;
+export declare function makeWorkflowIdempotencyKey(namespace: string, options: IdempotencyKeyOptions): IdempotencyKey;
+export declare function makeRunKey(namespace: string, runId: RunId): RunKey;
+export declare function makeEventsKey(namespace: string, runId: RunId): EventsKey;
+export declare function makeStepAttemptKey(namespace: string, runId: RunId, attemptKey: string): StepAttemptKey;
+export declare function makeStepAttemptKeyPrefix(namespace: string, runId: RunId): StepAttemptKeyPrefix;
+export declare function isStepAttemptKey(key: string, namespace: string, runId: RunId): boolean;
+export declare function makeMessageIdempotencyKey(namespace: string, runId: RunId, idempotencyKey: string): MessageIdempotencyKey;
+export declare function makeScheduleKey(namespace: string, scheduleId: ScheduleId): ScheduleKey;
+export declare function makeScheduleKeyPrefix(namespace: string): ScheduleKeyPrefix;
+export declare function makeLockKey(namespace: string, key: string): LockKey;
+export declare function makeCleanupMarkerKey(namespace: string, runId: RunId): CleanupMarkerKey;
+export declare function makeCleanupMarkerKeyPrefix(namespace: string): CleanupMarkerKeyPrefix;
+export declare function makeLockKeyPrefix(namespace: string): LockKeyPrefix;
+export declare function makeIdempotencyKey(namespace: string, options: IdempotencyKeyOptions): IdempotencyKey;
+export declare function makeRunKeyPrefix(namespace: string): RunKeyPrefix;
+export declare function runStepAttemptKey(runId: RunId, attempt: StepAttemptRecord): string;
 //#endregion
-export { MessageIdempotencyKey, WorkflowCleanupMarkerKey, WorkflowCleanupMarkerKeyPrefix, WorkflowEventsKey, WorkflowIdempotencyKey, WorkflowLockKey, WorkflowLockKeyPrefix, WorkflowNamespacePrefix, WorkflowRunKey, WorkflowRunKeyPrefix, WorkflowScheduleKey, WorkflowScheduleKeyPrefix, WorkflowStepAttemptKey, WorkflowStepAttemptKeyPrefix, isStepAttemptKey, makeCleanupMarkerKey, makeCleanupMarkerKeyPrefix, makeEventsKey, makeIdempotencyKey, makeLockKey, makeLockKeyPrefix, makeMessageIdempotencyKey, makeRunKey, makeRunKeyPrefix, makeScheduleKey, makeScheduleKeyPrefix, makeStepAttemptKey, makeStepAttemptKeyPrefix, makeWorkflowIdempotencyKey };
+export {};

package/dist/store-keys.mjs

@@ -1,22 +1,20 @@
-import { makeWorkflowStepAttemptKey } from "./history/attempt-key.mjs";
 //#region src/store-keys.ts
-/** Builds a validated workflow idempotency storage key. */
+/** The key of one step attempt within a run, such as `run:step_1:2`. */
+function stepAttemptKey(stepId, attempt) {
+	return `run:${stepId}:${attempt}`;
+}
 function makeWorkflowIdempotencyKey(namespace, options) {
 	return makeIdempotencyKey(namespace, options);
 }
-/** Builds a workflow run storage key. */
 function makeRunKey(namespace, runId) {
 	return `${namespacePrefix(namespace)}run:${runId}`;
 }
-/** Builds a workflow event-history storage key. */
 function makeEventsKey(namespace, runId) {
 	return `${namespacePrefix(namespace)}events:${runId}`;
 }
-/** Builds a workflow step-attempt storage key. */
 function makeStepAttemptKey(namespace, runId, attemptKey) {
 	return `${makeStepAttemptKeyPrefix(namespace, runId)}${encodeURIComponent(attemptKey)}`;
 }
-/** Builds a workflow step-attempt storage key prefix. */
 function makeStepAttemptKeyPrefix(namespace, runId) {
 	return `${namespacePrefix(namespace)}step-attempt:${runId}:`;
 }
@@ -30,7 +28,7 @@ function isStepAttemptKey(key, namespace, runId) {
 	const stepId = attemptKey.slice(4, separator);
 	const attempt = Number(attemptKey.slice(separator + 1));
 	try {
-		return makeWorkflowStepAttemptKey(stepId, attempt) === attemptKey;
+		return stepAttemptKey(stepId, attempt) === attemptKey;
 	} catch {
 		return false;
 	}
@@ -42,45 +40,39 @@ function decodeStepAttemptKey(key, prefix) {
 		return;
 	}
 }
-/** Builds a workflow message idempotency storage key. */
 function makeMessageIdempotencyKey(namespace, runId, idempotencyKey) {
 	return `${namespacePrefix(namespace)}message-idempotency:${encodeURIComponent(runId)}:${encodeURIComponent(idempotencyKey)}`;
 }
-/** Builds a workflow schedule storage key. */
 function makeScheduleKey(namespace, scheduleId) {
 	return `${namespacePrefix(namespace)}schedule:${encodeURIComponent(scheduleId)}`;
 }
-/** Builds a workflow schedule storage key prefix. */
 function makeScheduleKeyPrefix(namespace) {
 	return `${namespacePrefix(namespace)}schedule:`;
 }
-/** Builds a workflow lock storage key. */
 function makeLockKey(namespace, key) {
 	return `${namespacePrefix(namespace)}lock:${encodeURIComponent(key)}`;
 }
-/** Builds a workflow cleanup marker storage key. */
 function makeCleanupMarkerKey(namespace, runId) {
 	return `${namespacePrefix(namespace)}cleanup:${encodeURIComponent(runId)}`;
 }
-/** Builds a workflow cleanup marker storage key prefix. */
 function makeCleanupMarkerKeyPrefix(namespace) {
 	return `${namespacePrefix(namespace)}cleanup:`;
 }
-/** Builds a workflow lock storage key prefix. */
 function makeLockKeyPrefix(namespace) {
 	return `${namespacePrefix(namespace)}lock:`;
 }
-/** Builds a workflow idempotency storage key. */
 function makeIdempotencyKey(namespace, options) {
 	const versionedName = options.workflowVersion === void 0 ? options.workflowName : `${options.workflowName}@${options.workflowVersion}`;
 	return `${namespacePrefix(namespace)}idempotency:${encodeURIComponent(versionedName)}:${encodeURIComponent(options.idempotencyKey)}`;
 }
-/** Builds a workflow run storage key prefix. */
 function makeRunKeyPrefix(namespace) {
 	return `${namespacePrefix(namespace)}run:`;
 }
 function namespacePrefix(namespace) {
 	return `workflow:${encodeURIComponent(namespace)}:`;
 }
+function runStepAttemptKey(runId, attempt) {
+	return `${runId}:${stepAttemptKey(attempt.stepId, attempt.attempt)}`;
+}
 //#endregion
-export { isStepAttemptKey, makeCleanupMarkerKey, makeCleanupMarkerKeyPrefix, makeEventsKey, makeIdempotencyKey, makeLockKey, makeLockKeyPrefix, makeMessageIdempotencyKey, makeRunKey, makeRunKeyPrefix, makeScheduleKey, makeScheduleKeyPrefix, makeStepAttemptKey, makeStepAttemptKeyPrefix, makeWorkflowIdempotencyKey };
+export { isStepAttemptKey, makeCleanupMarkerKey, makeCleanupMarkerKeyPrefix, makeEventsKey, makeIdempotencyKey, makeLockKey, makeLockKeyPrefix, makeMessageIdempotencyKey, makeRunKey, makeRunKeyPrefix, makeScheduleKey, makeScheduleKeyPrefix, makeStepAttemptKey, makeStepAttemptKeyPrefix, makeWorkflowIdempotencyKey, runStepAttemptKey, stepAttemptKey };

package/dist/telemetry.d.mts

@@ -1,14 +1,15 @@
-import { ObservationEventMap } from "./types/observation.mjs";
+import { ObservationEventArgs } from "./types/observation.mjs";
+import { ExecutionResult } from "./types/result.mjs";
 import { RunTelemetryContext, StepTelemetryContext, StorageTelemetryContext, Telemetry, TelemetryContext } from "./types/telemetry.mjs";
+import "temporal-polyfill/global";
 //#region src/telemetry.d.ts
 /** Instrumentation scope used by workflow telemetry adapters. */
-declare const WORKFLOW_INSTRUMENTATION_NAME = "temelj.workflow";
-/** Version of the built-in workflow telemetry instrumentation. */
-declare const WORKFLOW_INSTRUMENTATION_VERSION = "0.1.0";
+export declare const WORKFLOW_INSTRUMENTATION_NAME = "temelj.workflow";
+export declare const WORKFLOW_INSTRUMENTATION_VERSION = "0.1.0";
 /** Stable workflow system identifier used on spans, metrics, and logs. */
-declare const WORKFLOW_SYSTEM = "temelj";
+export declare const WORKFLOW_SYSTEM = "temelj";
 /** Stable OpenTelemetry span names emitted by `@temelj/workflow`. */
-declare const WORKFLOW_SPAN_NAMES: {
+export declare const WORKFLOW_SPAN_NAMES: {
   readonly childWorkflowOperation: "temelj.workflow.child_workflow.operation";
   readonly cleanupOperation: "temelj.workflow.cleanup.operation";
   readonly hookResume: "temelj.workflow.hook.resume";
@@ -24,7 +25,7 @@ declare const WORKFLOW_SPAN_NAMES: {
   readonly workerOperation: "temelj.workflow.worker.operation";
 };
 /** Stable metric names emitted by `@temelj/workflow` telemetry. */
-declare const WORKFLOW_METRIC_NAMES: {
+export declare const WORKFLOW_METRIC_NAMES: {
   readonly cleanupDeletedRuns: "temelj.workflow.cleanup.deleted_runs";
   readonly eventsAppended: "temelj.workflow.events.appended";
   readonly hooksResumed: "temelj.workflow.hooks.resumed";
@@ -53,7 +54,7 @@ declare const WORKFLOW_METRIC_NAMES: {
   readonly workerLeaseReleases: "temelj.workflow.worker.lease_releases";
 };
 /** Stable workflow attribute names used by traces, metrics, and logs. */
-declare const WORKFLOW_ATTRIBUTES: {
+export declare const WORKFLOW_ATTRIBUTES: {
   readonly canceled: "workflow.canceled";
   readonly childWorkflowDurationMs: "workflow.child_workflow.duration_ms";
   readonly childWorkflowOperation: "workflow.child_workflow.operation";
@@ -116,17 +117,16 @@ declare const WORKFLOW_ATTRIBUTES: {
   readonly workflowVersion: "workflow.version";
 };
 /** OpenTelemetry semantic convention attributes used when workflow operations act like messages. */
-declare const WORKFLOW_MESSAGING_ATTRIBUTES: {
+export declare const WORKFLOW_MESSAGING_ATTRIBUTES: {
   readonly destinationName: "messaging.destination.name";
   readonly messageId: "messaging.message.id";
   readonly operationName: "messaging.operation.name";
   readonly operationType: "messaging.operation.type";
   readonly system: "messaging.system";
 };
-declare function captureTelemetryContext(telemetry: Telemetry | undefined): TelemetryContext | undefined;
-declare function withRunTelemetry<T>(telemetry: Telemetry | undefined, context: RunTelemetryContext, callback: () => Promise<T>): Promise<T>;
-declare function withStepTelemetry<T>(telemetry: Telemetry | undefined, context: StepTelemetryContext, callback: () => Promise<T>): Promise<T>;
-declare function withStorageTelemetry<T>(telemetry: Telemetry | undefined, context: StorageTelemetryContext, callback: () => Promise<T>): Promise<T>;
-declare function observeTelemetry<Key extends keyof ObservationEventMap>(telemetry: Telemetry | undefined, name: Key, payload: ObservationEventMap[Key]): void;
-//#endregion
-export { WORKFLOW_ATTRIBUTES, WORKFLOW_INSTRUMENTATION_NAME, WORKFLOW_INSTRUMENTATION_VERSION, WORKFLOW_MESSAGING_ATTRIBUTES, WORKFLOW_METRIC_NAMES, WORKFLOW_SPAN_NAMES, WORKFLOW_SYSTEM, captureTelemetryContext, observeTelemetry, withRunTelemetry, withStepTelemetry, withStorageTelemetry };
+export declare function captureTelemetryContext(telemetry: Telemetry | undefined): TelemetryContext | undefined;
+export declare function withRunTelemetry<T extends ExecutionResult>(telemetry: Telemetry | undefined, context: RunTelemetryContext, callback: () => Promise<T>): Promise<T>;
+export declare function withStepTelemetry<T>(telemetry: Telemetry | undefined, context: StepTelemetryContext, callback: () => Promise<T>): Promise<T>;
+export declare function withStorageTelemetry<T>(telemetry: Telemetry | undefined, context: StorageTelemetryContext, callback: () => Promise<T>): Promise<T>;
+export declare function observeTelemetry(telemetry: Telemetry | undefined, ...event: ObservationEventArgs): void;
+//#endregion

package/dist/telemetry.mjs

@@ -1,7 +1,7 @@
+import "temporal-polyfill/global";
 //#region src/telemetry.ts
 /** Instrumentation scope used by workflow telemetry adapters. */
 const WORKFLOW_INSTRUMENTATION_NAME = "temelj.workflow";
-/** Version of the built-in workflow telemetry instrumentation. */
 const WORKFLOW_INSTRUMENTATION_VERSION = "0.1.0";
 /** Stable workflow system identifier used on spans, metrics, and logs. */
 const WORKFLOW_SYSTEM = "temelj";
@@ -140,9 +140,9 @@ async function withStorageTelemetry(telemetry, context, callback) {
 	if (telemetry?.withStorageOperation === void 0) return await callback();
 	return await withTelemetry((wrappedCallback) => telemetry.withStorageOperation(context, wrappedCallback), callback);
 }
-function observeTelemetry(telemetry, name, payload) {
+function observeTelemetry(telemetry, ...event) {
 	try {
-		telemetry?.observe?.(name, payload);
+		telemetry?.observe?.(...event);
 	} catch {
 		return;
 	}

package/dist/temporal.d.mts

@@ -1,23 +1,18 @@
 //#region src/temporal.d.ts
-/** Returns a non-negative millisecond duration between two instants. */
-declare function durationBetweenMilliseconds(from: Temporal.Instant, to: Temporal.Instant): number;
+/** Returns a duration's total milliseconds, or NaN when Temporal cannot represent it safely. */
+export declare function durationTotal(value: Temporal.Duration): number;
 /** Returns a non-negative millisecond duration between optional instants. */
-declare function optionalDurationBetweenMilliseconds(from: Temporal.Instant | undefined, to: Temporal.Instant | undefined): number | undefined;
+export declare function optionalDurationBetweenMilliseconds(from: Temporal.Instant | undefined, to: Temporal.Instant | undefined): number | undefined;
 /** Returns a non-negative Temporal duration between two instants. */
-declare function durationBetween(from: Temporal.Instant, to: Temporal.Instant): Temporal.Duration;
+export declare function durationBetween(from: Temporal.Instant, to: Temporal.Instant): Temporal.Duration;
 /** Returns whether a timestamp falls inside an inclusive optional instant range. */
-declare function matchesTimestampRange(timestamp: Temporal.Instant, from: Temporal.Instant | undefined, to: Temporal.Instant | undefined): boolean;
+export declare function matchesTimestampRange(timestamp: Temporal.Instant, from: Temporal.Instant | undefined, to: Temporal.Instant | undefined): boolean;
 /** Returns whether an optional timestamp falls inside an inclusive optional instant range. */
-declare function matchesOptionalTimestampRange(timestamp: Temporal.Instant | undefined, from: Temporal.Instant | undefined, to: Temporal.Instant | undefined): boolean;
+export declare function matchesOptionalTimestampRange(timestamp: Temporal.Instant | undefined, from: Temporal.Instant | undefined, to: Temporal.Instant | undefined): boolean;
 /** Returns whether an optional duration falls inside an inclusive optional duration range. */
-declare function matchesOptionalDurationRange(value: Temporal.Duration | undefined, from: Temporal.Duration | undefined, to: Temporal.Duration | undefined): boolean;
+export declare function matchesOptionalDurationRange(value: Temporal.Duration | undefined, from: Temporal.Duration | undefined, to: Temporal.Duration | undefined): boolean;
 /** Compares optional timestamps, sorting present timestamps before undefined values. */
-declare function compareOptionalTimestamps(left: Temporal.Instant | undefined, right: Temporal.Instant | undefined): number;
-/** Returns the earlier of two optional timestamps. */
-declare function earliestOptionalTimestamp(current: Temporal.Instant | undefined, next: Temporal.Instant | undefined): Temporal.Instant | undefined;
-/** Returns the later of two optional timestamps. */
-declare function latestOptionalTimestamp(current: Temporal.Instant | undefined, next: Temporal.Instant | undefined): Temporal.Instant | undefined;
-/** Returns whether `next` should replace `current` as the earliest defined instant. */
-declare function shouldReplaceWorkflowEarliestDefinedInstant(current: Temporal.Instant | undefined, next: Temporal.Instant | undefined): boolean;
-//#endregion
-export { compareOptionalTimestamps, durationBetween, durationBetweenMilliseconds, earliestOptionalTimestamp, latestOptionalTimestamp, matchesOptionalDurationRange, matchesOptionalTimestampRange, matchesTimestampRange, optionalDurationBetweenMilliseconds, shouldReplaceWorkflowEarliestDefinedInstant };
+export declare function compareOptionalTimestamps(left: Temporal.Instant | undefined, right: Temporal.Instant | undefined): number;
+export declare function earliestOptionalTimestamp(current: Temporal.Instant | undefined, next: Temporal.Instant | undefined): Temporal.Instant | undefined;
+export declare function latestOptionalTimestamp(current: Temporal.Instant | undefined, next: Temporal.Instant | undefined): Temporal.Instant | undefined;
+//#endregion

package/dist/temporal.mjs

@@ -1,4 +1,9 @@
 //#region src/temporal.ts
+/** Returns a duration's total milliseconds, or NaN when Temporal cannot represent it safely. */
+function durationTotal(value) {
+	const total = value.total({ unit: "millisecond" });
+	return Number.isFinite(total) ? total : NaN;
+}
 /** Returns a non-negative millisecond duration between two instants. */
 function durationBetweenMilliseconds(from, to) {
 	return Math.max(0, to.epochMilliseconds - from.epochMilliseconds);
@@ -28,8 +33,8 @@ function matchesOptionalDurationRange(value, from, to) {
 	if (from === void 0 && to === void 0) return true;
 	if (value === void 0) return false;
 	const current = value.total({ unit: "millisecond" });
-	const lower = from === void 0 ? void 0 : from.total({ unit: "millisecond" });
-	const upper = to === void 0 ? void 0 : to.total({ unit: "millisecond" });
+	const lower = from?.total({ unit: "millisecond" });
+	const upper = to?.total({ unit: "millisecond" });
 	return (lower === void 0 || current >= lower) && (upper === void 0 || current <= upper);
 }
 /** Compares optional timestamps, sorting present timestamps before undefined values. */
@@ -39,21 +44,15 @@ function compareOptionalTimestamps(left, right) {
 	if (right !== void 0) return 1;
 	return 0;
 }
-/** Returns the earlier of two optional timestamps. */
 function earliestOptionalTimestamp(current, next) {
 	if (next === void 0) return current;
 	if (current === void 0) return next;
 	return Temporal.Instant.compare(next, current) < 0 ? next : current;
 }
-/** Returns the later of two optional timestamps. */
 function latestOptionalTimestamp(current, next) {
 	if (next === void 0) return current;
 	if (current === void 0) return next;
 	return Temporal.Instant.compare(next, current) > 0 ? next : current;
 }
-/** Returns whether `next` should replace `current` as the earliest defined instant. */
-function shouldReplaceWorkflowEarliestDefinedInstant(current, next) {
-	return next !== void 0 && (current === void 0 || Temporal.Instant.compare(next, current) < 0);
-}
 //#endregion
-export { compareOptionalTimestamps, durationBetween, durationBetweenMilliseconds, earliestOptionalTimestamp, latestOptionalTimestamp, matchesOptionalDurationRange, matchesOptionalTimestampRange, matchesTimestampRange, optionalDurationBetweenMilliseconds, shouldReplaceWorkflowEarliestDefinedInstant };
+export { compareOptionalTimestamps, durationBetween, durationTotal, earliestOptionalTimestamp, latestOptionalTimestamp, matchesOptionalDurationRange, matchesOptionalTimestampRange, matchesTimestampRange, optionalDurationBetweenMilliseconds };

package/dist/timer.d.mts

@@ -1,12 +1,14 @@
-import { TimerDelay } from "./types/common.mjs";
 //#region src/timer.d.ts
-declare const MAX_TIMER_DELAY: number;
-/** Runtime timer handle returned by setTimeout. */
-type TimeoutHandle = ReturnType<typeof setTimeout>;
-/** Runtime interval handle returned by setInterval. */
-type IntervalHandle = ReturnType<typeof setInterval>;
-declare function nonNegativeTimerDelay(duration: Temporal.Duration, label: string, maximumDelay?: number): TimerDelay;
-declare function positiveTimerDelay(duration: Temporal.Duration, label: string, maximumDelay?: number): TimerDelay;
-declare function sleep(duration: number): Promise<void>;
+/** Timer delay after validation and runtime clamping. */
+interface TimerDelay {
+  readonly duration: Temporal.Duration;
+  readonly clampedDelay: number;
+}
+export declare const MAX_TIMER_DELAY: number;
+export type TimeoutHandle = ReturnType<typeof setTimeout>;
+export type IntervalHandle = ReturnType<typeof setInterval>;
+export declare function nonNegativeTimerDelay(duration: Temporal.Duration, label: string, maximumDelay?: number): TimerDelay;
+export declare function positiveTimerDelay(duration: Temporal.Duration, label: string, maximumDelay?: number): TimerDelay;
+export declare function sleep(duration: number): Promise<void>;
 //#endregion
-export { IntervalHandle, MAX_TIMER_DELAY, TimeoutHandle, nonNegativeTimerDelay, positiveTimerDelay, sleep };
+export {};

package/dist/timer.mjs

@@ -1,11 +1,16 @@
+import { durationTotal } from "./temporal.mjs";
+import { WorkflowErrorCode } from "./errors/codes.mjs";
 import { WorkflowOptionsError } from "./errors/base.mjs";
-import { durationTotal, isNonNegativeSafeInteger, isPositiveSafeInteger } from "./utility.mjs";
 import "./errors/mod.mjs";
+import { isNonNegativeSafeInteger, isPositiveSafeInteger } from "./values.mjs";
 //#region src/timer.ts
 const MAX_TIMER_DELAY = 2 ** 31 - 1;
 function nonNegativeTimerDelay(duration, label, maximumDelay = MAX_TIMER_DELAY) {
 	const delay = durationTotal(duration);
-	if (!isNonNegativeSafeInteger(delay)) WorkflowOptionsError.nonNegativeDuration(label);
+	if (!isNonNegativeSafeInteger(delay)) throw new WorkflowOptionsError(`${label} must be non-negative`, {
+		code: WorkflowErrorCode.OPTIONS_EXPECTED_NON_NEGATIVE_DURATION,
+		details: { label }
+	});
 	return {
 		duration,
 		clampedDelay: Math.min(delay, maximumDelay)
@@ -13,7 +18,10 @@ function nonNegativeTimerDelay(duration, label, maximumDelay = MAX_TIMER_DELAY)
 }
 function positiveTimerDelay(duration, label, maximumDelay = MAX_TIMER_DELAY) {
 	const delay = durationTotal(duration);
-	if (!isPositiveSafeInteger(delay)) WorkflowOptionsError.positiveDuration(label);
+	if (!isPositiveSafeInteger(delay)) throw new WorkflowOptionsError(`${label} must be greater than zero`, {
+		code: WorkflowErrorCode.OPTIONS_EXPECTED_POSITIVE_DURATION,
+		details: { label }
+	});
 	return {
 		duration,
 		clampedDelay: Math.min(delay, maximumDelay)

package/dist/types/cleanup.d.mts

@@ -1,59 +1,29 @@
-import { RunId } from "./run-id.mjs";
-import { StepId } from "./step-id.mjs";
-import { WorkflowTerminalRunStatus } from "./run.mjs";
-import { z } from "zod";
+import { RunId } from "./ids.mjs";
+import { RunLinks, TerminalRunStatus } from "./run.mjs";
 //#region src/types/cleanup.d.ts
-declare const workflowCleanupModeSchema: z.ZodLiteral<"best_effort">;
-declare const workflowCleanupMarkerRecordSchema: z.ZodObject<{
-  mode: z.ZodLiteral<"best_effort">;
-  runId: z.ZodString;
-  workflowName: z.ZodString;
-  workflowVersion: z.ZodOptional<z.ZodString>;
-  status: z.ZodEnum<{
-    canceled: "canceled";
-    completed: "completed";
-    failed: "failed";
-  }>;
-  createdAt: z.ZodCustom<Temporal.Instant, Temporal.Instant>;
-  finishedAt: z.ZodCustom<Temporal.Instant, Temporal.Instant>;
-  cleanupStartedAt: z.ZodCustom<Temporal.Instant, Temporal.Instant>;
-  events: z.ZodNumber;
-  stepAttempts: z.ZodNumber;
-  idempotencyKeys: z.ZodNumber;
-  messageIdempotencyKeys: z.ZodNumber;
-}, z.core.$strip>;
 /** Cleanup strategy used when deleting terminal run data from the store. */
-type CleanupMode = "best_effort";
-/** Options for workflow cleanup runs. */
-interface CleanupRunsOptions extends WorkflowCleanupRunFilterOptions {
+export type CleanupMode = "best_effort";
+export interface CleanupRunsOptions extends CleanupRunFilterOptions {
   readonly finishedAtBefore: Temporal.Instant;
 }
-/** Status filter accepted by workflow cleanup operations. */
-type CleanupStatusFilter = WorkflowTerminalRunStatus | readonly WorkflowTerminalRunStatus[];
-/** Options for workflow retention policy. */
-interface RetentionPolicyOptions extends WorkflowCleanupRunFilterOptions {
+export type CleanupStatusFilter = TerminalRunStatus | readonly TerminalRunStatus[];
+export interface RetentionPolicyOptions extends CleanupRunFilterOptions {
   readonly olderThan: Temporal.Duration;
   readonly now?: Temporal.Instant;
 }
-interface WorkflowCleanupRunFilterOptions {
+interface CleanupRunFilterOptions extends RunLinks {
   readonly status?: CleanupStatusFilter;
   readonly workflowName?: string;
   readonly workflowVersion?: string;
-  readonly idempotencyKey?: string;
-  readonly parentRunId?: RunId;
-  readonly parentStepId?: StepId;
-  readonly parentStepName?: string;
-  readonly parentStepAttempt?: number;
   readonly dryRun?: boolean;
   readonly limit?: number;
 }
-/** Stored record for workflow cleanup marker. */
-interface CleanupMarkerRecord {
+export interface CleanupMarkerRecord {
   readonly mode: CleanupMode;
   readonly runId: RunId;
   readonly workflowName: string;
   readonly workflowVersion?: string;
-  readonly status: WorkflowTerminalRunStatus;
+  readonly status: TerminalRunStatus;
   readonly createdAt: Temporal.Instant;
   readonly finishedAt: Temporal.Instant;
   readonly cleanupStartedAt: Temporal.Instant;
@@ -62,8 +32,7 @@ interface CleanupMarkerRecord {
   readonly idempotencyKeys: number;
   readonly messageIdempotencyKeys: number;
 }
-/** Result returned by workflow cleanup runs. */
-interface CleanupRunsResult {
+export interface CleanupRunsResult {
   readonly mode: CleanupMode;
   readonly runIds: readonly RunId[];
   readonly runs: readonly CleanupRunResult[];
@@ -81,21 +50,15 @@ interface CleanupRunsResult {
   readonly deletedIdempotencyKeys: number;
   readonly deletedMessageIdempotencyKeys: number;
 }
-/** Result returned by workflow cleanup run. */
-interface CleanupRunResult {
+export interface CleanupRunResult extends RunLinks {
   readonly mode: CleanupMode;
   readonly runId: RunId;
   readonly workflowName: string;
   readonly workflowVersion?: string;
-  readonly status: WorkflowTerminalRunStatus;
+  readonly status: TerminalRunStatus;
   readonly createdAt: Temporal.Instant;
   readonly updatedAt: Temporal.Instant;
   readonly finishedAt: Temporal.Instant;
-  readonly idempotencyKey?: string;
-  readonly parentRunId?: RunId;
-  readonly parentStepId?: StepId;
-  readonly parentStepName?: string;
-  readonly parentStepAttempt?: number;
   readonly events: number;
   readonly stepAttempts: number;
   readonly idempotencyKeys: number;
@@ -109,4 +72,4 @@ interface CleanupRunResult {
   readonly deletedMessageIdempotencyKeys: number;
 }
 //#endregion
-export { CleanupMarkerRecord, CleanupMode, CleanupRunResult, CleanupRunsOptions, CleanupRunsResult, CleanupStatusFilter, RetentionPolicyOptions, workflowCleanupMarkerRecordSchema, workflowCleanupModeSchema };
+export {};

package/dist/types/cleanup.mjs

@@ -1,22 +1 @@
-import { nonBlankStringSchema, nonNegativeSafeIntegerSchema, temporalInstantSchema } from "./common.mjs";
-import { runIdSchema } from "./run-id.mjs";
-import { workflowTerminalRunStatusSchema } from "./run.mjs";
-import { z } from "zod";
-//#region src/types/cleanup.ts
-const workflowCleanupModeSchema = z.literal("best_effort");
-const workflowCleanupMarkerRecordSchema = z.object({
-	mode: workflowCleanupModeSchema,
-	runId: runIdSchema,
-	workflowName: nonBlankStringSchema,
-	workflowVersion: nonBlankStringSchema.optional(),
-	status: workflowTerminalRunStatusSchema,
-	createdAt: temporalInstantSchema,
-	finishedAt: temporalInstantSchema,
-	cleanupStartedAt: temporalInstantSchema,
-	events: nonNegativeSafeIntegerSchema,
-	stepAttempts: nonNegativeSafeIntegerSchema,
-	idempotencyKeys: nonNegativeSafeIntegerSchema,
-	messageIdempotencyKeys: nonNegativeSafeIntegerSchema
-});
-//#endregion
-export { workflowCleanupMarkerRecordSchema, workflowCleanupModeSchema };
+export {};