@temelj/workflow 0.0.0-alpha.1

package/dist/types/run.d.mts

@@ -0,0 +1,355 @@
+import { RunId } from "./run-id.mjs";
+import { StepId } from "./step-id.mjs";
+import { WorkerId } from "./worker-id.mjs";
+import { TelemetryContext } from "./telemetry.mjs";
+import { WorkflowErrorRecord } from "./error.mjs";
+import { StorageValue } from "@temelj/storage";
+import { z } from "zod";
+//#region src/types/run.d.ts
+declare const WORKFLOW_ATTRIBUTE_MAX_KEY_LENGTH = 128;
+declare const WORKFLOW_ATTRIBUTE_MAX_COUNT = 64;
+declare const WORKFLOW_ATTRIBUTE_MAX_VALUE_BYTES = 1024;
+declare const WORKFLOW_ATTRIBUTE_RESERVED_PREFIX = "$";
+/** Validation issue describing why a value cannot be stored in workflow history. */
+interface WorkflowValueIssue {
+  readonly path: string;
+  readonly message: string;
+}
+declare const workflowPersistedValueSchema: z.ZodType<StorageValue>;
+/** Returns the first persistence validation issue for a workflow value, if one exists. */
+declare function persistedValueIssue(value: unknown, path: string, seen: WeakSet<object>, allowUndefined: boolean): WorkflowValueIssue | undefined;
+declare const workflowAttributeKeySchema: z.ZodString;
+declare const workflowAttributePrimitiveValueSchema: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+declare const workflowAttributeValueSchema: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+declare const workflowRunAttributesSchema: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
+declare const workflowAttributePatchSchema: z.ZodRecord<z.ZodString, z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
+declare const workflowRunStatusSchema: z.ZodEnum<{
+  canceled: "canceled";
+  completed: "completed";
+  failed: "failed";
+  pending: "pending";
+  running: "running";
+  waiting: "waiting";
+}>;
+declare const workflowTerminalRunStatusSchema: z.ZodEnum<{
+  canceled: "canceled";
+  completed: "completed";
+  failed: "failed";
+}>;
+declare const workflowRunRetryReasonSchema: z.ZodEnum<{
+  missing_implementation: "missing_implementation";
+  step: "step";
+  workflow: "workflow";
+}>;
+declare const workflowRunTransitionReasonSchema: z.ZodEnum<{
+  canceled: "canceled";
+  claimed: "claimed";
+  completed: "completed";
+  created: "created";
+  deadline: "deadline";
+  failed: "failed";
+  lease_released: "lease_released";
+  manual_retry: "manual_retry";
+  missing_implementation: "missing_implementation";
+  permanent_failure: "permanent_failure";
+  reclaimed: "reclaimed";
+  rescheduled: "rescheduled";
+  retry: "retry";
+  started: "started";
+  waiting: "waiting";
+}>;
+/** Type used for workflow step type values. */
+declare const workflowStepTypeSchema: z.ZodEnum<{
+  attributes: "attributes";
+  deterministic: "deterministic";
+  "message-send": "message-send";
+  "message-wait": "message-wait";
+  metadata: "metadata";
+  run: "run";
+  sleep: "sleep";
+  stream: "stream";
+  workflow: "workflow";
+}>;
+declare const workflowMaterializedStepTypeSchema: z.ZodEnum<{
+  deterministic: "deterministic";
+  "message-send": "message-send";
+  "message-wait": "message-wait";
+  run: "run";
+  sleep: "sleep";
+  stream: "stream";
+  workflow: "workflow";
+}>;
+declare const workflowRunRecordSchema: z.ZodObject<{
+  id: z.ZodString;
+  namespace: z.ZodString;
+  workflowName: z.ZodString;
+  workflowVersion: z.ZodOptional<z.ZodString>;
+  status: z.ZodEnum<{
+    canceled: "canceled";
+    completed: "completed";
+    failed: "failed";
+    pending: "pending";
+    running: "running";
+    waiting: "waiting";
+  }>;
+  input: z.ZodOptional<z.ZodType<StorageValue, unknown, z.core.$ZodTypeInternals<StorageValue, unknown>>>;
+  context: z.ZodOptional<z.ZodType<StorageValue, unknown, z.core.$ZodTypeInternals<StorageValue, unknown>>>;
+  telemetryContext: z.ZodOptional<z.ZodObject<{
+    traceparent: z.ZodOptional<z.ZodString>;
+    tracestate: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  metadata: z.ZodOptional<z.ZodType<StorageValue, unknown, z.core.$ZodTypeInternals<StorageValue, unknown>>>;
+  attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
+  output: z.ZodOptional<z.ZodType<StorageValue, unknown, z.core.$ZodTypeInternals<StorageValue, unknown>>>;
+  error: z.ZodOptional<z.ZodObject<{
+    code: z.ZodOptional<z.ZodEnum<{
+      readonly ERROR: "workflow.error";
+      readonly DEFINITION_INVALID: "definition.invalid";
+      readonly CAPABILITY_UNSUPPORTED: "capability.unsupported";
+      readonly OPTIONS_INVALID: "options.invalid";
+      readonly OPTIONS_EXPECTED_OBJECT: "options.expected_object";
+      readonly OPTIONS_EXPECTED_ARRAY: "options.expected_array";
+      readonly OPTIONS_EXPECTED_FUNCTION: "options.expected_function";
+      readonly OPTIONS_EXPECTED_STRING: "options.expected_string";
+      readonly OPTIONS_EXPECTED_NON_EMPTY: "options.expected_non_empty";
+      readonly OPTIONS_EXPECTED_NON_BLANK: "options.expected_non_blank";
+      readonly OPTIONS_EXPECTED_NUMBER: "options.expected_number";
+      readonly OPTIONS_EXPECTED_BOOLEAN: "options.expected_boolean";
+      readonly OPTIONS_REQUIRED: "options.required";
+      readonly OPTIONS_EXPECTED_POSITIVE_SAFE_INTEGER: "options.expected_positive_safe_integer";
+      readonly OPTIONS_EXPECTED_NON_NEGATIVE_SAFE_INTEGER: "options.expected_non_negative_safe_integer";
+      readonly OPTIONS_EXPECTED_POSITIVE_DURATION: "options.expected_positive_duration";
+      readonly OPTIONS_EXPECTED_NON_NEGATIVE_DURATION: "options.expected_non_negative_duration";
+      readonly OPTIONS_EXPECTED_TIMER_SAFE_DURATION: "options.expected_timer_safe_duration";
+      readonly OPTIONS_EXPECTED_POSITIVE_SAFE_INTEGER_DURATION: "options.expected_positive_safe_integer_duration";
+      readonly OPTIONS_EXPECTED_TEMPORAL_INSTANT: "options.expected_temporal_instant";
+      readonly OPTIONS_EXPECTED_ABORT_SIGNAL: "options.expected_abort_signal";
+      readonly OPTIONS_CHILD_CANCELLATION_POLICY_INVALID: "options.child_cancellation_policy_invalid";
+      readonly OPTIONS_CURSOR_INVALID: "options.cursor_invalid";
+      readonly OPTIONS_RETRY_MAXIMUM_INTERVAL_TOO_SMALL: "options.retry_maximum_interval_too_small";
+      readonly OPTIONS_RETRYABLE_ERROR_DELAY_CONFLICT: "options.retryable_error_delay_conflict";
+      readonly OPTIONS_ENGINE_STORE_STORAGE_CONFLICT: "options.engine_store_storage_conflict";
+      readonly OPTIONS_MISSING_IMPLEMENTATION_RETRY_ATTEMPT_INVALID: "options.missing_implementation_retry_attempt_invalid";
+      readonly STATE_INVALID: "state.invalid";
+      readonly STATE_RUN_NAMESPACE_MISMATCH: "state.run_namespace_mismatch";
+      readonly STATE_RUN_ID_MISMATCH: "state.run_id_mismatch";
+      readonly STATE_RUN_ALREADY_EXISTS: "state.run_already_exists";
+      readonly STATE_EVENT_HISTORY_ALREADY_EXISTS: "state.event_history_already_exists";
+      readonly STATE_EVENT_NOT_TERMINAL_STEP: "state.event_not_terminal_step";
+      readonly STATE_RECORDED_STEP_EVENT_UNSUPPORTED: "state.recorded_step_event_unsupported";
+      readonly STATE_STEP_ATTEMPT_FIELD_MISMATCH: "state.step_attempt_field_mismatch";
+      readonly STATE_FAILED_RUN_MISSING_ERROR: "state.failed_run_missing_error";
+      readonly STATE_RUN_NOT_CLAIMABLE: "state.run_not_claimable";
+      readonly STATE_WORKER_STOPPED_BEFORE_RUN: "state.worker_stopped_before_run";
+      readonly STATE_STORE_RUN_ID_INVALID: "state.store_run_id_invalid";
+      readonly STATE_IDEMPOTENCY_KEY_CLAIMED_WITHOUT_RUN: "state.idempotency_key_claimed_without_run";
+      readonly STATE_RUN_MISSING_IDEMPOTENCY_KEY: "state.run_missing_idempotency_key";
+      readonly STATE_RUN_METADATA_UPDATE_FAILED: "state.run_metadata_update_failed";
+      readonly STATE_RUN_ATTRIBUTES_UPDATE_FAILED: "state.run_attributes_update_failed";
+      readonly STATE_RUN_CANNOT_BE_RESCHEDULED: "state.run_cannot_be_rescheduled";
+      readonly STATE_RUN_RESCHEDULE_FAILED: "state.run_reschedule_failed";
+      readonly STATE_STALE_LEASE_RELEASE_REQUIRES_RUNNING: "state.stale_lease_release_requires_running";
+      readonly STATE_RUN_LEASE_STILL_ACTIVE: "state.run_lease_still_active";
+      readonly STATE_STALE_RUN_LEASE_RELEASE_FAILED: "state.stale_run_lease_release_failed";
+      readonly STATE_RUN_RETRY_REQUIRES_FAILED: "state.run_retry_requires_failed";
+      readonly STATE_RUN_RETRY_REQUIRES_FORCE_AFTER_PERMANENT_FAILURE: "state.run_retry_requires_force_after_permanent_failure";
+      readonly STATE_FAILED_RUN_RETRY_REQUIRES_FORCE: "state.failed_run_retry_requires_force";
+      readonly STATE_RUN_RETRY_FAILED: "state.run_retry_failed";
+      readonly STATE_PERMANENT_RUN_FAILURE_FAILED: "state.permanent_run_failure_failed";
+      readonly STATE_PERMANENT_FAILURE_STATUS_INVALID: "state.permanent_failure_status_invalid";
+      readonly STATE_MESSAGE_APPEND_FAILED: "state.message_append_failed";
+      readonly STATE_CLEANUP_SELECTED_NON_TERMINAL_RUN: "state.cleanup_selected_non_terminal_run";
+      readonly STATE_CLEANUP_RUN_MISSING_FINISHED_AT: "state.cleanup_run_missing_finished_at";
+      readonly STATE_WORKFLOW_EVENT_APPEND_FAILED: "state.workflow_event_append_failed";
+      readonly STATE_STEP_ATTEMPT_MATERIALIZATION_FAILED: "state.step_attempt_materialization_failed";
+      readonly STATE_APPEND_PROJECTION_PIPELINE_MISSING: "state.append_projection_pipeline_missing";
+      readonly RUNTIME_INVALID: "runtime.invalid";
+      readonly RUN_ERROR: "run.error";
+      readonly STEP_ERROR: "step.error";
+      readonly MESSAGE_ERROR: "message.error";
+      readonly IMPLEMENTATION_NOT_FOUND: "implementation.not_found";
+      readonly DURATION_INVALID: "duration.invalid";
+      readonly SERIALIZATION_FAILED: "serialization.failed";
+      readonly NON_RETRYABLE_FAILURE: "failure.non_retryable";
+      readonly PERMANENT_FAILURE: "failure.permanent";
+      readonly RETRYABLE_FAILURE: "failure.retryable";
+      readonly REPLAY_DIVERGED: "replay.diverged";
+      readonly LOCK_ALREADY_HELD: "lock.already_held";
+      readonly RUN_NOT_FOUND: "run.not_found";
+      readonly RUN_INVALID: "run.invalid";
+      readonly RUN_WORKFLOW_MISMATCH: "run.workflow_mismatch";
+      readonly RUN_RESULT_TIMEOUT: "run.result_timeout";
+      readonly RUN_CANCELED: "run.canceled";
+      readonly RUN_CANCELLATION_REJECTED: "run.cancellation_rejected";
+      readonly RUN_TRANSITION_INVALID: "run.transition_invalid";
+      readonly RUN_PARENT_INVALID: "run.parent_invalid";
+      readonly RUN_DEADLINE_EXCEEDED: "run.deadline_exceeded";
+      readonly CHILD_WORKFLOW_TIMEOUT: "child_workflow.timeout";
+      readonly MESSAGE_WAIT_TIMEOUT: "message.wait_timeout";
+      readonly HOOK_DISPOSED: "hook.disposed";
+      readonly MESSAGE_DELIVERY_REJECTED: "message.delivery_rejected";
+      readonly MESSAGE_IDEMPOTENCY_CONFLICT: "message.idempotency_conflict";
+      readonly STEP_TIMEOUT: "step.timeout";
+      readonly STEP_EXECUTION_FAILED: "step.execution_failed";
+      readonly STEP_RETRY_LIMIT_EXCEEDED: "step.retry_limit_exceeded";
+      readonly STEP_ATTEMPT_LIMIT_EXCEEDED: "step.attempt_limit_exceeded";
+      readonly SCHEDULE_ALREADY_EXISTS: "schedule.already_exists";
+      readonly SCHEDULE_NAMESPACE_MISMATCH: "schedule.namespace_mismatch";
+      readonly SCHEDULE_RECORD_INVALID: "schedule.record_invalid";
+      readonly SCHEDULE_ID_CHANGE_REJECTED: "schedule.id_change_rejected";
+      readonly SCHEDULE_CURRENT_RECORD_INVALID: "schedule.current_record_invalid";
+      readonly SCHEDULE_NEXT_RECORD_INVALID: "schedule.next_record_invalid";
+      readonly SCHEDULE_UPSERT_CONFLICT_EXHAUSTED: "schedule.upsert_conflict_exhausted";
+      readonly SCHEDULE_NOT_FOUND: "schedule.not_found";
+      readonly SCHEDULE_UPDATE_CONFLICT_EXHAUSTED: "schedule.update_conflict_exhausted";
+      readonly STREAM_NOT_FOUND: "stream.not_found";
+      readonly STREAM_CHUNK_LIMIT_EXCEEDED: "stream.chunk_limit_exceeded";
+      readonly STREAM_READ_OFFSET_CONFLICT: "stream.read_offset_conflict";
+      readonly STREAM_CHUNK_INDEX_NON_CONTIGUOUS: "stream.chunk_index_non_contiguous";
+      readonly STREAM_CHUNK_AFTER_TERMINAL: "stream.chunk_after_terminal";
+      readonly STREAM_ALREADY_CLOSED: "stream.already_closed";
+      readonly LOCK_ALREADY_HELD_WITHOUT_WAIT: "lock.already_held_without_wait";
+      readonly LOCK_HOLDER_MISMATCH: "lock.holder_mismatch";
+      readonly LOCK_ALREADY_RELEASED: "lock.already_released";
+      readonly LOCK_NOT_STALE: "lock.not_stale";
+      readonly LOCK_WAIT_DEADLINE_CONFLICT: "lock.wait_deadline_conflict";
+      readonly LOCK_TIMEOUT_REQUIRES_WAIT: "lock.timeout_requires_wait";
+      readonly LOCK_NAMESPACE_MISMATCH: "lock.namespace_mismatch";
+      readonly LOCK_KEY_CHANGE_REJECTED: "lock.key_change_rejected";
+      readonly LOCK_CURRENT_RECORD_INVALID: "lock.current_record_invalid";
+      readonly LOCK_NEXT_RECORD_INVALID: "lock.next_record_invalid";
+      readonly LOCK_ACQUIRE_CONFLICT_EXHAUSTED: "lock.acquire_conflict_exhausted";
+      readonly LOCK_NOT_FOUND: "lock.not_found";
+      readonly LOCK_RELEASE_CONFLICT_EXHAUSTED: "lock.release_conflict_exhausted";
+      readonly LOCK_STALE_RELEASE_CONFLICT_EXHAUSTED: "lock.stale_release_conflict_exhausted";
+      readonly HOOK_TOKEN_INVALID: "hook.token_invalid";
+      readonly WEBHOOK_TOKEN_INVALID: "webhook.token_invalid";
+      readonly HOOK_TOKEN_NOT_UNIQUE: "hook.token_not_unique";
+      readonly HOOK_WAITING_STEP_MISSING: "hook.waiting_step_missing";
+    }>>;
+    name: z.ZodString;
+    message: z.ZodString;
+    stack: z.ZodOptional<z.ZodString>;
+    details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
+  }, z.core.$loose>>;
+  attempts: z.ZodOptional<z.ZodNumber>;
+  idempotencyKey: z.ZodOptional<z.ZodString>;
+  parentRunId: z.ZodOptional<z.ZodString>;
+  parentStepId: z.ZodOptional<z.ZodString>;
+  parentStepName: z.ZodOptional<z.ZodString>;
+  parentStepAttempt: z.ZodOptional<z.ZodNumber>;
+  workerId: z.ZodOptional<z.ZodCustom<string, string>>;
+  createdAt: z.ZodCustom<Temporal.Instant, Temporal.Instant>;
+  updatedAt: z.ZodCustom<Temporal.Instant, Temporal.Instant>;
+  lastTransitionAt: z.ZodCustom<Temporal.Instant, Temporal.Instant>;
+  lastTransitionReason: z.ZodEnum<{
+    canceled: "canceled";
+    claimed: "claimed";
+    completed: "completed";
+    created: "created";
+    deadline: "deadline";
+    failed: "failed";
+    lease_released: "lease_released";
+    manual_retry: "manual_retry";
+    missing_implementation: "missing_implementation";
+    permanent_failure: "permanent_failure";
+    reclaimed: "reclaimed";
+    rescheduled: "rescheduled";
+    retry: "retry";
+    started: "started";
+    waiting: "waiting";
+  }>;
+  availableAt: z.ZodOptional<z.ZodCustom<Temporal.Instant, Temporal.Instant>>;
+  retryAt: z.ZodOptional<z.ZodCustom<Temporal.Instant, Temporal.Instant>>;
+  retryReason: z.ZodOptional<z.ZodEnum<{
+    missing_implementation: "missing_implementation";
+    step: "step";
+    workflow: "workflow";
+  }>>;
+  retryAttempt: z.ZodOptional<z.ZodNumber>;
+  retryStepId: z.ZodOptional<z.ZodString>;
+  retryStepName: z.ZodOptional<z.ZodString>;
+  deadlineAt: z.ZodOptional<z.ZodCustom<Temporal.Instant, Temporal.Instant>>;
+  leaseExpiresAt: z.ZodOptional<z.ZodCustom<Temporal.Instant, Temporal.Instant>>;
+  startedAt: z.ZodOptional<z.ZodCustom<Temporal.Instant, Temporal.Instant>>;
+  finishedAt: z.ZodOptional<z.ZodCustom<Temporal.Instant, Temporal.Instant>>;
+}, z.core.$strip>;
+/** Type used for workflow attribute value values. */
+type WorkflowAttributeValue = string | number | boolean | null;
+/** Type used for workflow run attributes values. */
+type WorkflowRunAttributes = Readonly<Record<string, WorkflowAttributeValue>>;
+/** Type used for workflow attribute patch values. */
+type WorkflowAttributePatch = Readonly<Record<string, WorkflowAttributeValue | undefined>>;
+/** Status values for workflow run. */
+type WorkflowRunStatus = "pending" | "running" | "waiting" | "completed" | "failed" | "canceled";
+/** Status values for workflow terminal run. */
+type WorkflowTerminalRunStatus = "completed" | "failed" | "canceled";
+/** Type used for workflow step type values. */
+type WorkflowStepType = "run" | "sleep" | "workflow" | "message-send" | "message-wait" | "stream" | "deterministic" | "metadata" | "attributes";
+/** Stable identity assigned to a durable step occurrence within a workflow run. */
+interface WorkflowStepIdentity<TType extends WorkflowStepType = WorkflowStepType> {
+  readonly id: string;
+  readonly name: string;
+  readonly count: number;
+  readonly kind: TType;
+}
+/** Type used for workflow materialized step type values. */
+type WorkflowMaterializedStepType = "run" | "sleep" | "workflow" | "message-send" | "message-wait" | "stream" | "deterministic";
+/** Type used for workflow run retry reason values. */
+type WorkflowRunRetryReason = "workflow" | "step" | "missing_implementation";
+/** Type used for workflow definition name values stored on runs. */
+type WorkflowRunWorkflowName = string;
+/** Type used for workflow definition version values stored on runs. */
+type WorkflowRunWorkflowVersion = string;
+/** Type used for workflow run transition reason values. */
+type WorkflowRunTransitionReason = "created" | "claimed" | "reclaimed" | "started" | "waiting" | "rescheduled" | "lease_released" | "manual_retry" | "permanent_failure" | "retry" | "missing_implementation" | "completed" | "failed" | "deadline" | "canceled";
+/** Stored record for workflow run. */
+interface WorkflowRunRecord<TInput = StorageValue, TOutput = StorageValue> {
+  readonly id: RunId;
+  readonly namespace: string;
+  readonly workflowName: WorkflowRunWorkflowName;
+  readonly workflowVersion?: WorkflowRunWorkflowVersion;
+  readonly status: WorkflowRunStatus;
+  readonly input?: TInput;
+  readonly context?: StorageValue;
+  readonly telemetryContext?: TelemetryContext;
+  readonly metadata?: StorageValue;
+  readonly attributes?: WorkflowRunAttributes;
+  readonly output?: TOutput;
+  readonly error?: WorkflowErrorRecord;
+  readonly attempts?: number;
+  readonly idempotencyKey?: string;
+  readonly parentRunId?: RunId;
+  readonly parentStepId?: StepId;
+  readonly parentStepName?: string;
+  readonly parentStepAttempt?: number;
+  readonly workerId?: WorkerId;
+  readonly createdAt: Temporal.Instant;
+  readonly updatedAt: Temporal.Instant;
+  readonly lastTransitionAt: Temporal.Instant;
+  readonly lastTransitionReason: WorkflowRunTransitionReason;
+  readonly availableAt?: Temporal.Instant;
+  readonly retryAt?: Temporal.Instant;
+  readonly retryReason?: WorkflowRunRetryReason;
+  readonly retryAttempt?: number;
+  readonly retryStepId?: StepId;
+  readonly retryStepName?: string;
+  readonly deadlineAt?: Temporal.Instant;
+  readonly leaseExpiresAt?: Temporal.Instant;
+  readonly startedAt?: Temporal.Instant;
+  readonly finishedAt?: Temporal.Instant;
+}
+/** Describes the workflow lifecycle event contract. */
+interface WorkflowLifecycleEvent {
+  readonly run: WorkflowRunRecord;
+  readonly previousRun?: WorkflowRunRecord;
+  readonly status: WorkflowRunStatus;
+  readonly reason: WorkflowRunTransitionReason;
+  readonly timestamp: Temporal.Instant;
+  readonly workflowName: string;
+  readonly workflowVersion?: string;
+}
+/** Type used for workflow lifecycle callback values. */
+type WorkflowLifecycleCallback = (event: WorkflowLifecycleEvent) => void | Promise<void>;
+//#endregion
+export { type RunId, WORKFLOW_ATTRIBUTE_MAX_COUNT, WORKFLOW_ATTRIBUTE_MAX_KEY_LENGTH, WORKFLOW_ATTRIBUTE_MAX_VALUE_BYTES, WORKFLOW_ATTRIBUTE_RESERVED_PREFIX, WorkflowAttributePatch, WorkflowAttributeValue, WorkflowLifecycleCallback, WorkflowLifecycleEvent, WorkflowMaterializedStepType, WorkflowRunAttributes, WorkflowRunRecord, WorkflowRunRetryReason, WorkflowRunStatus, WorkflowRunTransitionReason, WorkflowRunWorkflowName, WorkflowRunWorkflowVersion, WorkflowStepIdentity, WorkflowStepType, WorkflowTerminalRunStatus, WorkflowValueIssue, persistedValueIssue, workflowAttributeKeySchema, workflowAttributePatchSchema, workflowAttributePrimitiveValueSchema, workflowAttributeValueSchema, workflowMaterializedStepTypeSchema, workflowPersistedValueSchema, workflowRunAttributesSchema, workflowRunRecordSchema, workflowRunRetryReasonSchema, workflowRunStatusSchema, workflowRunTransitionReasonSchema, workflowStepTypeSchema, workflowTerminalRunStatusSchema };

package/dist/types/run.mjs

@@ -0,0 +1,207 @@
+import { nonBlankStringSchema, nonNegativeSafeIntegerSchema, positiveSafeIntegerSchema, temporalInstantSchema } from "./common.mjs";
+import { workflowErrorRecordSchema } from "./error.mjs";
+import { runIdSchema } from "./run-id.mjs";
+import { stepIdSchema } from "./step-id.mjs";
+import { workflowTelemetryContextSchema } from "./telemetry.mjs";
+import { workerIdSchema } from "./worker-id.mjs";
+import { isTemporalStorageValue } from "@temelj/storage";
+import { z } from "zod";
+//#region src/types/run.ts
+const WORKFLOW_ATTRIBUTE_MAX_KEY_LENGTH = 128;
+const WORKFLOW_ATTRIBUTE_MAX_COUNT = 64;
+const WORKFLOW_ATTRIBUTE_MAX_VALUE_BYTES = 1024;
+const WORKFLOW_ATTRIBUTE_RESERVED_PREFIX = "$";
+const workflowPersistedValueSchema = z.custom((value) => persistedValueIssue(value, "value", /* @__PURE__ */ new WeakSet(), false) === void 0);
+/** Returns the first persistence validation issue for a workflow value, if one exists. */
+function persistedValueIssue(value, path, seen, allowUndefined) {
+	if (value === void 0) return allowUndefined ? void 0 : unsupportedUndefinedIssue(path);
+	if (value === null || typeof value === "boolean" || typeof value === "string") return;
+	if (typeof value === "number") return Number.isFinite(value) ? void 0 : {
+		path,
+		message: "number must be finite"
+	};
+	if (typeof value === "bigint") return;
+	if (typeof value === "function" || typeof value === "symbol") return {
+		path,
+		message: `${typeof value} values are not supported`
+	};
+	if (typeof value !== "object") return {
+		path,
+		message: `${typeof value} values are not supported`
+	};
+	if (seen.has(value)) return {
+		path,
+		message: "circular references are not supported"
+	};
+	if (value instanceof Date) return Number.isFinite(value.getTime()) ? void 0 : {
+		path,
+		message: "Date must be valid"
+	};
+	if (isTemporalStorageValue(value) || value instanceof RegExp || value instanceof Uint8Array) return;
+	seen.add(value);
+	try {
+		if (value instanceof Map) return persistedMapIssue(value, path, seen);
+		if (value instanceof Set) return persistedSetIssue(value, path, seen);
+		if (Array.isArray(value)) return persistedArrayIssue(value, path, seen);
+		if (isPlainPersistedRecord(value)) return persistedRecordIssue(value, path, seen);
+		return {
+			path,
+			message: "object type is not supported"
+		};
+	} finally {
+		seen.delete(value);
+	}
+}
+function persistedArrayIssue(value, path, seen) {
+	for (const [index, item] of value.entries()) {
+		const issue = persistedValueIssue(item, `${path}[${index}]`, seen, false);
+		if (issue !== void 0) return issue;
+	}
+}
+function persistedRecordIssue(value, path, seen) {
+	for (const [key, item] of Object.entries(value)) {
+		const issue = persistedValueIssue(item, `${path}.${key}`, seen, false);
+		if (issue !== void 0) return issue;
+	}
+}
+function persistedMapIssue(value, path, seen) {
+	let index = 0;
+	for (const [key, item] of value) {
+		const keyIssue = persistedValueIssue(key, `${path}.<key:${index}>`, seen, false);
+		if (keyIssue !== void 0) return keyIssue;
+		const itemIssue = persistedValueIssue(item, `${path}.<value:${index}>`, seen, false);
+		if (itemIssue !== void 0) return itemIssue;
+		index++;
+	}
+}
+function persistedSetIssue(value, path, seen) {
+	let index = 0;
+	for (const item of value) {
+		const issue = persistedValueIssue(item, `${path}.<value:${index}>`, seen, false);
+		if (issue !== void 0) return issue;
+		index++;
+	}
+}
+function unsupportedUndefinedIssue(path) {
+	return {
+		path,
+		message: "undefined is not supported here"
+	};
+}
+function isPlainPersistedRecord(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const prototype = Reflect.getPrototypeOf(value);
+	if (prototype === Object.prototype || prototype === null) return true;
+	return isObjectPrototypeNamedObject(prototype);
+}
+function isObjectPrototypeNamedObject(prototype) {
+	if (!("constructor" in prototype)) return false;
+	const constructor = prototype.constructor;
+	return typeof constructor === "function" && "name" in constructor && constructor.name === "Object";
+}
+const workflowAttributeKeySchema = z.string().min(1, "Workflow run attribute keys must not be empty").max(128, `Workflow run attribute key must not exceed 128 characters`).refine((key) => key.trim() !== "", { error: "Workflow run attribute keys must not be empty" }).refine((key) => !key.startsWith("$"), { error: `Workflow run attribute key uses reserved prefix \$` });
+const workflowAttributePrimitiveValueSchema = z.union([
+	z.string(),
+	z.number(),
+	z.boolean(),
+	z.null()
+]);
+const workflowAttributeValueSchema = workflowAttributePrimitiveValueSchema.refine((value) => encodedWorkflowAttributeByteLength(value) <= WORKFLOW_ATTRIBUTE_MAX_VALUE_BYTES, { error: `Workflow run attribute value must not exceed ${WORKFLOW_ATTRIBUTE_MAX_VALUE_BYTES} encoded bytes` });
+const workflowRunAttributesSchema = z.record(workflowAttributeKeySchema, workflowAttributeValueSchema).refine((attributes) => Object.keys(attributes).length <= 64, { error: `Workflow run attributes must not include more than 64 keys` });
+const workflowAttributePatchSchema = z.record(workflowAttributeKeySchema, workflowAttributeValueSchema.optional()).refine((attributes) => Object.keys(attributes).length <= 64, { error: `Workflow run attributes must not include more than 64 keys` });
+function encodedWorkflowAttributeByteLength(value) {
+	return new TextEncoder().encode(JSON.stringify(value)).byteLength;
+}
+const workflowRunStatusSchema = z.enum([
+	"pending",
+	"running",
+	"waiting",
+	"completed",
+	"failed",
+	"canceled"
+]);
+const workflowTerminalRunStatusSchema = z.enum([
+	"completed",
+	"failed",
+	"canceled"
+]);
+const workflowRunRetryReasonSchema = z.enum([
+	"workflow",
+	"step",
+	"missing_implementation"
+]);
+const workflowRunTransitionReasonSchema = z.enum([
+	"created",
+	"claimed",
+	"reclaimed",
+	"started",
+	"waiting",
+	"rescheduled",
+	"lease_released",
+	"manual_retry",
+	"permanent_failure",
+	"retry",
+	"missing_implementation",
+	"completed",
+	"failed",
+	"deadline",
+	"canceled"
+]);
+/** Type used for workflow step type values. */
+const workflowStepTypeSchema = z.enum([
+	"run",
+	"sleep",
+	"workflow",
+	"message-send",
+	"message-wait",
+	"stream",
+	"deterministic",
+	"metadata",
+	"attributes"
+]);
+const workflowMaterializedStepTypeSchema = z.enum([
+	"run",
+	"sleep",
+	"workflow",
+	"message-send",
+	"message-wait",
+	"stream",
+	"deterministic"
+]);
+const workflowRunRecordSchema = z.object({
+	id: runIdSchema,
+	namespace: nonBlankStringSchema,
+	workflowName: nonBlankStringSchema,
+	workflowVersion: nonBlankStringSchema.optional(),
+	status: workflowRunStatusSchema,
+	input: workflowPersistedValueSchema.optional(),
+	context: workflowPersistedValueSchema.optional(),
+	telemetryContext: workflowTelemetryContextSchema.optional(),
+	metadata: workflowPersistedValueSchema.optional(),
+	attributes: workflowRunAttributesSchema.optional(),
+	output: workflowPersistedValueSchema.optional(),
+	error: workflowErrorRecordSchema.optional(),
+	attempts: nonNegativeSafeIntegerSchema.optional(),
+	idempotencyKey: nonBlankStringSchema.optional(),
+	parentRunId: runIdSchema.optional(),
+	parentStepId: stepIdSchema.optional(),
+	parentStepName: nonBlankStringSchema.optional(),
+	parentStepAttempt: positiveSafeIntegerSchema.optional(),
+	workerId: workerIdSchema.optional(),
+	createdAt: temporalInstantSchema,
+	updatedAt: temporalInstantSchema,
+	lastTransitionAt: temporalInstantSchema,
+	lastTransitionReason: workflowRunTransitionReasonSchema,
+	availableAt: temporalInstantSchema.optional(),
+	retryAt: temporalInstantSchema.optional(),
+	retryReason: workflowRunRetryReasonSchema.optional(),
+	retryAttempt: positiveSafeIntegerSchema.optional(),
+	retryStepId: stepIdSchema.optional(),
+	retryStepName: nonBlankStringSchema.optional(),
+	deadlineAt: temporalInstantSchema.optional(),
+	leaseExpiresAt: temporalInstantSchema.optional(),
+	startedAt: temporalInstantSchema.optional(),
+	finishedAt: temporalInstantSchema.optional()
+});
+//#endregion
+export { WORKFLOW_ATTRIBUTE_MAX_COUNT, WORKFLOW_ATTRIBUTE_MAX_KEY_LENGTH, WORKFLOW_ATTRIBUTE_MAX_VALUE_BYTES, WORKFLOW_ATTRIBUTE_RESERVED_PREFIX, persistedValueIssue, workflowAttributeKeySchema, workflowAttributePatchSchema, workflowAttributePrimitiveValueSchema, workflowAttributeValueSchema, workflowMaterializedStepTypeSchema, workflowPersistedValueSchema, workflowRunAttributesSchema, workflowRunRecordSchema, workflowRunRetryReasonSchema, workflowRunStatusSchema, workflowRunTransitionReasonSchema, workflowStepTypeSchema, workflowTerminalRunStatusSchema };