@temelj/workflow 0.0.0-alpha.1

package/dist/errors/failures.d.mts

@@ -0,0 +1,81 @@
+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 { 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;
+}
+/** Error thrown for serialization failures. */
+declare class WorkflowSerializationError extends WorkflowError {
+  readonly path: string;
+  readonly reason: string;
+  constructor(path: string, reason: string, context?: Function);
+  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;
+}
+/** Error thrown when a run is intentionally marked permanently failed. */
+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 {
+  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;
+}
+/** Error thrown for replay divergence failures. */
+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);
+  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 };

package/dist/errors/failures.mjs

@@ -0,0 +1,168 @@
+import { WorkflowErrorCode } from "../types/error-code.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);
+		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) {
+		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);
+	}
+};
+/** Error thrown when workflow code wants to fail without retry. */
+var WorkflowNonRetryableError = class WorkflowNonRetryableError extends WorkflowError {
+	constructor(message, options = {}, context) {
+		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 {
+	runId;
+	reason;
+	constructor(options, context) {
+		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 {
+	retryAt;
+	retryDelay;
+	constructor(message, options, context) {
+		if (options.retryAt !== void 0 && options.retryDelay !== void 0) WorkflowOptionsError.retryableErrorDelayConflict();
+		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);
+		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) {
+		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);
+		this.name = "WorkflowReplayDivergenceError";
+		this.expectedStepId = options.expectedStepId;
+		this.actualStepId = options.actualStepId;
+	}
+	static diverged(message, options) {
+		throw new WorkflowReplayDivergenceError(message, options, WorkflowReplayDivergenceError.diverged);
+	}
+	static create(message, options) {
+		return new WorkflowReplayDivergenceError(message, options, WorkflowReplayDivergenceError.create);
+	}
+};
+//#endregion
+export { WorkflowDurationError, WorkflowNonRetryableError, WorkflowPermanentFailureError, WorkflowReplayDivergenceError, WorkflowRetryableError, WorkflowSerializationError };

package/dist/errors/hook.d.mts

@@ -0,0 +1,14 @@
+import { WorkflowErrorCode } from "../types/error-code.mjs";
+import { WorkflowErrorDetails } 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);
+  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 };

package/dist/errors/hook.mjs

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

package/dist/errors/implementation.d.mts

@@ -0,0 +1,11 @@
+import { WorkflowError } from "./base.mjs";
+//#region src/errors/implementation.d.ts
+/** Error thrown for implementation not found failures. */
+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;
+}
+//#endregion
+export { WorkflowImplementationNotFoundError };

package/dist/errors/implementation.mjs

@@ -0,0 +1,25 @@
+import { WorkflowErrorCode } from "../types/error-code.mjs";
+import { WorkflowError } from "./base.mjs";
+//#region src/errors/implementation.ts
+/** Error thrown for implementation not found failures. */
+var WorkflowImplementationNotFoundError = class WorkflowImplementationNotFoundError extends WorkflowError {
+	workflowName;
+	workflowVersion;
+	constructor(workflowName, workflowVersion, context) {
+		super(workflowVersion === void 0 ? `Workflow implementation not found: ${workflowName}` : `Workflow implementation not found: ${workflowName}@${workflowVersion}`, {
+			code: WorkflowErrorCode.IMPLEMENTATION_NOT_FOUND,
+			details: {
+				workflowName,
+				...workflowVersion === void 0 ? {} : { workflowVersion }
+			}
+		}, context);
+		this.name = "WorkflowImplementationNotFoundError";
+		this.workflowName = workflowName;
+		this.workflowVersion = workflowVersion;
+	}
+	static create(workflowName, workflowVersion) {
+		return new WorkflowImplementationNotFoundError(workflowName, workflowVersion, WorkflowImplementationNotFoundError.create);
+	}
+};
+//#endregion
+export { WorkflowImplementationNotFoundError };

package/dist/errors/lock.d.mts

@@ -0,0 +1,28 @@
+import { WorkflowErrorCode } from "../types/error-code.mjs";
+import { WorkflowErrorDetails } from "../types/error.mjs";
+import { WorkflowOptionsError, WorkflowStateError } from "./base.mjs";
+//#region src/errors/lock.d.ts
+/** Errors caused by invalid persisted lock state or exhausted lock updates. */
+declare class WorkflowLockStateError extends WorkflowStateError {
+  constructor(message: string, code: WorkflowErrorCode, details?: WorkflowErrorDetails, context?: Function);
+  static namespaceMismatch(this: void, actual: string, expected: string): never;
+  static keyChangeRejected(this: void): never;
+  static currentRecordInvalid(this: void): never;
+  static nextRecordInvalid(this: void): never;
+  static acquireConflictExhausted(this: void, key: string): never;
+  static notFound(this: void, key: string): never;
+  static releaseConflictExhausted(this: void, key: string): never;
+  static staleReleaseConflictExhausted(this: void, key: string): never;
+}
+/** Errors caused by invalid lock operations or lock options. */
+declare class WorkflowLockError extends WorkflowOptionsError {
+  constructor(message: string, code: WorkflowErrorCode, details?: WorkflowErrorDetails, context?: Function);
+  static alreadyHeld(this: void, key: string): never;
+  static holderMismatch(this: void, key: string): never;
+  static alreadyReleased(this: void, key: string): never;
+  static notStale(this: void, key: string): never;
+  static waitDeadlineConflict(this: void): never;
+  static timeoutRequiresWait(this: void): never;
+}
+//#endregion
+export { WorkflowLockError, WorkflowLockStateError };

package/dist/errors/lock.mjs

@@ -0,0 +1,70 @@
+import { WorkflowErrorCode } from "../types/error-code.mjs";
+import { WorkflowOptionsError, WorkflowStateError } from "./base.mjs";
+//#region src/errors/lock.ts
+/** Errors caused by invalid persisted lock state or exhausted lock updates. */
+var WorkflowLockStateError = class WorkflowLockStateError extends WorkflowStateError {
+	constructor(message, code, details, context) {
+		super(message, context, {
+			code,
+			details
+		});
+		this.name = "WorkflowLockStateError";
+	}
+	static namespaceMismatch(actual, expected) {
+		throw new WorkflowLockStateError(`Workflow lock namespace mismatch: ${actual} !== ${expected}`, WorkflowErrorCode.LOCK_NAMESPACE_MISMATCH, {
+			actual,
+			expected
+		}, WorkflowLockStateError.namespaceMismatch);
+	}
+	static keyChangeRejected() {
+		throw new WorkflowLockStateError("Workflow lock key cannot change", WorkflowErrorCode.LOCK_KEY_CHANGE_REJECTED, void 0, WorkflowLockStateError.keyChangeRejected);
+	}
+	static currentRecordInvalid() {
+		throw new WorkflowLockStateError("Current workflow lock record is invalid", WorkflowErrorCode.LOCK_CURRENT_RECORD_INVALID, void 0, WorkflowLockStateError.currentRecordInvalid);
+	}
+	static nextRecordInvalid() {
+		throw new WorkflowLockStateError("Next workflow lock record is invalid", WorkflowErrorCode.LOCK_NEXT_RECORD_INVALID, void 0, WorkflowLockStateError.nextRecordInvalid);
+	}
+	static acquireConflictExhausted(key) {
+		throw new WorkflowLockStateError(`Failed to acquire workflow lock ${key}`, WorkflowErrorCode.LOCK_ACQUIRE_CONFLICT_EXHAUSTED, { key }, WorkflowLockStateError.acquireConflictExhausted);
+	}
+	static notFound(key) {
+		throw new WorkflowLockStateError(`Workflow lock not found: ${key}`, WorkflowErrorCode.LOCK_NOT_FOUND, { key }, WorkflowLockStateError.notFound);
+	}
+	static releaseConflictExhausted(key) {
+		throw new WorkflowLockStateError(`Failed to release workflow lock ${key}`, WorkflowErrorCode.LOCK_RELEASE_CONFLICT_EXHAUSTED, { key }, WorkflowLockStateError.releaseConflictExhausted);
+	}
+	static staleReleaseConflictExhausted(key) {
+		throw new WorkflowLockStateError(`Failed to release stale workflow lock ${key}`, WorkflowErrorCode.LOCK_STALE_RELEASE_CONFLICT_EXHAUSTED, { key }, WorkflowLockStateError.staleReleaseConflictExhausted);
+	}
+};
+/** Errors caused by invalid lock operations or lock options. */
+var WorkflowLockError = class WorkflowLockError extends WorkflowOptionsError {
+	constructor(message, code, details, context) {
+		super(message, context, {
+			code,
+			details
+		});
+		this.name = "WorkflowLockError";
+	}
+	static alreadyHeld(key) {
+		throw new WorkflowLockError(`Workflow lock is already held: ${key}`, WorkflowErrorCode.LOCK_ALREADY_HELD_WITHOUT_WAIT, { key }, WorkflowLockError.alreadyHeld);
+	}
+	static holderMismatch(key) {
+		throw new WorkflowLockError(`Workflow lock holder mismatch: ${key}`, WorkflowErrorCode.LOCK_HOLDER_MISMATCH, { key }, WorkflowLockError.holderMismatch);
+	}
+	static alreadyReleased(key) {
+		throw new WorkflowLockError(`Workflow lock is already released: ${key}`, WorkflowErrorCode.LOCK_ALREADY_RELEASED, { key }, WorkflowLockError.alreadyReleased);
+	}
+	static notStale(key) {
+		throw new WorkflowLockError(`Workflow lock is not stale: ${key}`, WorkflowErrorCode.LOCK_NOT_STALE, { key }, WorkflowLockError.notStale);
+	}
+	static waitDeadlineConflict() {
+		throw new WorkflowLockError("Workflow lock options cannot include both waitTimeout and waitDeadlineAt", WorkflowErrorCode.LOCK_WAIT_DEADLINE_CONFLICT, void 0, WorkflowLockError.waitDeadlineConflict);
+	}
+	static timeoutRequiresWait() {
+		throw new WorkflowLockError("Workflow lock timeout options require wait: true", WorkflowErrorCode.LOCK_TIMEOUT_REQUIRES_WAIT, void 0, WorkflowLockError.timeoutRequiresWait);
+	}
+};
+//#endregion
+export { WorkflowLockError, WorkflowLockStateError };

package/dist/errors/message.d.mts

@@ -0,0 +1,106 @@
+import { MessageId } from "../types/message-id.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 { WorkflowMessageError } from "./base.mjs";
+//#region src/errors/message.d.ts
+/** Error thrown for message wait timeout failures. */
+declare class WorkflowMessageWaitTimeoutError extends WorkflowMessageError {
+  readonly runId: RunId;
+  readonly stepId: StepId;
+  readonly stepName: string;
+  readonly messageId: MessageId;
+  readonly timeoutAt: Temporal.Instant;
+  constructor(options: {
+    readonly runId: RunId;
+    readonly stepId: StepId;
+    readonly stepName: string;
+    readonly messageId: MessageId;
+    readonly timeoutAt: Temporal.Instant;
+  }, context?: Function);
+  static timedOut(this: void, options: {
+    readonly runId: RunId;
+    readonly stepId: StepId;
+    readonly stepName: string;
+    readonly messageId: MessageId;
+    readonly timeoutAt: Temporal.Instant;
+  }): never;
+  static create(this: void, options: {
+    readonly runId: RunId;
+    readonly stepId: StepId;
+    readonly stepName: string;
+    readonly messageId: MessageId;
+    readonly timeoutAt: Temporal.Instant;
+  }): WorkflowMessageWaitTimeoutError;
+}
+/** Error thrown for hook disposed failures. */
+declare class WorkflowHookDisposedError extends WorkflowMessageError {
+  readonly runId: RunId;
+  readonly stepId: StepId;
+  readonly stepName: string;
+  readonly messageId: MessageId;
+  constructor(options: {
+    readonly runId: RunId;
+    readonly stepId: StepId;
+    readonly stepName: string;
+    readonly messageId: MessageId;
+  }, context?: Function);
+  static disposed(this: void, options: {
+    readonly runId: RunId;
+    readonly stepId: StepId;
+    readonly stepName: string;
+    readonly messageId: MessageId;
+  }): never;
+  static create(this: void, options: {
+    readonly runId: RunId;
+    readonly stepId: StepId;
+    readonly stepName: string;
+    readonly messageId: MessageId;
+  }): WorkflowHookDisposedError;
+  static isDisposed(error: unknown): boolean;
+}
+/** Error thrown for message delivery failures. */
+declare class WorkflowMessageDeliveryError extends WorkflowMessageError {
+  readonly runId: RunId;
+  readonly status: WorkflowTerminalRunStatus;
+  readonly messageId: MessageId;
+  constructor(options: {
+    readonly runId: RunId;
+    readonly status: WorkflowTerminalRunStatus;
+    readonly messageId: MessageId;
+  }, context?: Function);
+  static cannotSend(this: void, options: {
+    readonly runId: RunId;
+    readonly status: WorkflowTerminalRunStatus;
+    readonly messageId: MessageId;
+  }): never;
+  static create(this: void, options: {
+    readonly runId: RunId;
+    readonly status: WorkflowTerminalRunStatus;
+    readonly messageId: MessageId;
+  }): WorkflowMessageDeliveryError;
+}
+/** Error thrown for message idempotency conflict failures. */
+declare class WorkflowMessageIdempotencyConflictError extends WorkflowMessageError {
+  readonly runId: RunId;
+  readonly messageId: MessageId;
+  readonly idempotencyKey: string;
+  constructor(options: {
+    readonly runId: RunId;
+    readonly messageId: MessageId;
+    readonly idempotencyKey: string;
+  }, context?: Function);
+  static conflict(this: void, options: {
+    readonly runId: RunId;
+    readonly messageId: MessageId;
+    readonly idempotencyKey: string;
+  }): never;
+  static create(this: void, options: {
+    readonly runId: RunId;
+    readonly messageId: MessageId;
+    readonly idempotencyKey: string;
+  }): WorkflowMessageIdempotencyConflictError;
+}
+//#endregion
+export { WorkflowHookDisposedError, WorkflowMessageDeliveryError, WorkflowMessageIdempotencyConflictError, WorkflowMessageWaitTimeoutError };

package/dist/errors/message.mjs

@@ -0,0 +1,122 @@
+import { WorkflowErrorCode } from "../types/error-code.mjs";
+import { WorkflowMessageError } from "./base.mjs";
+import { workflowErrorRecordView } from "./record-view.mjs";
+//#region src/errors/message.ts
+/** Error thrown for message wait timeout failures. */
+var WorkflowMessageWaitTimeoutError = class WorkflowMessageWaitTimeoutError extends WorkflowMessageError {
+	runId;
+	stepId;
+	stepName;
+	messageId;
+	timeoutAt;
+	constructor(options, context) {
+		super(`Workflow message wait timed out: ${options.messageId} for run ${options.runId} step ${options.stepId} at ${options.timeoutAt.toString()}`, {
+			code: WorkflowErrorCode.MESSAGE_WAIT_TIMEOUT,
+			details: {
+				runId: options.runId,
+				stepId: options.stepId,
+				stepName: options.stepName,
+				messageId: options.messageId,
+				timeoutAt: options.timeoutAt.toString()
+			}
+		}, context);
+		this.name = "WorkflowMessageWaitTimeoutError";
+		this.runId = options.runId;
+		this.stepId = options.stepId;
+		this.stepName = options.stepName;
+		this.messageId = options.messageId;
+		this.timeoutAt = options.timeoutAt;
+	}
+	static timedOut(options) {
+		throw new WorkflowMessageWaitTimeoutError(options, WorkflowMessageWaitTimeoutError.timedOut);
+	}
+	static create(options) {
+		return new WorkflowMessageWaitTimeoutError(options, WorkflowMessageWaitTimeoutError.create);
+	}
+};
+/** Error thrown for hook disposed failures. */
+var WorkflowHookDisposedError = class WorkflowHookDisposedError extends WorkflowMessageError {
+	runId;
+	stepId;
+	stepName;
+	messageId;
+	constructor(options, context) {
+		super(`Workflow hook disposed: ${options.messageId} for run ${options.runId} step ${options.stepId}`, {
+			code: WorkflowErrorCode.HOOK_DISPOSED,
+			details: {
+				runId: options.runId,
+				stepId: options.stepId,
+				stepName: options.stepName,
+				messageId: options.messageId
+			}
+		}, context);
+		this.name = "WorkflowHookDisposedError";
+		this.runId = options.runId;
+		this.stepId = options.stepId;
+		this.stepName = options.stepName;
+		this.messageId = options.messageId;
+	}
+	static disposed(options) {
+		throw new WorkflowHookDisposedError(options, WorkflowHookDisposedError.disposed);
+	}
+	static create(options) {
+		return new WorkflowHookDisposedError(options, WorkflowHookDisposedError.create);
+	}
+	static isDisposed(error) {
+		return workflowErrorRecordView(error)?.code === WorkflowErrorCode.HOOK_DISPOSED;
+	}
+};
+/** Error thrown for message delivery failures. */
+var WorkflowMessageDeliveryError = class WorkflowMessageDeliveryError extends WorkflowMessageError {
+	runId;
+	status;
+	messageId;
+	constructor(options, context) {
+		super(`Cannot send workflow message ${options.messageId} to ${options.status} run: ${options.runId}`, {
+			code: WorkflowErrorCode.MESSAGE_DELIVERY_REJECTED,
+			details: {
+				runId: options.runId,
+				status: options.status,
+				messageId: options.messageId
+			}
+		}, context);
+		this.name = "WorkflowMessageDeliveryError";
+		this.runId = options.runId;
+		this.status = options.status;
+		this.messageId = options.messageId;
+	}
+	static cannotSend(options) {
+		throw new WorkflowMessageDeliveryError(options, WorkflowMessageDeliveryError.cannotSend);
+	}
+	static create(options) {
+		return new WorkflowMessageDeliveryError(options, WorkflowMessageDeliveryError.create);
+	}
+};
+/** Error thrown for message idempotency conflict failures. */
+var WorkflowMessageIdempotencyConflictError = class WorkflowMessageIdempotencyConflictError extends WorkflowMessageError {
+	runId;
+	messageId;
+	idempotencyKey;
+	constructor(options, context) {
+		super(`Workflow message idempotency key conflict: ${options.idempotencyKey} for message ${options.messageId} on run ${options.runId}`, {
+			code: WorkflowErrorCode.MESSAGE_IDEMPOTENCY_CONFLICT,
+			details: {
+				runId: options.runId,
+				messageId: options.messageId,
+				idempotencyKey: options.idempotencyKey
+			}
+		}, context);
+		this.name = "WorkflowMessageIdempotencyConflictError";
+		this.runId = options.runId;
+		this.messageId = options.messageId;
+		this.idempotencyKey = options.idempotencyKey;
+	}
+	static conflict(options) {
+		throw new WorkflowMessageIdempotencyConflictError(options, WorkflowMessageIdempotencyConflictError.conflict);
+	}
+	static create(options) {
+		return new WorkflowMessageIdempotencyConflictError(options, WorkflowMessageIdempotencyConflictError.create);
+	}
+};
+//#endregion
+export { WorkflowHookDisposedError, WorkflowMessageDeliveryError, WorkflowMessageIdempotencyConflictError, WorkflowMessageWaitTimeoutError };