bunqueue 2.8.49 → 2.8.50

package/dist/client/workflow/executionTypes.d.ts

@@ -0,0 +1,133 @@
+/** Persisted workflow execution, step outcome, and store coordination types. */
+/** Execution state */
+export type ExecutionState = 'running' | 'waiting' | 'completed' | 'failed' | 'compensating'
+/**
+ * A compensation failed definitively and the unwind stopped. Deliberately NOT
+ * terminal: the run parks until an operator retries or abandons the unwind.
+ */
+ | 'compensation-stuck';
+/** What the engine did after a failure, independently of the failure reason. */
+export type RollbackStatus = 
+/** Every eligible step was compensated successfully. */
+'completed'
+/** The unwind ran past the pivot cutoff or had nothing left to do. */
+ | 'not-applicable'
+/** A compensation failed definitively; remaining reversals were not attempted. */
+ | 'stuck';
+/** Step execution state */
+export type StepState = 'pending' | 'running' | 'completed' | 'failed';
+/** Terminal outcome of one step's rollback. */
+export type CompensationStatus = 'compensated' | 'compensation-failed' | 'compensation-skipped';
+export interface CompensationOutcome {
+    status: CompensationStatus;
+    at: number;
+    /** Why it failed, or why it was skipped. */
+    error?: string;
+}
+/** Record of a step's execution */
+export interface StepRecord {
+    status: StepState;
+    result?: unknown;
+    error?: string;
+    startedAt?: number;
+    completedAt?: number;
+    attempts?: number;
+    /**
+     * Whether this step declared a compensate handler when it ran. This survives a
+     * deployment that removes or renames the definition.
+     */
+    compensatable?: boolean;
+    /** forEach iteration item — persisted so compensation can restore __item */
+    loopItem?: unknown;
+    /** forEach iteration index — persisted so compensation can restore __index */
+    loopIndex?: number;
+    /** Exactly one terminal compensation outcome for every eligible step. */
+    compensation?: CompensationOutcome;
+    /** Idempotency key of the forward execution, persisted before the body runs. */
+    idempotencyKey?: string;
+    /** Child execution owned by a sub-workflow record. */
+    childExecutionId?: string;
+    /** Occurrence of this step name within the run — loops reuse a single name. */
+    occurrence?: number;
+}
+/** Full persisted execution state */
+export interface Execution {
+    id: string;
+    workflowName: string;
+    state: ExecutionState;
+    input: unknown;
+    steps: Record<string, StepRecord>;
+    currentNodeIndex: number;
+    /** Flattened names selected by resolved branch paths. */
+    resolvedSteps?: string[];
+    /** Durable results of control-flow decisions, keyed by node/iteration identity. */
+    decisions?: Record<string, unknown>;
+    /** Structural identity of the sealed workflow definition that started this run. */
+    definitionHash?: string;
+    /** What happened to the rollback. Independent of `failureReason`. */
+    rollbackStatus?: RollbackStatus;
+    /** Why the run failed. Independent of `rollbackStatus`. */
+    failureReason?: string;
+    /**
+     * Node index at which `.pivot()` committed. Once set, backward recovery is off for
+     * the whole saga and recovery is forward-only.
+     */
+    committedAt?: number;
+    signals: Record<string, unknown>;
+    /** Parent execution that owns this sub-workflow child. */
+    parentExecutionId?: string;
+    createdAt: number;
+    updatedAt: number;
+}
+/** Handle returned from engine.start() */
+export interface RunHandle {
+    id: string;
+    workflowName: string;
+}
+/** Stable, bounded pagination for execution listings. */
+export interface ExecutionListOptions {
+    /** Page size. Defaults to 100 and is capped at 1000. */
+    limit?: number;
+    /** Number of rows to skip in the deterministic createdAt/id order. */
+    offset?: number;
+}
+/** Internal job data for step execution */
+export interface StepJobData {
+    executionId: string;
+    workflowName: string;
+    nodeIndex: number;
+}
+/** Result of engine.recover() */
+export interface RecoverResult {
+    /** Number of running executions re-enqueued */
+    running: number;
+    /** Number of waiting executions with re-armed timers */
+    waiting: number;
+    /** Number of compensating executions re-run */
+    compensating: number;
+    /** Total recovered */
+    total: number;
+}
+/** Result of WorkflowStore.recordSignal() */
+export interface SignalOutcome {
+    /** Whether the execution row exists */
+    found: boolean;
+    /** True for the single caller that claimed the resume of a parked run */
+    resumed: boolean;
+    workflowName: string;
+    currentNodeIndex: number;
+}
+/** Result of WorkflowStore.parkForSignal() */
+export interface ParkOutcome {
+    /** The awaited signal was already recorded — advance instead of parking */
+    signalPresent: boolean;
+    /** This caller transitioned the run to 'waiting' */
+    parked: boolean;
+    /** Signals as persisted, for refreshing a stale in-memory snapshot */
+    signals: Record<string, unknown>;
+}
+/** Options for cleanup */
+export interface CleanupOptions {
+    maxAge: number;
+    states?: ExecutionState[];
+}

package/dist/client/workflow/executionTypes.js

@@ -0,0 +1,2 @@
+/** Persisted workflow execution, step outcome, and store coordination types. */
+export {};

package/dist/client/workflow/executor.d.ts

@@ -3,7 +3,7 @@ import type { Queue } from '../queue/queue';
 import type { Workflow } from './workflow';
 import type { WorkflowStore } from './store';
 import type { WorkflowEmitter } from './emitter';
-import type { Execution, StepJobData, RunHandle, RecoverResult } from './types';
+import type { Execution, ExecutionListOptions, StepJobData, RunHandle, RecoverResult } from './types';
 export declare class WorkflowExecutor {
     private readonly store;
     private readonly queue;
@@ -39,28 +39,15 @@ export declare class WorkflowExecutor {
     processStep(data: StepJobData): Promise<unknown>;
     private runNode;
     signal(executionId: string, event: string, payload: unknown): Promise<void>;
+    private get lifecycleDeps();
     /** Retry the compensation that parked the run, then finish the unwind. */
     resumeCompensation(executionId: string): Promise<void>;
     /** Give up on a parked unwind, recording the outstanding steps as skipped. */
     abandonCompensation(executionId: string): void;
     private get rollbackDeps();
     getExecution(id: string): Execution | null;
-    listExecutions(wfName?: string, state?: Execution['state']): Execution[];
-    private executeNode;
-    private runStep;
-    private runBranch;
-    private runParallel;
-    private runSubWorkflow;
-    /**
-     * Commit the saga. From here the run can still fail, but it can no longer be
-     * rolled back: recovery past this point is forward-only.
-     */
-    private runPivot;
-    /**
-     * Run a node body that manages its own step records (loops, forEach, map), then
-     * move on. These differ only in which executor they delegate to.
-     */
-    private runBody;
+    listExecutions(wfName?: string, state?: Execution['state'], options?: ExecutionListOptions): Execution[];
+    private get nodeDeps();
     private advance;
     private enqueue;
     private get waitForDeps();

package/dist/client/workflow/executor.js

@@ -1,13 +1,13 @@
-import { assertNoIndexCollision, assertNoDuplicateWaitFor, unusableEventName } from './workflow';
-import { executeStepWithRetry, executeParallelSteps, executeSubWorkflow, buildContext, } from './runner';
-import { executeDoUntil, executeDoWhile, executeForEach, executeMap } from './loops';
+import { assertNoIndexCollision, assertNoDuplicateWaitFor } from './workflow';
 import { WaitForSignalError, runCompensation } from './compensator';
 import { abandonParkedCompensation, resumeCompensation, } from './rollbackControl';
 import { recoverExecutions } from './recovery';
-import { clearTimers, runWaitFor, scheduleTimeoutCheck } from './waitFor';
-import { clock } from './clock';
+import { clearTimers, scheduleTimeoutCheck } from './waitFor';
 import { describeError } from './identity';
 import { claimKey, decideAdmission } from './admission';
+import { signalExecution, startExecution } from './executorLifecycle';
+import { executeWorkflowNode } from './executorNodes';
+import { bindExecutionDefinition, WorkflowDefinitionMismatchError } from './definitionGuard';
 export class WorkflowExecutor {
     store;
     queue;
@@ -33,6 +33,12 @@ export class WorkflowExecutor {
         };
     }
     register(workflow) {
+        if (this.workflows.has(workflow.name)) {
+            throw new Error(`Workflow "${workflow.name}" is already registered`);
+        }
+        if (workflow.nodes.length === 0) {
+            throw new Error(`Workflow "${workflow.name}" has no steps`);
+        }
         const names = workflow.getStepNames();
         const dupes = names.filter((n, i) => names.indexOf(n) !== i);
         if (dupes.length > 0) {
@@ -40,32 +46,19 @@ export class WorkflowExecutor {
         }
         assertNoIndexCollision(workflow);
         assertNoDuplicateWaitFor(workflow);
+        const definitionHash = workflow.seal();
+        const conflict = this.store
+            .listActive(workflow.name)
+            .find((exec) => exec.state !== 'compensation-stuck' &&
+            exec.definitionHash !== undefined &&
+            exec.definitionHash !== definitionHash);
+        if (conflict) {
+            throw new WorkflowDefinitionMismatchError(conflict.id, workflow.name);
+        }
         this.workflows.set(workflow.name, workflow);
     }
     async start(workflowName, input, parentExecutionId) {
-        const wf = this.workflows.get(workflowName);
-        if (!wf)
-            throw new Error(`Workflow "${workflowName}" not registered`);
-        if (wf.nodes.length === 0)
-            throw new Error(`Workflow "${workflowName}" has no steps`);
-        const now = clock().now();
-        const id = `wf_${now}_${clock().random().toString(36).slice(2, 10)}`;
-        const exec = {
-            id,
-            workflowName,
-            state: 'running',
-            input,
-            steps: {},
-            currentNodeIndex: 0,
-            signals: {},
-            ...(parentExecutionId ? { parentExecutionId } : {}),
-            createdAt: now,
-            updatedAt: now,
-        };
-        this.store.save(exec);
-        this.emitter?.emitWorkflow('workflow:started', id, workflowName, 'running', { input });
-        await this.enqueue(exec);
-        return { id, workflowName };
+        return await startExecution(this.lifecycleDeps, workflowName, input, parentExecutionId);
     }
     /**
      * Nodes this process is currently executing, keyed `<execution>:<nodeIndex>`.
@@ -104,12 +97,13 @@ export class WorkflowExecutor {
         }
     }
     async runNode(data, exec) {
-        // If waiting, set back to running for timeout re-check
-        if (exec.state === 'waiting')
-            exec.state = 'running';
         const wf = this.workflows.get(exec.workflowName);
         if (!wf)
             throw new Error(`Workflow "${exec.workflowName}" not registered`);
+        bindExecutionDefinition(exec, wf, this.updateFn);
+        // If waiting, set back to running for timeout re-check
+        if (exec.state === 'waiting')
+            exec.state = 'running';
         const node = wf.nodes[data.nodeIndex];
         if (!node) {
             exec.state = 'completed';
@@ -118,7 +112,7 @@ export class WorkflowExecutor {
             return null;
         }
         try {
-            await this.executeNode(exec, node, data.nodeIndex, wf);
+            await executeWorkflowNode(this.nodeDeps, exec, node, data.nodeIndex, wf);
         }
         catch (err) {
             if (err instanceof WaitForSignalError)
@@ -141,48 +135,17 @@ export class WorkflowExecutor {
         return null;
     }
     async signal(executionId, event, payload) {
-        // Same predicate as registration. A name that cannot be stored has to fail here
-        // too: a caller who signals it would otherwise get a clean return for a delivery
-        // that went nowhere.
-        const bad = unusableEventName(event);
-        if (bad)
-            throw new Error(`Cannot signal an event ${bad}`);
-        // A finished run cannot receive anything. Accepting it wrote the payload into the
-        // persisted row and emitted `signal:received`, so a dashboard reported an approval
-        // against a run that had already ended and a closed audit record was mutated after
-        // the fact, while the caller got a clean return for a delivery that did nothing.
-        // A signal racing a run to its end is real, and rejecting is how the caller finds
-        // out (`test/repro-workflow-operator-signal.test.ts`).
-        const current = this.store.get(executionId);
-        if (current && current.state !== 'running' && current.state !== 'waiting') {
-            throw new Error(`Execution "${executionId}" is "${current.state}" and cannot receive the signal "${event}"`);
-        }
-        const timer = this.timeoutTimers.get(executionId);
-        if (timer) {
-            clock().clearTimeout(timer);
-            this.timeoutTimers.delete(executionId);
-        }
-        // Record the payload and claim the resume in a single transaction that touches
-        // only the `signals` and `state` columns. Writing through the store — rather than
-        // mutating a snapshot and calling update() — is what keeps a concurrently
-        // executing step from overwriting the payload with its own stale `signals`
-        // (test/repro-workflow-signal-lost-update.test.ts).
-        //
-        // The claim is a conditional `state = 'waiting'` UPDATE, so duplicate or
-        // concurrent signals collapse to exactly one resume and every step after the
-        // waitFor runs exactly once. A signal that lands before the run parks records
-        // its payload and returns; runWaitFor then consumes it via parkForSignal().
-        const outcome = this.store.recordSignal(executionId, event, payload);
-        if (!outcome.found)
-            throw new Error(`Execution "${executionId}" not found`);
-        this.emitter?.emitSignal('signal:received', executionId, outcome.workflowName, event, payload);
-        if (!outcome.resumed)
-            return;
-        await this.queue.add('wf:step', {
-            executionId,
-            workflowName: outcome.workflowName,
-            nodeIndex: outcome.currentNodeIndex,
-        });
+        await signalExecution(this.lifecycleDeps, executionId, event, payload);
+    }
+    get lifecycleDeps() {
+        return {
+            store: this.store,
+            queue: this.queue,
+            workflows: this.workflows,
+            emitter: this.emitter,
+            timers: this.timeoutTimers,
+            enqueue: (exec) => this.enqueue(exec),
+        };
     }
     /** Retry the compensation that parked the run, then finish the unwind. */
     async resumeCompensation(executionId) {
@@ -202,140 +165,19 @@ export class WorkflowExecutor {
     getExecution(id) {
         return this.store.get(id);
     }
-    listExecutions(wfName, state) {
-        return this.store.list(wfName, state);
-    }
-    async executeNode(exec, node, idx, wf) {
-        if (node.type === 'step')
-            await this.runStep(exec, node.def, idx, wf);
-        else if (node.type === 'branch')
-            await this.runBranch(exec, node, idx, wf);
-        else if (node.type === 'parallel')
-            await this.runParallel(exec, node, idx, wf);
-        else if (node.type === 'subWorkflow')
-            await this.runSubWorkflow(exec, node, idx, wf);
-        else if (node.type === 'doUntil')
-            await this.runBody(exec, idx, wf, executeDoUntil, node.def);
-        else if (node.type === 'doWhile')
-            await this.runBody(exec, idx, wf, executeDoWhile, node.def);
-        else if (node.type === 'forEach')
-            await this.runBody(exec, idx, wf, executeForEach, node.def);
-        else if (node.type === 'map')
-            await this.runBody(exec, idx, wf, executeMap, node.def);
-        else if (node.type === 'pivot')
-            await this.runPivot(exec, idx, wf);
-        else
-            await runWaitFor(this.waitForDeps, exec, node, idx, wf);
-    }
-    async runStep(exec, def, idx, wf) {
-        const ctx = buildContext(exec);
-        await executeStepWithRetry(def, ctx, exec, { emitter: this.emitter, updateFn: this.updateFn });
-        await this.advance(exec, idx + 1, wf);
-    }
-    async runBranch(exec, node, idx, wf) {
-        const pathName = node.def.condition(buildContext(exec));
-        const pathSteps = node.def.paths.get(pathName);
-        if (pathSteps && pathSteps.length > 0) {
-            for (const step of pathSteps) {
-                await executeStepWithRetry(step, buildContext(exec), exec, {
-                    emitter: this.emitter,
-                    updateFn: this.updateFn,
-                });
-            }
-        }
-        await this.advance(exec, idx + 1, wf);
-    }
-    async runParallel(exec, node, idx, wf) {
-        await executeParallelSteps(node.def.steps, buildContext(exec), exec, this.emitter, this.updateFn);
-        await this.advance(exec, idx + 1, wf);
-    }
-    async runSubWorkflow(exec, node, idx, wf) {
-        const subInput = node.inputMapper(buildContext(exec));
-        const recordKey = `sub:${node.name}`;
-        try {
-            const { results, executionId } = await executeSubWorkflow(node.name, subInput, 
-            // The child must record who owns it: without this, recovery treats it as a
-            // top-level run and drives it behind this parent's back.
-            async (name, input) => {
-                const handle = await this.start(name, input, exec.id);
-                // Claim it in the parent's record BEFORE waiting on it. The record used to be
-                // written only on completion, so a re-entry after a restart found nothing to
-                // resume and started a second child.
-                //
-                // Awaited rather than done on a side branch: a detached `.then()` on a start
-                // that REJECTS, which is what an unregistered child does, leaves an unhandled
-                // rejection even though the caller handles the same rejection properly.
-                exec.steps[recordKey] = { status: 'running', childExecutionId: handle.id };
-                this.store.update(exec);
-                return handle;
-            }, (id) => this.store.get(id), undefined, exec.steps[recordKey]?.childExecutionId);
-            exec.steps[recordKey] = {
-                status: 'completed',
-                result: results,
-                completedAt: clock().now(),
-                childExecutionId: executionId,
-            };
-        }
-        catch (error) {
-            // Settle the record before letting the failure through.
-            //
-            // Only the success write existed, so every interesting outcome — the child failed,
-            // parked in `compensation-stuck`, or timed out — left the record `running`.
-            // `unwindSet` drops anything that is neither `completed` nor `failed` one line
-            // before the `sub:` branch can admit it, so `unwindChild` was never called: a
-            // parent whose child was parked with stock still reserved reversed its own steps,
-            // reached the end of the pass and reported `rollbackStatus: 'completed'`
-            // (`test/repro-workflow-child-park-inherit.test.ts`).
-            //
-            // It is also the truthful record on its own terms. A `sub:` step left `running`
-            // after the parent has failed reads on a dashboard as a child still in flight.
-            const claimed = exec.steps[recordKey];
-            if (claimed) {
-                exec.steps[recordKey] = {
-                    ...claimed,
-                    status: 'failed',
-                    error: describeError(error),
-                    completedAt: clock().now(),
-                };
-                // Guarded for the same reason as the failure write in `runner.ts`: `error` below
-                // carries the real cause, and letting a write failure propagate instead replaced
-                // it. The child's own diagnostic is what the rollback guide's field table points
-                // an operator at, `... timed out` or `... is parked mid-rollback; resolve it with
-                // resumeCompensation or abandonCompensation`, so destroying it takes away the
-                // pointer to the child.
-                //
-                // This one does not self-heal, which is what made it worth guarding rather than
-                // commenting: the next write succeeds, persists the wrong diagnostic, and the run
-                // goes terminal carrying it
-                // (`test/repro-workflow-step-error-masking.test.ts`).
-                try {
-                    this.store.update(exec);
-                }
-                catch {
-                    // Deliberately swallowed; the in-memory record still settles the `sub:` step, and
-                    // `runNode` re-persists the whole execution one frame up.
-                }
-            }
-            throw error;
-        }
-        await this.advance(exec, idx + 1, wf);
-    }
-    /**
-     * Commit the saga. From here the run can still fail, but it can no longer be
-     * rolled back: recovery past this point is forward-only.
-     */
-    async runPivot(exec, idx, wf) {
-        exec.committedAt = idx;
-        this.store.update(exec);
-        await this.advance(exec, idx + 1, wf);
+    listExecutions(wfName, state, options) {
+        return this.store.list(wfName, state, options);
     }
-    /**
-     * Run a node body that manages its own step records (loops, forEach, map), then
-     * move on. These differ only in which executor they delegate to.
-     */
-    async runBody(exec, idx, wf, run, def) {
-        await run(def, exec, this.emitter, this.updateFn);
-        await this.advance(exec, idx + 1, wf);
+    get nodeDeps() {
+        return {
+            store: this.store,
+            emitter: this.emitter,
+            updateFn: this.updateFn,
+            advance: (exec, nextIdx, wf) => this.advance(exec, nextIdx, wf),
+            start: (name, input, parentId) => this.start(name, input, parentId),
+            enqueue: (exec) => this.enqueue(exec),
+            waitFor: this.waitForDeps,
+        };
     }
     async advance(exec, nextIdx, wf) {
         exec.currentNodeIndex = nextIdx;
@@ -386,7 +228,7 @@ export class WorkflowExecutor {
     }
     /** Recover orphaned executions after a crash/restart */
     async recover() {
-        return recoverExecutions({
+        return await recoverExecutions({
             store: this.store,
             queue: this.queue,
             workflows: this.workflows,

package/dist/client/workflow/executorLifecycle.d.ts

@@ -0,0 +1,18 @@
+/** Durable start and signal publication for WorkflowExecutor. */
+import type { Queue } from '../queue/queue';
+import { type TimerHandle } from './clock';
+import type { WorkflowEmitter } from './emitter';
+import type { WorkflowStore } from './store';
+import type { Execution, RunHandle } from './types';
+import type { Workflow } from './workflow';
+interface LifecycleDeps {
+    store: WorkflowStore;
+    queue: Queue;
+    workflows: ReadonlyMap<string, Workflow>;
+    emitter: WorkflowEmitter | null;
+    timers: Map<string, TimerHandle>;
+    enqueue: (exec: Execution) => Promise<void>;
+}
+export declare function startExecution(deps: LifecycleDeps, workflowName: string, input: unknown, parentExecutionId?: string): Promise<RunHandle>;
+export declare function signalExecution(deps: LifecycleDeps, executionId: string, event: string, payload: unknown): Promise<void>;
+export {};

package/dist/client/workflow/executorLifecycle.js

@@ -0,0 +1,69 @@
+/** Durable start and signal publication for WorkflowExecutor. */
+import { clock } from './clock';
+import { unusableEventName } from './workflow';
+import { newExecutionId } from './identity';
+export async function startExecution(deps, workflowName, input, parentExecutionId) {
+    const wf = deps.workflows.get(workflowName);
+    if (!wf)
+        throw new Error(`Workflow "${workflowName}" not registered`);
+    if (wf.nodes.length === 0)
+        throw new Error(`Workflow "${workflowName}" has no steps`);
+    const now = clock().now();
+    const id = newExecutionId();
+    const exec = {
+        id,
+        workflowName,
+        state: 'running',
+        input,
+        steps: {},
+        currentNodeIndex: 0,
+        signals: {},
+        definitionHash: wf.seal(),
+        ...(parentExecutionId ? { parentExecutionId } : {}),
+        createdAt: now,
+        updatedAt: now,
+    };
+    deps.store.save(exec);
+    deps.emitter?.emitWorkflow('workflow:started', id, workflowName, 'running', { input });
+    try {
+        await deps.enqueue(exec);
+    }
+    catch (error) {
+        // start() cannot return an id when publication fails. Removing the row keeps both
+        // top-level starts and sub-workflow starts from creating an unreachable orphan.
+        deps.store.remove(id);
+        throw error;
+    }
+    return { id, workflowName };
+}
+export async function signalExecution(deps, executionId, event, payload) {
+    const bad = unusableEventName(event);
+    if (bad)
+        throw new Error(`Cannot signal an event ${bad}`);
+    // recordSignal owns the read/check/write transaction. In particular it rejects a
+    // duplicate key before writing, so concurrent deliveries are first-writer-wins.
+    const outcome = deps.store.recordSignal(executionId, event, payload);
+    if (!outcome.found)
+        throw new Error(`Execution "${executionId}" not found`);
+    deps.emitter?.emitSignal('signal:received', executionId, outcome.workflowName, event, payload);
+    if (!outcome.resumed)
+        return;
+    const timer = deps.timers.get(executionId);
+    if (timer) {
+        clock().clearTimeout(timer);
+        deps.timers.delete(executionId);
+    }
+    try {
+        await deps.queue.add('wf:step', {
+            executionId,
+            workflowName: outcome.workflowName,
+            nodeIndex: outcome.currentNodeIndex,
+        });
+    }
+    catch (error) {
+        // Preserve the accepted payload but release the publication claim. Recovery sees
+        // a waiting execution with its signal present and republishes the same node.
+        deps.store.restoreSignalWait(executionId, event, outcome.currentNodeIndex);
+        throw error;
+    }
+}

package/dist/client/workflow/executorNodes.d.ts

@@ -0,0 +1,17 @@
+/** Workflow node dispatch, split from the executor's lifecycle orchestration. */
+import type { WorkflowEmitter } from './emitter';
+import type { WorkflowStore } from './store';
+import type { Execution, RunHandle, WorkflowNode } from './types';
+import { type WaitForDeps } from './waitFor';
+import type { Workflow } from './workflow';
+interface NodeExecutionDeps {
+    store: WorkflowStore;
+    emitter: WorkflowEmitter | null;
+    updateFn: (exec: Execution) => void;
+    advance: (exec: Execution, nextIdx: number, workflow: Workflow) => Promise<void>;
+    start: (name: string, input: unknown, parentId: string) => Promise<RunHandle>;
+    enqueue: (exec: Execution) => Promise<void>;
+    waitFor: WaitForDeps;
+}
+export declare function executeWorkflowNode(deps: NodeExecutionDeps, exec: Execution, node: WorkflowNode, idx: number, wf: Workflow): Promise<void>;
+export {};