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

package/dist/errors/codes.d.mts

@@ -0,0 +1,116 @@
+//#region src/errors/codes.d.ts
+/** Stable machine-readable conditions emitted by the workflow package. */
+export declare const WorkflowErrorCode: {
+  readonly ERROR: "workflow.error";
+  readonly DEFINITION_INVALID: "definition.invalid";
+  readonly CAPABILITY_UNSUPPORTED: "capability.unsupported";
+  readonly OPTIONS_INVALID: "options.invalid";
+  readonly OPTIONS_EXPECTED_NON_BLANK: "options.expected_non_blank";
+  readonly OPTIONS_REQUIRED: "options.required";
+  readonly OPTIONS_EXPECTED_POSITIVE_SAFE_INTEGER: "options.expected_positive_safe_integer";
+  readonly OPTIONS_EXPECTED_NON_NEGATIVE_SAFE_INTEGER: "options.expected_non_negative_safe_integer";
+  readonly OPTIONS_EXPECTED_POSITIVE_DURATION: "options.expected_positive_duration";
+  readonly OPTIONS_EXPECTED_NON_NEGATIVE_DURATION: "options.expected_non_negative_duration";
+  readonly OPTIONS_EXPECTED_TIMER_SAFE_DURATION: "options.expected_timer_safe_duration";
+  readonly OPTIONS_EXPECTED_POSITIVE_SAFE_INTEGER_DURATION: "options.expected_positive_safe_integer_duration";
+  readonly OPTIONS_EXPECTED_TEMPORAL_INSTANT: "options.expected_temporal_instant";
+  readonly OPTIONS_CHILD_CANCELLATION_POLICY_INVALID: "options.child_cancellation_policy_invalid";
+  readonly OPTIONS_CURSOR_INVALID: "options.cursor_invalid";
+  readonly OPTIONS_RETRY_MAXIMUM_INTERVAL_TOO_SMALL: "options.retry_maximum_interval_too_small";
+  readonly OPTIONS_RETRYABLE_ERROR_DELAY_CONFLICT: "options.retryable_error_delay_conflict";
+  readonly OPTIONS_ENGINE_STORE_STORAGE_CONFLICT: "options.engine_store_storage_conflict";
+  readonly OPTIONS_MISSING_IMPLEMENTATION_RETRY_ATTEMPT_INVALID: "options.missing_implementation_retry_attempt_invalid";
+  readonly STATE_INVALID: "state.invalid";
+  readonly STATE_RUN_NAMESPACE_MISMATCH: "state.run_namespace_mismatch";
+  readonly STATE_RUN_ID_MISMATCH: "state.run_id_mismatch";
+  readonly STATE_RUN_ALREADY_EXISTS: "state.run_already_exists";
+  readonly STATE_EVENT_HISTORY_ALREADY_EXISTS: "state.event_history_already_exists";
+  readonly STATE_EVENT_NOT_TERMINAL_STEP: "state.event_not_terminal_step";
+  readonly STATE_RECORDED_STEP_EVENT_UNSUPPORTED: "state.recorded_step_event_unsupported";
+  readonly STATE_STEP_ATTEMPT_FIELD_MISMATCH: "state.step_attempt_field_mismatch";
+  readonly STATE_FAILED_RUN_MISSING_ERROR: "state.failed_run_missing_error";
+  readonly STATE_RUN_NOT_CLAIMABLE: "state.run_not_claimable";
+  readonly STATE_WORKER_STOPPED_BEFORE_RUN: "state.worker_stopped_before_run";
+  readonly STATE_IDEMPOTENCY_KEY_CLAIMED_WITHOUT_RUN: "state.idempotency_key_claimed_without_run";
+  readonly STATE_RUN_MISSING_IDEMPOTENCY_KEY: "state.run_missing_idempotency_key";
+  readonly STATE_RUN_METADATA_UPDATE_FAILED: "state.run_metadata_update_failed";
+  readonly STATE_RUN_ATTRIBUTES_UPDATE_FAILED: "state.run_attributes_update_failed";
+  readonly STATE_RUN_CANNOT_BE_RESCHEDULED: "state.run_cannot_be_rescheduled";
+  readonly STATE_RUN_RESCHEDULE_FAILED: "state.run_reschedule_failed";
+  readonly STATE_STALE_LEASE_RELEASE_REQUIRES_RUNNING: "state.stale_lease_release_requires_running";
+  readonly STATE_RUN_LEASE_STILL_ACTIVE: "state.run_lease_still_active";
+  readonly STATE_STALE_RUN_LEASE_RELEASE_FAILED: "state.stale_run_lease_release_failed";
+  readonly STATE_RUN_RETRY_REQUIRES_FAILED: "state.run_retry_requires_failed";
+  readonly STATE_RUN_RETRY_REQUIRES_FORCE_AFTER_PERMANENT_FAILURE: "state.run_retry_requires_force_after_permanent_failure";
+  readonly STATE_FAILED_RUN_RETRY_REQUIRES_FORCE: "state.failed_run_retry_requires_force";
+  readonly STATE_RUN_RETRY_FAILED: "state.run_retry_failed";
+  readonly STATE_PERMANENT_RUN_FAILURE_FAILED: "state.permanent_run_failure_failed";
+  readonly STATE_PERMANENT_FAILURE_STATUS_INVALID: "state.permanent_failure_status_invalid";
+  readonly STATE_MESSAGE_APPEND_FAILED: "state.message_append_failed";
+  readonly STATE_CLEANUP_SELECTED_NON_TERMINAL_RUN: "state.cleanup_selected_non_terminal_run";
+  readonly STATE_CLEANUP_RUN_MISSING_FINISHED_AT: "state.cleanup_run_missing_finished_at";
+  readonly STATE_WORKFLOW_EVENT_APPEND_FAILED: "state.workflow_event_append_failed";
+  readonly STATE_STEP_ATTEMPT_MATERIALIZATION_FAILED: "state.step_attempt_materialization_failed";
+  readonly STATE_APPEND_PROJECTION_PIPELINE_MISSING: "state.append_projection_pipeline_missing";
+  readonly RUN_ERROR: "run.error";
+  readonly STEP_ERROR: "step.error";
+  readonly MESSAGE_ERROR: "message.error";
+  readonly IMPLEMENTATION_NOT_FOUND: "implementation.not_found";
+  readonly DURATION_INVALID: "duration.invalid";
+  readonly SERIALIZATION_FAILED: "serialization.failed";
+  readonly NON_RETRYABLE_FAILURE: "failure.non_retryable";
+  readonly PERMANENT_FAILURE: "failure.permanent";
+  readonly RETRYABLE_FAILURE: "failure.retryable";
+  readonly REPLAY_DIVERGED: "replay.diverged";
+  readonly LOCK_ALREADY_HELD: "lock.already_held";
+  readonly RUN_NOT_FOUND: "run.not_found";
+  readonly RUN_INVALID: "run.invalid";
+  readonly RUN_WORKFLOW_MISMATCH: "run.workflow_mismatch";
+  readonly RUN_RESULT_TIMEOUT: "run.result_timeout";
+  readonly RUN_CANCELED: "run.canceled";
+  readonly RUN_CANCELLATION_REJECTED: "run.cancellation_rejected";
+  readonly RUN_TRANSITION_INVALID: "run.transition_invalid";
+  readonly RUN_PARENT_INVALID: "run.parent_invalid";
+  readonly RUN_DEADLINE_EXCEEDED: "run.deadline_exceeded";
+  readonly CHILD_WORKFLOW_TIMEOUT: "child_workflow.timeout";
+  readonly MESSAGE_WAIT_TIMEOUT: "message.wait_timeout";
+  readonly HOOK_DISPOSED: "hook.disposed";
+  readonly MESSAGE_DELIVERY_REJECTED: "message.delivery_rejected";
+  readonly MESSAGE_IDEMPOTENCY_CONFLICT: "message.idempotency_conflict";
+  readonly STEP_TIMEOUT: "step.timeout";
+  readonly STEP_EXECUTION_FAILED: "step.execution_failed";
+  readonly STEP_RETRY_LIMIT_EXCEEDED: "step.retry_limit_exceeded";
+  readonly STEP_ATTEMPT_LIMIT_EXCEEDED: "step.attempt_limit_exceeded";
+  readonly SCHEDULE_ALREADY_EXISTS: "schedule.already_exists";
+  readonly SCHEDULE_NAMESPACE_MISMATCH: "schedule.namespace_mismatch";
+  readonly SCHEDULE_RECORD_INVALID: "schedule.record_invalid";
+  readonly SCHEDULE_ID_CHANGE_REJECTED: "schedule.id_change_rejected";
+  readonly SCHEDULE_CURRENT_RECORD_INVALID: "schedule.current_record_invalid";
+  readonly SCHEDULE_NEXT_RECORD_INVALID: "schedule.next_record_invalid";
+  readonly SCHEDULE_UPSERT_CONFLICT_EXHAUSTED: "schedule.upsert_conflict_exhausted";
+  readonly SCHEDULE_NOT_FOUND: "schedule.not_found";
+  readonly SCHEDULE_UPDATE_CONFLICT_EXHAUSTED: "schedule.update_conflict_exhausted";
+  readonly STREAM_NOT_FOUND: "stream.not_found";
+  readonly STREAM_CHUNK_LIMIT_EXCEEDED: "stream.chunk_limit_exceeded";
+  readonly STREAM_READ_OFFSET_CONFLICT: "stream.read_offset_conflict";
+  readonly STREAM_CHUNK_INDEX_NON_CONTIGUOUS: "stream.chunk_index_non_contiguous";
+  readonly STREAM_CHUNK_AFTER_TERMINAL: "stream.chunk_after_terminal";
+  readonly STREAM_ALREADY_CLOSED: "stream.already_closed";
+  readonly LOCK_ALREADY_HELD_WITHOUT_WAIT: "lock.already_held_without_wait";
+  readonly LOCK_HOLDER_MISMATCH: "lock.holder_mismatch";
+  readonly LOCK_ALREADY_RELEASED: "lock.already_released";
+  readonly LOCK_NOT_STALE: "lock.not_stale";
+  readonly LOCK_WAIT_DEADLINE_CONFLICT: "lock.wait_deadline_conflict";
+  readonly LOCK_TIMEOUT_REQUIRES_WAIT: "lock.timeout_requires_wait";
+  readonly LOCK_NAMESPACE_MISMATCH: "lock.namespace_mismatch";
+  readonly LOCK_KEY_CHANGE_REJECTED: "lock.key_change_rejected";
+  readonly LOCK_ACQUIRE_CONFLICT_EXHAUSTED: "lock.acquire_conflict_exhausted";
+  readonly LOCK_NOT_FOUND: "lock.not_found";
+  readonly LOCK_RELEASE_CONFLICT_EXHAUSTED: "lock.release_conflict_exhausted";
+  readonly LOCK_STALE_RELEASE_CONFLICT_EXHAUSTED: "lock.stale_release_conflict_exhausted";
+  readonly HOOK_TOKEN_INVALID: "hook.token_invalid";
+  readonly HOOK_TOKEN_NOT_UNIQUE: "hook.token_not_unique";
+  readonly HOOK_WAITING_STEP_MISSING: "hook.waiting_step_missing";
+};
+export type WorkflowErrorCode = (typeof WorkflowErrorCode)[keyof typeof WorkflowErrorCode];
+//#endregion

package/dist/{types/error-code.mjs → errors/codes.mjs}

@@ -1,19 +1,11 @@
-import { z } from "zod";
-//#region src/types/error-code.ts
+//#region src/errors/codes.ts
 /** Stable machine-readable conditions emitted by the workflow package. */
 const WorkflowErrorCode = {
 	ERROR: "workflow.error",
 	DEFINITION_INVALID: "definition.invalid",
 	CAPABILITY_UNSUPPORTED: "capability.unsupported",
 	OPTIONS_INVALID: "options.invalid",
-	OPTIONS_EXPECTED_OBJECT: "options.expected_object",
-	OPTIONS_EXPECTED_ARRAY: "options.expected_array",
-	OPTIONS_EXPECTED_FUNCTION: "options.expected_function",
-	OPTIONS_EXPECTED_STRING: "options.expected_string",
-	OPTIONS_EXPECTED_NON_EMPTY: "options.expected_non_empty",
 	OPTIONS_EXPECTED_NON_BLANK: "options.expected_non_blank",
-	OPTIONS_EXPECTED_NUMBER: "options.expected_number",
-	OPTIONS_EXPECTED_BOOLEAN: "options.expected_boolean",
 	OPTIONS_REQUIRED: "options.required",
 	OPTIONS_EXPECTED_POSITIVE_SAFE_INTEGER: "options.expected_positive_safe_integer",
 	OPTIONS_EXPECTED_NON_NEGATIVE_SAFE_INTEGER: "options.expected_non_negative_safe_integer",
@@ -22,7 +14,6 @@ const WorkflowErrorCode = {
 	OPTIONS_EXPECTED_TIMER_SAFE_DURATION: "options.expected_timer_safe_duration",
 	OPTIONS_EXPECTED_POSITIVE_SAFE_INTEGER_DURATION: "options.expected_positive_safe_integer_duration",
 	OPTIONS_EXPECTED_TEMPORAL_INSTANT: "options.expected_temporal_instant",
-	OPTIONS_EXPECTED_ABORT_SIGNAL: "options.expected_abort_signal",
 	OPTIONS_CHILD_CANCELLATION_POLICY_INVALID: "options.child_cancellation_policy_invalid",
 	OPTIONS_CURSOR_INVALID: "options.cursor_invalid",
 	OPTIONS_RETRY_MAXIMUM_INTERVAL_TOO_SMALL: "options.retry_maximum_interval_too_small",
@@ -40,7 +31,6 @@ const WorkflowErrorCode = {
 	STATE_FAILED_RUN_MISSING_ERROR: "state.failed_run_missing_error",
 	STATE_RUN_NOT_CLAIMABLE: "state.run_not_claimable",
 	STATE_WORKER_STOPPED_BEFORE_RUN: "state.worker_stopped_before_run",
-	STATE_STORE_RUN_ID_INVALID: "state.store_run_id_invalid",
 	STATE_IDEMPOTENCY_KEY_CLAIMED_WITHOUT_RUN: "state.idempotency_key_claimed_without_run",
 	STATE_RUN_MISSING_IDEMPOTENCY_KEY: "state.run_missing_idempotency_key",
 	STATE_RUN_METADATA_UPDATE_FAILED: "state.run_metadata_update_failed",
@@ -62,7 +52,6 @@ const WorkflowErrorCode = {
 	STATE_WORKFLOW_EVENT_APPEND_FAILED: "state.workflow_event_append_failed",
 	STATE_STEP_ATTEMPT_MATERIALIZATION_FAILED: "state.step_attempt_materialization_failed",
 	STATE_APPEND_PROJECTION_PIPELINE_MISSING: "state.append_projection_pipeline_missing",
-	RUNTIME_INVALID: "runtime.invalid",
 	RUN_ERROR: "run.error",
 	STEP_ERROR: "step.error",
 	MESSAGE_ERROR: "message.error",
@@ -115,17 +104,13 @@ const WorkflowErrorCode = {
 	LOCK_TIMEOUT_REQUIRES_WAIT: "lock.timeout_requires_wait",
 	LOCK_NAMESPACE_MISMATCH: "lock.namespace_mismatch",
 	LOCK_KEY_CHANGE_REJECTED: "lock.key_change_rejected",
-	LOCK_CURRENT_RECORD_INVALID: "lock.current_record_invalid",
-	LOCK_NEXT_RECORD_INVALID: "lock.next_record_invalid",
 	LOCK_ACQUIRE_CONFLICT_EXHAUSTED: "lock.acquire_conflict_exhausted",
 	LOCK_NOT_FOUND: "lock.not_found",
 	LOCK_RELEASE_CONFLICT_EXHAUSTED: "lock.release_conflict_exhausted",
 	LOCK_STALE_RELEASE_CONFLICT_EXHAUSTED: "lock.stale_release_conflict_exhausted",
 	HOOK_TOKEN_INVALID: "hook.token_invalid",
-	WEBHOOK_TOKEN_INVALID: "webhook.token_invalid",
 	HOOK_TOKEN_NOT_UNIQUE: "hook.token_not_unique",
 	HOOK_WAITING_STEP_MISSING: "hook.waiting_step_missing"
 };
-const workflowErrorCodeSchema = z.enum(WorkflowErrorCode);
 //#endregion
-export { WorkflowErrorCode, workflowErrorCodeSchema };
+export { WorkflowErrorCode };

package/dist/errors/definition.d.mts

@@ -1,22 +1,8 @@
 import { WorkflowError } from "./base.mjs";
 //#region src/errors/definition.d.ts
-/** Error thrown for definition failures. */
-declare class WorkflowDefinitionError extends WorkflowError {
-  constructor(message: string, context?: Function);
-  static create(this: void, message: string): WorkflowDefinitionError;
-  static object(this: void, label: string): never;
-  static standardObject(this: void, label: string): never;
-  static standardValidateFunction(this: void, label: string): never;
-  static handlerFunction(this: void): never;
-  static stepNameOrCommandIdRequired(this: void): never;
-  static string(this: void, label: string): never;
-  static nonEmpty(this: void, label: string): never;
-  static nameMismatch(this: void, label: string): never;
-  static versionMismatch(this: void, label: string): never;
+export declare class WorkflowDefinitionError extends WorkflowError {
+  constructor(message: string);
   static compiledMetadataMissing(this: void): never;
-  static compiledStepMetadataMissing(this: void): never;
-  static implementationAlreadyRegistered(this: void, key: string): never;
   static implementationNotBundled(this: void, key: string): never;
 }
-//#endregion
-export { WorkflowDefinitionError };
+//#endregion

package/dist/errors/definition.mjs

@@ -1,53 +1,16 @@
-import { WorkflowErrorCode } from "../types/error-code.mjs";
+import { WorkflowErrorCode } from "./codes.mjs";
 import { WorkflowError } from "./base.mjs";
 //#region src/errors/definition.ts
-/** Error thrown for definition failures. */
 var WorkflowDefinitionError = class WorkflowDefinitionError extends WorkflowError {
-	constructor(message, context) {
-		super(message, { code: WorkflowErrorCode.DEFINITION_INVALID }, context);
+	constructor(message) {
+		super(message, { code: WorkflowErrorCode.DEFINITION_INVALID });
 		this.name = "WorkflowDefinitionError";
 	}
-	static create(message) {
-		return new WorkflowDefinitionError(message, WorkflowDefinitionError.create);
-	}
-	static object(label) {
-		throw new WorkflowDefinitionError(`${label} must be an object`, WorkflowDefinitionError.object);
-	}
-	static standardObject(label) {
-		throw new WorkflowDefinitionError(`${label}.~standard must be an object`, WorkflowDefinitionError.standardObject);
-	}
-	static standardValidateFunction(label) {
-		throw new WorkflowDefinitionError(`${label}.~standard.validate must be a function`, WorkflowDefinitionError.standardValidateFunction);
-	}
-	static handlerFunction() {
-		throw new WorkflowDefinitionError("Workflow handler must be a function", WorkflowDefinitionError.handlerFunction);
-	}
-	static stepNameOrCommandIdRequired() {
-		throw new WorkflowDefinitionError("Workflow step name or commandId is required", WorkflowDefinitionError.stepNameOrCommandIdRequired);
-	}
-	static string(label) {
-		throw new WorkflowDefinitionError(`${label} must be a string`, WorkflowDefinitionError.string);
-	}
-	static nonEmpty(label) {
-		throw new WorkflowDefinitionError(`${label} must not be empty`, WorkflowDefinitionError.nonEmpty);
-	}
-	static nameMismatch(label) {
-		throw new WorkflowDefinitionError(`${label} name mismatch`, WorkflowDefinitionError.nameMismatch);
-	}
-	static versionMismatch(label) {
-		throw new WorkflowDefinitionError(`${label} version mismatch`, WorkflowDefinitionError.versionMismatch);
-	}
 	static compiledMetadataMissing() {
-		throw new WorkflowDefinitionError("Compiled workflow function is missing compiled workflow metadata", WorkflowDefinitionError.compiledMetadataMissing);
-	}
-	static compiledStepMetadataMissing() {
-		throw new WorkflowDefinitionError("Compiled workflow step function is missing compiled workflow metadata", WorkflowDefinitionError.compiledStepMetadataMissing);
-	}
-	static implementationAlreadyRegistered(key) {
-		throw new WorkflowDefinitionError(`Workflow implementation already registered: ${key}`, WorkflowDefinitionError.implementationAlreadyRegistered);
+		throw new WorkflowDefinitionError("Compiled workflow function is missing compiled workflow metadata");
 	}
 	static implementationNotBundled(key) {
-		throw new WorkflowDefinitionError(`Workflow implementation is not included in the workflow bundle: ${key}`, WorkflowDefinitionError.implementationNotBundled);
+		throw new WorkflowDefinitionError(`Workflow implementation is not included in the workflow bundle: ${key}`);
 	}
 };
 //#endregion

package/dist/errors/failures.d.mts

@@ -1,81 +1,47 @@
-import { RunId } from "../types/run-id.mjs";
-import { StepId } from "../types/step-id.mjs";
-import "../types/step.mjs";
-import "../types/run.mjs";
-import { WorkflowNonRetryableErrorOptions, WorkflowRetryableErrorOptions } from "../types/error.mjs";
+import { RunId, StepId } from "../types/ids.mjs";
+import { RetryableErrorOptions, WorkflowErrorOptions } from "../types/error.mjs";
 import { WorkflowError } from "./base.mjs";
 //#region src/errors/failures.d.ts
-/** Error thrown for duration failures. */
-declare class WorkflowDurationError extends WorkflowError {
-  constructor(message: string, context?: Function);
-  static create(this: void, message: string): WorkflowDurationError;
-  static retryAtInstant(this: void, label: string): never;
-  static timerSafe(this: void, label: string): never;
-  static temporalDuration(this: void, label: string): never;
-  static finite(this: void, label: string): never;
-  static positiveSafeInteger(this: void, label: string): never;
-  static stepTimeoutPositive(this: void): never;
-  static signalTimeoutPositive(this: void): never;
-  static childPollIntervalTimerSafe(this: void): never;
-  static childTimeoutPositive(this: void): never;
+export declare class WorkflowDurationError extends WorkflowError {
+  constructor(message: string);
 }
-/** Error thrown for serialization failures. */
-declare class WorkflowSerializationError extends WorkflowError {
+export declare class WorkflowSerializationError extends WorkflowError {
   readonly path: string;
   readonly reason: string;
-  constructor(path: string, reason: string, context?: Function);
+  constructor(path: string, reason: string);
   static notSerializable(this: void, path: string, reason: string): never;
-  static create(this: void, path: string, reason: string): WorkflowSerializationError;
 }
 /** Error thrown when workflow code wants to fail without retry. */
-declare class WorkflowNonRetryableError extends WorkflowError {
-  constructor(message: string, options?: WorkflowNonRetryableErrorOptions, context?: Function);
-  static failed(this: void, message: string, options?: WorkflowNonRetryableErrorOptions): never;
-  static create(this: void, message: string, options?: WorkflowNonRetryableErrorOptions): WorkflowNonRetryableError;
+export declare class WorkflowNonRetryableError extends WorkflowError {
+  constructor(message: string, options?: WorkflowErrorOptions);
 }
 /** Error thrown when a run is intentionally marked permanently failed. */
-declare class WorkflowPermanentFailureError extends WorkflowError {
+export declare class WorkflowPermanentFailureError extends WorkflowError {
   readonly runId: RunId;
   readonly reason: string;
   constructor(options: {
     readonly runId: RunId;
     readonly reason: string;
-  }, context?: Function);
-  static failed(this: void, options: {
-    readonly runId: RunId;
-    readonly reason: string;
-  }): never;
-  static create(this: void, options: {
-    readonly runId: RunId;
-    readonly reason: string;
-  }): WorkflowPermanentFailureError;
+  });
 }
-/** Error thrown for retryable failures. */
-declare class WorkflowRetryableError extends WorkflowError {
+export declare class WorkflowRetryableError extends WorkflowError {
   readonly retryAt: Temporal.Instant | undefined;
   readonly retryDelay: Temporal.Duration | undefined;
-  constructor(message: string, options: WorkflowRetryableErrorOptions, context?: Function);
-  static lockAlreadyHeld(this: void, key: string, options: WorkflowRetryableErrorOptions): never;
-  static isLockAlreadyHeld(error: unknown, key?: string): boolean;
-  static failed(this: void, message: string, options: WorkflowRetryableErrorOptions): never;
-  static create(this: void, message: string, options: WorkflowRetryableErrorOptions): WorkflowRetryableError;
+  constructor(message: string, options: RetryableErrorOptions);
 }
-/** Error thrown for replay divergence failures. */
-declare class WorkflowReplayDivergenceError extends WorkflowError {
+export declare class WorkflowReplayDivergenceError extends WorkflowError {
   readonly expectedStepId: StepId | undefined;
   readonly actualStepId: StepId | undefined;
   constructor(message: string, options: {
     readonly expectedStepId?: string;
     readonly actualStepId?: string;
-  }, context?: Function);
+  });
+  /** A divergence in one step, where the recorded and the replayed step are the same. */
+  static atStep(this: void, stepId: string | undefined, message: string): never;
   static diverged(this: void, message: string, options: {
     readonly expectedStepId?: string;
     readonly actualStepId?: string;
   }): never;
-  static create(this: void, message: string, options: {
-    readonly expectedStepId?: string;
-    readonly actualStepId?: string;
-  }): WorkflowReplayDivergenceError;
 }
 //#endregion
-export { WorkflowDurationError, WorkflowNonRetryableError, type WorkflowNonRetryableErrorOptions, WorkflowPermanentFailureError, WorkflowReplayDivergenceError, WorkflowRetryableError, type WorkflowRetryableErrorOptions, WorkflowSerializationError };
+export type { RetryableErrorOptions, WorkflowErrorOptions };

package/dist/errors/failures.mjs

@@ -1,167 +1,100 @@
-import { WorkflowErrorCode } from "../types/error-code.mjs";
+import { WorkflowErrorCode } from "./codes.mjs";
 import { WorkflowError, WorkflowOptionsError } from "./base.mjs";
-import { workflowErrorRecordView } from "./record-view.mjs";
 //#region src/errors/failures.ts
-/** Error thrown for duration failures. */
-var WorkflowDurationError = class WorkflowDurationError extends WorkflowError {
-	constructor(message, context) {
-		super(message, { code: WorkflowErrorCode.DURATION_INVALID }, context);
+var WorkflowDurationError = class extends WorkflowError {
+	constructor(message) {
+		super(message, { code: WorkflowErrorCode.DURATION_INVALID });
 		this.name = "WorkflowDurationError";
 	}
-	static create(message) {
-		return new WorkflowDurationError(message, WorkflowDurationError.create);
-	}
-	static retryAtInstant(label) {
-		throw new WorkflowDurationError(`${label} retryAt must be a Temporal.Instant`, WorkflowDurationError.retryAtInstant);
-	}
-	static timerSafe(label) {
-		throw new WorkflowDurationError(`${label} must be a timer-safe duration`, WorkflowDurationError.timerSafe);
-	}
-	static temporalDuration(label) {
-		throw new WorkflowDurationError(`${label} must be a Temporal.Duration`, WorkflowDurationError.temporalDuration);
-	}
-	static finite(label) {
-		throw new WorkflowDurationError(`${label} must be finite`, WorkflowDurationError.finite);
-	}
-	static positiveSafeInteger(label) {
-		throw new WorkflowDurationError(`${label} must be a positive safe integer`, WorkflowDurationError.positiveSafeInteger);
-	}
-	static stepTimeoutPositive() {
-		throw new WorkflowDurationError("Workflow step timeout must be greater than zero", WorkflowDurationError.stepTimeoutPositive);
-	}
-	static signalTimeoutPositive() {
-		throw new WorkflowDurationError("Workflow message timeout must be greater than zero", WorkflowDurationError.signalTimeoutPositive);
-	}
-	static childPollIntervalTimerSafe() {
-		throw new WorkflowDurationError("Workflow child pollInterval must be a timer-safe duration", WorkflowDurationError.childPollIntervalTimerSafe);
-	}
-	static childTimeoutPositive() {
-		throw new WorkflowDurationError("Workflow child timeout must be greater than zero", WorkflowDurationError.childTimeoutPositive);
-	}
 };
-/** Error thrown for serialization failures. */
 var WorkflowSerializationError = class WorkflowSerializationError extends WorkflowError {
 	path;
 	reason;
-	constructor(path, reason, context) {
+	constructor(path, reason) {
 		super(`Workflow value is not serializable at ${path}: ${reason}`, {
 			code: WorkflowErrorCode.SERIALIZATION_FAILED,
 			details: {
 				path,
 				reason
 			}
-		}, context);
+		});
 		this.name = "WorkflowSerializationError";
 		this.path = path;
 		this.reason = reason;
 	}
 	static notSerializable(path, reason) {
-		throw new WorkflowSerializationError(path, reason, WorkflowSerializationError.notSerializable);
-	}
-	static create(path, reason) {
-		return new WorkflowSerializationError(path, reason, WorkflowSerializationError.create);
+		throw new WorkflowSerializationError(path, reason);
 	}
 };
 /** Error thrown when workflow code wants to fail without retry. */
-var WorkflowNonRetryableError = class WorkflowNonRetryableError extends WorkflowError {
-	constructor(message, options = {}, context) {
+var WorkflowNonRetryableError = class extends WorkflowError {
+	constructor(message, options = {}) {
 		super(message, {
 			...options,
 			code: WorkflowErrorCode.NON_RETRYABLE_FAILURE
-		}, context);
+		});
 		this.name = "WorkflowNonRetryableError";
 	}
-	static failed(message, options = {}) {
-		throw new WorkflowNonRetryableError(message, options, WorkflowNonRetryableError.failed);
-	}
-	static create(message, options = {}) {
-		return new WorkflowNonRetryableError(message, options, WorkflowNonRetryableError.create);
-	}
 };
 /** Error thrown when a run is intentionally marked permanently failed. */
-var WorkflowPermanentFailureError = class WorkflowPermanentFailureError extends WorkflowError {
+var WorkflowPermanentFailureError = class extends WorkflowError {
 	runId;
 	reason;
-	constructor(options, context) {
+	constructor(options) {
 		super(`Workflow run permanently failed: ${options.runId}: ${options.reason}`, {
 			code: WorkflowErrorCode.PERMANENT_FAILURE,
 			details: {
 				runId: options.runId,
 				reason: options.reason
 			}
-		}, context);
+		});
 		this.name = "WorkflowPermanentFailureError";
 		this.runId = options.runId;
 		this.reason = options.reason;
 	}
-	static failed(options) {
-		throw new WorkflowPermanentFailureError(options, WorkflowPermanentFailureError.failed);
-	}
-	static create(options) {
-		return new WorkflowPermanentFailureError(options, WorkflowPermanentFailureError.create);
-	}
 };
-/** Error thrown for retryable failures. */
-var WorkflowRetryableError = class WorkflowRetryableError extends WorkflowError {
+var WorkflowRetryableError = class extends WorkflowError {
 	retryAt;
 	retryDelay;
-	constructor(message, options, context) {
-		if (options.retryAt !== void 0 && options.retryDelay !== void 0) WorkflowOptionsError.retryableErrorDelayConflict();
+	constructor(message, options) {
+		if (options.retryAt !== void 0 && options.retryDelay !== void 0) throw new WorkflowOptionsError("Workflow retryable error cannot include both retryAt and retryDelay", { code: WorkflowErrorCode.OPTIONS_RETRYABLE_ERROR_DELAY_CONFLICT });
+		const details = { ...options.details };
+		if (options.retryAt !== void 0) details.retryAt = options.retryAt.toString();
+		if (options.retryDelay !== void 0) details.retryDelay = options.retryDelay.toString();
 		super(message, {
 			...options,
 			code: options.code ?? WorkflowErrorCode.RETRYABLE_FAILURE,
-			details: {
-				...options.details,
-				...options.retryAt === void 0 ? {} : { retryAt: options.retryAt.toString() },
-				...options.retryDelay === void 0 ? {} : { retryDelay: options.retryDelay.toString() }
-			}
-		}, context);
+			details
+		});
 		this.name = "WorkflowRetryableError";
 		this.retryAt = options.retryAt;
 		this.retryDelay = options.retryDelay;
 	}
-	static lockAlreadyHeld(key, options) {
-		throw new WorkflowRetryableError(`Workflow lock is already held: ${key}`, {
-			...options,
-			code: WorkflowErrorCode.LOCK_ALREADY_HELD,
-			details: {
-				...options.details,
-				key
-			}
-		}, WorkflowRetryableError.lockAlreadyHeld);
-	}
-	static isLockAlreadyHeld(error, key) {
-		const record = workflowErrorRecordView(error);
-		return record?.code === WorkflowErrorCode.LOCK_ALREADY_HELD && (key === void 0 || record.details?.key === key);
-	}
-	static failed(message, options) {
-		throw new WorkflowRetryableError(message, options, WorkflowRetryableError.failed);
-	}
-	static create(message, options) {
-		return new WorkflowRetryableError(message, options, WorkflowRetryableError.create);
-	}
 };
-/** Error thrown for replay divergence failures. */
 var WorkflowReplayDivergenceError = class WorkflowReplayDivergenceError extends WorkflowError {
 	expectedStepId;
 	actualStepId;
-	constructor(message, options, context) {
+	constructor(message, options) {
+		const details = {};
+		if (options.expectedStepId !== void 0) details.expectedStepId = options.expectedStepId;
+		if (options.actualStepId !== void 0) details.actualStepId = options.actualStepId;
 		super(`Workflow replay diverged: ${message}`, {
 			code: WorkflowErrorCode.REPLAY_DIVERGED,
-			details: {
-				...options.expectedStepId === void 0 ? {} : { expectedStepId: options.expectedStepId },
-				...options.actualStepId === void 0 ? {} : { actualStepId: options.actualStepId }
-			}
-		}, context);
+			details
+		});
 		this.name = "WorkflowReplayDivergenceError";
 		this.expectedStepId = options.expectedStepId;
 		this.actualStepId = options.actualStepId;
 	}
-	static diverged(message, options) {
-		throw new WorkflowReplayDivergenceError(message, options, WorkflowReplayDivergenceError.diverged);
+	/** A divergence in one step, where the recorded and the replayed step are the same. */
+	static atStep(stepId, message) {
+		throw new WorkflowReplayDivergenceError(message, {
+			expectedStepId: stepId,
+			actualStepId: stepId
+		});
 	}
-	static create(message, options) {
-		return new WorkflowReplayDivergenceError(message, options, WorkflowReplayDivergenceError.create);
+	static diverged(message, options) {
+		throw new WorkflowReplayDivergenceError(message, options);
 	}
 };
 //#endregion

package/dist/errors/hook.d.mts

@@ -1,14 +1,10 @@
-import { WorkflowErrorCode } from "../types/error-code.mjs";
-import { WorkflowErrorDetails } from "../types/error.mjs";
+import { WorkflowErrorCode } from "./codes.mjs";
+import { ErrorDetails } from "../types/error.mjs";
 import { WorkflowOptionsError } from "./base.mjs";
 //#region src/errors/hook.d.ts
 /** Errors caused by invalid hook or webhook tokens and hook state. */
-declare class WorkflowHookError extends WorkflowOptionsError {
-  constructor(message: string, code: WorkflowErrorCode, details?: WorkflowErrorDetails, context?: Function);
+export declare class WorkflowHookError extends WorkflowOptionsError {
+  constructor(message: string, code: WorkflowErrorCode, details?: ErrorDetails);
   static tokenInvalid(this: void): never;
-  static webhookTokenInvalid(this: void): never;
-  static tokenNotUnique(this: void, kind: "hook" | "webhook", name: string): never;
-  static waitingStepMissing(this: void): never;
 }
-//#endregion
-export { WorkflowHookError };
+//#endregion

package/dist/errors/hook.mjs

@@ -1,29 +1,17 @@
-import { WorkflowErrorCode } from "../types/error-code.mjs";
+import { WorkflowErrorCode } from "./codes.mjs";
 import { WorkflowOptionsError } from "./base.mjs";
 //#region src/errors/hook.ts
 /** Errors caused by invalid hook or webhook tokens and hook state. */
 var WorkflowHookError = class WorkflowHookError extends WorkflowOptionsError {
-	constructor(message, code, details, context) {
-		super(message, context, {
+	constructor(message, code, details) {
+		super(message, {
 			code,
 			details
 		});
 		this.name = "WorkflowHookError";
 	}
 	static tokenInvalid() {
-		throw new WorkflowHookError("Workflow hook token is invalid", WorkflowErrorCode.HOOK_TOKEN_INVALID, void 0, WorkflowHookError.tokenInvalid);
-	}
-	static webhookTokenInvalid() {
-		throw new WorkflowHookError("Workflow webhook token is invalid", WorkflowErrorCode.WEBHOOK_TOKEN_INVALID, void 0, WorkflowHookError.webhookTokenInvalid);
-	}
-	static tokenNotUnique(kind, name) {
-		throw new WorkflowHookError(`Workflow ${kind} token must be unique within a run: ${name}`, WorkflowErrorCode.HOOK_TOKEN_NOT_UNIQUE, {
-			kind,
-			name
-		}, WorkflowHookError.tokenNotUnique);
-	}
-	static waitingStepMissing() {
-		throw new WorkflowHookError("Workflow hook inspection is missing a waiting step id", WorkflowErrorCode.HOOK_WAITING_STEP_MISSING, void 0, WorkflowHookError.waitingStepMissing);
+		throw new WorkflowHookError("Workflow hook token is invalid", WorkflowErrorCode.HOOK_TOKEN_INVALID, void 0);
 	}
 };
 //#endregion

package/dist/errors/implementation.d.mts

@@ -1,11 +1,8 @@
 import { WorkflowError } from "./base.mjs";
 //#region src/errors/implementation.d.ts
-/** Error thrown for implementation not found failures. */
-declare class WorkflowImplementationNotFoundError extends WorkflowError {
+export declare class WorkflowImplementationNotFoundError extends WorkflowError {
   readonly workflowName: string;
   readonly workflowVersion: string | undefined;
-  constructor(workflowName: string, workflowVersion?: string, context?: Function);
-  static create(this: void, workflowName: string, workflowVersion?: string): WorkflowImplementationNotFoundError;
+  constructor(workflowName: string, workflowVersion?: string);
 }
-//#endregion
-export { WorkflowImplementationNotFoundError };
+//#endregion