@temelj/workflow 0.0.0-alpha.1

package/dist/types/step-attempts.d.mts

@@ -0,0 +1,326 @@
+import { MessageId } from "./message-id.mjs";
+import { RunId } from "./run-id.mjs";
+import { StepId } from "./step-id.mjs";
+import { WorkflowChildWorkflowCancellationPolicy } from "./step.mjs";
+import { WorkflowRunFailureSummary, WorkflowRunRetrySummary, WorkflowRunStatusCounts } from "./summary.mjs";
+import { WorkflowMaterializedStepType } from "./run.mjs";
+import { WorkflowErrorRecord } from "./error.mjs";
+import { StorageValue } from "@temelj/storage";
+import { z } from "zod";
+//#region src/types/step-attempts.d.ts
+declare const workflowStepAttemptStatusSchema: z.ZodEnum<{
+  abandoned: "abandoned";
+  completed: "completed";
+  failed: "failed";
+  running: "running";
+}>;
+declare const workflowStepAttemptRecordSchema: z.ZodObject<{
+  runId: z.ZodString;
+  stepId: z.ZodString;
+  stepName: z.ZodString;
+  kind: z.ZodEnum<{
+    deterministic: "deterministic";
+    "message-send": "message-send";
+    "message-wait": "message-wait";
+    run: "run";
+    sleep: "sleep";
+    stream: "stream";
+    workflow: "workflow";
+  }>;
+  status: z.ZodEnum<{
+    abandoned: "abandoned";
+    completed: "completed";
+    failed: "failed";
+    running: "running";
+  }>;
+  attempt: z.ZodNumber;
+  count: z.ZodOptional<z.ZodNumber>;
+  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>>;
+  until: z.ZodOptional<z.ZodCustom<Temporal.Instant, Temporal.Instant>>;
+  duration: z.ZodOptional<z.ZodCustom<Temporal.Duration, Temporal.Duration>>;
+  childRunId: z.ZodOptional<z.ZodString>;
+  workflowName: z.ZodOptional<z.ZodString>;
+  workflowVersion: z.ZodOptional<z.ZodString>;
+  cancellation: z.ZodOptional<z.ZodEnum<{
+    cascade: "cascade";
+    detach: "detach";
+  }>>;
+  input: z.ZodOptional<z.ZodType<StorageValue, unknown, z.core.$ZodTypeInternals<StorageValue, unknown>>>;
+  timeoutAt: z.ZodOptional<z.ZodCustom<Temporal.Instant, Temporal.Instant>>;
+  messageId: z.ZodOptional<z.ZodString>;
+  targetRunId: z.ZodOptional<z.ZodString>;
+  payload: z.ZodOptional<z.ZodType<StorageValue, unknown, z.core.$ZodTypeInternals<StorageValue, unknown>>>;
+  messageTimestamp: z.ZodOptional<z.ZodCustom<Temporal.Instant, Temporal.Instant>>;
+  createdAt: z.ZodCustom<Temporal.Instant, Temporal.Instant>;
+  startedAt: z.ZodCustom<Temporal.Instant, Temporal.Instant>;
+  finishedAt: z.ZodOptional<z.ZodCustom<Temporal.Instant, Temporal.Instant>>;
+}, z.core.$strip>;
+/** Status values for workflow step attempt. */
+type WorkflowStepAttemptStatus = "running" | "completed" | "failed" | "abandoned";
+/** Stored record for workflow step attempt. */
+interface WorkflowStepAttemptRecord {
+  readonly runId: RunId;
+  readonly stepId: StepId;
+  readonly stepName: string;
+  readonly kind: WorkflowMaterializedStepType;
+  readonly status: WorkflowStepAttemptStatus;
+  readonly attempt: number;
+  readonly count?: number;
+  readonly output?: StorageValue;
+  readonly error?: WorkflowErrorRecord;
+  readonly until?: Temporal.Instant;
+  readonly duration?: Temporal.Duration;
+  readonly childRunId?: RunId;
+  readonly workflowName?: string;
+  readonly workflowVersion?: string;
+  readonly cancellation?: WorkflowChildWorkflowCancellationPolicy;
+  readonly input?: StorageValue;
+  readonly timeoutAt?: Temporal.Instant;
+  readonly messageId?: MessageId;
+  readonly targetRunId?: RunId;
+  readonly payload?: StorageValue;
+  readonly messageTimestamp?: Temporal.Instant;
+  readonly createdAt: Temporal.Instant;
+  readonly startedAt: Temporal.Instant;
+  readonly finishedAt?: Temporal.Instant;
+}
+/** Options for workflow list step attempts. */
+interface WorkflowListStepAttemptsOptions {
+  readonly status?: WorkflowStepAttemptStatus | readonly WorkflowStepAttemptStatus[];
+  readonly kind?: WorkflowMaterializedStepType | readonly WorkflowMaterializedStepType[];
+  readonly stepId?: StepId;
+  readonly stepName?: string;
+  readonly attempt?: number;
+  readonly childRunId?: RunId;
+  readonly workflowName?: string;
+  readonly workflowVersion?: string;
+  readonly messageId?: MessageId;
+  readonly targetRunId?: RunId;
+  readonly createdAtFrom?: Temporal.Instant;
+  readonly createdAtTo?: Temporal.Instant;
+  readonly startedAtFrom?: Temporal.Instant;
+  readonly startedAtTo?: Temporal.Instant;
+  readonly finishedAtFrom?: Temporal.Instant;
+  readonly finishedAtTo?: Temporal.Instant;
+  readonly untilFrom?: Temporal.Instant;
+  readonly untilTo?: Temporal.Instant;
+  readonly durationFrom?: Temporal.Duration;
+  readonly durationTo?: Temporal.Duration;
+  readonly timeoutAtFrom?: Temporal.Instant;
+  readonly timeoutAtTo?: Temporal.Instant;
+  readonly messageTimestampFrom?: Temporal.Instant;
+  readonly messageTimestampTo?: Temporal.Instant;
+  readonly limit?: number;
+}
+type WorkflowStepAttemptSummaryStringArray = readonly string[];
+/** Summary data for workflow step attempt. */
+interface WorkflowStepAttemptSummary {
+  readonly total: number;
+  readonly status: WorkflowStepAttemptStatusCounts;
+  readonly statusStepIds: WorkflowStepAttemptStatusStepIds;
+  readonly statusAttemptKeys: WorkflowStepAttemptStatusAttemptKeys;
+  readonly kind: WorkflowStepAttemptKindCounts;
+  readonly kindStepIds: WorkflowStepAttemptKindStepIds;
+  readonly kindAttemptKeys: WorkflowStepAttemptKindAttemptKeys;
+  readonly failure?: WorkflowStepAttemptFailureSummary;
+  readonly oldestRunningAt?: Temporal.Instant;
+  readonly latestFinishedAt?: Temporal.Instant;
+  readonly activeSleepStepIds?: WorkflowStepAttemptSummaryStringArray;
+  readonly activeSleepAttemptKeys?: WorkflowStepAttemptSummaryStringArray;
+  readonly nextSleepUntil?: Temporal.Instant;
+  readonly nextSleepStepId?: StepId;
+  readonly nextSleepAttemptKey?: string;
+  readonly nextSleepDuration?: Temporal.Duration;
+  readonly activeChildWorkflows?: WorkflowActiveChildWorkflowSummary;
+  readonly activeMessageWaits?: WorkflowActiveMessageWaitSummary;
+}
+/** Counts grouped by step attempt status. */
+type WorkflowStepAttemptStatusCounts = Readonly<Record<WorkflowStepAttemptStatus, number>>;
+/** Step IDs grouped by step attempt status. */
+type WorkflowStepAttemptStatusStepIds = Readonly<Record<WorkflowStepAttemptStatus, WorkflowStepAttemptSummaryStringArray>>;
+/** Step attempt keys grouped by step attempt status. */
+type WorkflowStepAttemptStatusAttemptKeys = Readonly<Record<WorkflowStepAttemptStatus, WorkflowStepAttemptSummaryStringArray>>;
+/** Counts grouped by step attempt kind. */
+type WorkflowStepAttemptKindCounts = Readonly<Record<WorkflowMaterializedStepType, number>>;
+/** Step IDs grouped by step attempt kind. */
+type WorkflowStepAttemptKindStepIds = Readonly<Record<WorkflowMaterializedStepType, WorkflowStepAttemptSummaryStringArray>>;
+/** Step attempt keys grouped by step attempt kind. */
+type WorkflowStepAttemptKindAttemptKeys = Readonly<Record<WorkflowMaterializedStepType, WorkflowStepAttemptSummaryStringArray>>;
+/** Summary data for workflow step attempt failure. */
+interface WorkflowStepAttemptFailureSummary {
+  readonly total: number;
+  readonly failedStepIds: WorkflowStepAttemptSummaryStringArray;
+  readonly failedAttemptKeys: WorkflowStepAttemptSummaryStringArray;
+  readonly errors: readonly WorkflowStepAttemptFailureErrorSummary[];
+  readonly latestFailedAt?: Temporal.Instant;
+}
+/** Summary data for workflow step attempt failure error. */
+interface WorkflowStepAttemptFailureErrorSummary {
+  readonly name: string;
+  readonly count: number;
+  readonly failedStepIds: WorkflowStepAttemptSummaryStringArray;
+  readonly failedAttemptKeys: WorkflowStepAttemptSummaryStringArray;
+  readonly latestFailedAt?: Temporal.Instant;
+}
+/** Summary data for workflow active message wait. */
+interface WorkflowActiveMessageWaitSummary {
+  readonly total: number;
+  readonly stepIds: WorkflowStepAttemptSummaryStringArray;
+  readonly attemptKeys: WorkflowStepAttemptSummaryStringArray;
+  readonly messages: WorkflowStepAttemptSummaryStringArray;
+  readonly oldestStartedAt?: Temporal.Instant;
+  readonly nextTimeoutAt?: Temporal.Instant;
+  readonly nextTimeoutStepId?: StepId;
+  readonly nextTimeoutAttemptKey?: string;
+}
+/** Summary data for workflow active child workflow. */
+interface WorkflowActiveChildWorkflowSummary {
+  readonly total: number;
+  readonly stepIds: WorkflowStepAttemptSummaryStringArray;
+  readonly attemptKeys: WorkflowStepAttemptSummaryStringArray;
+  readonly childRunIds: WorkflowStepAttemptSummaryStringArray;
+  readonly retryChildRunIds?: WorkflowStepAttemptSummaryStringArray;
+  readonly failedChildRunIds?: WorkflowStepAttemptSummaryStringArray;
+  readonly canceledChildRunIds?: WorkflowStepAttemptSummaryStringArray;
+  readonly workflows: WorkflowStepAttemptSummaryStringArray;
+  readonly childStatus: WorkflowRunStatusCounts;
+  readonly childRetry?: WorkflowRunRetrySummary;
+  readonly childFailure?: WorkflowRunFailureSummary;
+  readonly oldestStartedAt?: Temporal.Instant;
+  readonly nextTimeoutAt?: Temporal.Instant;
+  readonly nextTimeoutStepId?: StepId;
+  readonly nextTimeoutAttemptKey?: string;
+}
+//#endregion
+export { WorkflowActiveChildWorkflowSummary, WorkflowActiveMessageWaitSummary, WorkflowListStepAttemptsOptions, WorkflowStepAttemptFailureErrorSummary, WorkflowStepAttemptFailureSummary, WorkflowStepAttemptKindAttemptKeys, WorkflowStepAttemptKindCounts, WorkflowStepAttemptKindStepIds, WorkflowStepAttemptRecord, WorkflowStepAttemptStatus, WorkflowStepAttemptStatusAttemptKeys, WorkflowStepAttemptStatusCounts, WorkflowStepAttemptStatusStepIds, WorkflowStepAttemptSummary, workflowStepAttemptRecordSchema, workflowStepAttemptStatusSchema };

package/dist/types/step-attempts.mjs

@@ -0,0 +1,43 @@
+import { nonBlankStringSchema, positiveSafeIntegerSchema, temporalInstantSchema } from "./common.mjs";
+import { workflowErrorRecordSchema } from "./error.mjs";
+import { runIdSchema } from "./run-id.mjs";
+import { stepIdSchema } from "./step-id.mjs";
+import { workflowMaterializedStepTypeSchema, workflowPersistedValueSchema } from "./run.mjs";
+import { messageIdSchema } from "./message-id.mjs";
+import { workflowChildWorkflowCancellationPolicySchema } from "./step.mjs";
+import { z } from "zod";
+//#region src/types/step-attempts.ts
+const workflowStepAttemptStatusSchema = z.enum([
+	"running",
+	"completed",
+	"failed",
+	"abandoned"
+]);
+const workflowStepAttemptRecordSchema = z.object({
+	runId: runIdSchema,
+	stepId: stepIdSchema,
+	stepName: nonBlankStringSchema,
+	kind: workflowMaterializedStepTypeSchema,
+	status: workflowStepAttemptStatusSchema,
+	attempt: positiveSafeIntegerSchema,
+	count: positiveSafeIntegerSchema.optional(),
+	output: workflowPersistedValueSchema.optional(),
+	error: workflowErrorRecordSchema.optional(),
+	until: temporalInstantSchema.optional(),
+	duration: z.instanceof(Temporal.Duration, { error: "Expected a Temporal.Duration" }).optional(),
+	childRunId: runIdSchema.optional(),
+	workflowName: nonBlankStringSchema.optional(),
+	workflowVersion: nonBlankStringSchema.optional(),
+	cancellation: workflowChildWorkflowCancellationPolicySchema.optional(),
+	input: workflowPersistedValueSchema.optional(),
+	timeoutAt: temporalInstantSchema.optional(),
+	messageId: messageIdSchema.optional(),
+	targetRunId: runIdSchema.optional(),
+	payload: workflowPersistedValueSchema.optional(),
+	messageTimestamp: temporalInstantSchema.optional(),
+	createdAt: temporalInstantSchema,
+	startedAt: temporalInstantSchema,
+	finishedAt: temporalInstantSchema.optional()
+});
+//#endregion
+export { workflowStepAttemptRecordSchema, workflowStepAttemptStatusSchema };

package/dist/types/step-id.d.mts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+//#region src/types/step-id.d.ts
+declare const stepIdSchema: z.ZodString;
+/** Non-empty identifier used for workflow steps. */
+type StepId = string;
+//#endregion
+export { StepId, stepIdSchema };

package/dist/types/step-id.mjs

@@ -0,0 +1,5 @@
+import { z } from "zod";
+//#region src/types/step-id.ts
+const stepIdSchema = z.string().refine((value) => value.trim().length > 0, "Expected an ID");
+//#endregion
+export { stepIdSchema };

package/dist/types/step.d.mts

@@ -0,0 +1,183 @@
+import { RunId } from "./run-id.mjs";
+import { StepId } from "./step-id.mjs";
+import { WorkflowResolvedStepRetryConfig, WorkflowRetryConfig } from "./retry.mjs";
+import { WorkflowStartTarget } from "./definition.mjs";
+import { CreateHookOptions, CreateWebhookOptions, Hook, Webhook } from "./hook.mjs";
+import { LockRecord, WorkflowStepAcquireLockOptions, WorkflowStepReleaseLockOptions } from "./lock.mjs";
+import { MessageChannel, SendMessageChannelOptions, SendMessageOptions, WaitForMessageChannelOptions, WaitForMessageOptions } from "./message.mjs";
+import { CreateStreamOptions, Stream } from "./stream.mjs";
+import { WorkflowAttributePatch, WorkflowMaterializedStepType } from "./run.mjs";
+import { z } from "zod";
+import { Schema, SchemaOutput } from "@temelj/standard-schema";
+import { Logger } from "@temelj/log";
+//#region src/types/step.d.ts
+declare const workflowChildWorkflowCancellationPolicySchema: z.ZodEnum<{
+  cascade: "cascade";
+  detach: "detach";
+}>;
+/** Grouped durable commands available inside a workflow handler. */
+interface WorkflowStepApi {
+  /** Scoped operational logger for workflow orchestration code. */
+  readonly log: Logger;
+  /** Durable task, reusable step, sleep, and sleep-until commands. */
+  readonly task: WorkflowStepTaskApi;
+  /** Durable child-workflow start and run commands. */
+  readonly workflow: WorkflowStepWorkflowApi;
+  /** Durable message send and wait commands. */
+  readonly message: WorkflowStepMessageApi;
+  /** Durable lock acquire, release, and scoped lock commands. */
+  readonly lock: WorkflowStepLockApi;
+  /** Commands that persist workflow run metadata and attributes. */
+  readonly runData: WorkflowStepRunDataApi;
+  /** Replay-safe time, random, ID, and byte sources. */
+  readonly deterministic: WorkflowDeterministicApi;
+  /** Durable stream creation commands. */
+  readonly stream: WorkflowStepStreamApi;
+  /** External resume hook and webhook creation commands. */
+  readonly hook: WorkflowStepHookApi;
+}
+/** Durable task, reusable step, and sleep commands available inside a workflow handler. */
+interface WorkflowStepTaskApi {
+  /** Runs an inline durable task and records the callback result for replay. */
+  run<TOutput>(config: WorkflowStepRunConfig, callback: (context: WorkflowStepContext) => Promise<TOutput> | TOutput): Promise<TOutput>;
+  /** Calls a reusable step definition with typed arguments. */
+  call<const TArgs extends readonly unknown[], TOutput>(definition: WorkflowStepDefinition<TArgs, TOutput>, ...args: TArgs): Promise<TOutput>;
+  /** Pauses workflow execution for a durable duration. */
+  sleep(commandId: string, duration: Temporal.Duration): Promise<void>;
+  /** Pauses workflow execution until a durable instant. */
+  sleepUntil(commandId: string, timestamp: Temporal.Instant): Promise<void>;
+}
+/** Durable child-workflow commands available inside a workflow handler. */
+interface WorkflowStepWorkflowApi {
+  /** Starts a child workflow and waits for its result. */
+  run<TInput, TOutput, TRawInput = TInput>(workflow: WorkflowStartTarget<TInput, TOutput, TRawInput>, input: TRawInput, options?: WorkflowStepRunWorkflowOptions): Promise<TOutput>;
+  /** Starts a child workflow without waiting for it to finish and returns its run ID. */
+  start<TInput, TOutput, TRawInput = TInput>(workflow: WorkflowStartTarget<TInput, TOutput, TRawInput>, input: TRawInput, options?: WorkflowStepStartWorkflowOptions): Promise<string>;
+}
+/** Durable message send and wait commands available inside a workflow handler. */
+interface WorkflowStepMessageApi {
+  /** Sends a named message to another workflow run. */
+  send(runId: RunId, options: SendMessageOptions): Promise<void>;
+  /** Sends a message through a typed message channel to another workflow run. */
+  send<TPayload, TKey = void>(runId: RunId, channel: MessageChannel<TPayload, TKey>, options?: SendMessageChannelOptions<TPayload, TKey>): Promise<void>;
+  /** Waits for a named message and returns its payload. */
+  wait<TPayload = unknown>(options: WaitForMessageOptions): Promise<TPayload>;
+  /** Waits for a named message and validates its payload with the configured schema. */
+  wait<const TSchema extends Schema>(options: WaitForMessageOptions<TSchema>): Promise<SchemaOutput<TSchema>>;
+  /** Waits for a message through a typed message channel. */
+  wait<TPayload, TKey = void>(channel: MessageChannel<TPayload, TKey>, options?: WaitForMessageChannelOptions<TKey>): Promise<TPayload>;
+}
+/** Durable lock commands available inside a workflow handler. */
+interface WorkflowStepLockApi {
+  /** Acquires a workflow lock and records the fencing token in history. */
+  acquire(commandId: string, key: string, options: WorkflowStepAcquireLockOptions): Promise<LockRecord>;
+  /** Releases a workflow lock held by this workflow. */
+  release(commandId: string, key: string, options?: WorkflowStepReleaseLockOptions): Promise<LockRecord>;
+  /** Acquires a workflow lock, runs a callback, and releases the lock afterward. */
+  with<TOutput>(commandId: string, key: string, options: WorkflowStepAcquireLockOptions, callback: (lock: LockRecord) => Promise<TOutput> | TOutput): Promise<TOutput>;
+}
+/** Durable run metadata and attribute update commands available inside a workflow handler. */
+interface WorkflowStepRunDataApi {
+  /** Replaces the workflow run metadata value. */
+  setMetadata(commandId: string, metadata: unknown): Promise<void>;
+  /** Applies a workflow run attribute patch. */
+  setAttributes(commandId: string, attributes: WorkflowAttributePatch): Promise<void>;
+}
+/** Replay-safe sources for time, randomness, generated IDs, and bytes inside a workflow handler. */
+interface WorkflowDeterministicApi {
+  /** Returns the current instant, recording it once so replay sees the same value. */
+  now(commandId?: string): Promise<Temporal.Instant>;
+  /** Returns a random number in [0, 1), recording it once so replay sees the same value. */
+  random(commandId?: string): Promise<number>;
+  /** Returns an engine-generated recorded ID for the command. */
+  recordedId(commandId?: string): Promise<string>;
+  /** Alias for recordedId. */
+  id(commandId?: string): Promise<string>;
+  /** Returns a random UUID, recording it once so replay sees the same value. */
+  uuid(commandId?: string): Promise<string>;
+  /** Returns recorded random bytes with the requested length. */
+  bytes(commandId: string, length: number): Promise<Uint8Array>;
+}
+/** Compatibility alias for the deterministic API exposed on WorkflowStepApi. */
+type WorkflowStepDeterministicApi = WorkflowDeterministicApi;
+/** Durable stream creation commands available inside a workflow handler. */
+interface WorkflowStepStreamApi {
+  /** Creates a durable stream that can be read while the workflow is running. */
+  create<TChunk = unknown>(commandId: string, options?: CreateStreamOptions): Stream<TChunk>;
+}
+/** External resume token commands available inside a workflow handler. */
+interface WorkflowStepHookApi {
+  /** Creates a message-backed external resume hook. */
+  create<TPayload = unknown>(options: CreateHookOptions): Hook<TPayload>;
+  /** Creates a message-backed external resume hook with schema-validated payloads. */
+  create<const TSchema extends Schema>(options: CreateHookOptions<TSchema>): Hook<SchemaOutput<TSchema>>;
+  /** Creates a webhook-labeled external resume hook. */
+  createWebhook<TPayload = unknown>(options: CreateWebhookOptions): Webhook<TPayload>;
+  /** Creates a webhook-labeled external resume hook with schema-validated payloads. */
+  createWebhook<const TSchema extends Schema>(options: CreateWebhookOptions<TSchema>): Webhook<SchemaOutput<TSchema>>;
+}
+/** Configuration for a single durable task command or reusable step definition. */
+interface WorkflowStepRunConfig {
+  readonly name?: string;
+  readonly commandId?: string;
+  readonly retry?: WorkflowRetryConfig;
+  readonly timeout?: Temporal.Duration;
+}
+/** Handler signature for reusable durable step definitions. */
+type WorkflowStepDefinitionHandler<TArgs extends readonly unknown[], TOutput> = (...args: [...TArgs, WorkflowStepContext]) => Promise<TOutput> | TOutput;
+/** Reusable named durable task that can be called from workflow handlers. */
+interface WorkflowStepDefinition<TArgs extends readonly unknown[] = readonly unknown[], TOutput = unknown> {
+  /** Runtime configuration used when the reusable step is called. */
+  readonly config: WorkflowStepRunConfig;
+  /** Durable command name used as the step identity by default. */
+  readonly name: string;
+  /** Handler invoked when the step is first executed. */
+  readonly handler: WorkflowStepDefinitionHandler<TArgs, TOutput>;
+  /** Compile-time type markers for arguments and output. */
+  readonly types?: WorkflowStepDefinitionTypes<TArgs, TOutput>;
+}
+/** Compile-time type markers carried by a reusable step definition. */
+interface WorkflowStepDefinitionTypes<TArgs extends readonly unknown[], TOutput> {
+  /** Argument tuple accepted by the step handler before the context parameter. */
+  readonly args: TArgs;
+  /** Awaited output returned by the step handler. */
+  readonly output: TOutput;
+}
+/** Options for running a child workflow and waiting for its result from a durable step. */
+interface WorkflowStepRunWorkflowOptions extends WorkflowStepStartWorkflowOptions {
+  readonly timeout?: Temporal.Duration;
+  readonly pollInterval?: Temporal.Duration;
+  readonly retry?: WorkflowRetryConfig;
+}
+/** Options for starting a child workflow in the background from a durable step. */
+interface WorkflowStepStartWorkflowOptions {
+  readonly commandId?: string;
+  readonly name?: string;
+  readonly id?: string;
+  readonly idempotencyKey?: string;
+  readonly cancellation?: WorkflowChildWorkflowCancellationPolicy;
+}
+/** Controls whether child workflow runs are canceled when their parent run is canceled. */
+type WorkflowChildWorkflowCancellationPolicy = "cascade" | "detach";
+/** Context passed to a durable task attempt. */
+interface WorkflowStepContext {
+  /** Stable identity and encounter count for this durable command. */
+  readonly step: WorkflowStepMetadata;
+  /** Current attempt number for retryable durable work. */
+  readonly attempt: number;
+  /** Resolved retry configuration for this attempt. */
+  readonly config: WorkflowResolvedStepRetryConfig;
+  /** Abort signal for cancellation or timeout of this attempt. */
+  readonly signal: AbortSignal;
+  /** Scoped operational logger for this durable task attempt. */
+  readonly log: Logger;
+}
+/** Identity and encounter metadata for a durable task attempt. */
+interface WorkflowStepMetadata {
+  readonly id: string;
+  readonly name: string;
+  readonly count: number;
+  readonly kind: WorkflowMaterializedStepType;
+}
+//#endregion
+export { type StepId, WorkflowChildWorkflowCancellationPolicy, WorkflowDeterministicApi, WorkflowStepApi, WorkflowStepContext, WorkflowStepDefinition, WorkflowStepDefinitionHandler, WorkflowStepDefinitionTypes, WorkflowStepDeterministicApi, WorkflowStepHookApi, WorkflowStepLockApi, WorkflowStepMessageApi, WorkflowStepMetadata, WorkflowStepRunConfig, WorkflowStepRunDataApi, WorkflowStepRunWorkflowOptions, WorkflowStepStartWorkflowOptions, WorkflowStepStreamApi, WorkflowStepTaskApi, WorkflowStepWorkflowApi, workflowChildWorkflowCancellationPolicySchema };

package/dist/types/step.mjs

@@ -0,0 +1,5 @@
+import { z } from "zod";
+//#region src/types/step.ts
+const workflowChildWorkflowCancellationPolicySchema = z.enum(["cascade", "detach"]);
+//#endregion
+export { workflowChildWorkflowCancellationPolicySchema };