@temelj/workflow 0.0.0-alpha.1

package/dist/types/error-code.mjs

@@ -0,0 +1,131 @@
+import { z } from "zod";
+//#region src/types/error-code.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",
+	OPTIONS_EXPECTED_POSITIVE_DURATION: "options.expected_positive_duration",
+	OPTIONS_EXPECTED_NON_NEGATIVE_DURATION: "options.expected_non_negative_duration",
+	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",
+	OPTIONS_RETRYABLE_ERROR_DELAY_CONFLICT: "options.retryable_error_delay_conflict",
+	OPTIONS_ENGINE_STORE_STORAGE_CONFLICT: "options.engine_store_storage_conflict",
+	OPTIONS_MISSING_IMPLEMENTATION_RETRY_ATTEMPT_INVALID: "options.missing_implementation_retry_attempt_invalid",
+	STATE_INVALID: "state.invalid",
+	STATE_RUN_NAMESPACE_MISMATCH: "state.run_namespace_mismatch",
+	STATE_RUN_ID_MISMATCH: "state.run_id_mismatch",
+	STATE_RUN_ALREADY_EXISTS: "state.run_already_exists",
+	STATE_EVENT_HISTORY_ALREADY_EXISTS: "state.event_history_already_exists",
+	STATE_EVENT_NOT_TERMINAL_STEP: "state.event_not_terminal_step",
+	STATE_RECORDED_STEP_EVENT_UNSUPPORTED: "state.recorded_step_event_unsupported",
+	STATE_STEP_ATTEMPT_FIELD_MISMATCH: "state.step_attempt_field_mismatch",
+	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",
+	STATE_RUN_ATTRIBUTES_UPDATE_FAILED: "state.run_attributes_update_failed",
+	STATE_RUN_CANNOT_BE_RESCHEDULED: "state.run_cannot_be_rescheduled",
+	STATE_RUN_RESCHEDULE_FAILED: "state.run_reschedule_failed",
+	STATE_STALE_LEASE_RELEASE_REQUIRES_RUNNING: "state.stale_lease_release_requires_running",
+	STATE_RUN_LEASE_STILL_ACTIVE: "state.run_lease_still_active",
+	STATE_STALE_RUN_LEASE_RELEASE_FAILED: "state.stale_run_lease_release_failed",
+	STATE_RUN_RETRY_REQUIRES_FAILED: "state.run_retry_requires_failed",
+	STATE_RUN_RETRY_REQUIRES_FORCE_AFTER_PERMANENT_FAILURE: "state.run_retry_requires_force_after_permanent_failure",
+	STATE_FAILED_RUN_RETRY_REQUIRES_FORCE: "state.failed_run_retry_requires_force",
+	STATE_RUN_RETRY_FAILED: "state.run_retry_failed",
+	STATE_PERMANENT_RUN_FAILURE_FAILED: "state.permanent_run_failure_failed",
+	STATE_PERMANENT_FAILURE_STATUS_INVALID: "state.permanent_failure_status_invalid",
+	STATE_MESSAGE_APPEND_FAILED: "state.message_append_failed",
+	STATE_CLEANUP_SELECTED_NON_TERMINAL_RUN: "state.cleanup_selected_non_terminal_run",
+	STATE_CLEANUP_RUN_MISSING_FINISHED_AT: "state.cleanup_run_missing_finished_at",
+	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",
+	IMPLEMENTATION_NOT_FOUND: "implementation.not_found",
+	DURATION_INVALID: "duration.invalid",
+	SERIALIZATION_FAILED: "serialization.failed",
+	NON_RETRYABLE_FAILURE: "failure.non_retryable",
+	PERMANENT_FAILURE: "failure.permanent",
+	RETRYABLE_FAILURE: "failure.retryable",
+	REPLAY_DIVERGED: "replay.diverged",
+	LOCK_ALREADY_HELD: "lock.already_held",
+	RUN_NOT_FOUND: "run.not_found",
+	RUN_INVALID: "run.invalid",
+	RUN_WORKFLOW_MISMATCH: "run.workflow_mismatch",
+	RUN_RESULT_TIMEOUT: "run.result_timeout",
+	RUN_CANCELED: "run.canceled",
+	RUN_CANCELLATION_REJECTED: "run.cancellation_rejected",
+	RUN_TRANSITION_INVALID: "run.transition_invalid",
+	RUN_PARENT_INVALID: "run.parent_invalid",
+	RUN_DEADLINE_EXCEEDED: "run.deadline_exceeded",
+	CHILD_WORKFLOW_TIMEOUT: "child_workflow.timeout",
+	MESSAGE_WAIT_TIMEOUT: "message.wait_timeout",
+	HOOK_DISPOSED: "hook.disposed",
+	MESSAGE_DELIVERY_REJECTED: "message.delivery_rejected",
+	MESSAGE_IDEMPOTENCY_CONFLICT: "message.idempotency_conflict",
+	STEP_TIMEOUT: "step.timeout",
+	STEP_EXECUTION_FAILED: "step.execution_failed",
+	STEP_RETRY_LIMIT_EXCEEDED: "step.retry_limit_exceeded",
+	STEP_ATTEMPT_LIMIT_EXCEEDED: "step.attempt_limit_exceeded",
+	SCHEDULE_ALREADY_EXISTS: "schedule.already_exists",
+	SCHEDULE_NAMESPACE_MISMATCH: "schedule.namespace_mismatch",
+	SCHEDULE_RECORD_INVALID: "schedule.record_invalid",
+	SCHEDULE_ID_CHANGE_REJECTED: "schedule.id_change_rejected",
+	SCHEDULE_CURRENT_RECORD_INVALID: "schedule.current_record_invalid",
+	SCHEDULE_NEXT_RECORD_INVALID: "schedule.next_record_invalid",
+	SCHEDULE_UPSERT_CONFLICT_EXHAUSTED: "schedule.upsert_conflict_exhausted",
+	SCHEDULE_NOT_FOUND: "schedule.not_found",
+	SCHEDULE_UPDATE_CONFLICT_EXHAUSTED: "schedule.update_conflict_exhausted",
+	STREAM_NOT_FOUND: "stream.not_found",
+	STREAM_CHUNK_LIMIT_EXCEEDED: "stream.chunk_limit_exceeded",
+	STREAM_READ_OFFSET_CONFLICT: "stream.read_offset_conflict",
+	STREAM_CHUNK_INDEX_NON_CONTIGUOUS: "stream.chunk_index_non_contiguous",
+	STREAM_CHUNK_AFTER_TERMINAL: "stream.chunk_after_terminal",
+	STREAM_ALREADY_CLOSED: "stream.already_closed",
+	LOCK_ALREADY_HELD_WITHOUT_WAIT: "lock.already_held_without_wait",
+	LOCK_HOLDER_MISMATCH: "lock.holder_mismatch",
+	LOCK_ALREADY_RELEASED: "lock.already_released",
+	LOCK_NOT_STALE: "lock.not_stale",
+	LOCK_WAIT_DEADLINE_CONFLICT: "lock.wait_deadline_conflict",
+	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 };

package/dist/types/error.d.mts

@@ -0,0 +1,236 @@
+import { WorkflowErrorCode, workflowErrorCodeSchema } from "./error-code.mjs";
+import { MessageId } from "./message-id.mjs";
+import { RunId } from "./run-id.mjs";
+import { StepId } from "./step-id.mjs";
+import { WorkflowRunStatus, WorkflowTerminalRunStatus } from "./run.mjs";
+import { z } from "zod";
+//#region src/types/error.d.ts
+declare const workflowErrorDetailSchema: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+declare const workflowErrorDetailsSchema: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
+declare const workflowErrorRecordSchema: z.ZodObject<{
+  code: z.ZodOptional<z.ZodEnum<{
+    readonly ERROR: "workflow.error";
+    readonly DEFINITION_INVALID: "definition.invalid";
+    readonly CAPABILITY_UNSUPPORTED: "capability.unsupported";
+    readonly OPTIONS_INVALID: "options.invalid";
+    readonly OPTIONS_EXPECTED_OBJECT: "options.expected_object";
+    readonly OPTIONS_EXPECTED_ARRAY: "options.expected_array";
+    readonly OPTIONS_EXPECTED_FUNCTION: "options.expected_function";
+    readonly OPTIONS_EXPECTED_STRING: "options.expected_string";
+    readonly OPTIONS_EXPECTED_NON_EMPTY: "options.expected_non_empty";
+    readonly OPTIONS_EXPECTED_NON_BLANK: "options.expected_non_blank";
+    readonly OPTIONS_EXPECTED_NUMBER: "options.expected_number";
+    readonly OPTIONS_EXPECTED_BOOLEAN: "options.expected_boolean";
+    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_EXPECTED_ABORT_SIGNAL: "options.expected_abort_signal";
+    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_STORE_RUN_ID_INVALID: "state.store_run_id_invalid";
+    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 RUNTIME_INVALID: "runtime.invalid";
+    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_CURRENT_RECORD_INVALID: "lock.current_record_invalid";
+    readonly LOCK_NEXT_RECORD_INVALID: "lock.next_record_invalid";
+    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 WEBHOOK_TOKEN_INVALID: "webhook.token_invalid";
+    readonly HOOK_TOKEN_NOT_UNIQUE: "hook.token_not_unique";
+    readonly HOOK_WAITING_STEP_MISSING: "hook.waiting_step_missing";
+  }>>;
+  name: z.ZodString;
+  message: z.ZodString;
+  stack: z.ZodOptional<z.ZodString>;
+  details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
+}, z.core.$loose>;
+declare const optionalWorkflowErrorStringSchema: z.ZodOptional<z.ZodString>;
+declare const workflowErrorRunStatusSchema: z.ZodType<WorkflowRunStatus>;
+declare const workflowTerminalErrorRunStatusSchema: z.ZodType<WorkflowTerminalRunStatus>;
+/** Returns workflow-safe error details, or undefined when the input cannot be persisted. */
+declare function sanitizedWorkflowErrorDetails(details: unknown): WorkflowErrorDetails | undefined;
+/** JSON-serializable detail fields attached to workflow errors. */
+type WorkflowErrorDetails = Readonly<Record<string, string | number | boolean | null>>;
+/** Persisted representation of an error captured during workflow execution. */
+interface WorkflowErrorRecord {
+  readonly [key: string]: unknown;
+  readonly code?: WorkflowErrorCode;
+  readonly name: string;
+  readonly message: string;
+  readonly stack?: string;
+  readonly details?: WorkflowErrorDetails;
+}
+/** Options for workflow error. */
+interface WorkflowErrorOptions extends ErrorOptions {
+  readonly code?: WorkflowErrorCode;
+  readonly details?: WorkflowErrorDetails;
+}
+/** Options for marking a workflow failure as non-retryable. */
+type WorkflowNonRetryableErrorOptions = WorkflowErrorOptions;
+/** Options for workflow retryable error. */
+interface WorkflowRetryableErrorOptions extends WorkflowErrorOptions {
+  readonly retryAt?: Temporal.Instant;
+  readonly retryDelay?: Temporal.Duration;
+}
+/** Options for workflow step execution error. */
+interface WorkflowStepExecutionErrorOptions {
+  readonly stepId: StepId;
+  readonly stepName: string;
+  readonly attempt: number;
+  readonly cause: unknown;
+}
+/** Options for errors raised when a run belongs to a different workflow than expected. */
+interface WorkflowRunMismatchErrorOptions {
+  readonly runId: RunId;
+  readonly expectedWorkflowName: string;
+  readonly actualWorkflowName: string;
+}
+/** Options for errors raised when a child workflow does not finish before its timeout. */
+interface WorkflowChildWorkflowTimeoutErrorOptions {
+  readonly runId: RunId;
+  readonly childrunId: RunId;
+  readonly stepId: StepId;
+  readonly timeoutAt: Temporal.Instant;
+}
+/** Options for errors raised when a workflow message wait times out. */
+interface WorkflowMessageWaitTimeoutErrorOptions {
+  readonly runId: RunId;
+  readonly stepId: StepId;
+  readonly stepName: string;
+  readonly messageId: MessageId;
+  readonly timeoutAt: Temporal.Instant;
+}
+/** Options for errors raised when a pending external resume hook is disposed. */
+interface WorkflowHookDisposedErrorOptions {
+  readonly runId: RunId;
+  readonly stepId: StepId;
+  readonly stepName: string;
+  readonly messageId: MessageId;
+}
+/** Options for errors raised when a messageId cannot be delivered to a terminal run. */
+interface WorkflowMessageDeliveryErrorOptions {
+  readonly runId: RunId;
+  readonly status: WorkflowTerminalRunStatus;
+  readonly messageId: MessageId;
+}
+/** Options for errors raised when a messageId idempotency key conflicts with another messageId. */
+interface WorkflowMessageIdempotencyConflictErrorOptions {
+  readonly runId: RunId;
+  readonly messageId: MessageId;
+  readonly idempotencyKey: string;
+}
+/** Options for marking a workflow run as permanently failed with an operator reason. */
+interface WorkflowPermanentFailureErrorOptions {
+  readonly runId: RunId;
+  readonly reason: string;
+}
+/** Options for errors raised when a durable step attempt exceeds its timeout. */
+interface WorkflowStepTimeoutErrorOptions {
+  readonly runId: RunId;
+  readonly stepId: StepId;
+  readonly stepName: string;
+  readonly attempt: number;
+  readonly timeoutAt: Temporal.Instant;
+}
+/** Options for errors raised when replayed history no longer matches the workflow code. */
+interface WorkflowReplayDivergenceErrorOptions {
+  readonly expectedStepId?: string;
+  readonly actualStepId?: string;
+  readonly message: string;
+}
+//#endregion
+export { WorkflowChildWorkflowTimeoutErrorOptions, WorkflowErrorCode, WorkflowErrorDetails, WorkflowErrorOptions, WorkflowErrorRecord, WorkflowHookDisposedErrorOptions, WorkflowMessageDeliveryErrorOptions, WorkflowMessageIdempotencyConflictErrorOptions, WorkflowMessageWaitTimeoutErrorOptions, WorkflowNonRetryableErrorOptions, WorkflowPermanentFailureErrorOptions, WorkflowReplayDivergenceErrorOptions, WorkflowRetryableErrorOptions, WorkflowRunMismatchErrorOptions, WorkflowStepExecutionErrorOptions, WorkflowStepTimeoutErrorOptions, optionalWorkflowErrorStringSchema, sanitizedWorkflowErrorDetails, workflowErrorCodeSchema, workflowErrorDetailSchema, workflowErrorDetailsSchema, workflowErrorRecordSchema, workflowErrorRunStatusSchema, workflowTerminalErrorRunStatusSchema };

package/dist/types/error.mjs

@@ -0,0 +1,48 @@
+import { WorkflowErrorCode, workflowErrorCodeSchema } from "./error-code.mjs";
+import { nonBlankStringSchema } from "./common.mjs";
+import { z } from "zod";
+//#region src/types/error.ts
+const workflowRunStatuses = [
+	"pending",
+	"running",
+	"waiting",
+	"completed",
+	"failed",
+	"canceled"
+];
+const workflowTerminalRunStatuses = [
+	"completed",
+	"failed",
+	"canceled"
+];
+const workflowErrorDetailSchema = z.union([
+	z.string(),
+	z.number(),
+	z.boolean(),
+	z.null()
+]);
+const workflowErrorDetailsSchema = z.record(nonBlankStringSchema, workflowErrorDetailSchema).refine((value) => {
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}, { error: "Expected a plain error details object" });
+const workflowErrorRecordSchema = z.looseObject({
+	code: workflowErrorCodeSchema.optional(),
+	name: nonBlankStringSchema,
+	message: nonBlankStringSchema,
+	stack: nonBlankStringSchema.optional(),
+	details: workflowErrorDetailsSchema.optional()
+});
+const optionalWorkflowErrorStringSchema = nonBlankStringSchema.optional();
+const workflowErrorRunStatusSchema = z.enum(workflowRunStatuses, { error: "Expected a workflow run status" });
+const workflowTerminalErrorRunStatusSchema = z.enum(workflowTerminalRunStatuses, { error: "Expected a terminal workflow run status" });
+/** Returns workflow-safe error details, or undefined when the input cannot be persisted. */
+function sanitizedWorkflowErrorDetails(details) {
+	const parsed = workflowErrorDetailsSchema.safeParse(details);
+	if (!parsed.success) return;
+	const sanitized = Object.fromEntries(Object.entries(parsed.data).filter(([key, value]) => {
+		return nonBlankStringSchema.safeParse(key).success && workflowErrorDetailSchema.safeParse(value).success;
+	}));
+	return Object.keys(sanitized).length === 0 ? void 0 : sanitized;
+}
+//#endregion
+export { WorkflowErrorCode, optionalWorkflowErrorStringSchema, sanitizedWorkflowErrorDetails, workflowErrorCodeSchema, workflowErrorDetailSchema, workflowErrorDetailsSchema, workflowErrorRecordSchema, workflowErrorRunStatusSchema, workflowTerminalErrorRunStatusSchema };