@temelj/workflow 0.0.0-alpha.1

package/dist/errors/run.mjs

@@ -0,0 +1,232 @@
+import { WorkflowErrorCode } from "../types/error-code.mjs";
+import { WorkflowRunError } from "./base.mjs";
+//#region src/errors/run.ts
+/** Error thrown for run not found failures. */
+var WorkflowRunNotFoundError = class WorkflowRunNotFoundError extends WorkflowRunError {
+	runId;
+	constructor(runId, context) {
+		super(`Workflow run not found: ${runId}`, {
+			code: WorkflowErrorCode.RUN_NOT_FOUND,
+			details: { runId }
+		}, context);
+		this.name = "WorkflowRunNotFoundError";
+		this.runId = runId;
+	}
+	static notFound(runId) {
+		throw new WorkflowRunNotFoundError(runId, WorkflowRunNotFoundError.notFound);
+	}
+	static create(runId) {
+		return new WorkflowRunNotFoundError(runId, WorkflowRunNotFoundError.create);
+	}
+};
+/** Error thrown for run not found failures. */
+var WorkflowRunInvalidError = class WorkflowRunInvalidError extends WorkflowRunError {
+	runId;
+	constructor(runId, message, context) {
+		super(`Workflow run '${runId}' invalid: ${message}`, {
+			code: WorkflowErrorCode.RUN_INVALID,
+			details: { runId }
+		}, context);
+		this.name = "WorkflowRunInvalidError";
+		this.runId = runId;
+	}
+	static invalid(runId, message) {
+		throw new WorkflowRunInvalidError(runId, message, WorkflowRunInvalidError.invalid);
+	}
+	static create(runId, message) {
+		return new WorkflowRunInvalidError(runId, message, WorkflowRunInvalidError.create);
+	}
+};
+/** Error thrown for run mismatch failures. */
+var WorkflowRunMismatchError = class WorkflowRunMismatchError extends WorkflowRunError {
+	runId;
+	expectedWorkflowName;
+	actualWorkflowName;
+	constructor(options, context) {
+		super(`Workflow run ${options.runId} belongs to ${options.actualWorkflowName}, not ${options.expectedWorkflowName}`, {
+			code: WorkflowErrorCode.RUN_WORKFLOW_MISMATCH,
+			details: {
+				runId: options.runId,
+				expectedWorkflowName: options.expectedWorkflowName,
+				actualWorkflowName: options.actualWorkflowName
+			}
+		}, context);
+		this.name = "WorkflowRunMismatchError";
+		this.runId = options.runId;
+		this.expectedWorkflowName = options.expectedWorkflowName;
+		this.actualWorkflowName = options.actualWorkflowName;
+	}
+	static mismatch(options) {
+		throw new WorkflowRunMismatchError(options, WorkflowRunMismatchError.mismatch);
+	}
+	static create(options) {
+		return new WorkflowRunMismatchError(options, WorkflowRunMismatchError.create);
+	}
+};
+/** Error thrown for result timeout failures. */
+var WorkflowResultTimeoutError = class WorkflowResultTimeoutError extends WorkflowRunError {
+	runId;
+	timeout;
+	constructor(runId, timeout, context) {
+		super(`Workflow result timed out after ${timeout.toString()}: ${runId}`, {
+			code: WorkflowErrorCode.RUN_RESULT_TIMEOUT,
+			details: {
+				runId,
+				timeout: timeout.toString()
+			}
+		}, context);
+		this.name = "WorkflowResultTimeoutError";
+		this.runId = runId;
+		this.timeout = timeout;
+	}
+	static timedOut(runId, timeout) {
+		throw new WorkflowResultTimeoutError(runId, timeout, WorkflowResultTimeoutError.timedOut);
+	}
+	static create(runId, timeout) {
+		return new WorkflowResultTimeoutError(runId, timeout, WorkflowResultTimeoutError.create);
+	}
+};
+/** Error thrown for run canceled failures. */
+var WorkflowRunCanceledError = class WorkflowRunCanceledError extends WorkflowRunError {
+	runId;
+	constructor(runId, context) {
+		super(`Workflow run was canceled: ${runId}`, {
+			code: WorkflowErrorCode.RUN_CANCELED,
+			details: { runId }
+		}, context);
+		this.name = "WorkflowRunCanceledError";
+		this.runId = runId;
+	}
+	static canceled(runId) {
+		throw new WorkflowRunCanceledError(runId, WorkflowRunCanceledError.canceled);
+	}
+	static create(runId) {
+		return new WorkflowRunCanceledError(runId, WorkflowRunCanceledError.create);
+	}
+};
+/** Error thrown for run cancellation failures. */
+var WorkflowRunCancellationError = class WorkflowRunCancellationError extends WorkflowRunError {
+	runId;
+	status;
+	constructor(runId, status, context) {
+		super(`Cannot cancel ${status} workflow run: ${runId}`, {
+			code: WorkflowErrorCode.RUN_CANCELLATION_REJECTED,
+			details: {
+				runId,
+				status
+			}
+		}, context);
+		this.name = "WorkflowRunCancellationError";
+		this.runId = runId;
+		this.status = status;
+	}
+	static cannotCancel(runId, status) {
+		throw new WorkflowRunCancellationError(runId, status, WorkflowRunCancellationError.cannotCancel);
+	}
+	static create(runId, status) {
+		return new WorkflowRunCancellationError(runId, status, WorkflowRunCancellationError.create);
+	}
+};
+/** Error thrown for run transition failures. */
+var WorkflowRunTransitionError = class WorkflowRunTransitionError extends WorkflowRunError {
+	runId;
+	from;
+	to;
+	constructor(runId, from, to, context) {
+		super(`Invalid workflow run status transition: ${runId} ${from} -> ${to}`, {
+			code: WorkflowErrorCode.RUN_TRANSITION_INVALID,
+			details: {
+				runId,
+				from,
+				to
+			}
+		}, context);
+		this.name = "WorkflowRunTransitionError";
+		this.runId = runId;
+		this.from = from;
+		this.to = to;
+	}
+	static invalidTransition(runId, from, to) {
+		throw new WorkflowRunTransitionError(runId, from, to, WorkflowRunTransitionError.invalidTransition);
+	}
+	static create(runId, from, to) {
+		return new WorkflowRunTransitionError(runId, from, to, WorkflowRunTransitionError.create);
+	}
+};
+/** Error thrown for run parent failures. */
+var WorkflowRunParentError = class WorkflowRunParentError extends WorkflowRunError {
+	runId;
+	reason;
+	constructor(runId, message, context) {
+		super(`Invalid workflow run parent metadata for ${runId}: ${message}`, {
+			code: WorkflowErrorCode.RUN_PARENT_INVALID,
+			details: {
+				runId,
+				reason: message
+			}
+		}, context);
+		this.name = "WorkflowRunParentError";
+		this.runId = runId;
+		this.reason = message;
+	}
+	static invalidParent(runId, message) {
+		throw new WorkflowRunParentError(runId, message, WorkflowRunParentError.invalidParent);
+	}
+	static create(runId, message) {
+		return new WorkflowRunParentError(runId, message, WorkflowRunParentError.create);
+	}
+};
+/** Error thrown for run deadline exceeded failures. */
+var WorkflowRunDeadlineExceededError = class WorkflowRunDeadlineExceededError extends WorkflowRunError {
+	runId;
+	deadlineAt;
+	constructor(runId, deadlineAt, context) {
+		super(`Workflow run deadline exceeded: ${runId} at ${deadlineAt.toString()}`, {
+			code: WorkflowErrorCode.RUN_DEADLINE_EXCEEDED,
+			details: {
+				runId,
+				deadlineAt: deadlineAt.toString()
+			}
+		}, context);
+		this.name = "WorkflowRunDeadlineExceededError";
+		this.runId = runId;
+		this.deadlineAt = deadlineAt;
+	}
+	static deadlineExceeded(runId, deadlineAt) {
+		throw new WorkflowRunDeadlineExceededError(runId, deadlineAt, WorkflowRunDeadlineExceededError.deadlineExceeded);
+	}
+	static create(runId, deadlineAt) {
+		return new WorkflowRunDeadlineExceededError(runId, deadlineAt, WorkflowRunDeadlineExceededError.create);
+	}
+};
+/** Error thrown for child workflow timeout failures. */
+var WorkflowChildWorkflowTimeoutError = class WorkflowChildWorkflowTimeoutError extends WorkflowRunError {
+	runId;
+	childRunId;
+	stepId;
+	timeoutAt;
+	constructor(options, context) {
+		super(`Child workflow timed out: ${options.childRunId} for parent ${options.runId} step ${options.stepId} at ${options.timeoutAt.toString()}`, {
+			code: WorkflowErrorCode.CHILD_WORKFLOW_TIMEOUT,
+			details: {
+				runId: options.runId,
+				childRunId: options.childRunId,
+				stepId: options.stepId,
+				timeoutAt: options.timeoutAt.toString()
+			}
+		}, context);
+		this.name = "WorkflowChildWorkflowTimeoutError";
+		this.runId = options.runId;
+		this.childRunId = options.childRunId;
+		this.stepId = options.stepId;
+		this.timeoutAt = options.timeoutAt;
+	}
+	static timedOut(options) {
+		throw new WorkflowChildWorkflowTimeoutError(options, WorkflowChildWorkflowTimeoutError.timedOut);
+	}
+	static create(options) {
+		return new WorkflowChildWorkflowTimeoutError(options, WorkflowChildWorkflowTimeoutError.create);
+	}
+};
+//#endregion
+export { WorkflowChildWorkflowTimeoutError, WorkflowResultTimeoutError, WorkflowRunCanceledError, WorkflowRunCancellationError, WorkflowRunDeadlineExceededError, WorkflowRunInvalidError, WorkflowRunMismatchError, WorkflowRunNotFoundError, WorkflowRunParentError, WorkflowRunTransitionError };

package/dist/errors/runtime.d.mts

@@ -0,0 +1,12 @@
+import { WorkflowError } from "./base.mjs";
+//#region src/errors/runtime.d.ts
+/** Error thrown for invalid workflow runtime usage. */
+declare class WorkflowRuntimeError extends WorkflowError {
+  constructor(message: string, context?: Function);
+  static create(this: void, message: string): WorkflowRuntimeError;
+  static invalid(this: void): never;
+  static clientMissing(this: void): never;
+  static registryMissing(this: void): never;
+}
+//#endregion
+export { WorkflowRuntimeError };

package/dist/errors/runtime.mjs

@@ -0,0 +1,24 @@
+import { WorkflowErrorCode } from "../types/error-code.mjs";
+import { WorkflowError } from "./base.mjs";
+//#region src/errors/runtime.ts
+/** Error thrown for invalid workflow runtime usage. */
+var WorkflowRuntimeError = class WorkflowRuntimeError extends WorkflowError {
+	constructor(message, context) {
+		super(message, { code: WorkflowErrorCode.RUNTIME_INVALID }, context);
+		this.name = "WorkflowRuntimeError";
+	}
+	static create(message) {
+		return new WorkflowRuntimeError(message, WorkflowRuntimeError.create);
+	}
+	static invalid() {
+		throw new WorkflowRuntimeError("Workflow runtime is invalid", WorkflowRuntimeError.invalid);
+	}
+	static clientMissing() {
+		throw new WorkflowRuntimeError("Workflow runtime is not backed by a workflow client", WorkflowRuntimeError.clientMissing);
+	}
+	static registryMissing() {
+		throw new WorkflowRuntimeError("Workflow runtime is not backed by a workflow registry", WorkflowRuntimeError.registryMissing);
+	}
+};
+//#endregion
+export { WorkflowRuntimeError };

package/dist/errors/schedule.d.mts

@@ -0,0 +1,27 @@
+import { WorkflowErrorCode } from "../types/error-code.mjs";
+import { ScheduleId } from "../types/schedule.mjs";
+import { WorkflowErrorDetails } from "../types/error.mjs";
+import { WorkflowStateError } from "./base.mjs";
+//#region src/errors/schedule.d.ts
+/** Errors caused by invalid persisted schedule state or exhausted schedule updates. */
+declare class WorkflowScheduleError extends WorkflowStateError {
+  constructor(message: string, code: WorkflowErrorCode, details?: WorkflowErrorDetails, context?: Function);
+  static namespaceMismatch(this: void, actual: string, expected: string): never;
+  static recordInvalid(this: void): never;
+  static idChangeRejected(this: void): never;
+  static currentRecordInvalid(this: void): never;
+  static nextRecordInvalid(this: void): never;
+  static upsertConflictExhausted(this: void, scheduleId: ScheduleId): never;
+  static notFound(this: void, scheduleId: ScheduleId): never;
+  static updateConflictExhausted(this: void, scheduleId: ScheduleId): never;
+}
+/** Error thrown when creating a schedule whose id is already stored. */
+declare class WorkflowScheduleAlreadyExistsError extends WorkflowStateError {
+  readonly scheduleId: ScheduleId;
+  constructor(scheduleId: ScheduleId, context?: Function);
+  static alreadyExists(this: void, scheduleId: ScheduleId): never;
+  static create(this: void, scheduleId: ScheduleId): WorkflowScheduleAlreadyExistsError;
+  static isAlreadyExists(error: unknown, scheduleId?: ScheduleId): boolean;
+}
+//#endregion
+export { WorkflowScheduleAlreadyExistsError, WorkflowScheduleError };

package/dist/errors/schedule.mjs

@@ -0,0 +1,65 @@
+import { WorkflowErrorCode } from "../types/error-code.mjs";
+import { WorkflowStateError } from "./base.mjs";
+import { workflowErrorRecordView } from "./record-view.mjs";
+//#region src/errors/schedule.ts
+/** Errors caused by invalid persisted schedule state or exhausted schedule updates. */
+var WorkflowScheduleError = class WorkflowScheduleError extends WorkflowStateError {
+	constructor(message, code, details, context) {
+		super(message, context, {
+			code,
+			details
+		});
+		this.name = "WorkflowScheduleError";
+	}
+	static namespaceMismatch(actual, expected) {
+		throw new WorkflowScheduleError(`Workflow schedule namespace mismatch: ${actual} !== ${expected}`, WorkflowErrorCode.SCHEDULE_NAMESPACE_MISMATCH, {
+			actual,
+			expected
+		}, WorkflowScheduleError.namespaceMismatch);
+	}
+	static recordInvalid() {
+		throw new WorkflowScheduleError("Workflow schedule record is invalid", WorkflowErrorCode.SCHEDULE_RECORD_INVALID, void 0, WorkflowScheduleError.recordInvalid);
+	}
+	static idChangeRejected() {
+		throw new WorkflowScheduleError("Workflow schedule id cannot change", WorkflowErrorCode.SCHEDULE_ID_CHANGE_REJECTED, void 0, WorkflowScheduleError.idChangeRejected);
+	}
+	static currentRecordInvalid() {
+		throw new WorkflowScheduleError("Current workflow schedule record is invalid", WorkflowErrorCode.SCHEDULE_CURRENT_RECORD_INVALID, void 0, WorkflowScheduleError.currentRecordInvalid);
+	}
+	static nextRecordInvalid() {
+		throw new WorkflowScheduleError("Next workflow schedule record is invalid", WorkflowErrorCode.SCHEDULE_NEXT_RECORD_INVALID, void 0, WorkflowScheduleError.nextRecordInvalid);
+	}
+	static upsertConflictExhausted(scheduleId) {
+		throw new WorkflowScheduleError(`Failed to upsert workflow schedule ${scheduleId}`, WorkflowErrorCode.SCHEDULE_UPSERT_CONFLICT_EXHAUSTED, { scheduleId }, WorkflowScheduleError.upsertConflictExhausted);
+	}
+	static notFound(scheduleId) {
+		throw new WorkflowScheduleError(`Workflow schedule not found: ${scheduleId}`, WorkflowErrorCode.SCHEDULE_NOT_FOUND, { scheduleId }, WorkflowScheduleError.notFound);
+	}
+	static updateConflictExhausted(scheduleId) {
+		throw new WorkflowScheduleError(`Failed to update workflow schedule ${scheduleId}`, WorkflowErrorCode.SCHEDULE_UPDATE_CONFLICT_EXHAUSTED, { scheduleId }, WorkflowScheduleError.updateConflictExhausted);
+	}
+};
+/** Error thrown when creating a schedule whose id is already stored. */
+var WorkflowScheduleAlreadyExistsError = class WorkflowScheduleAlreadyExistsError extends WorkflowStateError {
+	scheduleId;
+	constructor(scheduleId, context) {
+		super(`Workflow schedule already exists: ${scheduleId}`, context, {
+			code: WorkflowErrorCode.SCHEDULE_ALREADY_EXISTS,
+			details: { scheduleId }
+		});
+		this.name = "WorkflowScheduleAlreadyExistsError";
+		this.scheduleId = scheduleId;
+	}
+	static alreadyExists(scheduleId) {
+		throw new WorkflowScheduleAlreadyExistsError(scheduleId, WorkflowScheduleAlreadyExistsError.alreadyExists);
+	}
+	static create(scheduleId) {
+		return new WorkflowScheduleAlreadyExistsError(scheduleId, WorkflowScheduleAlreadyExistsError.create);
+	}
+	static isAlreadyExists(error, scheduleId) {
+		const record = workflowErrorRecordView(error);
+		return record?.code === WorkflowErrorCode.SCHEDULE_ALREADY_EXISTS && (scheduleId === void 0 || record.details?.scheduleId === scheduleId);
+	}
+};
+//#endregion
+export { WorkflowScheduleAlreadyExistsError, WorkflowScheduleError };

package/dist/errors/step.d.mts

@@ -0,0 +1,76 @@
+import { RunId } from "../types/run-id.mjs";
+import { StepId } from "../types/step-id.mjs";
+import "../types/step.mjs";
+import "../types/run.mjs";
+import { WorkflowStepExecutionErrorOptions } from "../types/error.mjs";
+import { WorkflowStepError } from "./base.mjs";
+//#region src/errors/step.d.ts
+/** Error thrown for step timeout failures. */
+declare class WorkflowStepTimeoutError extends WorkflowStepError {
+  readonly runId: RunId;
+  readonly stepId: StepId;
+  readonly stepName: string;
+  readonly attempt: number;
+  readonly timeoutAt: Temporal.Instant;
+  constructor(options: {
+    readonly runId: RunId;
+    readonly stepId: StepId;
+    readonly stepName: string;
+    readonly attempt: number;
+    readonly timeoutAt: Temporal.Instant;
+  }, context?: Function);
+  static timedOut(this: void, options: {
+    readonly runId: RunId;
+    readonly stepId: StepId;
+    readonly stepName: string;
+    readonly attempt: number;
+    readonly timeoutAt: Temporal.Instant;
+  }): never;
+  static create(this: void, options: {
+    readonly runId: RunId;
+    readonly stepId: StepId;
+    readonly stepName: string;
+    readonly attempt: number;
+    readonly timeoutAt: Temporal.Instant;
+  }): WorkflowStepTimeoutError;
+}
+/** Error thrown for step execution failures. */
+declare class WorkflowStepExecutionError extends WorkflowStepError {
+  readonly stepId: StepId;
+  readonly stepName: string;
+  readonly attempt: number;
+  constructor(options: WorkflowStepExecutionErrorOptions, context?: Function);
+  static failed(this: void, options: WorkflowStepExecutionErrorOptions): never;
+  static create(this: void, options: WorkflowStepExecutionErrorOptions): WorkflowStepExecutionError;
+}
+/** Error thrown when a step exhausts its retry policy. */
+declare class WorkflowStepRetryLimitError extends WorkflowStepError {
+  readonly stepId: StepId;
+  readonly stepName: string;
+  readonly attempt: number;
+  constructor(options: {
+    readonly stepId: StepId;
+    readonly stepName: string;
+    readonly attempt: number;
+  }, context?: Function);
+  static exceeded(this: void, options: {
+    readonly stepId: StepId;
+    readonly stepName: string;
+    readonly attempt: number;
+  }): never;
+  static create(this: void, options: {
+    readonly stepId: StepId;
+    readonly stepName: string;
+    readonly attempt: number;
+  }): WorkflowStepRetryLimitError;
+}
+/** Error thrown for step attempt limit failures. */
+declare class WorkflowStepAttemptLimitError extends WorkflowStepError {
+  readonly runId: RunId;
+  readonly maximumAttempts: number;
+  constructor(runId: RunId, maximumAttempts: number, context?: Function);
+  static exceeded(this: void, runId: RunId, maximumAttempts: number): never;
+  static create(this: void, runId: RunId, maximumAttempts: number): WorkflowStepAttemptLimitError;
+}
+//#endregion
+export { WorkflowStepAttemptLimitError, WorkflowStepExecutionError, WorkflowStepRetryLimitError, WorkflowStepTimeoutError };

package/dist/errors/step.mjs

@@ -0,0 +1,113 @@
+import { WorkflowErrorCode } from "../types/error-code.mjs";
+import { WorkflowStepError } from "./base.mjs";
+//#region src/errors/step.ts
+/** Error thrown for step timeout failures. */
+var WorkflowStepTimeoutError = class WorkflowStepTimeoutError extends WorkflowStepError {
+	runId;
+	stepId;
+	stepName;
+	attempt;
+	timeoutAt;
+	constructor(options, context) {
+		super(`Workflow step timed out: ${options.stepName} for run ${options.runId} attempt ${options.attempt} at ${options.timeoutAt.toString()}`, {
+			code: WorkflowErrorCode.STEP_TIMEOUT,
+			details: {
+				runId: options.runId,
+				stepId: options.stepId,
+				stepName: options.stepName,
+				attempt: options.attempt,
+				timeoutAt: options.timeoutAt.toString()
+			}
+		}, context);
+		this.name = "WorkflowStepTimeoutError";
+		this.runId = options.runId;
+		this.stepId = options.stepId;
+		this.stepName = options.stepName;
+		this.attempt = options.attempt;
+		this.timeoutAt = options.timeoutAt;
+	}
+	static timedOut(options) {
+		throw new WorkflowStepTimeoutError(options, WorkflowStepTimeoutError.timedOut);
+	}
+	static create(options) {
+		return new WorkflowStepTimeoutError(options, WorkflowStepTimeoutError.create);
+	}
+};
+/** Error thrown for step execution failures. */
+var WorkflowStepExecutionError = class WorkflowStepExecutionError extends WorkflowStepError {
+	stepId;
+	stepName;
+	attempt;
+	constructor(options, context) {
+		super(`Workflow step failed: ${options.stepName}`, {
+			code: WorkflowErrorCode.STEP_EXECUTION_FAILED,
+			cause: options.cause,
+			details: {
+				stepId: options.stepId,
+				stepName: options.stepName,
+				attempt: options.attempt
+			}
+		}, context);
+		this.name = "WorkflowStepExecutionError";
+		this.stepId = options.stepId;
+		this.stepName = options.stepName;
+		this.attempt = options.attempt;
+	}
+	static failed(options) {
+		throw new WorkflowStepExecutionError(options, WorkflowStepExecutionError.failed);
+	}
+	static create(options) {
+		return new WorkflowStepExecutionError(options, WorkflowStepExecutionError.create);
+	}
+};
+/** Error thrown when a step exhausts its retry policy. */
+var WorkflowStepRetryLimitError = class WorkflowStepRetryLimitError extends WorkflowStepError {
+	stepId;
+	stepName;
+	attempt;
+	constructor(options, context) {
+		super(`Workflow step retry limit exceeded: ${options.stepName}`, {
+			code: WorkflowErrorCode.STEP_RETRY_LIMIT_EXCEEDED,
+			details: {
+				stepId: options.stepId,
+				stepName: options.stepName,
+				attempt: options.attempt
+			}
+		}, context);
+		this.name = "WorkflowStepRetryLimitError";
+		this.stepId = options.stepId;
+		this.stepName = options.stepName;
+		this.attempt = options.attempt;
+	}
+	static exceeded(options) {
+		throw new WorkflowStepRetryLimitError(options, WorkflowStepRetryLimitError.exceeded);
+	}
+	static create(options) {
+		return new WorkflowStepRetryLimitError(options, WorkflowStepRetryLimitError.create);
+	}
+};
+/** Error thrown for step attempt limit failures. */
+var WorkflowStepAttemptLimitError = class WorkflowStepAttemptLimitError extends WorkflowStepError {
+	runId;
+	maximumAttempts;
+	constructor(runId, maximumAttempts, context) {
+		super(`Workflow run exceeded total step attempt limit: ${runId} (${maximumAttempts})`, {
+			code: WorkflowErrorCode.STEP_ATTEMPT_LIMIT_EXCEEDED,
+			details: {
+				runId,
+				maximumAttempts
+			}
+		}, context);
+		this.name = "WorkflowStepAttemptLimitError";
+		this.runId = runId;
+		this.maximumAttempts = maximumAttempts;
+	}
+	static exceeded(runId, maximumAttempts) {
+		throw new WorkflowStepAttemptLimitError(runId, maximumAttempts, WorkflowStepAttemptLimitError.exceeded);
+	}
+	static create(runId, maximumAttempts) {
+		return new WorkflowStepAttemptLimitError(runId, maximumAttempts, WorkflowStepAttemptLimitError.create);
+	}
+};
+//#endregion
+export { WorkflowStepAttemptLimitError, WorkflowStepExecutionError, WorkflowStepRetryLimitError, WorkflowStepTimeoutError };

package/dist/errors/stream.d.mts

@@ -0,0 +1,24 @@
+import { WorkflowErrorCode } from "../types/error-code.mjs";
+import { StreamIdOrName } from "../types/stream-id.mjs";
+import { WorkflowErrorDetails } from "../types/error.mjs";
+import { WorkflowOptionsError } from "./base.mjs";
+//#region src/errors/stream.d.ts
+/** Errors caused by invalid stream operations or stream history. */
+declare class WorkflowStreamError extends WorkflowOptionsError {
+  constructor(message: string, code: WorkflowErrorCode, details?: WorkflowErrorDetails, context?: Function);
+  static chunkLimitExceeded(this: void, streamId: string, maximumChunks: number): never;
+  static readOffsetConflict(this: void): never;
+  static nonContiguousChunkIndex(this: void, streamId: string, actualIndex: number, expectedIndex: number): never;
+  static chunkAfterTerminal(this: void, streamId: string, chunkIndex: number, terminalKind: string): never;
+  static alreadyClosed(this: void, streamId: string): never;
+}
+/** Error thrown when a requested workflow stream cannot be found. */
+declare class WorkflowStreamNotFoundError extends WorkflowOptionsError {
+  readonly streamIdOrName: StreamIdOrName;
+  constructor(streamIdOrName: StreamIdOrName, context?: Function);
+  static notFound(this: void, streamIdOrName: StreamIdOrName): never;
+  static create(this: void, streamIdOrName: StreamIdOrName): WorkflowStreamNotFoundError;
+  static isNotFound(error: unknown, streamIdOrName?: StreamIdOrName): boolean;
+}
+//#endregion
+export { WorkflowStreamError, WorkflowStreamNotFoundError };

package/dist/errors/stream.mjs

@@ -0,0 +1,64 @@
+import { WorkflowErrorCode } from "../types/error-code.mjs";
+import { WorkflowOptionsError } from "./base.mjs";
+import { workflowErrorRecordView } from "./record-view.mjs";
+//#region src/errors/stream.ts
+/** Errors caused by invalid stream operations or stream history. */
+var WorkflowStreamError = class WorkflowStreamError extends WorkflowOptionsError {
+	constructor(message, code, details, context) {
+		super(message, context, {
+			code,
+			details
+		});
+		this.name = "WorkflowStreamError";
+	}
+	static chunkLimitExceeded(streamId, maximumChunks) {
+		throw new WorkflowStreamError(`Workflow stream ${streamId} chunk count would exceed maximumStreamChunks ${maximumChunks}`, WorkflowErrorCode.STREAM_CHUNK_LIMIT_EXCEEDED, {
+			streamId,
+			maximumChunks
+		}, WorkflowStreamError.chunkLimitExceeded);
+	}
+	static readOffsetConflict() {
+		throw new WorkflowStreamError("Cannot include both fromIndex and fromTail", WorkflowErrorCode.STREAM_READ_OFFSET_CONFLICT, void 0, WorkflowStreamError.readOffsetConflict);
+	}
+	static nonContiguousChunkIndex(streamId, actualIndex, expectedIndex) {
+		throw new WorkflowStreamError(`Workflow stream ${streamId} has non-contiguous chunk index ${actualIndex}; expected ${expectedIndex}`, WorkflowErrorCode.STREAM_CHUNK_INDEX_NON_CONTIGUOUS, {
+			streamId,
+			actualIndex,
+			expectedIndex
+		}, WorkflowStreamError.nonContiguousChunkIndex);
+	}
+	static chunkAfterTerminal(streamId, chunkIndex, terminalKind) {
+		throw new WorkflowStreamError(`Workflow stream ${streamId} has chunk ${chunkIndex} after terminal event ${terminalKind}`, WorkflowErrorCode.STREAM_CHUNK_AFTER_TERMINAL, {
+			streamId,
+			chunkIndex,
+			terminalKind
+		}, WorkflowStreamError.chunkAfterTerminal);
+	}
+	static alreadyClosed(streamId) {
+		throw new WorkflowStreamError(`Workflow stream is already closed: ${streamId}`, WorkflowErrorCode.STREAM_ALREADY_CLOSED, { streamId }, WorkflowStreamError.alreadyClosed);
+	}
+};
+/** Error thrown when a requested workflow stream cannot be found. */
+var WorkflowStreamNotFoundError = class WorkflowStreamNotFoundError extends WorkflowOptionsError {
+	streamIdOrName;
+	constructor(streamIdOrName, context) {
+		super(`Workflow stream was not found: ${streamIdOrName}`, context, {
+			code: WorkflowErrorCode.STREAM_NOT_FOUND,
+			details: { streamIdOrName }
+		});
+		this.name = "WorkflowStreamNotFoundError";
+		this.streamIdOrName = streamIdOrName;
+	}
+	static notFound(streamIdOrName) {
+		throw new WorkflowStreamNotFoundError(streamIdOrName, WorkflowStreamNotFoundError.notFound);
+	}
+	static create(streamIdOrName) {
+		return new WorkflowStreamNotFoundError(streamIdOrName, WorkflowStreamNotFoundError.create);
+	}
+	static isNotFound(error, streamIdOrName) {
+		const record = workflowErrorRecordView(error);
+		return record?.code === WorkflowErrorCode.STREAM_NOT_FOUND && (streamIdOrName === void 0 || record.details?.streamIdOrName === streamIdOrName);
+	}
+};
+//#endregion
+export { WorkflowStreamError, WorkflowStreamNotFoundError };

package/dist/esbuild.d.mts

@@ -0,0 +1,7 @@
+import { WorkflowPluginOptions } from "./types/vite.mjs";
+import { workflowPlugin } from "./vite/plugin.mjs";
+//#region src/esbuild.d.ts
+/** Creates the esbuild plugin that compiles workflow and step directives. */
+declare const workflow: (options?: WorkflowPluginOptions | undefined) => import("esbuild").Plugin;
+//#endregion
+export { type WorkflowPluginOptions, workflow, workflowPlugin };

package/dist/esbuild.mjs

@@ -0,0 +1,6 @@
+import { workflowPlugin } from "./vite/plugin.mjs";
+//#region src/esbuild.ts
+/** Creates the esbuild plugin that compiles workflow and step directives. */
+const workflow = workflowPlugin.esbuild;
+//#endregion
+export { workflow, workflowPlugin };