@adonis-agora/durable 0.1.0

package/dist/src/engine.d.ts

@@ -0,0 +1,583 @@
+import { type AdmissionBackend } from './admission.js';
+import { type EntityConfig } from './entities.js';
+import { type EventBatchConfig } from './event-accumulators.js';
+import type { ControlPlane, EngineListener, GroupHealth, NamedTransport, RunDispatcher, RunQuery, RunResult, SearchAttributes, StateStore, StepCheckpoint, StepError, StepInterceptor, Transport, UpdateResult, UpdateValidator, WorkflowCtx, WorkflowExecutor, WorkflowRun } from './interfaces.js';
+import type { QueueConfig } from './queue.js';
+import { type WorkflowClass, type WorkflowInputOf, type WorkflowRef } from './workflow-ref.js';
+type WorkflowFn = (ctx: WorkflowCtx, input: unknown) => Promise<unknown>;
+/** Options for {@link WorkflowEngine.start}. */
+export interface StartOptions {
+    /** Run-scoped tags, merged with the workflow's static `@Workflow({ tags })` onto the run. */
+    tags?: string[] | undefined;
+    /** Typed, queryable run data stamped on the run (e.g. `{ amount: 200, tier: 'pro' }`). */
+    searchAttributes?: SearchAttributes | undefined;
+    /**
+     * Dispatch priority for a remote run — stamped on the run and carried onto every {@link WorkflowTask}
+     * the engine dispatches to advance it. Higher wins; absent = unprioritised. See {@link WorkflowRun.priority}.
+     */
+    priority?: number | undefined;
+}
+/**
+ * Serialize runs of a workflow that share a key — a durable, FIFO mutex (e.g. one pipeline per base).
+ * Excess runs are admitted in creation order, `limit` at a time; the rest wait (suspended) and retry
+ * admission on a timer until a slot frees. Race-free on a consistent store (admission order is the
+ * same `(createdAt, id)` view for every instance).
+ */
+export interface SingletonConfig {
+    /** Derive the serialization key from the workflow input. */
+    key: (input: unknown) => string;
+    /** Max concurrent runs sharing the key. Default 1 (a mutex). */
+    limit?: number;
+    /**
+     * Max GATED (waiting-for-admission) runs allowed to queue behind the `limit` in-flight ones. When
+     * set, `start` rejects with {@link SingletonQueueFullError} once in-flight + gated reaches
+     * `limit + maxQueueDepth` — back-pressure against an unbounded same-key backlog. Omit for the
+     * default unbounded queue. Counts `pending`/`running`/`suspended` runs sharing the key.
+     */
+    maxQueueDepth?: number;
+}
+export interface WorkflowEngineDeps {
+    store: StateStore;
+    /** A single task transport. Shorthand for a one-entry `transports` pool (id `default`). */
+    transport?: Transport | undefined;
+    /**
+     * An ordered pool of named transports. The engine dispatches on the first and fails over to the
+     * next on a dispatch error; a step pins one via `ctx.call(step, input, { transport: id })`. Use
+     * this instead of `transport` for failover / multi-broker setups.
+     */
+    transports?: NamedTransport[] | undefined;
+    /**
+     * Cross-instance broadcast pub/sub for lifecycle events + cancellation (see {@link ControlPlane}).
+     * Separate from the task `transport`; omit for a single-instance / local-only setup. A transport
+     * that can also broadcast may be passed here as well.
+     */
+    controlPlane?: ControlPlane | undefined;
+    /** Epoch-ms clock; injectable for tests. Defaults to `Date.now`. */
+    clock?: (() => number) | undefined;
+    /** Unique id for this engine instance, used for recovery leases. Defaults to a random id. */
+    instanceId?: string | undefined;
+    /** Recovery lease duration in ms — how long this instance owns a run it picked up. Default 30s. */
+    leaseMs?: number | undefined;
+    /**
+     * Flow-control admission backend for `ctx.call(step, input, { queue })`. Defaults to an in-process
+     * {@link InMemoryAdmissionBackend} (per-instance caps). Inject a store/Redis-backed backend to make
+     * the concurrency/rate/ordering caps GLOBAL across engine replicas.
+     */
+    admission?: AdmissionBackend | undefined;
+    /**
+     * Cap how many times crash-recovery may pick up the same still-`running` run before giving up and
+     * moving it to the `dead` dead-letter state (a poison pill that crashes the process every boot).
+     * Omit for unlimited (the default — recovery always retries).
+     */
+    maxRecoveryAttempts?: number | undefined;
+    /**
+     * Build the public callback URL for a `ctx.webhook()` token (e.g.
+     * ``(t) => `https://api.example.com/durable/webhooks/${t}` ``). Populates
+     * {@link DurableWebhook.url}. Omit if you build URLs yourself from the token.
+     */
+    webhookUrl?: ((token: string) => string) | undefined;
+    /**
+     * Provide the current W3C `traceparent` to stamp on each dispatched {@link RemoteTask}, so a
+     * worker (including the Python SDK) continues the distributed trace. Keep core OTel-free: supply
+     * `otelTraceparent` from `@dudousxd/nestjs-durable-otel`, or your own context reader. Omit to send none.
+     */
+    traceparent?: (() => string | undefined) | undefined;
+    /**
+     * Provide an opaque context carrier (tenant / user / correlation ids) to attach to each dispatched
+     * {@link RemoteTask} as its `context`, so a worker (including the Python SDK) re-exposes it to the
+     * step handler — cross-process propagation alongside the {@link traceparent}. Keep core dependency-free:
+     * supply this from `@dudousxd/nestjs-context` or your own request-scoped reader. The engine never
+     * inspects the returned object's shape. Omit to send none.
+     *
+     * Re-evaluated at each (re)dispatch — including a retry or a resume that the engine drives AFTER a
+     * crash/scale-down, which runs OUTSIDE the originating request scope. On such a path this provider
+     * may return empty or stale values (the request-scoped tenant/user is gone). Treat the carrier as
+     * best-effort correlation/propagation metadata only — do NOT treat it as an authorization boundary.
+     */
+    context?: (() => Record<string, unknown> | undefined) | undefined;
+    /**
+     * Re-hydrate the originating context around a LOCAL step body, so a `@DurableStep` reader sees the
+     * tenant / user / correlation ids that were live when the run was started — even on a path the
+     * engine drives outside the originating request scope (a resume after crash/scale-down, a timer).
+     * Given the carrier produced by {@link context} (may be empty/undefined) and the step body `fn`, it
+     * runs `fn` with that context ambiently established (e.g. inside `@dudousxd/nestjs-context`'s ALS)
+     * and returns its result. Keep core dependency-free: supply this from the nestjs wiring (which owns
+     * nestjs-context) or your own ALS bridge. The handler signature is unchanged — re-hydration is
+     * ambient. Default: passthrough (`(_, fn) => fn()`), so behavior is byte-identical when unset.
+     */
+    rehydrate?: (<T>(carrier: Record<string, unknown> | undefined, fn: () => T) => T) | undefined;
+    /**
+     * Attempts for each saga compensation when the run fails (a transient undo — e.g. a refund API
+     * hiccup — gets another try). Default 1 (no retry). Compensations must be idempotent.
+     */
+    compensationRetries?: number | undefined;
+    /**
+     * Persist a `running` checkpoint when a local step's body begins, so an in-flight step shows up
+     * in the dashboard (and a fresh page load / REST query) the moment it starts — not only once it
+     * completes. The `step.started` lifecycle event is emitted either way (the live SSE view always
+     * sees the start); this flag only controls the extra checkpoint write. Default `true`. Set
+     * `false` on hot paths with many short local steps to halve their checkpoint writes — you keep
+     * the live event but lose reload-survivable in-flight visibility.
+     */
+    trackStepStart?: boolean | undefined;
+    /**
+     * Where a freshly-`start`ed run executes (see {@link RunDispatcher}). Defaults to in-process: the
+     * run executes on this instance asynchronously (a microtask), so `start` returns without blocking.
+     * Pass a no-op dispatcher on a caller that must NOT run workflows (e.g. an API/dashboard pod), and
+     * run `runPending` on a worker pod to pick those up; or a broker-backed one for a worker pool.
+     */
+    runDispatcher?: RunDispatcher | undefined;
+}
+/**
+ * The orchestrator. Owns workflow state and replays runs deterministically: each step's
+ * result is checkpointed, so on resume a completed step returns its saved output instead of
+ * re-executing. Remote steps are dispatched over the Transport; their results checkpoint the
+ * same way local steps do.
+ */
+export declare class WorkflowEngine {
+    private readonly store;
+    /** Ordered transport pool (dispatch + failover). Empty = no remote steps. */
+    private readonly pool;
+    private readonly controlPlane?;
+    private readonly clock;
+    private readonly instanceId;
+    private readonly leaseMs;
+    private readonly maxRecoveryAttempts?;
+    private readonly webhookUrl?;
+    private readonly traceparent?;
+    private readonly context?;
+    /** Establish the originating context ambiently around a local step body (see {@link WorkflowEngineDeps.rehydrate}). Default passthrough. */
+    private readonly rehydrate;
+    private readonly compensationRetries;
+    /** Persist a `running` checkpoint at the start of a local step body (see {@link WorkflowEngineDeps.trackStepStart}). */
+    private readonly trackStepStart;
+    /** Where a freshly-started run executes — in-process by default (see {@link RunDispatcher}). */
+    private readonly runDispatcher;
+    /** Per-key serialization for singleton workflows (admission, back-pressure, notify-on-release). */
+    private readonly singletons;
+    /** Every registered workflow, keyed by `name@version` — so old versions stay runnable. */
+    private readonly workflows;
+    /** The newest registered version per workflow name — used to `start` new runs. */
+    private readonly latest;
+    /** Event name → workflow names started when that event is published (see `onEvent`). */
+    private readonly eventTriggers;
+    /** Durable-entity subsystem (registers the `__entity` runner; see `registerEntity`). */
+    private readonly entities;
+    /** Event debounce/batch accumulators (register the `__evt_*` runners; see `accumulators.route`). */
+    private readonly accumulators;
+    /** In-flight remote steps awaiting a worker result, keyed by stepId. */
+    private readonly pending;
+    /** Per-step "reset the liveness timer" callbacks, called when a heartbeat arrives. */
+    private readonly heartbeatResets;
+    private readonly listeners;
+    /** Step interceptors (onion middleware around real local-step execution), first = outermost. */
+    private readonly interceptors;
+    /** Callbacks notified (on any instance) when a run is cancelled — for cooperative cancellation. */
+    private readonly cancelListeners;
+    /** Callbacks notified when a run is enqueued elsewhere — for low-latency cross-pod dispatch. */
+    private readonly enqueuedListeners;
+    /** Notified when a run is dead-lettered (moved to `dead`) — a hook for a DLQ handler. */
+    private readonly deadListeners;
+    /** Validators gating `engine.update`, keyed by `<workflow>:<updateName>`. */
+    private readonly updateValidators;
+    /** Runs being cancelled WITH saga compensation — see `cancel({ compensate: true })`. */
+    private readonly cancelRequested;
+    /** Flow-control admission backend for remote steps (see {@link registerQueue}). */
+    private readonly admission;
+    /** Runs on THIS instance blocked on admission, by queue — woken early on a freed-slot signal. */
+    private readonly queueWaiters;
+    /** Which queue a dispatched step took a slot from, by stepId — so the result can release it. */
+    private readonly stepQueue;
+    /** Executions currently in flight, so a graceful shutdown can wait for them to settle. */
+    private readonly inflight;
+    private draining;
+    constructor(deps: WorkflowEngineDeps);
+    /**
+     * Register a **durable entity** (a virtual object): a keyed actor whose `handlers` run **serialized
+     * per key** over **durable state**, exactly once. Drive it with `signalEntity` (fire) /
+     * `ctx.callEntity` (call + await result) and read its state with `getEntityState`. See {@link Entities}.
+     */
+    registerEntity<S>(name: string, config: EntityConfig<S>): void;
+    /** Send an operation to an entity (fire-and-forget). Ordered + exactly-once per key. */
+    signalEntity(name: string, key: string, op: string, arg?: unknown): Promise<void>;
+    /** Read an entity's current durable state (published after each op), or undefined if it has none yet. */
+    getEntityState<S = unknown>(name: string, key: string): Promise<S | undefined>;
+    /**
+     * Be notified when a run is enqueued on ANOTHER instance (via the control plane), so a worker can
+     * pick it up at once — e.g. `engine.onEnqueued((runId) => engine.runOne(runId))`. Returns an
+     * unsubscribe function. Only wire this on instances that should execute runs (workers).
+     */
+    onEnqueued(listener: (runId: string) => void): () => void;
+    /** Fire cooperative-cancellation listeners for `runId` (a worker bridge aborts in-flight work). */
+    private notifyCancelled;
+    /**
+     * Register a workflow version. Register multiple versions of the same name to keep in-flight
+     * runs working across a breaking change: old runs resume on the version they started on, new
+     * runs start on the newest registered version.
+     */
+    register(name: string, version: string, fn: WorkflowFn, opts?: {
+        tags?: string[] | undefined;
+        singleton?: SingletonConfig | undefined;
+        executionTimeout?: string | number | undefined;
+        validateInput?: ((input: unknown) => void | Promise<void>) | undefined;
+        onEvent?: string[] | undefined;
+        eventBatch?: EventBatchConfig | undefined;
+    }): void;
+    /**
+     * Register a workflow whose body runs in another SDK (e.g. Python). The engine owns the run exactly
+     * as for a TS workflow — it persists checkpoints, recovers, runs timers — but advances it by handing
+     * the run's history to `executor` (which dispatches a {@link WorkflowTask} to the worker) and applying
+     * the {@link WorkflowDecision} the worker's replay returns. The worker never touches the store.
+     */
+    registerRemote(name: string, version: string, opts: {
+        group: string;
+        executor: WorkflowExecutor;
+        tags?: string[];
+        singleton?: SingletonConfig;
+        executionTimeout?: string | number;
+        validateInput?: (input: unknown) => void | Promise<void>;
+    }): void;
+    /**
+     * Register a flow-control queue referenced by `ctx.call(step, input, { queue })`. Caps concurrent
+     * in-flight steps and/or the admission rate; blocked calls re-suspend and retry, so the limit is
+     * durable. Per engine instance (see {@link QueueConfig}). Registering the same name replaces it.
+     */
+    registerQueue(config: QueueConfig): void;
+    /** Subscribe to lifecycle events. Returns an unsubscribe function. */
+    subscribe(listener: EngineListener): () => void;
+    /**
+     * Register a {@link StepInterceptor} — onion middleware run around the real execution of every
+     * local `ctx.step` (timing, logging, tracing, error enrichment, context propagation). First
+     * registered is outermost; interceptors fire only when a step executes, never on replay. Returns
+     * an unsubscribe function.
+     */
+    use(interceptor: StepInterceptor): () => void;
+    /**
+     * Fold the registered interceptors around a local step body (identity when there are none), then
+     * run the whole thing inside the re-hydrated originating context. The carrier is read at execution
+     * time from {@link context} — the SAME reader stamped on dispatched remote tasks — so a local step
+     * sees the live tenant / user / trace ids ambiently (via the {@link rehydrate} bridge). Default
+     * `rehydrate` is a passthrough, so this is byte-identical to a bare body call when unwired.
+     */
+    private interceptStep;
+    /**
+     * Be notified when a run is cancelled — on ANY instance, via the transport control plane. A
+     * worker bridge can use this for cooperative cancellation: abort the in-flight work for `runId`
+     * instead of finishing it just to have the result discarded. Returns an unsubscribe function.
+     */
+    onCancel(listener: (runId: string) => void): () => void;
+    /**
+     * Be notified when a run is **dead-lettered** — moved to `dead` after exceeding
+     * `maxRecoveryAttempts`. The listener receives the dead run (status `dead`, with its error), so a
+     * DLQ handler can do something other than just leaving it parked: alert, push to a real queue, or
+     * start a dead-letter workflow (e.g. `engine.onDead((run) => engine.start('pipeline-dlq', run, ...))`).
+     * Returns an unsubscribe function.
+     */
+    onDead(listener: (run: WorkflowRun) => void): () => void;
+    private notifyDead;
+    /** Emit a locally-produced lifecycle event: deliver to subscribers AND broadcast it on the
+     *  control plane so other instances (e.g. a dashboard pod) can live-tail this run. */
+    private emit;
+    /** Deliver an event to local subscribers only (no re-broadcast) — used for both locally-produced
+     *  events and ones received from the control plane, so an event shows up once on every instance. */
+    private deliver;
+    start<C extends WorkflowClass>(workflow: C, input: WorkflowInputOf<C>, runId: string, opts?: StartOptions): Promise<RunResult>;
+    start<TInput>(workflow: string, input: TInput, runId: string, opts?: StartOptions): Promise<RunResult>;
+    /** Read a run's current persisted state (or null if unknown). A thin pass-through to the store. */
+    getRun(runId: string): Promise<WorkflowRun | null>;
+    /**
+     * List persisted runs matching `query` (newest activity first, per the store's own ordering). The
+     * engine's read API for inspection surfaces (the dashboard, the `durable:runs` CLI) so they query
+     * through the engine rather than reaching for its private store.
+     */
+    listRuns(query: RunQuery): Promise<WorkflowRun[]>;
+    /** List a run's step checkpoints (its timeline). Part of the engine's read API; see {@link listRuns}. */
+    listCheckpoints(runId: string): Promise<StepCheckpoint[]>;
+    /**
+     * Hard-delete a run and its whole child subtree from the store, returning the number of runs
+     * removed (0 if `runId` is unknown). Children are collected BEFORE this run's checkpoints are
+     * deleted (the parent→children edge is read from them). Use for retention/cleanup; this is a
+     * destructive store operation, not a cancellation — a running run should be {@link cancel}led first.
+     */
+    deleteRun(runId: string): Promise<number>;
+    resume(runId: string): Promise<RunResult>;
+    /** Track an in-flight execution so {@link drain} can wait for it. */
+    private track;
+    /**
+     * Graceful shutdown: stop picking up new runs (recovery/timer become no-ops) and wait for
+     * in-flight executions to settle, up to `timeoutMs`. Call from your app's shutdown hook so a
+     * deploy hands off cleanly instead of leaving runs to the lease timeout.
+     */
+    drain(timeoutMs?: number): Promise<void>;
+    /**
+     * Cancel in-flight runs that have outlived their workflow's `executionTimeout`. Call it from the
+     * timer poller alongside {@link resumeDueTimers}. A timed-out run is moved to `cancelled` with an
+     * `execution_timeout` error (terminal, so a late step result can't resurrect it).
+     */
+    sweepTimeouts(now?: number): Promise<void>;
+    /**
+     * Resume every run left incomplete by a crash or deploy. Called on boot. Completed steps
+     * replay from their checkpoints, so only the work that had not finished runs again.
+     */
+    recoverIncomplete(nowMs?: number): Promise<RunResult[]>;
+    /**
+     * Per-recovery bookkeeping (called once the lease is held): count the attempt, or — past
+     * `maxRecoveryAttempts` — move a poison pill to the `dead` dead-letter state. Returns a terminal
+     * result to skip the resume, or `undefined` to proceed.
+     */
+    private countRecovery;
+    /**
+     * Resume every suspended run whose durable timer is due. Call periodically (a poller) and on
+     * boot. A run still not due re-suspends cheaply without running new work.
+     */
+    resumeDueTimers(nowMs?: number): Promise<RunResult[]>;
+    /**
+     * Lease and execute one run by id — the worker side of dispatch. Acquires the recovery lease (so
+     * exactly one instance runs it), then resumes the body. Returns the result, or null if another
+     * instance holds the lease or the engine is draining. The default in-process dispatcher calls this;
+     * a broker-backed worker calls it per consumed run id.
+     */
+    runOne(runId: string): Promise<RunResult | null>;
+    /**
+     * Re-enqueue a run for a worker to (re-)execute — the dispatch-model **retry**. Sets it back to
+     * `pending`, clears any stale lease, and dispatches; a worker resumes it (replaying its checkpoints,
+     * re-attempting the failed step). Returns the enqueued state immediately — never runs the body
+     * inline — or null if the run is unknown. The dashboard "retry" goes through here so it can't block
+     * the HTTP request on workflow execution.
+     */
+    requeue(runId: string): Promise<RunResult | null>;
+    /**
+     * **Fix-and-replay**: re-run a run (typically a `dead`/`failed` one) with a corrected `input`, as a
+     * fresh run with clean history. It's a NEW run — `newRunId` defaults to `<runId>~retry~<uuid>` — so
+     * the original stays inspectable. Returns the new run's id, or null if `runId` is unknown.
+     */
+    retryWithInput(runId: string, input: unknown, newRunId?: string): Promise<{
+        runId: string;
+    } | null>;
+    /**
+     * Pick up and execute every `pending` run — the poll-based side of dispatch for a worker pod with
+     * no broker. Runs enqueued by other pods (or by a caller using a no-op dispatcher) sit `pending`
+     * in the store until polled; leasing ensures exactly one pod runs each. Call periodically alongside
+     * {@link resumeDueTimers}.
+     */
+    runPending(nowMs?: number): Promise<RunResult[]>;
+    /**
+     * Resolve once `runId` reaches a settled state — terminal (completed/failed/cancelled/dead) or
+     * suspended (handed off to a timer/signal/event). The async counterpart to dispatch: pair it with
+     * `start` when a call site needs the outcome — `await start(...); const r = await waitForRun(id)`.
+     */
+    waitForRun(runId: string, opts?: {
+        timeoutMs?: number;
+    }): Promise<RunResult>;
+    /**
+     * Resume each run only if this instance can acquire its recovery lease — so when several
+     * replicas recover or poll at once, each run is picked up by exactly one of them.
+     */
+    private resumeLeased;
+    /**
+     * Deliver an external signal to the run waiting on `token` and resume it with `payload`.
+     * Returns the run result, or null if no run is waiting for that token.
+     */
+    /**
+     * Publish a named event. It does two things, and returns how many runs it touched (the sum):
+     *  1. **Resumes** every in-flight run waiting on it via `ctx.waitForEvent(name, { match })` whose
+     *     match the payload satisfies (fan-out, vs `signal`'s point-to-point token).
+     *  2. **Starts** a fresh run of every workflow registered with `onEvent: [name]`, passing the
+     *     payload as input. Idempotent by `evt:<id>:<workflow>` — pass `opts.id` to dedupe redeliveries
+     *     of the same logical event (default: a fresh uuid, so each publish triggers once).
+     */
+    publishEvent(name: string, payload: unknown, opts?: {
+        id?: string;
+    }): Promise<number>;
+    signal(token: string, payload: unknown): Promise<RunResult | null>;
+    /**
+     * Ensure a run exists for `runId`, then deliver a signal to it — atomically race-free thanks to
+     * signal buffering: if the run is new (or busy / not yet waiting), the signal is buffered and
+     * consumed when it reaches `waitForSignal(token)`. The canonical **durable-entity / accumulator**
+     * pattern: one long-lived run per key (the `runId`) that loops on `waitForSignal`, fed events by
+     * many `signalWithStart` calls. `start` is idempotent by `runId`, so concurrent callers converge on
+     * one run. (Use a per-run `token`, e.g. derived from `runId`, so the signal targets this entity.)
+     */
+    signalWithStart(workflow: WorkflowRef, input: unknown, runId: string, signal: {
+        token: string;
+        payload?: unknown;
+    }, opts?: StartOptions): Promise<{
+        runId: string;
+    }>;
+    /**
+     * Report the result of a `ctx.task(name, …)` back to its run (async completion). The external
+     * worker that the task dispatched to calls this when done; the run resumes with `result`. Returns
+     * null if no run is waiting on the task (e.g. a duplicate/late delivery) — a safe no-op.
+     */
+    completeTask(runId: string, name: string, result: unknown): Promise<RunResult | null>;
+    /** Report that a `ctx.task` failed — the run resumes and throws a FatalError at the task. */
+    failTask(runId: string, name: string, error: string): Promise<RunResult | null>;
+    /**
+     * Notify a parent that's waiting on `runId` as a child of its terminal outcome (the `ctx.child`
+     * rendezvous). A no-op when no parent is waiting, so `execute()` can call it on every run without
+     * knowing about the child feature.
+     */
+    private notifyParent;
+    /**
+     * Cancel a run (e.g. from the dashboard). Returns null if the run does not exist. Pass
+     * `{ compensate: true }` to undo the saga first: the suspended run is resumed so its completed
+     * steps' compensations run in reverse (visible as `compensate:<step>` events), then it's marked
+     * cancelled. Without it, cancellation is immediate (no undo).
+     */
+    cancel(runId: string, opts?: {
+        compensate?: boolean;
+    }): Promise<RunResult | null>;
+    /**
+     * Bulk-cancel every run matching a filter — e.g. cancel all `order` runs tagged `vip`, or every run
+     * whose `tier` search attribute is `free`. The filter is a {@link RunQuery} (workflow / status / tag
+     * / search-attribute predicates), so it reuses the same matching the dashboard list uses. Each match
+     * is run through {@link cancel}, so the same plumbing applies per run: child cascade, the optional
+     * saga `compensate`, local cancel listeners, and the control-plane broadcast that tells the owning
+     * worker to abort. Returns one {@link RunResult} per matched run (already-finished matches report
+     * their terminal status — `cancel` is a no-op on them, never clobbering a completed/dead run).
+     */
+    cancelWhere(filter: Omit<RunQuery, 'limit' | 'offset'>, opts?: {
+        compensate?: boolean;
+    }): Promise<RunResult[]>;
+    /**
+     * Cascade cancellation to a run's children — both awaited (`ctx.child`, found via its live
+     * `child:<id>` waiter) and fire-and-forget (`ctx.startChild`, found via its `spawn:<id>`
+     * checkpoint). Recursive, so a whole subtree is cancelled; the terminal guard in `cancel` stops it
+     * at finished / already-cancelled runs (no loops, no re-cancel).
+     */
+    private cancelChildren;
+    /**
+     * The ids of the runs a run spawned — both awaited (`ctx.child`) and fire-and-forget
+     * (`ctx.startChild`, found via its `spawn:<id>` checkpoint). The canonical parent→children edge,
+     * used for both cancellation cascades and the dashboard run-tree.
+     *
+     * An awaited child is discovered two ways, because the live `child:<id>` waiter only exists WHILE
+     * the parent is suspended on it: the waiter resolves and is consumed the moment the child settles,
+     * so a completed parent (or a completed awaited child) would otherwise drop out of the tree. The
+     * `signal:child:<id>` checkpoint (the placeholder written when the parent first awaits the child,
+     * overwritten as completed/failed when it settles) persists across completion, so we read both and
+     * dedupe — the edge stays stable for a finished run, not just a live one.
+     */
+    getRunChildren(parentRunId: string): Promise<string[]>;
+    /** The worker groups this engine dispatches to: every registered remote workflow's group, plus any
+     *  `extra` the caller declares. Local-step groups (a group consumed by in-process `@DurableStep`
+     *  workers, e.g. `pipeline`) aren't derivable from registrations — pass them via `extra` so a group
+     *  with backlog and ZERO workers is still reported (the alert case has no heartbeat to discover). */
+    knownGroups(extra?: string[]): string[];
+    /** Per-group worker health (queue backlog + live worker heartbeats). Covers {@link knownGroups}
+     *  (so a registered group with backlog and ZERO workers still reports — the alert case) UNION the
+     *  groups discovered from live heartbeats (so a local-step group like `pipeline`, not derivable
+     *  from registrations, shows once its workers beat). Empty when no transport can introspect health
+     *  (only the BullMQ transport implements `groupHealth`). */
+    workerHealth(extra?: string[]): Promise<GroupHealth[]>;
+    /**
+     * Persist a streamed local-step lifecycle event from a remote workflow worker (see
+     * {@link WorkflowStepEvent}). A Python `@workflow` runs its `ctx.step`s inline over one turn that
+     * can last minutes; the worker streams each step's start/finish so the engine checkpoints it LIVE —
+     * a step shows `running` the moment its body begins, then resolves to `completed`/`failed` with its
+     * real wall-clock window and sub-process events — instead of every step appearing at once when the
+     * turn ends. The turn's final `recordStep` command re-persists the same (runId, seq) checkpoint
+     * idempotently, so this is purely additive observability and never changes the run's outcome.
+     */
+    private persistStepEvent;
+    /**
+     * Announce a local step's body has begun and (when `trackStepStart`) checkpoint it as `running`,
+     * so it's visible in flight rather than appearing only on completion. The checkpoint is a
+     * placeholder overwritten by {@link completeStep}/{@link failStep}; it never short-circuits replay
+     * (only `completed` does), so a crash mid-body just re-runs the step. The `step.started` event
+     * fires regardless — the live SSE view sees the start even with persistence off.
+     */
+    private startStep;
+    /** Checkpoint a finished step and announce it — the two things that must always happen together. */
+    private completeStep;
+    /** Checkpoint a step that failed terminally, so the failure point is visible (not just the run). */
+    private failStep;
+    private execute;
+    /**
+     * Advance a remote (cross-SDK) workflow one turn: hand its history to the executor (which dispatches
+     * a workflow task to the worker and awaits its replay) and apply the decision. Mirrors
+     * {@link runExecution}'s settle/suspend; the lease is held by {@link execute}. The result that lands
+     * us back here (a remote step finished, a timer fired) goes through `resume` like any TS workflow.
+     */
+    /**
+     * Apply a terminal/suspended transition once: persist the new run status, emit the matching
+     * lifecycle event, and (on completion/failure) wake a waiting parent. Both the TS and remote
+     * executors funnel their completed/failed/suspended outcomes through here so a status update can
+     * never drift from its event or `notifyParent` call. Does NOT touch the run lock — each executor
+     * keeps its own lease handling (the TS executor's `finally`, the remote path's caller).
+     */
+    private settleRun;
+    private runRemoteExecution;
+    /** The run's resolved durable ops as replay inputs: completed/failed steps + elapsed timers. */
+    private remoteHistory;
+    /** Apply a turn's commands: persist recorded local steps, dispatch remote calls, schedule timers.
+     *  Returns the earliest timer deadline to suspend on (or undefined — suspended on a result). */
+    private applyCommands;
+    /** The run body, lease held + renewed by {@link execute}. */
+    private runExecution;
+    /**
+     * Run one saga compensation, retried up to `compensationRetries`, emitting a `compensate:<step>`
+     * step event for its outcome so a stranded undo is visible. Never throws — a permanently-failing
+     * compensation is skipped so it can't mask the original failure.
+     */
+    private runCompensation;
+    /** The seam handed to {@link createWorkflowCtx}: the authoring API reaches durability + lifecycle
+     *  (checkpointing, dispatch, child start) through this, so the ctx primitives live in their own
+     *  module and the engine stays the orchestrator. */
+    private ctxHostFor;
+    /**
+     * Resume a run paused at a {@link WorkflowCtx.breakpoint} (e.g. the dashboard "continue" button).
+     * Finds the run's pending breakpoint checkpoint and signals it. Returns null if the run isn't
+     * paused at a breakpoint.
+     */
+    continue(runId: string): Promise<RunResult | null>;
+    /**
+     * Read the latest value a run published for `key` via {@link WorkflowCtx.setEvent} — a
+     * side-effect-free query of a live (or finished) run's state. Returns `undefined` if the run
+     * never published that key. The suspend-model counterpart of a Temporal query.
+     */
+    getEvent<TValue = unknown>(runId: string, key: string): Promise<TValue | undefined>;
+    /**
+     * Register a validator gating `engine.update(runId, name, …)` for runs of `workflow`. The
+     * validator runs BEFORE the update is delivered, so a rejection leaves the run untouched. One
+     * validator per (workflow, update name); registering again replaces it.
+     */
+    registerUpdateValidator<TArg>(workflow: string, name: string, validate: UpdateValidator<TArg>): void;
+    /**
+     * Deliver a validated update to the run waiting at `ctx.onUpdate(name)`. Runs the registered
+     * validator (if any) first: on rejection returns `{ accepted: false, reason }` without disturbing
+     * the run; otherwise delivers `arg` and resumes, returning `{ accepted: true, run }` (`run` is null
+     * if nothing was waiting — a too-early or duplicate update).
+     */
+    update(runId: string, name: string, arg: unknown): Promise<UpdateResult>;
+    private callRemote;
+    /**
+     * Complete a durable remote step from its worker result and resume the run — runs on whichever
+     * instance receives the result (the dispatching one may be gone), so the run is crash/scale-safe.
+     * A no-op if the checkpoint isn't `pending` (a duplicate or late delivery).
+     */
+    private completeRemoteResult;
+    /**
+     * A slot freed on `queue` (a fleet-wide signal): resume this instance's runs blocked on it so they
+     * re-contend now instead of at their retry tick. Snapshot-and-clear — a run still blocked after the
+     * retry re-registers itself, and one that's gone (cancelled/admitted) is dropped. Best-effort.
+     */
+    private wakeQueueWaiters;
+    /** Release the flow-control slot a dispatched step held (if any), by its stepId. */
+    private releaseQueueSlot;
+    /** In-memory await path for a remote step with a liveness `timeoutMs` (re-dispatch on timeout). */
+    private callRemoteInMemory;
+    /**
+     * Await a remote result, but reject with `RemoteStepTimeout` if neither the result nor a heartbeat
+     * arrives within `timeoutMs`. Each heartbeat (delivered via `transport.onHeartbeat`) rearms the
+     * window, so a worker that keeps beating stays alive past `timeoutMs`.
+     */
+    private awaitWithHeartbeat;
+}
+/** Raised inside the workflow when a remote worker reports a step failure. */
+export declare class RemoteStepError extends Error {
+    readonly stepError?: StepError | undefined;
+    constructor(stepError?: StepError);
+}
+export {};
+//# sourceMappingURL=engine.d.ts.map

package/dist/src/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../src/engine.ts"],"names":[],"mappings":"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"}