@dudousxd/nestjs-durable-core 0.32.0 → 0.33.0

package/dist/index.d.cts

@@ -283,6 +283,13 @@ interface StepCheckpoint {
     events?: StepEvent[] | undefined;
     /** For sleep steps: epoch ms the sleep elapses at. */
     wakeAt?: number | undefined;
+    /**
+     * Set on the running placeholder checkpoints of the children dispatched by one `ctx.all` call —
+     * a shared tag (`all:<firstSeq>`) grouping the N siblings so the dashboard can render them as one
+     * parallel fan-out. Optional and additive: absent on every non-`all` checkpoint. Mirrors the
+     * Python SDK's `parallelGroup`.
+     */
+    parallelGroup?: string | undefined;
     /**
      * When the step entered the system: for a remote step, when the engine dispatched it to the
      * transport; for a local step, when it began. Queue-wait time = `startedAt − enqueuedAt`.
@@ -636,6 +643,9 @@ type WorkflowCommand =
     startedAt?: number;
     finishedAt?: number;
     events?: StepEvent[];
+    /** A worker's `ctx.gather([...])` tags every step in the parallel fan with the same group, so the
+     *  engine carries it onto the checkpoint and the dashboard renders the fan as one group. */
+    parallelGroup?: string;
 }
 /** `ctx.sleep(ms)` — a durable timer of `ms` duration. The engine computes the absolute deadline
  *  (now + ms) when it applies the command, so the worker never reads the clock (determinism). */
@@ -650,12 +660,15 @@ type WorkflowCommand =
     seq: number;
     signal: string;
 }
-/** `ctx.start_child(workflow, input)` — start a child run with its own lifecycle. */
+/** `ctx.start_child(workflow, input)` — start a child run with its own lifecycle. A worker's
+ *  `ctx.all([...])` fan-out tags every dispatched child with the same `parallelGroup` so the
+ *  dashboard can render the fan as one group (parity with the gathered `recordStep` tag). */
  | {
     kind: 'startChild';
     seq: number;
     workflow: string;
     input: unknown;
+    parallelGroup?: string;
 };
 /** workflow worker → engine: the result of replaying one turn of a remote workflow. */
 interface WorkflowDecision {
@@ -693,6 +706,9 @@ interface WorkflowStepEvent {
     error?: StepError;
     /** Sub-process + log trail the step emitted so far (the handler's p-processes). */
     events?: StepEvent[];
+    /** A worker's `ctx.gather([...])` fan tags every step's lifecycle with the same group so the
+     *  dashboard renders the live fan-out as one group (parity with the `recordStep` tag). */
+    parallelGroup?: string | undefined;
 }
 /**
  * Advances a workflow run one turn. The engine has one per workflow: the default {@link InProcess}
@@ -988,6 +1004,24 @@ interface WorkflowCtx {
      */
     startChild<C extends WorkflowClass>(workflow: C, input: WorkflowInputOf<C>, options?: string | ChildCallOptions): Promise<string>;
     startChild(workflow: string, input: unknown, options?: string | ChildCallOptions): Promise<string>;
+    /**
+     * Run N children of the SAME workflow **in parallel** and wait for ALL of them: dispatches one
+     * child per entry in `inputs` (concurrently, each with its own durable lifecycle), suspends — zero
+     * compute — until every child reaches a terminal state, then resumes with their outputs in **input
+     * order**. Child ids are group-scoped and stable (`<runId>.all.<firstSeq>.<i>`), and the running
+     * placeholders share a `parallelGroup` tag so the dashboard renders the fan-out as one group.
+     *
+     * `mode` (default `waitAll`): `waitAll` waits for all then throws an aggregate {@link GatherError}
+     * if any failed; `failFast` throws as soon as a failed child is seen (siblings are not cancelled in
+     * v1 — their eventual results are ignored). Empty `inputs` returns `[]` with no side effects. The
+     * wait-all / fan-out counterpart to {@link child}; parity with the Python SDK's `gather_children`.
+     */
+    all<C extends WorkflowClass>(workflow: C, inputs: WorkflowInputOf<C>[], opts?: {
+        mode?: 'waitAll' | 'failFast';
+    }): Promise<WorkflowOutputOf<C>[]>;
+    all<TOutput = unknown>(workflow: string, inputs: unknown[], opts?: {
+        mode?: 'waitAll' | 'failFast';
+    }): Promise<TOutput[]>;
     /**
      * Pause the run at this point until a human resumes it from the dashboard (or
      * `engine.continue(runId)`). Records a visible `pending` checkpoint so the breakpoint shows up
@@ -1803,6 +1837,29 @@ declare class RemoteStepTimeout extends Error {
     readonly timeoutMs: number;
     constructor(stepId: string, timeoutMs: number);
 }
+/**
+ * Thrown by a remote {@link WorkflowExecutor} (e.g. {@link RemoteWorkflowExecutor}) when an `advance`
+ * does not produce its decision within the configured `timeoutMs` — i.e. the worker is presumed gone
+ * (the decision was dropped by a stall/redelivery or an instance restart spanning the in-memory waiter
+ * map). Crucially this is NOT a run failure: the work may have actually completed and only the decision
+ * was lost. The engine treats it as RECOVERABLE — it releases the run lease and leaves the run
+ * `running` so `recoverIncomplete` re-drives it deterministically (replaying completed steps from
+ * history). Distinct from a real executor error, which still fails the run.
+ *
+ * OPT-IN: only thrown when the executor was constructed with a `timeoutMs`. Absent a timeout, the
+ * engine awaits the decision with its prior (unbounded) behavior — so existing users see no change.
+ *
+ * Known hazard: a timeout that fires while a worker is LEGITIMATELY still executing a not-yet-
+ * checkpointed step will re-drive and re-run that in-flight step → DUPLICATE side effects. Therefore
+ * the timeout is only safe when set GENEROUSLY (longer than the longest legitimate single turn). The
+ * robust fix — a liveness/heartbeat-rearmed deadline so only a genuinely-dead worker re-drives — is the
+ * documented follow-up (see the Track A diagnosis doc, "Part B").
+ */
+declare class RemoteWorkflowTimeout extends Error {
+    readonly taskId: string;
+    readonly timeoutMs: number;
+    constructor(taskId: string, timeoutMs: number);
+}
 /**
  * Thrown on resume when the workflow code no longer matches the recorded history: the step at a
  * logical position has a different name/kind than the checkpoint saved there. This means the
@@ -1816,6 +1873,24 @@ declare class NonDeterminismError extends Error {
     readonly seq: number;
     constructor(runId: string, seq: number, expected: string, recorded: string);
 }
+/**
+ * Thrown by `ctx.all` when one or more parallel child workflows fail. Carries the per-item failures
+ * (input index, child run id, error message) and presents an aggregate message summarizing the count
+ * and the failing ids — the wait-all/fail-fast counterpart to a single child's FatalError. Mirrors
+ * the Python SDK's `GatherFailed`.
+ */
+declare class GatherError extends Error {
+    readonly failures: {
+        index: number;
+        id: string;
+        error: string;
+    }[];
+    constructor(failures: {
+        index: number;
+        id: string;
+        error: string;
+    }[], total?: number);
+}
 declare class WorkflowSuspended extends Error {
     /** Epoch ms to auto-resume (durable sleep), or undefined when waiting on an external signal. */
     readonly wakeAt?: number | undefined;
@@ -2059,6 +2134,14 @@ declare function prevCronFireMs(expr: string, nowMs: number, timezone?: string):
  */
 declare function runSchedules(engine: Pick<WorkflowEngine, 'start' | 'getRun'>, schedules: readonly ScheduledWorkflow[], nowMs: number, opts?: RunSchedulesOptions): Promise<string[]>;
 
+/**
+ * A {@link StepLogger} that appends to `events`, stamping each line with `now()`. Shared by the
+ * local-step path (`ctx.step`) and the remote-worker path (`runStepHandler`) so a step records
+ * the same {@link StepEvent} shape wherever it runs — the TypeScript twin of the Python SDK's
+ * `StepContext`.
+ */
+declare function createStepLogger(events: StepEvent[], now: () => number): StepLogger;
+
 /**
  * Does a run's search attributes satisfy EVERY filter (AND)? A missing key never matches (so `ne`
  * on an absent key is false too — the attribute simply isn't there to compare). Empty/undefined
@@ -2119,8 +2202,20 @@ declare function attributeOperand(filter: AttributeFilter): string | number;
  * (`STATE_STORE is not available in the DurableApiModule context`). A registered symbol collapses
  * them to one. Mirrors the `CONTEXT_ACCESSOR` token in `@dudousxd/nestjs-durable`'s `tokens.ts`.
  */
+/**
+ * @deprecated Use {@link STATE_STORE_CANONICAL} (`@dudousxd/nestjs-durable:state-store`). The legacy
+ * token stays bound as a back-compat alias and still resolves; it will be removed in a future major.
+ */
 declare const STATE_STORE: unique symbol;
+/**
+ * @deprecated Use {@link TRANSPORT_CANONICAL} (`@dudousxd/nestjs-durable:transport`). The legacy
+ * token stays bound as a back-compat alias and still resolves; it will be removed in a future major.
+ */
 declare const TRANSPORT: unique symbol;
+/**
+ * @deprecated Use {@link DURABLE_OPTIONS_CANONICAL} (`@dudousxd/nestjs-durable:options`). The legacy
+ * token stays bound as a back-compat alias and still resolves; it will be removed in a future major.
+ */
 declare const DURABLE_OPTIONS: unique symbol;
 /**
  * Canonical, cross-lib-discoverable aliases of the durable DI tokens, following the ecosystem
@@ -2220,4 +2315,4 @@ declare class InMemoryTransport implements Transport, ControlPlane {
     onControl(handler: (msg: ControlMessage) => void): void;
 }
 
-export { type AccumulatorHost, type Admission, type AdmissionBackend, type AdmissionItem, type AttributeFilter, type AttributeOp, type BackoffStrategy, type ChildCallOptions, CodecStateStore, ContinueAsNew, type ControlMessage, type ControlPlane, DURABLE_OPTIONS, DURABLE_OPTIONS_CANONICAL, type DurableWebhook, type EngineEvent, type EngineEventType, type EngineListener, Entities, type EntityConfig, type EntityHandler, type EntityHost, EventAccumulators, type EventBatchConfig, FatalError, type GroupHealth, type Heartbeat, type HistoryEvent, InMemoryAdmissionBackend, InMemoryStateStore, InMemoryTransport, type MetricsCollector, type MetricsSnapshot, type NamedTransport, NonDeterminismError, type PayloadCodec, type QueueConfig, QueueController, type RemoteStepConfig, type RemoteStepDef, RemoteStepError, RemoteStepTimeout, type RemoteTask, RemoteWorkflowExecutor, type RunAttributeRow, type RunDispatcher, type RunQuery, type RunResult, type RunSchedulesOptions, type RunStatus, STATE_STORE, STATE_STORE_CANONICAL, type ScheduledWorkflow, type SearchAttributes, SignalTimeoutError, type SignalWaiter, type SingletonConfig, SingletonQueueFullError, type StartOptions, type StateStore, type StepCheckpoint, type StepError, type StepEvent, type StepHandler, type StepInterceptor, type StepInvocation, type StepKind, type StepLogger, type StepOptions, type StepResult, type StoreTransaction, type SubProcessHandle, TRANSPORT, TRANSPORT_CANONICAL, type Transport, type UpdateResult, type UpdateValidator, WORKFLOW_NAME_KEY, type WorkerHeartbeat, type WorkflowClass, type WorkflowCommand, type WorkflowCtx, type WorkflowDecision, WorkflowEngine, type WorkflowEngineDeps, type WorkflowExecutor, type WorkflowInputOf, type WorkflowOutputOf, type WorkflowRef, type WorkflowRun, type WorkflowStepEvent, WorkflowSuspended, type WorkflowTask, applyAttributeQuery, attributeColumnFor, attributeOperand, breakpointToken, collectMetrics, eventMatchOf, eventMatches, eventPrefix, eventToken, matchesAttributes, normalizeAttributeRows, parseDuration, prevCronFireMs, remoteStep, runSchedules, runStepHandler, scheduledRunId, sqlComparator, stepId, workflowName };
+export { type AccumulatorHost, type Admission, type AdmissionBackend, type AdmissionItem, type AttributeFilter, type AttributeOp, type BackoffStrategy, type ChildCallOptions, CodecStateStore, ContinueAsNew, type ControlMessage, type ControlPlane, DURABLE_OPTIONS, DURABLE_OPTIONS_CANONICAL, type DurableWebhook, type EngineEvent, type EngineEventType, type EngineListener, Entities, type EntityConfig, type EntityHandler, type EntityHost, EventAccumulators, type EventBatchConfig, FatalError, GatherError, type GroupHealth, type Heartbeat, type HistoryEvent, InMemoryAdmissionBackend, InMemoryStateStore, InMemoryTransport, type MetricsCollector, type MetricsSnapshot, type NamedTransport, NonDeterminismError, type PayloadCodec, type QueueConfig, QueueController, type RemoteStepConfig, type RemoteStepDef, RemoteStepError, RemoteStepTimeout, type RemoteTask, RemoteWorkflowExecutor, RemoteWorkflowTimeout, type RunAttributeRow, type RunDispatcher, type RunQuery, type RunResult, type RunSchedulesOptions, type RunStatus, STATE_STORE, STATE_STORE_CANONICAL, type ScheduledWorkflow, type SearchAttributes, SignalTimeoutError, type SignalWaiter, type SingletonConfig, SingletonQueueFullError, type StartOptions, type StateStore, type StepCheckpoint, type StepError, type StepEvent, type StepHandler, type StepInterceptor, type StepInvocation, type StepKind, type StepLogger, type StepOptions, type StepResult, type StoreTransaction, type SubProcessHandle, TRANSPORT, TRANSPORT_CANONICAL, type Transport, type UpdateResult, type UpdateValidator, WORKFLOW_NAME_KEY, type WorkerHeartbeat, type WorkflowClass, type WorkflowCommand, type WorkflowCtx, type WorkflowDecision, WorkflowEngine, type WorkflowEngineDeps, type WorkflowExecutor, type WorkflowInputOf, type WorkflowOutputOf, type WorkflowRef, type WorkflowRun, type WorkflowStepEvent, WorkflowSuspended, type WorkflowTask, applyAttributeQuery, attributeColumnFor, attributeOperand, breakpointToken, collectMetrics, createStepLogger, eventMatchOf, eventMatches, eventPrefix, eventToken, matchesAttributes, normalizeAttributeRows, parseDuration, prevCronFireMs, remoteStep, runSchedules, runStepHandler, scheduledRunId, sqlComparator, stepId, workflowName };

package/dist/index.d.ts

@@ -283,6 +283,13 @@ interface StepCheckpoint {
     events?: StepEvent[] | undefined;
     /** For sleep steps: epoch ms the sleep elapses at. */
     wakeAt?: number | undefined;
+    /**
+     * Set on the running placeholder checkpoints of the children dispatched by one `ctx.all` call —
+     * a shared tag (`all:<firstSeq>`) grouping the N siblings so the dashboard can render them as one
+     * parallel fan-out. Optional and additive: absent on every non-`all` checkpoint. Mirrors the
+     * Python SDK's `parallelGroup`.
+     */
+    parallelGroup?: string | undefined;
     /**
      * When the step entered the system: for a remote step, when the engine dispatched it to the
      * transport; for a local step, when it began. Queue-wait time = `startedAt − enqueuedAt`.
@@ -636,6 +643,9 @@ type WorkflowCommand =
     startedAt?: number;
     finishedAt?: number;
     events?: StepEvent[];
+    /** A worker's `ctx.gather([...])` tags every step in the parallel fan with the same group, so the
+     *  engine carries it onto the checkpoint and the dashboard renders the fan as one group. */
+    parallelGroup?: string;
 }
 /** `ctx.sleep(ms)` — a durable timer of `ms` duration. The engine computes the absolute deadline
  *  (now + ms) when it applies the command, so the worker never reads the clock (determinism). */
@@ -650,12 +660,15 @@ type WorkflowCommand =
     seq: number;
     signal: string;
 }
-/** `ctx.start_child(workflow, input)` — start a child run with its own lifecycle. */
+/** `ctx.start_child(workflow, input)` — start a child run with its own lifecycle. A worker's
+ *  `ctx.all([...])` fan-out tags every dispatched child with the same `parallelGroup` so the
+ *  dashboard can render the fan as one group (parity with the gathered `recordStep` tag). */
  | {
     kind: 'startChild';
     seq: number;
     workflow: string;
     input: unknown;
+    parallelGroup?: string;
 };
 /** workflow worker → engine: the result of replaying one turn of a remote workflow. */
 interface WorkflowDecision {
@@ -693,6 +706,9 @@ interface WorkflowStepEvent {
     error?: StepError;
     /** Sub-process + log trail the step emitted so far (the handler's p-processes). */
     events?: StepEvent[];
+    /** A worker's `ctx.gather([...])` fan tags every step's lifecycle with the same group so the
+     *  dashboard renders the live fan-out as one group (parity with the `recordStep` tag). */
+    parallelGroup?: string | undefined;
 }
 /**
  * Advances a workflow run one turn. The engine has one per workflow: the default {@link InProcess}
@@ -988,6 +1004,24 @@ interface WorkflowCtx {
      */
     startChild<C extends WorkflowClass>(workflow: C, input: WorkflowInputOf<C>, options?: string | ChildCallOptions): Promise<string>;
     startChild(workflow: string, input: unknown, options?: string | ChildCallOptions): Promise<string>;
+    /**
+     * Run N children of the SAME workflow **in parallel** and wait for ALL of them: dispatches one
+     * child per entry in `inputs` (concurrently, each with its own durable lifecycle), suspends — zero
+     * compute — until every child reaches a terminal state, then resumes with their outputs in **input
+     * order**. Child ids are group-scoped and stable (`<runId>.all.<firstSeq>.<i>`), and the running
+     * placeholders share a `parallelGroup` tag so the dashboard renders the fan-out as one group.
+     *
+     * `mode` (default `waitAll`): `waitAll` waits for all then throws an aggregate {@link GatherError}
+     * if any failed; `failFast` throws as soon as a failed child is seen (siblings are not cancelled in
+     * v1 — their eventual results are ignored). Empty `inputs` returns `[]` with no side effects. The
+     * wait-all / fan-out counterpart to {@link child}; parity with the Python SDK's `gather_children`.
+     */
+    all<C extends WorkflowClass>(workflow: C, inputs: WorkflowInputOf<C>[], opts?: {
+        mode?: 'waitAll' | 'failFast';
+    }): Promise<WorkflowOutputOf<C>[]>;
+    all<TOutput = unknown>(workflow: string, inputs: unknown[], opts?: {
+        mode?: 'waitAll' | 'failFast';
+    }): Promise<TOutput[]>;
     /**
      * Pause the run at this point until a human resumes it from the dashboard (or
      * `engine.continue(runId)`). Records a visible `pending` checkpoint so the breakpoint shows up
@@ -1803,6 +1837,29 @@ declare class RemoteStepTimeout extends Error {
     readonly timeoutMs: number;
     constructor(stepId: string, timeoutMs: number);
 }
+/**
+ * Thrown by a remote {@link WorkflowExecutor} (e.g. {@link RemoteWorkflowExecutor}) when an `advance`
+ * does not produce its decision within the configured `timeoutMs` — i.e. the worker is presumed gone
+ * (the decision was dropped by a stall/redelivery or an instance restart spanning the in-memory waiter
+ * map). Crucially this is NOT a run failure: the work may have actually completed and only the decision
+ * was lost. The engine treats it as RECOVERABLE — it releases the run lease and leaves the run
+ * `running` so `recoverIncomplete` re-drives it deterministically (replaying completed steps from
+ * history). Distinct from a real executor error, which still fails the run.
+ *
+ * OPT-IN: only thrown when the executor was constructed with a `timeoutMs`. Absent a timeout, the
+ * engine awaits the decision with its prior (unbounded) behavior — so existing users see no change.
+ *
+ * Known hazard: a timeout that fires while a worker is LEGITIMATELY still executing a not-yet-
+ * checkpointed step will re-drive and re-run that in-flight step → DUPLICATE side effects. Therefore
+ * the timeout is only safe when set GENEROUSLY (longer than the longest legitimate single turn). The
+ * robust fix — a liveness/heartbeat-rearmed deadline so only a genuinely-dead worker re-drives — is the
+ * documented follow-up (see the Track A diagnosis doc, "Part B").
+ */
+declare class RemoteWorkflowTimeout extends Error {
+    readonly taskId: string;
+    readonly timeoutMs: number;
+    constructor(taskId: string, timeoutMs: number);
+}
 /**
  * Thrown on resume when the workflow code no longer matches the recorded history: the step at a
  * logical position has a different name/kind than the checkpoint saved there. This means the
@@ -1816,6 +1873,24 @@ declare class NonDeterminismError extends Error {
     readonly seq: number;
     constructor(runId: string, seq: number, expected: string, recorded: string);
 }
+/**
+ * Thrown by `ctx.all` when one or more parallel child workflows fail. Carries the per-item failures
+ * (input index, child run id, error message) and presents an aggregate message summarizing the count
+ * and the failing ids — the wait-all/fail-fast counterpart to a single child's FatalError. Mirrors
+ * the Python SDK's `GatherFailed`.
+ */
+declare class GatherError extends Error {
+    readonly failures: {
+        index: number;
+        id: string;
+        error: string;
+    }[];
+    constructor(failures: {
+        index: number;
+        id: string;
+        error: string;
+    }[], total?: number);
+}
 declare class WorkflowSuspended extends Error {
     /** Epoch ms to auto-resume (durable sleep), or undefined when waiting on an external signal. */
     readonly wakeAt?: number | undefined;
@@ -2059,6 +2134,14 @@ declare function prevCronFireMs(expr: string, nowMs: number, timezone?: string):
  */
 declare function runSchedules(engine: Pick<WorkflowEngine, 'start' | 'getRun'>, schedules: readonly ScheduledWorkflow[], nowMs: number, opts?: RunSchedulesOptions): Promise<string[]>;
 
+/**
+ * A {@link StepLogger} that appends to `events`, stamping each line with `now()`. Shared by the
+ * local-step path (`ctx.step`) and the remote-worker path (`runStepHandler`) so a step records
+ * the same {@link StepEvent} shape wherever it runs — the TypeScript twin of the Python SDK's
+ * `StepContext`.
+ */
+declare function createStepLogger(events: StepEvent[], now: () => number): StepLogger;
+
 /**
  * Does a run's search attributes satisfy EVERY filter (AND)? A missing key never matches (so `ne`
  * on an absent key is false too — the attribute simply isn't there to compare). Empty/undefined
@@ -2119,8 +2202,20 @@ declare function attributeOperand(filter: AttributeFilter): string | number;
  * (`STATE_STORE is not available in the DurableApiModule context`). A registered symbol collapses
  * them to one. Mirrors the `CONTEXT_ACCESSOR` token in `@dudousxd/nestjs-durable`'s `tokens.ts`.
  */
+/**
+ * @deprecated Use {@link STATE_STORE_CANONICAL} (`@dudousxd/nestjs-durable:state-store`). The legacy
+ * token stays bound as a back-compat alias and still resolves; it will be removed in a future major.
+ */
 declare const STATE_STORE: unique symbol;
+/**
+ * @deprecated Use {@link TRANSPORT_CANONICAL} (`@dudousxd/nestjs-durable:transport`). The legacy
+ * token stays bound as a back-compat alias and still resolves; it will be removed in a future major.
+ */
 declare const TRANSPORT: unique symbol;
+/**
+ * @deprecated Use {@link DURABLE_OPTIONS_CANONICAL} (`@dudousxd/nestjs-durable:options`). The legacy
+ * token stays bound as a back-compat alias and still resolves; it will be removed in a future major.
+ */
 declare const DURABLE_OPTIONS: unique symbol;
 /**
  * Canonical, cross-lib-discoverable aliases of the durable DI tokens, following the ecosystem
@@ -2220,4 +2315,4 @@ declare class InMemoryTransport implements Transport, ControlPlane {
     onControl(handler: (msg: ControlMessage) => void): void;
 }
 
-export { type AccumulatorHost, type Admission, type AdmissionBackend, type AdmissionItem, type AttributeFilter, type AttributeOp, type BackoffStrategy, type ChildCallOptions, CodecStateStore, ContinueAsNew, type ControlMessage, type ControlPlane, DURABLE_OPTIONS, DURABLE_OPTIONS_CANONICAL, type DurableWebhook, type EngineEvent, type EngineEventType, type EngineListener, Entities, type EntityConfig, type EntityHandler, type EntityHost, EventAccumulators, type EventBatchConfig, FatalError, type GroupHealth, type Heartbeat, type HistoryEvent, InMemoryAdmissionBackend, InMemoryStateStore, InMemoryTransport, type MetricsCollector, type MetricsSnapshot, type NamedTransport, NonDeterminismError, type PayloadCodec, type QueueConfig, QueueController, type RemoteStepConfig, type RemoteStepDef, RemoteStepError, RemoteStepTimeout, type RemoteTask, RemoteWorkflowExecutor, type RunAttributeRow, type RunDispatcher, type RunQuery, type RunResult, type RunSchedulesOptions, type RunStatus, STATE_STORE, STATE_STORE_CANONICAL, type ScheduledWorkflow, type SearchAttributes, SignalTimeoutError, type SignalWaiter, type SingletonConfig, SingletonQueueFullError, type StartOptions, type StateStore, type StepCheckpoint, type StepError, type StepEvent, type StepHandler, type StepInterceptor, type StepInvocation, type StepKind, type StepLogger, type StepOptions, type StepResult, type StoreTransaction, type SubProcessHandle, TRANSPORT, TRANSPORT_CANONICAL, type Transport, type UpdateResult, type UpdateValidator, WORKFLOW_NAME_KEY, type WorkerHeartbeat, type WorkflowClass, type WorkflowCommand, type WorkflowCtx, type WorkflowDecision, WorkflowEngine, type WorkflowEngineDeps, type WorkflowExecutor, type WorkflowInputOf, type WorkflowOutputOf, type WorkflowRef, type WorkflowRun, type WorkflowStepEvent, WorkflowSuspended, type WorkflowTask, applyAttributeQuery, attributeColumnFor, attributeOperand, breakpointToken, collectMetrics, eventMatchOf, eventMatches, eventPrefix, eventToken, matchesAttributes, normalizeAttributeRows, parseDuration, prevCronFireMs, remoteStep, runSchedules, runStepHandler, scheduledRunId, sqlComparator, stepId, workflowName };
+export { type AccumulatorHost, type Admission, type AdmissionBackend, type AdmissionItem, type AttributeFilter, type AttributeOp, type BackoffStrategy, type ChildCallOptions, CodecStateStore, ContinueAsNew, type ControlMessage, type ControlPlane, DURABLE_OPTIONS, DURABLE_OPTIONS_CANONICAL, type DurableWebhook, type EngineEvent, type EngineEventType, type EngineListener, Entities, type EntityConfig, type EntityHandler, type EntityHost, EventAccumulators, type EventBatchConfig, FatalError, GatherError, type GroupHealth, type Heartbeat, type HistoryEvent, InMemoryAdmissionBackend, InMemoryStateStore, InMemoryTransport, type MetricsCollector, type MetricsSnapshot, type NamedTransport, NonDeterminismError, type PayloadCodec, type QueueConfig, QueueController, type RemoteStepConfig, type RemoteStepDef, RemoteStepError, RemoteStepTimeout, type RemoteTask, RemoteWorkflowExecutor, RemoteWorkflowTimeout, type RunAttributeRow, type RunDispatcher, type RunQuery, type RunResult, type RunSchedulesOptions, type RunStatus, STATE_STORE, STATE_STORE_CANONICAL, type ScheduledWorkflow, type SearchAttributes, SignalTimeoutError, type SignalWaiter, type SingletonConfig, SingletonQueueFullError, type StartOptions, type StateStore, type StepCheckpoint, type StepError, type StepEvent, type StepHandler, type StepInterceptor, type StepInvocation, type StepKind, type StepLogger, type StepOptions, type StepResult, type StoreTransaction, type SubProcessHandle, TRANSPORT, TRANSPORT_CANONICAL, type Transport, type UpdateResult, type UpdateValidator, WORKFLOW_NAME_KEY, type WorkerHeartbeat, type WorkflowClass, type WorkflowCommand, type WorkflowCtx, type WorkflowDecision, WorkflowEngine, type WorkflowEngineDeps, type WorkflowExecutor, type WorkflowInputOf, type WorkflowOutputOf, type WorkflowRef, type WorkflowRun, type WorkflowStepEvent, WorkflowSuspended, type WorkflowTask, applyAttributeQuery, attributeColumnFor, attributeOperand, breakpointToken, collectMetrics, createStepLogger, eventMatchOf, eventMatches, eventPrefix, eventToken, matchesAttributes, normalizeAttributeRows, parseDuration, prevCronFireMs, remoteStep, runSchedules, runStepHandler, scheduledRunId, sqlComparator, stepId, workflowName };

package/dist/index.js

@@ -385,6 +385,7 @@ function stepCheckpoint(p) {
     attempts: p.attempts,
     workerGroup: p.workerGroup,
     wakeAt: p.wakeAt,
+    parallelGroup: p.parallelGroup,
     enqueuedAt: p.enqueuedAt,
     startedAt: p.startedAt,
     finishedAt: p.finishedAt
@@ -402,6 +403,7 @@ function instantCheckpoint(p) {
     status: p.status ?? "completed",
     output: p.output,
     wakeAt: p.wakeAt,
+    parallelGroup: p.parallelGroup,
     attempts: 1,
     enqueuedAt: at,
     startedAt: at,
@@ -463,6 +465,19 @@ var RemoteStepTimeout = class extends Error {
     this.timeoutMs = timeoutMs;
   }
 };
+var RemoteWorkflowTimeout = class extends Error {
+  static {
+    __name(this, "RemoteWorkflowTimeout");
+  }
+  taskId;
+  timeoutMs;
+  constructor(taskId, timeoutMs) {
+    super(`remote workflow task ${taskId} produced no decision within ${timeoutMs}ms \u2014 presumed dropped; re-driving via recovery`);
+    this.name = "RemoteWorkflowTimeout";
+    this.taskId = taskId;
+    this.timeoutMs = timeoutMs;
+  }
+};
 var NonDeterminismError = class extends Error {
   static {
     __name(this, "NonDeterminismError");
@@ -476,6 +491,19 @@ var NonDeterminismError = class extends Error {
     this.seq = seq;
   }
 };
+var GatherError = class extends Error {
+  static {
+    __name(this, "GatherError");
+  }
+  failures;
+  constructor(failures, total) {
+    const ids = failures.map((f) => f.id).join(", ");
+    const denom = total ?? failures.length;
+    super(`ctx.all: ${failures.length} of ${denom} child(ren) failed: ${ids}`);
+    this.name = "GatherError";
+    this.failures = failures;
+  }
+};
 var WorkflowSuspended = class extends Error {
   static {
     __name(this, "WorkflowSuspended");
@@ -1145,6 +1173,72 @@ function createWorkflowCtx(host, runId, compensations, workflow = "") {
     }
     throw new WorkflowSuspended();
   }, "child");
+  const all = /* @__PURE__ */ __name(async (workflow2, inputs, opts) => {
+    if (inputs.length === 0) return [];
+    const mode = opts?.mode ?? "waitAll";
+    const name = workflowName(workflow2);
+    const positions = inputs.map(() => pos.next());
+    const group = `all:${positions[0]}`;
+    const id = /* @__PURE__ */ __name((i) => `${runId}.all.${positions[0]}.${i}`, "id");
+    const existing = await Promise.all(positions.map((seq) => readCheckpoint(seq)));
+    if (mode === "failFast") {
+      for (let i = 0; i < inputs.length; i += 1) {
+        const cp = existing[i];
+        const c = cp?.status === "completed" ? cp.output : null;
+        if (c && c.ok === false) {
+          throw new GatherError([
+            {
+              index: i,
+              id: id(i),
+              error: c.error ?? "unknown"
+            }
+          ], inputs.length);
+        }
+      }
+    }
+    let pending = false;
+    for (let i = 0; i < inputs.length; i += 1) {
+      const cp = existing[i];
+      if (cp?.status === "completed") continue;
+      pending = true;
+      const seq = positions[i];
+      const childId = id(i);
+      await store.putSignalWaiter({
+        token: `child:${childId}`,
+        runId,
+        seq
+      });
+      if (!await store.getRun(childId)) host.startChild(name, inputs[i], childId);
+      if (!cp) {
+        await writeCheckpoint(instantCheckpoint({
+          runId,
+          seq,
+          name: `signal:child:${childId}`,
+          kind: "signal",
+          status: "running",
+          parallelGroup: group
+        }));
+      }
+    }
+    if (pending) throw new WorkflowSuspended();
+    const outputs = [];
+    const failures = [];
+    for (let i = 0; i < inputs.length; i += 1) {
+      const c = existing[i]?.output;
+      if (c && typeof c === "object" && "ok" in c && c.ok === false) {
+        failures.push({
+          index: i,
+          id: id(i),
+          error: c.error ?? "unknown"
+        });
+        outputs.push(void 0);
+      } else {
+        outputs.push(c?.value);
+      }
+    }
+    if (failures.length > 0) throw new GatherError(failures, inputs.length);
+    return outputs;
+  }, "all");
   const startChild = /* @__PURE__ */ __name(async (workflow2, input, options) => {
     const { childId, priority } = normalizeChildOptions(options);
     const current = pos.next();
@@ -1279,6 +1373,7 @@ function createWorkflowCtx(host, runId, compensations, workflow = "") {
     waitForEvent,
     task,
     child,
+    all,
     startChild,
     breakpoint,
     webhook,
@@ -2268,7 +2363,8 @@ var WorkflowEngine = class {
         attempts: 1,
         enqueuedAt: startedAt,
         startedAt,
-        finishedAt: startedAt
+        finishedAt: startedAt,
+        parallelGroup: event.parallelGroup
       }));
       this.emit({
         type: "step.started",
@@ -2292,7 +2388,8 @@ var WorkflowEngine = class {
       attempts: 1,
       enqueuedAt: startedAt,
       startedAt,
-      finishedAt: event.finishedAt != null ? new Date(event.finishedAt) : /* @__PURE__ */ new Date()
+      finishedAt: event.finishedAt != null ? new Date(event.finishedAt) : /* @__PURE__ */ new Date(),
+      parallelGroup: event.parallelGroup
     }));
     this.emit({
       type: failed ? "step.failed" : "step.completed",
@@ -2529,6 +2626,13 @@ var WorkflowEngine = class {
     try {
       decision = await remote.executor.advance(run, history);
     } catch (err) {
+      if (err instanceof RemoteWorkflowTimeout) {
+        await this.store.releaseRunLock(run.id);
+        return {
+          runId: run.id,
+          status: "running"
+        };
+      }
       const error = {
         message: err instanceof Error ? err.message : String(err),
         stack: err instanceof Error ? err.stack : void 0
@@ -2648,7 +2752,11 @@ var WorkflowEngine = class {
           attempts: 1,
           enqueuedAt: startedAt,
           startedAt,
-          finishedAt
+          finishedAt,
+          // Carry the worker's `parallelGroup` (a Python `ctx.gather` tags every step in the fan with
+          // the same group) onto the checkpoint, so the dashboard can render the steps as one parallel
+          // group instead of a sequential list. Additive: undefined for ordinary sequential steps.
+          parallelGroup: cmd.parallelGroup
         }));
         this.emit({
           type: cmd.error ? "step.failed" : "step.completed",
@@ -3283,11 +3391,12 @@ var RemoteWorkflowExecutor = class {
     };
     const decision = new Promise((resolve, reject) => {
       this.pending.set(taskId, resolve);
-      if (this.opts.timeoutMs) {
+      const { timeoutMs } = this.opts;
+      if (timeoutMs) {
         const timer = setTimeout(() => {
           this.pending.delete(taskId);
-          reject(new Error(`workflow task ${taskId} timed out after ${this.opts.timeoutMs}ms`));
-        }, this.opts.timeoutMs);
+          reject(new RemoteWorkflowTimeout(taskId, timeoutMs));
+        }, timeoutMs);
         timer.unref?.();
       }
     });
@@ -4014,6 +4123,7 @@ export {
   Entities,
   EventAccumulators,
   FatalError,
+  GatherError,
   InMemoryAdmissionBackend,
   InMemoryStateStore,
   InMemoryTransport,
@@ -4022,6 +4132,7 @@ export {
   RemoteStepError,
   RemoteStepTimeout,
   RemoteWorkflowExecutor,
+  RemoteWorkflowTimeout,
   STATE_STORE,
   STATE_STORE_CANONICAL,
   SignalTimeoutError,
@@ -4036,6 +4147,7 @@ export {
   attributeOperand,
   breakpointToken,
   collectMetrics,
+  createStepLogger,
   eventMatchOf,
   eventMatches,
   eventPrefix,