@dudousxd/nestjs-durable-core 0.27.0 → 0.28.0

package/dist/engine.d.ts

@@ -1,525 +0,0 @@
-import { type EntityConfig } from './entities';
-import { type EventBatchConfig } from './event-accumulators';
-import type { ControlPlane, EngineListener, GroupHealth, NamedTransport, RunDispatcher, RunResult, SearchAttributes, StateStore, StepError, StepInterceptor, Transport, UpdateResult, UpdateValidator, WorkflowCtx, WorkflowExecutor, WorkflowRun } from './interfaces';
-import { type QueueConfig } from './queue';
-import { type WorkflowClass, type WorkflowInputOf, type WorkflowRef } from './workflow-ref';
-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[];
-    /** Typed, queryable run data stamped on the run (e.g. `{ amount: 200, tier: 'pro' }`). */
-    searchAttributes?: SearchAttributes;
-}
-/**
- * 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;
-}
-export interface WorkflowEngineDeps {
-    store: StateStore;
-    /** A single task transport. Shorthand for a one-entry `transports` pool (id `default`). */
-    transport?: Transport;
-    /**
-     * 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[];
-    /**
-     * 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;
-    /** Epoch-ms clock; injectable for tests. Defaults to `Date.now`. */
-    clock?: () => number;
-    /** Unique id for this engine instance, used for recovery leases. Defaults to a random id. */
-    instanceId?: string;
-    /** Recovery lease duration in ms — how long this instance owns a run it picked up. Default 30s. */
-    leaseMs?: number;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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;
-}
-/**
- * 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;
-    /** 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 queues for remote steps, keyed by name (see {@link registerQueue}). */
-    private readonly queues;
-    /** 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[];
-        singleton?: SingletonConfig;
-        executionTimeout?: string | number;
-        validateInput?: (input: unknown) => void | Promise<void>;
-        onEvent?: string[];
-        eventBatch?: EventBatchConfig;
-    }): 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>;
-    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>;
-    /**
-     * 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;
-    /**
-     * Whether `run` may run now under its singleton key: it's among the `limit` oldest in-flight runs
-     * (running or suspended) sharing the key, by `(createdAt, id)` order. A consistent store gives every
-     * instance the same ordering, so admission is race-free + FIFO.
-     */
-    private admitSingleton;
-    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.
-     */
-    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 get ctxHost();
-    /**
-     * 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;
-    /** 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;
-    constructor(stepError?: StepError);
-}
-export {};
-//# sourceMappingURL=engine.d.ts.map

package/dist/engine.d.ts.map

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