@temelj/workflow 0.0.0-alpha.1

package/dist/errors/base.mjs

@@ -0,0 +1,426 @@
+import { WorkflowErrorCode } from "../types/error-code.mjs";
+//#region src/errors/base.ts
+/** Base error for workflow failures that carry optional structured details. */
+var WorkflowError = class WorkflowError extends Error {
+	code;
+	cause;
+	details;
+	constructor(message, options = {}, context) {
+		super(message);
+		this.name = "WorkflowError";
+		this.code = options.code ?? WorkflowErrorCode.ERROR;
+		this.cause = options.cause;
+		this.details = options.details;
+		if (Error.captureStackTrace !== void 0) Error.captureStackTrace(this, context ?? this.constructor);
+	}
+	static fromMessage(message, options = {}) {
+		return new WorkflowError(message, options, WorkflowError.fromMessage);
+	}
+};
+/** Error thrown for options failures. */
+var WorkflowOptionsError = class WorkflowOptionsError extends WorkflowError {
+	constructor(message, context, options = {}) {
+		super(message, {
+			...options,
+			code: options.code ?? WorkflowErrorCode.OPTIONS_INVALID
+		}, context);
+		this.name = "WorkflowOptionsError";
+	}
+	static create(message) {
+		return new WorkflowOptionsError(message, WorkflowOptionsError.create);
+	}
+	static object(label) {
+		throw new WorkflowOptionsError(`${label} must be an object`, WorkflowOptionsError.object, {
+			code: WorkflowErrorCode.OPTIONS_EXPECTED_OBJECT,
+			details: { label }
+		});
+	}
+	static array(label) {
+		throw new WorkflowOptionsError(`${label} must be an array`, WorkflowOptionsError.array, {
+			code: WorkflowErrorCode.OPTIONS_EXPECTED_ARRAY,
+			details: { label }
+		});
+	}
+	static function(label) {
+		throw new WorkflowOptionsError(`${label} must be a function`, WorkflowOptionsError.function, {
+			code: WorkflowErrorCode.OPTIONS_EXPECTED_FUNCTION,
+			details: { label }
+		});
+	}
+	static string(label) {
+		throw new WorkflowOptionsError(`${label} must be a string`, WorkflowOptionsError.string, {
+			code: WorkflowErrorCode.OPTIONS_EXPECTED_STRING,
+			details: { label }
+		});
+	}
+	static nonEmpty(label) {
+		throw new WorkflowOptionsError(`${label} must not be empty`, WorkflowOptionsError.nonEmpty, {
+			code: WorkflowErrorCode.OPTIONS_EXPECTED_NON_EMPTY,
+			details: { label }
+		});
+	}
+	static nonBlank(label) {
+		throw new WorkflowOptionsError(`${label} must not be blank`, WorkflowOptionsError.nonBlank, {
+			code: WorkflowErrorCode.OPTIONS_EXPECTED_NON_BLANK,
+			details: { label }
+		});
+	}
+	static number(label) {
+		throw new WorkflowOptionsError(`${label} must be a number`, WorkflowOptionsError.number, {
+			code: WorkflowErrorCode.OPTIONS_EXPECTED_NUMBER,
+			details: { label }
+		});
+	}
+	static boolean(label) {
+		throw new WorkflowOptionsError(`${label} must be a boolean`, WorkflowOptionsError.boolean, {
+			code: WorkflowErrorCode.OPTIONS_EXPECTED_BOOLEAN,
+			details: { label }
+		});
+	}
+	static required(label) {
+		throw new WorkflowOptionsError(`${label} is required`, WorkflowOptionsError.required, {
+			code: WorkflowErrorCode.OPTIONS_REQUIRED,
+			details: { label }
+		});
+	}
+	static positiveSafeInteger(label) {
+		throw new WorkflowOptionsError(`${label} must be a positive safe integer`, WorkflowOptionsError.positiveSafeInteger, {
+			code: WorkflowErrorCode.OPTIONS_EXPECTED_POSITIVE_SAFE_INTEGER,
+			details: { label }
+		});
+	}
+	static nonNegativeSafeInteger(label) {
+		throw new WorkflowOptionsError(`${label} must be a non-negative safe integer`, WorkflowOptionsError.nonNegativeSafeInteger, {
+			code: WorkflowErrorCode.OPTIONS_EXPECTED_NON_NEGATIVE_SAFE_INTEGER,
+			details: { label }
+		});
+	}
+	static positiveDuration(label) {
+		throw new WorkflowOptionsError(`${label} must be greater than zero`, WorkflowOptionsError.positiveDuration, {
+			code: WorkflowErrorCode.OPTIONS_EXPECTED_POSITIVE_DURATION,
+			details: { label }
+		});
+	}
+	static nonNegativeDuration(label) {
+		throw new WorkflowOptionsError(`${label} must be non-negative`, WorkflowOptionsError.nonNegativeDuration, {
+			code: WorkflowErrorCode.OPTIONS_EXPECTED_NON_NEGATIVE_DURATION,
+			details: { label }
+		});
+	}
+	static safeDuration(label) {
+		throw new WorkflowOptionsError(`${label} must be a timer-safe duration`, WorkflowOptionsError.safeDuration, {
+			code: WorkflowErrorCode.OPTIONS_EXPECTED_TIMER_SAFE_DURATION,
+			details: { label }
+		});
+	}
+	static positiveSafeIntegerDuration(label) {
+		throw new WorkflowOptionsError(`${label} must be a positive safe integer duration`, WorkflowOptionsError.positiveSafeIntegerDuration, {
+			code: WorkflowErrorCode.OPTIONS_EXPECTED_POSITIVE_SAFE_INTEGER_DURATION,
+			details: { label }
+		});
+	}
+	static temporalInstant(label) {
+		throw new WorkflowOptionsError(`${label} must be a Temporal.Instant`, WorkflowOptionsError.temporalInstant, {
+			code: WorkflowErrorCode.OPTIONS_EXPECTED_TEMPORAL_INSTANT,
+			details: { label }
+		});
+	}
+	static abortSignal(label) {
+		throw new WorkflowOptionsError(`${label} must be an AbortSignal`, WorkflowOptionsError.abortSignal, {
+			code: WorkflowErrorCode.OPTIONS_EXPECTED_ABORT_SIGNAL,
+			details: { label }
+		});
+	}
+	static childCancellationPolicy() {
+		throw new WorkflowOptionsError("Workflow child cancellation policy must be cascade or detach", WorkflowOptionsError.childCancellationPolicy, { code: WorkflowErrorCode.OPTIONS_CHILD_CANCELLATION_POLICY_INVALID });
+	}
+	static cursorInvalid(label) {
+		throw new WorkflowOptionsError(`${label} cursor is invalid`, WorkflowOptionsError.cursorInvalid, {
+			code: WorkflowErrorCode.OPTIONS_CURSOR_INVALID,
+			details: { label }
+		});
+	}
+	static retryMaximumIntervalTooSmall(label) {
+		throw new WorkflowOptionsError(`${label} maximumInterval must be at least initialInterval`, WorkflowOptionsError.retryMaximumIntervalTooSmall, {
+			code: WorkflowErrorCode.OPTIONS_RETRY_MAXIMUM_INTERVAL_TOO_SMALL,
+			details: { label }
+		});
+	}
+	static retryableErrorDelayConflict() {
+		throw new WorkflowOptionsError("Workflow retryable error cannot include both retryAt and retryDelay", WorkflowOptionsError.retryableErrorDelayConflict, { code: WorkflowErrorCode.OPTIONS_RETRYABLE_ERROR_DELAY_CONFLICT });
+	}
+	static engineStoreAndStorageConflict() {
+		throw new WorkflowOptionsError("Workflow engine options cannot include both store and storage", WorkflowOptionsError.engineStoreAndStorageConflict, { code: WorkflowErrorCode.OPTIONS_ENGINE_STORE_STORAGE_CONFLICT });
+	}
+	static missingImplementationRetryAttemptPositiveSafeInteger() {
+		throw new WorkflowOptionsError("Workflow missing implementation retry delay attempt must be a positive safe integer", WorkflowOptionsError.missingImplementationRetryAttemptPositiveSafeInteger, { code: WorkflowErrorCode.OPTIONS_MISSING_IMPLEMENTATION_RETRY_ATTEMPT_INVALID });
+	}
+};
+/** Error thrown for state failures. */
+var WorkflowStateError = class WorkflowStateError extends WorkflowError {
+	constructor(message, context, options = {}) {
+		super(message, {
+			...options,
+			code: options.code ?? WorkflowErrorCode.STATE_INVALID
+		}, context);
+		this.name = "WorkflowStateError";
+		if (Error.captureStackTrace) Error.captureStackTrace(this, context ?? this.constructor);
+	}
+	static create(message) {
+		return new WorkflowStateError(message, WorkflowStateError.create);
+	}
+	static runNamespaceMismatch(actual, expected) {
+		throw new WorkflowStateError(`Workflow run namespace mismatch: ${actual} !== ${expected}`, WorkflowStateError.runNamespaceMismatch, {
+			code: WorkflowErrorCode.STATE_RUN_NAMESPACE_MISMATCH,
+			details: {
+				actual,
+				expected
+			}
+		});
+	}
+	static runIdMismatch(actual, expected) {
+		throw new WorkflowStateError(`Workflow store runId mismatch: ${actual} !== ${expected}`, WorkflowStateError.runIdMismatch, {
+			code: WorkflowErrorCode.STATE_RUN_ID_MISMATCH,
+			details: {
+				actual,
+				expected
+			}
+		});
+	}
+	static runIdAlreadyExists(runId) {
+		throw new WorkflowStateError(`Workflow run already exists: ${runId}`, WorkflowStateError.runIdAlreadyExists, {
+			code: WorkflowErrorCode.STATE_RUN_ALREADY_EXISTS,
+			details: { runId }
+		});
+	}
+	static eventHistoryAlreadyExists(runId) {
+		throw new WorkflowStateError(`Workflow event history already exists: ${runId}`, WorkflowStateError.eventHistoryAlreadyExists, {
+			code: WorkflowErrorCode.STATE_EVENT_HISTORY_ALREADY_EXISTS,
+			details: { runId }
+		});
+	}
+	static eventNotTerminalStep(kind) {
+		throw new WorkflowStateError(`Workflow event is not a terminal step event: ${kind}`, WorkflowStateError.eventNotTerminalStep, {
+			code: WorkflowErrorCode.STATE_EVENT_NOT_TERMINAL_STEP,
+			details: { kind }
+		});
+	}
+	static unsupportedRecordedStepEventType(kind) {
+		throw new WorkflowStateError(`Workflow recorded step event type is not supported: ${kind}`, WorkflowStateError.unsupportedRecordedStepEventType, {
+			code: WorkflowErrorCode.STATE_RECORDED_STEP_EVENT_UNSUPPORTED,
+			details: { kind }
+		});
+	}
+	static stepAttemptFieldMismatch(stepId, field) {
+		throw new WorkflowStateError(`Workflow step attempt ${stepId} ${field} must match started attempt`, WorkflowStateError.stepAttemptFieldMismatch, {
+			code: WorkflowErrorCode.STATE_STEP_ATTEMPT_FIELD_MISMATCH,
+			details: {
+				stepId,
+				field
+			}
+		});
+	}
+	static failedRunMissingError(runId) {
+		throw new WorkflowStateError(`Failed workflow run is missing error: ${runId}`, WorkflowStateError.failedRunMissingError, {
+			code: WorkflowErrorCode.STATE_FAILED_RUN_MISSING_ERROR,
+			details: { runId }
+		});
+	}
+	static runNotClaimable(runId) {
+		throw new WorkflowStateError(`Workflow run is not claimable: ${runId}`, WorkflowStateError.runNotClaimable, {
+			code: WorkflowErrorCode.STATE_RUN_NOT_CLAIMABLE,
+			details: { runId }
+		});
+	}
+	static workerStoppedBeforeRun(runId) {
+		throw new WorkflowStateError(`Workflow worker stopped before executing run: ${runId}`, WorkflowStateError.workerStoppedBeforeRun, {
+			code: WorkflowErrorCode.STATE_WORKER_STOPPED_BEFORE_RUN,
+			details: { runId }
+		});
+	}
+	static storeRunIdInvalid() {
+		throw new WorkflowStateError("Workflow store runId is invalid: Expected a non-blank string", WorkflowStateError.storeRunIdInvalid, { code: WorkflowErrorCode.STATE_STORE_RUN_ID_INVALID });
+	}
+	static invalid(label, issues) {
+		throw new WorkflowStateError(`${label} is invalid: ${issues}`, WorkflowStateError.invalid, {
+			code: WorkflowErrorCode.STATE_INVALID,
+			details: {
+				label,
+				issues
+			}
+		});
+	}
+	static idempotencyKeyClaimedWithoutRun(runId) {
+		throw new WorkflowStateError(`Workflow idempotency key was claimed without a run: ${runId}`, WorkflowStateError.idempotencyKeyClaimedWithoutRun, {
+			code: WorkflowErrorCode.STATE_IDEMPOTENCY_KEY_CLAIMED_WITHOUT_RUN,
+			details: { runId }
+		});
+	}
+	static runMissingIdempotencyKey(runId) {
+		throw new WorkflowStateError(`Workflow run does not have an idempotency key: ${runId}`, WorkflowStateError.runMissingIdempotencyKey, {
+			code: WorkflowErrorCode.STATE_RUN_MISSING_IDEMPOTENCY_KEY,
+			details: { runId }
+		});
+	}
+	static failedRunMetadataUpdate(runId) {
+		throw new WorkflowStateError(`Failed to update workflow run metadata for run ${runId}`, WorkflowStateError.failedRunMetadataUpdate, {
+			code: WorkflowErrorCode.STATE_RUN_METADATA_UPDATE_FAILED,
+			details: { runId }
+		});
+	}
+	static failedRunAttributesUpdate(runId) {
+		throw new WorkflowStateError(`Failed to update workflow run attributes for run ${runId}`, WorkflowStateError.failedRunAttributesUpdate, {
+			code: WorkflowErrorCode.STATE_RUN_ATTRIBUTES_UPDATE_FAILED,
+			details: { runId }
+		});
+	}
+	static runCannotBeRescheduled(runId) {
+		throw new WorkflowStateError(`Workflow run cannot be rescheduled unless pending or waiting: ${runId}`, WorkflowStateError.runCannotBeRescheduled, {
+			code: WorkflowErrorCode.STATE_RUN_CANNOT_BE_RESCHEDULED,
+			details: { runId }
+		});
+	}
+	static failedRunReschedule(runId) {
+		throw new WorkflowStateError(`Failed to reschedule workflow run ${runId}`, WorkflowStateError.failedRunReschedule, {
+			code: WorkflowErrorCode.STATE_RUN_RESCHEDULE_FAILED,
+			details: { runId }
+		});
+	}
+	static staleLeaseReleaseRequiresRunning(runId) {
+		throw new WorkflowStateError(`Workflow run stale lease cannot be released unless running: ${runId}`, WorkflowStateError.staleLeaseReleaseRequiresRunning, {
+			code: WorkflowErrorCode.STATE_STALE_LEASE_RELEASE_REQUIRES_RUNNING,
+			details: { runId }
+		});
+	}
+	static runLeaseStillActive(runId) {
+		throw new WorkflowStateError(`Workflow run lease is still active: ${runId}`, WorkflowStateError.runLeaseStillActive, {
+			code: WorkflowErrorCode.STATE_RUN_LEASE_STILL_ACTIVE,
+			details: { runId }
+		});
+	}
+	static failedStaleRunLeaseRelease(runId) {
+		throw new WorkflowStateError(`Failed to release stale workflow run lease ${runId}`, WorkflowStateError.failedStaleRunLeaseRelease, {
+			code: WorkflowErrorCode.STATE_STALE_RUN_LEASE_RELEASE_FAILED,
+			details: { runId }
+		});
+	}
+	static runRetryRequiresFailed(runId) {
+		throw new WorkflowStateError(`Workflow run cannot be retried unless failed: ${runId}`, WorkflowStateError.runRetryRequiresFailed, {
+			code: WorkflowErrorCode.STATE_RUN_RETRY_REQUIRES_FAILED,
+			details: { runId }
+		});
+	}
+	static runRetryRequiresForceAfterPermanentFailure(runId) {
+		throw new WorkflowStateError(`Workflow run cannot be retried after permanent failure without force: ${runId}`, WorkflowStateError.runRetryRequiresForceAfterPermanentFailure, {
+			code: WorkflowErrorCode.STATE_RUN_RETRY_REQUIRES_FORCE_AFTER_PERMANENT_FAILURE,
+			details: { runId }
+		});
+	}
+	static failedRunRetryRequiresForce(runId) {
+		throw new WorkflowStateError(`Workflow failed run retry requires force when no retry metadata exists: ${runId}`, WorkflowStateError.failedRunRetryRequiresForce, {
+			code: WorkflowErrorCode.STATE_FAILED_RUN_RETRY_REQUIRES_FORCE,
+			details: { runId }
+		});
+	}
+	static failedRunRetry(runId) {
+		throw new WorkflowStateError(`Failed to retry workflow run ${runId}`, WorkflowStateError.failedRunRetry, {
+			code: WorkflowErrorCode.STATE_RUN_RETRY_FAILED,
+			details: { runId }
+		});
+	}
+	static failedPermanentRunFailure(runId) {
+		throw new WorkflowStateError(`Failed to mark workflow run permanently failed ${runId}`, WorkflowStateError.failedPermanentRunFailure, {
+			code: WorkflowErrorCode.STATE_PERMANENT_RUN_FAILURE_FAILED,
+			details: { runId }
+		});
+	}
+	static permanentFailureInvalidStatus(runId, status) {
+		throw new WorkflowStateError(`Workflow run cannot be marked permanently failed from ${status}: ${runId}`, WorkflowStateError.permanentFailureInvalidStatus, {
+			code: WorkflowErrorCode.STATE_PERMANENT_FAILURE_STATUS_INVALID,
+			details: {
+				runId,
+				status
+			}
+		});
+	}
+	static failedMessageAppend(runId) {
+		throw new WorkflowStateError(`Failed to append workflow message for run ${runId}`, WorkflowStateError.failedMessageAppend, {
+			code: WorkflowErrorCode.STATE_MESSAGE_APPEND_FAILED,
+			details: { runId }
+		});
+	}
+	static cleanupSelectedNonTerminalRun(runId) {
+		throw new WorkflowStateError(`Workflow cleanup selected non-terminal run: ${runId}`, WorkflowStateError.cleanupSelectedNonTerminalRun, {
+			code: WorkflowErrorCode.STATE_CLEANUP_SELECTED_NON_TERMINAL_RUN,
+			details: { runId }
+		});
+	}
+	static cleanupRunMissingFinishedAt(runId) {
+		throw new WorkflowStateError(`Workflow cleanup run is missing finishedAt: ${runId}`, WorkflowStateError.cleanupRunMissingFinishedAt, {
+			code: WorkflowErrorCode.STATE_CLEANUP_RUN_MISSING_FINISHED_AT,
+			details: { runId }
+		});
+	}
+	static failedWorkflowEventAppend(runId, attempts) {
+		throw new WorkflowStateError(`Failed to append workflow event for run ${runId} after ${attempts} attempts`, WorkflowStateError.failedWorkflowEventAppend, {
+			code: WorkflowErrorCode.STATE_WORKFLOW_EVENT_APPEND_FAILED,
+			details: {
+				runId,
+				attempts
+			}
+		});
+	}
+	static failedStepAttemptMaterialization(runId, attempts) {
+		throw new WorkflowStateError(`Failed to materialize workflow step attempt for run ${runId} after ${attempts} attempts`, WorkflowStateError.failedStepAttemptMaterialization, {
+			code: WorkflowErrorCode.STATE_STEP_ATTEMPT_MATERIALIZATION_FAILED,
+			details: {
+				runId,
+				attempts
+			}
+		});
+	}
+	static appendProjectionPipelineMissing() {
+		throw new WorkflowStateError("Cannot finalize workflow event append without an append projection pipeline.", WorkflowStateError.appendProjectionPipelineMissing, { code: WorkflowErrorCode.STATE_APPEND_PROJECTION_PIPELINE_MISSING });
+	}
+};
+/** Error thrown for run failures. */
+var WorkflowRunError = class WorkflowRunError extends WorkflowError {
+	constructor(message, options, context) {
+		super(message, {
+			...options,
+			code: options.code ?? WorkflowErrorCode.RUN_ERROR
+		}, context);
+		this.name = "WorkflowRunError";
+	}
+	static fromMessage(message, options) {
+		return new WorkflowRunError(message, options, WorkflowRunError.fromMessage);
+	}
+};
+/** Error thrown for step failures. */
+var WorkflowStepError = class WorkflowStepError extends WorkflowError {
+	constructor(message, options, context) {
+		super(message, {
+			...options,
+			code: options.code ?? WorkflowErrorCode.STEP_ERROR
+		}, context);
+		this.name = "WorkflowStepError";
+	}
+	static fromMessage(message, options) {
+		return new WorkflowStepError(message, options, WorkflowStepError.fromMessage);
+	}
+};
+/** Error thrown for message failures. */
+var WorkflowMessageError = class WorkflowMessageError extends WorkflowError {
+	constructor(message, options, context) {
+		super(message, {
+			...options,
+			code: options.code ?? WorkflowErrorCode.MESSAGE_ERROR
+		}, context);
+		this.name = "WorkflowMessageError";
+	}
+	static fromMessage(message, options) {
+		return new WorkflowMessageError(message, options, WorkflowMessageError.fromMessage);
+	}
+};
+//#endregion
+export { WorkflowError, WorkflowMessageError, WorkflowOptionsError, WorkflowRunError, WorkflowStateError, WorkflowStepError };

package/dist/errors/capability.d.mts

@@ -0,0 +1,11 @@
+import { WorkflowError } from "./base.mjs";
+//#region src/errors/capability.d.ts
+/** Error thrown for capability failures. */
+declare class WorkflowCapabilityError extends WorkflowError {
+  readonly capability: string;
+  constructor(capability: string, context?: Function);
+  static create(this: void, capability: string): WorkflowCapabilityError;
+  static unsupported(this: void, capability: string): never;
+}
+//#endregion
+export { WorkflowCapabilityError };

package/dist/errors/capability.mjs

@@ -0,0 +1,23 @@
+import { WorkflowErrorCode } from "../types/error-code.mjs";
+import { WorkflowError } from "./base.mjs";
+//#region src/errors/capability.ts
+/** Error thrown for capability failures. */
+var WorkflowCapabilityError = class WorkflowCapabilityError extends WorkflowError {
+	capability;
+	constructor(capability, context) {
+		super(`Workflow engine does not support ${capability}`, {
+			code: WorkflowErrorCode.CAPABILITY_UNSUPPORTED,
+			details: { capability }
+		}, context);
+		this.name = "WorkflowCapabilityError";
+		this.capability = capability;
+	}
+	static create(capability) {
+		return new WorkflowCapabilityError(capability, WorkflowCapabilityError.create);
+	}
+	static unsupported(capability) {
+		throw new WorkflowCapabilityError(capability, WorkflowCapabilityError.unsupported);
+	}
+};
+//#endregion
+export { WorkflowCapabilityError };

package/dist/errors/definition.d.mts

@@ -0,0 +1,21 @@
+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;
+  static compiledMetadataMissing(this: void): never;
+  static compiledStepMetadataMissing(this: void): never;
+  static implementationAlreadyRegistered(this: void, key: string): never;
+}
+//#endregion
+export { WorkflowDefinitionError };

package/dist/errors/definition.mjs

@@ -0,0 +1,51 @@
+import { WorkflowErrorCode } from "../types/error-code.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);
+		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);
+	}
+};
+//#endregion
+export { WorkflowDefinitionError };

package/dist/errors/details.d.mts

@@ -0,0 +1,13 @@
+import { WorkflowRunStatus, WorkflowTerminalRunStatus } from "../types/run.mjs";
+import { WorkflowErrorDetails, WorkflowErrorRecord } from "../types/error.mjs";
+//#region src/errors/details.d.ts
+declare function hasWorkflowErrorCauseDetails(details: WorkflowErrorDetails): boolean;
+declare function unprefixWorkflowErrorCauseDetails(details: WorkflowErrorDetails): WorkflowErrorRecord;
+declare function workflowErrorDetailString(details: WorkflowErrorDetails | undefined, key: string): string | undefined;
+declare function workflowErrorDetailPositiveSafeInteger(details: WorkflowErrorDetails | undefined, key: string): number | undefined;
+declare function workflowErrorRunStatusOrUndefined(value: unknown): WorkflowRunStatus | undefined;
+declare function workflowTerminalErrorRunStatusOrUndefined(value: unknown): WorkflowTerminalRunStatus | undefined;
+declare function workflowErrorDetailTimestamp(details: WorkflowErrorDetails | undefined, key: string): Temporal.Instant | undefined;
+declare function workflowErrorDetailDuration(details: WorkflowErrorDetails | undefined, key: string): Temporal.Duration | undefined;
+//#endregion
+export { hasWorkflowErrorCauseDetails, unprefixWorkflowErrorCauseDetails, workflowErrorDetailDuration, workflowErrorDetailPositiveSafeInteger, workflowErrorDetailString, workflowErrorDetailTimestamp, workflowErrorRunStatusOrUndefined, workflowTerminalErrorRunStatusOrUndefined };

package/dist/errors/details.mjs

@@ -0,0 +1,65 @@
+import { workflowErrorCodeSchema } from "../types/error-code.mjs";
+import { positiveSafeIntegerSchema } from "../types/common.mjs";
+import { optionalWorkflowErrorStringSchema, sanitizedWorkflowErrorDetails, workflowErrorDetailsSchema, workflowErrorRunStatusSchema, workflowTerminalErrorRunStatusSchema } from "../types/error.mjs";
+//#region src/errors/details.ts
+function hasWorkflowErrorCauseDetails(details) {
+	return workflowErrorDetailString(details, "causeName") !== void 0 || workflowErrorDetailString(details, "causeMessage") !== void 0;
+}
+function unprefixWorkflowErrorCauseDetails(details) {
+	const unprefixed = Object.fromEntries(Object.entries(details).filter(([key]) => /^cause[A-Z]/.test(key)).map(([key, value]) => {
+		const unprefixedKey = key.slice(5);
+		return [`${unprefixedKey[0]?.toLowerCase() ?? ""}${unprefixedKey.slice(1)}`, value];
+	}));
+	const name = typeof unprefixed.name === "string" && unprefixed.name.trim() !== "" ? unprefixed.name : "WorkflowError";
+	const message = typeof unprefixed.message === "string" && unprefixed.message.trim() !== "" ? unprefixed.message : name;
+	const stack = typeof unprefixed.stack === "string" && unprefixed.stack.trim() !== "" ? unprefixed.stack : void 0;
+	const code = workflowErrorCodeSchema.safeParse(unprefixed.code);
+	const sanitizedDetails = sanitizedWorkflowErrorDetails(Object.fromEntries(Object.entries(unprefixed).filter(([key]) => key !== "code" && key !== "name" && key !== "message" && key !== "stack")));
+	return {
+		...code.success ? { code: code.data } : {},
+		name,
+		message,
+		...stack === void 0 ? {} : { stack },
+		...sanitizedDetails === void 0 ? {} : { details: sanitizedDetails }
+	};
+}
+function workflowErrorDetailString(details, key) {
+	const parsed = workflowErrorDetailsSchema.safeParse(details);
+	if (!parsed.success) return;
+	const result = optionalWorkflowErrorStringSchema.safeParse(parsed.data[key]);
+	return result.success ? result.data : void 0;
+}
+function workflowErrorDetailPositiveSafeInteger(details, key) {
+	const parsed = workflowErrorDetailsSchema.safeParse(details);
+	if (!parsed.success) return;
+	const result = positiveSafeIntegerSchema.optional().safeParse(parsed.data[key]);
+	return result.success ? result.data : void 0;
+}
+function workflowErrorRunStatusOrUndefined(value) {
+	const result = workflowErrorRunStatusSchema.safeParse(value);
+	return result.success ? result.data : void 0;
+}
+function workflowTerminalErrorRunStatusOrUndefined(value) {
+	const result = workflowTerminalErrorRunStatusSchema.safeParse(value);
+	return result.success ? result.data : void 0;
+}
+function workflowErrorDetailTimestamp(details, key) {
+	const value = workflowErrorDetailString(details, key);
+	if (value === void 0) return;
+	try {
+		return Temporal.Instant.from(value);
+	} catch {
+		return;
+	}
+}
+function workflowErrorDetailDuration(details, key) {
+	const value = workflowErrorDetailString(details, key);
+	if (value === void 0) return;
+	try {
+		return Temporal.Duration.from(value);
+	} catch {
+		return;
+	}
+}
+//#endregion
+export { hasWorkflowErrorCauseDetails, unprefixWorkflowErrorCauseDetails, workflowErrorDetailDuration, workflowErrorDetailPositiveSafeInteger, workflowErrorDetailString, workflowErrorDetailTimestamp, workflowErrorRunStatusOrUndefined, workflowTerminalErrorRunStatusOrUndefined };