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

package/dist/errors/base.d.mts

@@ -1,99 +1,39 @@
-import { WorkflowErrorCode } from "../types/error-code.mjs";
-import { RunId } from "../types/run-id.mjs";
-import { StepId } from "../types/step-id.mjs";
-import "../types/step.mjs";
-import { WorkflowTerminalRunStatus } from "../types/run.mjs";
-import { WorkflowErrorDetails, WorkflowErrorOptions } from "../types/error.mjs";
+import { WorkflowErrorCode } from "./codes.mjs";
+import { RunId } from "../types/ids.mjs";
+import { ErrorDetails, WorkflowErrorOptions } from "../types/error.mjs";
 import { EventKind } from "../types/events.mjs";
 //#region src/errors/base.d.ts
 /** Base error for workflow failures that carry optional structured details. */
-declare class WorkflowError extends Error {
+export declare class WorkflowError extends Error {
   readonly code: WorkflowErrorCode;
   readonly cause: unknown;
-  readonly details: WorkflowErrorDetails | undefined;
-  constructor(message: string, options?: WorkflowErrorOptions, context?: Function);
-  static fromMessage(this: void, message: string, options?: WorkflowErrorOptions): WorkflowError;
+  readonly details: ErrorDetails | undefined;
+  constructor(message: string, options?: WorkflowErrorOptions);
 }
-/** Error thrown for options failures. */
-declare class WorkflowOptionsError extends WorkflowError {
-  constructor(message: string, context?: Function, options?: WorkflowErrorOptions);
-  static create(this: void, message: string): WorkflowOptionsError;
-  static object(this: void, label: string): never;
-  static array(this: void, label: string): never;
-  static function(this: void, label: string): never;
-  static string(this: void, label: string): never;
-  static nonEmpty(this: void, label: string): never;
-  static nonBlank(this: void, label: string): never;
-  static number(this: void, label: string): never;
-  static boolean(this: void, label: string): never;
-  static required(this: void, label: string): never;
+export declare class WorkflowOptionsError extends WorkflowError {
+  constructor(message: string, options?: WorkflowErrorOptions);
   static positiveSafeInteger(this: void, label: string): never;
   static nonNegativeSafeInteger(this: void, label: string): never;
-  static positiveDuration(this: void, label: string): never;
-  static nonNegativeDuration(this: void, label: string): never;
-  static safeDuration(this: void, label: string): never;
-  static positiveSafeIntegerDuration(this: void, label: string): never;
-  static temporalInstant(this: void, label: string): never;
-  static abortSignal(this: void, label: string): never;
-  static childCancellationPolicy(this: void): never;
   static cursorInvalid(this: void, label: string): never;
   static retryMaximumIntervalTooSmall(this: void, label: string): never;
-  static retryableErrorDelayConflict(this: void): never;
-  static engineStoreAndStorageConflict(this: void): never;
-  static missingImplementationRetryAttemptPositiveSafeInteger(this: void): never;
 }
-/** Error thrown for state failures. */
-declare class WorkflowStateError extends WorkflowError {
-  constructor(message: string, context?: Function, options?: WorkflowErrorOptions);
-  static create(this: void, message: string): WorkflowStateError;
+export declare class WorkflowStateError extends WorkflowError {
+  constructor(message: string, options?: WorkflowErrorOptions);
   static runNamespaceMismatch(this: void, actual: string, expected: string): never;
-  static runIdMismatch(this: void, actual: string, expected: string): never;
   static runIdAlreadyExists(this: void, runId: RunId): never;
   static eventHistoryAlreadyExists(this: void, runId: RunId): never;
   static eventNotTerminalStep(this: void, kind: EventKind): never;
-  static unsupportedRecordedStepEventType(this: void, kind: EventKind): never;
-  static stepAttemptFieldMismatch(this: void, stepId: StepId, field: string): never;
-  static failedRunMissingError(this: void, runId: RunId): never;
-  static runNotClaimable(this: void, runId: RunId): never;
-  static workerStoppedBeforeRun(this: void, runId: RunId): never;
-  static storeRunIdInvalid(this: void): never;
-  static invalid(this: void, label: string, issues: string): never;
   static idempotencyKeyClaimedWithoutRun(this: void, runId: RunId): never;
-  static runMissingIdempotencyKey(this: void, runId: RunId): never;
-  static failedRunMetadataUpdate(this: void, runId: RunId): never;
-  static failedRunAttributesUpdate(this: void, runId: RunId): never;
-  static runCannotBeRescheduled(this: void, runId: RunId): never;
-  static failedRunReschedule(this: void, runId: RunId): never;
-  static staleLeaseReleaseRequiresRunning(this: void, runId: RunId): never;
-  static runLeaseStillActive(this: void, runId: RunId): never;
-  static failedStaleRunLeaseRelease(this: void, runId: RunId): never;
-  static runRetryRequiresFailed(this: void, runId: RunId): never;
-  static runRetryRequiresForceAfterPermanentFailure(this: void, runId: RunId): never;
-  static failedRunRetryRequiresForce(this: void, runId: RunId): never;
-  static failedRunRetry(this: void, runId: RunId): never;
-  static failedPermanentRunFailure(this: void, runId: RunId): never;
-  static permanentFailureInvalidStatus(this: void, runId: RunId, status: WorkflowTerminalRunStatus): never;
-  static failedMessageAppend(this: void, runId: RunId): never;
   static cleanupSelectedNonTerminalRun(this: void, runId: RunId): never;
-  static cleanupRunMissingFinishedAt(this: void, runId: RunId): never;
-  static failedWorkflowEventAppend(this: void, runId: RunId, attempts: number): never;
-  static failedStepAttemptMaterialization(this: void, runId: RunId, attempts: number): never;
-  static appendProjectionPipelineMissing(this: void): never;
 }
-/** Error thrown for run failures. */
-declare class WorkflowRunError extends WorkflowError {
-  constructor(message: string, options: WorkflowErrorOptions, context?: Function);
-  static fromMessage(this: void, message: string, options: WorkflowErrorOptions): WorkflowRunError;
+export declare class WorkflowRunError extends WorkflowError {
+  constructor(message: string, options: WorkflowErrorOptions);
 }
-/** Error thrown for step failures. */
-declare class WorkflowStepError extends WorkflowError {
-  constructor(message: string, options: WorkflowErrorOptions, context?: Function);
-  static fromMessage(this: void, message: string, options: WorkflowErrorOptions): WorkflowStepError;
+export declare class WorkflowStepError extends WorkflowError {
+  constructor(message: string, options: WorkflowErrorOptions);
 }
-/** Error thrown for message failures. */
-declare class WorkflowMessageError extends WorkflowError {
-  constructor(message: string, options: WorkflowErrorOptions, context?: Function);
-  static fromMessage(this: void, message: string, options: WorkflowErrorOptions): WorkflowMessageError;
+export declare class WorkflowMessageError extends WorkflowError {
+  constructor(message: string, options: WorkflowErrorOptions);
 }
 //#endregion
-export { WorkflowError, type WorkflowErrorOptions, WorkflowMessageError, WorkflowOptionsError, WorkflowRunError, WorkflowStateError, WorkflowStepError };
+export type { WorkflowErrorOptions };

package/dist/errors/base.mjs

@@ -1,176 +1,61 @@
-import { WorkflowErrorCode } from "../types/error-code.mjs";
+import { WorkflowErrorCode } from "./codes.mjs";
 //#region src/errors/base.ts
 /** Base error for workflow failures that carry optional structured details. */
-var WorkflowError = class WorkflowError extends Error {
+var WorkflowError = class extends Error {
 	code;
 	cause;
 	details;
-	constructor(message, options = {}, context) {
+	constructor(message, options = {}) {
 		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 = {}) {
+	constructor(message, 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 }
 		});
+		this.name = "WorkflowOptionsError";
 	}
 	static positiveSafeInteger(label) {
-		throw new WorkflowOptionsError(`${label} must be a positive safe integer`, WorkflowOptionsError.positiveSafeInteger, {
+		throw new WorkflowOptionsError(`${label} must be a positive safe integer`, {
 			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, {
+		throw new WorkflowOptionsError(`${label} must be a non-negative safe integer`, {
 			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, {
+		throw new WorkflowOptionsError(`${label} cursor is invalid`, {
 			code: WorkflowErrorCode.OPTIONS_CURSOR_INVALID,
 			details: { label }
 		});
 	}
 	static retryMaximumIntervalTooSmall(label) {
-		throw new WorkflowOptionsError(`${label} maximumInterval must be at least initialInterval`, WorkflowOptionsError.retryMaximumIntervalTooSmall, {
+		throw new WorkflowOptionsError(`${label} maximumInterval must be at least initialInterval`, {
 			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 = {}) {
+	constructor(message, 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, {
+		throw new WorkflowStateError(`Workflow run namespace mismatch: ${actual} !== ${expected}`, {
 			code: WorkflowErrorCode.STATE_RUN_NAMESPACE_MISMATCH,
 			details: {
 				actual,
@@ -178,249 +63,63 @@ var WorkflowStateError = class WorkflowStateError extends WorkflowError {
 			}
 		});
 	}
-	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, {
+		throw new WorkflowStateError(`Workflow run already exists: ${runId}`, {
 			code: WorkflowErrorCode.STATE_RUN_ALREADY_EXISTS,
 			details: { runId }
 		});
 	}
 	static eventHistoryAlreadyExists(runId) {
-		throw new WorkflowStateError(`Workflow event history already exists: ${runId}`, WorkflowStateError.eventHistoryAlreadyExists, {
+		throw new WorkflowStateError(`Workflow event history already exists: ${runId}`, {
 			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, {
+		throw new WorkflowStateError(`Workflow event is not a terminal step event: ${kind}`, {
 			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, {
+		throw new WorkflowStateError(`Workflow idempotency key was claimed without a run: ${runId}`, {
 			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, {
+		throw new WorkflowStateError(`Workflow cleanup selected non-terminal run: ${runId}`, {
 			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) {
+var WorkflowRunError = class extends WorkflowError {
+	constructor(message, options) {
 		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) {
+var WorkflowStepError = class extends WorkflowError {
+	constructor(message, options) {
 		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) {
+var WorkflowMessageError = class extends WorkflowError {
+	constructor(message, options) {
 		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

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

package/dist/errors/capability.mjs

@@ -1,22 +1,18 @@
-import { WorkflowErrorCode } from "../types/error-code.mjs";
+import { WorkflowErrorCode } from "./codes.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) {
+	constructor(capability) {
 		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);
+		throw new WorkflowCapabilityError(capability);
 	}
 };
 //#endregion