bunqueue 2.8.59 → 2.8.60

package/dist/client/workflow/loops.js

@@ -1,9 +1,11 @@
 /**
  * Loop execution logic for the Workflow Engine.
  */
+import { assertWorkflowActive, isWorkflowExecutionClosed } from './executionFence';
 import { executeStepWithRetry, buildContext } from './runner';
-import { forEachItemsDecisionKey, loopDecisionKey, resolveDecision } from './workflowDecisions';
+import { loopDecisionKey, resolveDecision } from './workflowDecisions';
 export { executeMap } from './mapRunner';
+export { executeForEach } from './forEachRunner';
 /**
  * Run one iteration of a loop body step, unless it already ran.
  *
@@ -34,7 +36,10 @@ export { executeMap } from './mapRunner';
  * the opposite, which was true only while a loop compensated its last iteration
  * alone.
  */
-async function runIteration(step, exec, iteration, emitter, updateFn) {
+async function runIteration(step, exec, iteration, hooks) {
+    const { emitter, updateFn } = hooks;
+    const assertActive = hooks.assertActive ?? assertWorkflowActive;
+    assertActive();
     const indexed = `${step.name}:${iteration}`;
     const already = exec.steps[indexed];
     if (already?.status === 'completed') {
@@ -47,9 +52,13 @@ async function runIteration(step, exec, iteration, emitter, updateFn) {
     let thrown;
     let threw = false;
     try {
-        await executeStepWithRetry(step, buildContext(exec), exec, { emitter, updateFn }, iteration);
+        await executeStepWithRetry(step, buildContext(exec), exec, { emitter, updateFn, assertActive }, iteration);
+        assertActive();
     }
     catch (error) {
+        if (isWorkflowExecutionClosed(error))
+            throw error;
+        assertActive();
         // Caught rather than left to a `finally`, because the mirror write below must not be
         // able to REPLACE this error. An exception thrown from a `finally` supersedes the one
         // in flight, so a store that refused the mirror write turned "provider timeout after
@@ -88,6 +97,8 @@ async function runIteration(step, exec, iteration, emitter, updateFn) {
                 updateFn(exec);
             }
             catch (writeError) {
+                if (isWorkflowExecutionClosed(writeError))
+                    throw writeError;
                 if (!threw)
                     throw writeError;
             }
@@ -97,29 +108,35 @@ async function runIteration(step, exec, iteration, emitter, updateFn) {
         throw thrown;
 }
 /** Execute a doUntil loop: run steps, then check condition. Repeat until condition returns true. */
-export async function executeDoUntil(def, exec, emitter, updateFn) {
+export async function executeDoUntil(def, exec, emitter, updateFn, assertActive = assertWorkflowActive) {
+    assertActive();
     let iteration = 0;
     let shouldStop = false;
     while (!shouldStop) {
+        assertActive();
         if (iteration >= def.maxIterations) {
             throw new Error(`doUntil exceeded maxIterations (${def.maxIterations})`);
         }
         for (const step of def.steps) {
-            await runIteration(step, exec, iteration, emitter, updateFn);
+            await runIteration(step, exec, iteration, { emitter, updateFn, assertActive });
+            assertActive();
         }
         iteration++;
         const ctx = buildContext(exec);
-        shouldStop = await resolveDecision(exec, loopDecisionKey('doUntil', def.steps[0].name, iteration), () => def.condition(ctx, iteration), updateFn);
+        shouldStop = await resolveDecision(exec, loopDecisionKey('doUntil', def.steps[0].name, iteration), () => def.condition(ctx, iteration), updateFn, assertActive);
+        assertActive();
         if (typeof shouldStop !== 'boolean') {
             throw new Error('doUntil condition must return a boolean');
         }
     }
 }
 /** Execute a doWhile loop: check condition first, then run steps. Repeat while condition is true. */
-export async function executeDoWhile(def, exec, emitter, updateFn) {
+export async function executeDoWhile(def, exec, emitter, updateFn, assertActive = assertWorkflowActive) {
+    assertActive();
     for (let iteration = 0;; iteration++) {
         const ctx = buildContext(exec);
-        const shouldContinue = await resolveDecision(exec, loopDecisionKey('doWhile', def.steps[0].name, iteration), () => def.condition(ctx, iteration), updateFn);
+        const shouldContinue = await resolveDecision(exec, loopDecisionKey('doWhile', def.steps[0].name, iteration), () => def.condition(ctx, iteration), updateFn, assertActive);
+        assertActive();
         if (typeof shouldContinue !== 'boolean') {
             throw new Error('doWhile condition must return a boolean');
         }
@@ -129,91 +146,8 @@ export async function executeDoWhile(def, exec, emitter, updateFn) {
             throw new Error(`doWhile exceeded maxIterations (${def.maxIterations})`);
         }
         for (const step of def.steps) {
-            await runIteration(step, exec, iteration, emitter, updateFn);
-        }
-    }
-}
-/** Execute a forEach loop: iterate over items, executing the step for each */
-export async function executeForEach(def, exec, emitter, updateFn) {
-    const ctx = buildContext(exec);
-    const items = await resolveDecision(exec, forEachItemsDecisionKey(def.step.name), () => structuredClone(def.items(ctx)), updateFn);
-    // Anything with a `length` used to be accepted, and JavaScript is generous about
-    // what has one. A number iterated ZERO times and the run reported `completed`, so a
-    // batch that processed nothing was indistinguishable from a batch with nothing to
-    // do. A string iterated its CHARACTERS, so an id list that arrived as `'u1,u2'`
-    // silently processed five "items" nobody passed. `null`/`undefined` were caught only
-    // by accident, because reading `.length` throws. The likely production shapes were
-    // exactly the ones that passed (`test/repro-workflow-foreach-non-array.test.ts`).
-    if (!Array.isArray(items)) {
-        throw new Error(`forEach items must be an array, got ${items === null ? 'null' : typeof items}`);
-    }
-    if (items.length > def.maxIterations) {
-        throw new Error(`forEach items (${items.length}) exceeds maxIterations (${def.maxIterations})`);
-    }
-    for (let i = 0; i < items.length; i++) {
-        const item = structuredClone(items[i]);
-        const indexedName = `${def.step.name}:${i}`;
-        const indexedStep = {
-            ...def.step,
-            name: indexedName,
-            handler: (stepCtx) => {
-                const enrichedCtx = {
-                    ...stepCtx,
-                    steps: { ...stepCtx.steps, __item: item, __index: i },
-                };
-                return def.step.handler(enrichedCtx);
-            },
-        };
-        // Memoised the same way as doUntil/doWhile: an item already provisioned before a
-        // crash must not be provisioned again when the node is re-entered. Restore the
-        // declared bare name too: it is the public result of the final iteration, while
-        // the indexed record remains the durable execution/compensation identity.
-        const completed = exec.steps[indexedName];
-        if (completed?.status === 'completed') {
-            exec.steps[def.step.name] = { ...completed };
-            updateFn(exec);
-            continue;
-        }
-        const stepCtx = buildContext(exec);
-        let thrown;
-        let threw = false;
-        try {
-            await executeStepWithRetry(indexedStep, stepCtx, exec, { emitter, updateFn }, i);
-        }
-        catch (error) {
-            // Same reason `runIteration` catches instead of using a `finally`: a write that
-            // fails below must not REPLACE the step's own error, which is what `failureReason`
-            // records and the only account of what went wrong.
-            thrown = error;
-            threw = true;
-        }
-        {
-            // Persist this iteration's __item/__index alongside the step record so saga
-            // compensation can restore the correct per-iteration context later.
-            //
-            // Recording on BOTH paths is load-bearing: the iteration that THROWS is itself
-            // eligible for compensation, and without its item recorded its compensate handler
-            // is handed an undefined `__item` and silently releases nothing — the reservation
-            // it had already taken at the warehouse leaks
-            // (test/workflow-saga-extreme.test.ts).
-            const record = exec.steps[indexedName];
-            if (record) {
-                record.loopItem = item;
-                record.loopIndex = i;
-                // Keep the documented aggregate view in sync on success and failure. The
-                // indexed record is still the authoritative unit of work; compensator.ts
-                // excludes this mirror whenever an indexed sibling exists.
-                exec.steps[def.step.name] = { ...record };
-                try {
-                    updateFn(exec);
-                }
-                catch (writeError) {
-                    if (!threw)
-                        throw writeError;
-                }
-            }
+            await runIteration(step, exec, iteration, { emitter, updateFn, assertActive });
+            assertActive();
         }
-        if (threw)
-            throw thrown;
     }
 }

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

@@ -1,4 +1,4 @@
 import type { WorkflowEmitter } from './emitter';
 import type { Execution, MapDefinition } from './types';
 /** Execute a map node with the same durable lifecycle signals as a regular step. */
-export declare function executeMap(def: MapDefinition, exec: Execution, emitter: WorkflowEmitter | null, updateFn: (exec: Execution) => void): Promise<void>;
+export declare function executeMap(def: MapDefinition, exec: Execution, emitter: WorkflowEmitter | null, updateFn: (exec: Execution) => void, assertActive?: () => void): Promise<void>;

package/dist/client/workflow/mapRunner.js

@@ -1,19 +1,26 @@
 import { clock } from './clock';
+import { assertWorkflowActive, isWorkflowExecutionClosed } from './executionFence';
 import { describeError } from './identity';
 import { buildContext } from './runner';
 /** Execute a map node with the same durable lifecycle signals as a regular step. */
-export async function executeMap(def, exec, emitter, updateFn) {
+export async function executeMap(def, exec, emitter, updateFn, assertActive = assertWorkflowActive) {
+    assertActive();
     if (exec.steps[def.name]?.status === 'completed')
         return;
     const startedAt = clock().now();
     exec.steps[def.name] = { status: 'running', startedAt };
     updateFn(exec);
     emitter?.emitStep('step:started', exec.id, exec.workflowName, def.name);
+    assertActive();
     let result;
     try {
         result = await def.transform(buildContext(exec));
+        assertActive();
     }
     catch (error) {
+        if (isWorkflowExecutionClosed(error))
+            throw error;
+        assertActive();
         const failure = error instanceof Error ? error : new Error(describeError(error));
         exec.steps[def.name] = {
             status: 'failed',
@@ -24,7 +31,9 @@ export async function executeMap(def, exec, emitter, updateFn) {
         try {
             updateFn(exec);
         }
-        catch {
+        catch (writeError) {
+            if (isWorkflowExecutionClosed(writeError))
+                throw writeError;
             // Preserve the transform failure; generic workflow failure handling retries the write.
         }
         emitter?.emitStep('step:failed', exec.id, exec.workflowName, def.name, {

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

@@ -27,5 +27,6 @@ export interface RecoverDeps {
      * the ordinary way to reach this.
      */
     nodesInFlight: ReadonlySet<string>;
+    assertActive: () => void;
 }
 export declare function recoverExecutions(deps: RecoverDeps): Promise<RecoverResult>;

package/dist/client/workflow/recovery.js

@@ -11,11 +11,14 @@ import { hasSignal } from './storeSignals';
 import { clock } from './clock';
 import { decideAdmission } from './admission';
 import { bindExecutionDefinition } from './definitionGuard';
+import { enqueueWorkflowStep } from './executorQueue';
 export async function recoverExecutions(deps) {
     const { store, workflows } = deps;
+    deps.assertActive();
     const executions = store.listRecoverable();
     const result = { running: 0, waiting: 0, compensating: 0, total: 0 };
     for (const snapshot of executions) {
+        deps.assertActive();
         const wf = workflows.get(snapshot.workflowName);
         if (!wf)
             continue;
@@ -36,12 +39,14 @@ export async function recoverExecutions(deps) {
             // Only `already-in-flight` is reachable here: the state is `running` by the
             // branch and the index is the execution's own cursor.
             if (admission.kind === 'run') {
-                await enqueueExecution(exec, deps.queue);
+                await enqueueWorkflowStep(deps.queue, exec, deps.assertActive);
+                deps.assertActive();
                 result.running++;
             }
         }
         else if (exec.state === 'waiting') {
             await recoverWaiting(exec, wf, deps);
+            deps.assertActive();
             result.waiting++;
         }
         else if (exec.state === 'compensating' ||
@@ -51,8 +56,10 @@ export async function recoverExecutions(deps) {
             // recoverable until runCompensation writes an explicit rollbackStatus.
             // A lost claim means another driver owns this unwind, so nothing happened here
             // and counting it as a recovery would overstate what recover() did.
-            if (await recoverCompensation(exec.id, wf, deps))
+            if (await recoverCompensation(exec.id, wf, deps)) {
+                deps.assertActive();
                 result.compensating++;
+            }
         }
     }
     result.total = result.running + result.waiting + result.compensating;
@@ -60,6 +67,7 @@ export async function recoverExecutions(deps) {
 }
 async function recoverCompensation(executionId, wf, deps) {
     while (true) {
+        deps.assertActive();
         const exec = deps.store.get(executionId);
         if (!exec ||
             (exec.state !== 'compensating' &&
@@ -67,7 +75,10 @@ async function recoverCompensation(executionId, wf, deps) {
             return false;
         }
         bindExecutionDefinition(exec, wf, (value) => deps.store.update(value));
-        const outcome = await runCompensation(exec, wf, deps.store, deps.emitter, deps.workflows);
+        const outcome = await runCompensation(exec, wf, deps.store, deps.emitter, deps.workflows, {
+            assertActive: deps.assertActive,
+        });
+        deps.assertActive();
         if (outcome === 'ran')
             return true;
         // A live unwind owned by this executor's store is not orphaned. Waiting here
@@ -80,33 +91,25 @@ async function recoverCompensation(executionId, wf, deps) {
         // identity, so it waits for that owner, then re-reads the durable row: it may have
         // finished, or this engine must resume the owed unwind.
         await outcome.settled;
+        deps.assertActive();
     }
 }
-async function enqueueExecution(exec, queue) {
-    const jobData = {
-        executionId: exec.id,
-        workflowName: exec.workflowName,
-        nodeIndex: exec.currentNodeIndex,
-    };
-    // No deterministic jobId, for the reason documented in WorkflowExecutor.enqueue:
-    // the duplicate this path can create is neutralised by the cursor guard in
-    // processStep, and dedup here risks swallowing a legitimate re-enqueue after a
-    // restart, which wedges the run for good.
-    await queue.add('wf:step', jobData);
-}
 async function recoverWaiting(exec, wf, deps) {
     const node = wf.nodes[exec.currentNodeIndex];
     if (node?.type !== 'waitFor') {
-        await enqueueExecution(exec, deps.queue);
+        await enqueueWorkflowStep(deps.queue, exec, deps.assertActive);
+        deps.assertActive();
         return;
     }
     // The signal may have been persisted before the crash, or accepted after this
     // engine was recreated but before recover() reached the row. Key presence, not
     // value: a payload-less signal records the key with an `undefined` value.
     if (hasSignal(exec.signals, node.event)) {
+        deps.assertActive();
         exec.state = 'running';
         deps.store.update(exec);
-        await enqueueExecution(exec, deps.queue);
+        await enqueueWorkflowStep(deps.queue, exec, deps.assertActive);
+        deps.assertActive();
         return;
     }
     // Re-arm timeout if configured
@@ -119,11 +122,14 @@ async function recoverWaiting(exec, wf, deps) {
         const elapsed = clock().now() - waitingSince;
         const remaining = node.timeout - elapsed;
         if (remaining <= 0) {
+            deps.assertActive();
             exec.state = 'running';
             deps.store.update(exec);
-            await enqueueExecution(exec, deps.queue);
+            await enqueueWorkflowStep(deps.queue, exec, deps.assertActive);
+            deps.assertActive();
         }
         else {
+            deps.assertActive();
             deps.scheduleTimeoutCheck(exec.id, exec.workflowName, exec.currentNodeIndex, remaining);
         }
     }

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

@@ -14,6 +14,7 @@ export interface RollbackDeps {
     store: WorkflowStore;
     emitter: WorkflowEmitter | null;
     workflows: Map<string, Workflow>;
+    assertActive: () => void;
 }
 /**
  * Retry the compensation that parked the run, then carry on with the rest.

package/dist/client/workflow/rollbackControl.js

@@ -25,8 +25,9 @@ import { abandonCompensation, runCompensation } from './compensator';
  * the parked run exactly as the operator found it.
  */
 export async function resumeCompensation(deps, executionId) {
+    deps.assertActive();
     const { exec, wf } = parked(deps, executionId);
-    const outcome = await runCompensation(exec, wf, deps.store, deps.emitter, deps.workflows, { retryFailed: true });
+    const outcome = await runCompensation(exec, wf, deps.store, deps.emitter, deps.workflows, { retryFailed: true, assertActive: deps.assertActive });
     if (outcome !== 'ran') {
         // Nothing was mutated: `runCompensation` returns this before the unwind begins.
         throw new Error(`execution "${executionId}" is already being rolled back by another driver`);
@@ -34,10 +35,12 @@ export async function resumeCompensation(deps, executionId) {
 }
 /** Accept a partial rollback: the outstanding steps are recorded as skipped. */
 export function abandonParkedCompensation(deps, executionId) {
+    deps.assertActive();
     const { exec, wf } = parked(deps, executionId);
-    abandonCompensation(exec, wf, deps.store, deps.emitter);
+    abandonCompensation(exec, wf, deps.store, deps.emitter, deps.assertActive);
 }
 function parked(deps, executionId) {
+    deps.assertActive();
     const exec = deps.store.get(executionId);
     if (!exec)
         throw new Error(`Execution "${executionId}" not found`);

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

@@ -10,11 +10,13 @@ export { executeSubWorkflow } from './subWorkflowRunner';
 export interface StepHooks {
     emitter: WorkflowEmitter | null;
     updateFn: (exec: Execution) => void;
+    assertActive?: () => void;
 }
+export { isWorkflowExecutionClosed, WorkflowExecutionClosedError } from './executionFence';
 /** Execute a step with retry logic and exponential backoff */
 export declare function executeStepWithRetry(def: StepDefinition, ctx: StepContext, exec: Execution, hooks: StepHooks, occurrence?: number): Promise<void>;
 /** Execute multiple steps in parallel via Promise.allSettled */
-export declare function executeParallelSteps(steps: StepDefinition[], ctx: StepContext, exec: Execution, emitter: WorkflowEmitter | null, updateFn: (exec: Execution) => void): Promise<void>;
+export declare function executeParallelSteps(steps: StepDefinition[], ctx: StepContext, exec: Execution, hooks: StepHooks): Promise<void>;
 /** Find a step definition by name across all node types */
 export declare function findStepDef(wf: Workflow, name: string): StepDefinition | null;
 /** Build a StepContext from the current execution state */

package/dist/client/workflow/runner.js

@@ -4,11 +4,15 @@
 import { idempotencyKey, isIterationOf, describeError } from './identity';
 import { clock } from './clock';
 import { retryBackoffDelay, runWithTimeout } from './runnerTiming';
+import { assertWorkflowActive, isWorkflowExecutionClosed } from './executionFence';
 export { runWithTimeout } from './runnerTiming';
 export { executeSubWorkflow } from './subWorkflowRunner';
+export { isWorkflowExecutionClosed, WorkflowExecutionClosedError } from './executionFence';
 /** Execute a step with retry logic and exponential backoff */
 export async function executeStepWithRetry(def, ctx, exec, hooks, occurrence = 0) {
     const { emitter, updateFn } = hooks;
+    const assertActive = hooks.assertActive ?? assertWorkflowActive;
+    assertActive();
     const maxAttempts = def.retry;
     const current = exec.steps[def.name];
     const previous = current && (current.occurrence ?? 0) === occurrence ? current : undefined;
@@ -29,6 +33,7 @@ export async function executeStepWithRetry(def, ctx, exec, hooks, occurrence = 0
     let inputParsed = false;
     let finalAttempt = attemptsUsed;
     for (let attempt = attemptsUsed + 1; attempt <= maxAttempts; attempt++) {
+        assertActive();
         finalAttempt = attempt;
         exec.steps[def.name] = {
             status: 'running',
@@ -42,6 +47,7 @@ export async function executeStepWithRetry(def, ctx, exec, hooks, occurrence = 0
             attempt,
             maxAttempts,
         });
+        assertActive();
         try {
             if (!inputParsed) {
                 inputParsed = true;
@@ -55,6 +61,7 @@ export async function executeStepWithRetry(def, ctx, exec, hooks, occurrence = 0
                 catch (error) {
                     inputValidationError = new Error(`Input validation failed for "${def.name}": ${describeError(error)}`, { cause: error });
                 }
+                assertActive();
             }
             if (inputValidationError)
                 throw inputValidationError;
@@ -64,7 +71,9 @@ export async function executeStepWithRetry(def, ctx, exec, hooks, occurrence = 0
                 input: validatedInput,
                 signal: controller.signal,
             };
+            assertActive();
             let result = await runWithTimeout(def.handler(handlerCtx), def.timeout, controller);
+            assertActive();
             if (def.outputSchema) {
                 try {
                     const parsed = def.outputSchema.parse(result);
@@ -76,7 +85,9 @@ export async function executeStepWithRetry(def, ctx, exec, hooks, occurrence = 0
                         cause: e,
                     });
                 }
+                assertActive();
             }
+            assertActive();
             exec.steps[def.name] = {
                 status: 'completed',
                 compensatable: def.compensate !== undefined,
@@ -96,6 +107,9 @@ export async function executeStepWithRetry(def, ctx, exec, hooks, occurrence = 0
             return;
         }
         catch (err) {
+            if (isWorkflowExecutionClosed(err))
+                throw err;
+            assertActive();
             lastError = err instanceof Error ? err : new Error(describeError(err));
             if (attempt < maxAttempts) {
                 emitter?.emitStep('step:retry', exec.id, exec.workflowName, def.name, {
@@ -103,12 +117,15 @@ export async function executeStepWithRetry(def, ctx, exec, hooks, occurrence = 0
                     attempt,
                     maxAttempts,
                 });
+                assertActive();
                 await new Promise((r) => clock().setTimeout(() => r(), retryBackoffDelay(attempt)));
+                assertActive();
                 continue;
             }
         }
     }
     const finalError = lastError ?? new Error('Step failed');
+    assertActive();
     exec.steps[def.name] = {
         status: 'failed',
         compensatable: def.compensate !== undefined,
@@ -135,7 +152,9 @@ export async function executeStepWithRetry(def, ctx, exec, hooks, occurrence = 0
     try {
         updateFn(exec);
     }
-    catch {
+    catch (error) {
+        if (isWorkflowExecutionClosed(error))
+            throw error;
         // Deliberately swallowed: `finalError` is thrown below and carries the real cause.
     }
     emitter?.emitStep('step:failed', exec.id, exec.workflowName, def.name, {
@@ -146,8 +165,12 @@ export async function executeStepWithRetry(def, ctx, exec, hooks, occurrence = 0
     throw finalError;
 }
 /** Execute multiple steps in parallel via Promise.allSettled */
-export async function executeParallelSteps(steps, ctx, exec, emitter, updateFn) {
-    const results = await Promise.allSettled(steps.map((def) => executeStepWithRetry(def, ctx, exec, { emitter, updateFn })));
+export async function executeParallelSteps(steps, ctx, exec, hooks) {
+    const { emitter, updateFn } = hooks;
+    const assertActive = hooks.assertActive ?? assertWorkflowActive;
+    assertActive();
+    const results = await Promise.allSettled(steps.map((def) => executeStepWithRetry(def, ctx, exec, { emitter, updateFn, assertActive })));
+    assertActive();
     const failed = results.filter((r) => r.status === 'rejected');
     if (failed.length > 0) {
         const errors = failed.map((r) => r.reason instanceof Error ? r.reason : new Error(describeError(r.reason)));

package/dist/client/workflow/stepTypes.js

@@ -1,3 +1,3 @@
-/* biome-ignore-all lint/suspicious/noExplicitAny: runtime definitions intentionally erase accumulated generics */
+/* oxlint-disable typescript/no-explicit-any -- runtime definitions intentionally erase accumulated generics */
 /** Workflow handler, definition, and graph types. */
 export {};

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

@@ -3,6 +3,7 @@ export interface SubWorkflowRunOptions {
     pollIntervalMs?: number;
     maxWaitMs?: number;
     existingChildId?: string;
+    assertActive?: () => void;
 }
 /** Start or resume a child execution and poll its durable terminal state. */
 export declare function executeSubWorkflow(workflowName: string, input: unknown, startFn: (name: string, input: unknown) => Promise<{

package/dist/client/workflow/subWorkflowRunner.js

@@ -1,9 +1,12 @@
 import { clock } from './clock';
+import { assertWorkflowActive } from './executionFence';
 const MAX_TIMER_DELAY_MS = 2_147_483_647;
 /** Start or resume a child execution and poll its durable terminal state. */
 export async function executeSubWorkflow(workflowName, input, startFn, getFn, options = {}) {
     const pollIntervalMs = options.pollIntervalMs ?? 100;
     const maxWaitMs = options.maxWaitMs ?? 300_000;
+    const assertActive = options.assertActive ?? assertWorkflowActive;
+    assertActive();
     if (!Number.isFinite(pollIntervalMs) || pollIntervalMs <= 0) {
         throw new Error('Sub-workflow pollIntervalMs must be finite and greater than 0');
     }
@@ -11,10 +14,13 @@ export async function executeSubWorkflow(workflowName, input, startFn, getFn, op
         throw new Error('Sub-workflow maxWaitMs must be finite and greater than 0');
     }
     // Resume a durable child claimed by an earlier entry into this parent node.
+    assertActive();
     const existing = options.existingChildId ? getFn(options.existingChildId) : null;
     const handle = existing ? { id: existing.id } : await startFn(workflowName, input);
+    assertActive();
     const startedAt = existing?.createdAt ?? getFn(handle.id)?.createdAt ?? clock().now();
     for (;;) {
+        assertActive();
         const subExec = getFn(handle.id);
         if (subExec?.state === 'completed') {
             const results = {};
@@ -36,5 +42,6 @@ export async function executeSubWorkflow(workflowName, input, startFn, getFn, op
             throw new Error(`Sub-workflow "${workflowName}" (${handle.id}) timed out after ${maxWaitMs}ms`);
         }
         await new Promise((resolve) => clock().setTimeout(() => resolve(), Math.min(pollIntervalMs, remaining, MAX_TIMER_DELAY_MS)));
+        assertActive();
     }
 }

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

@@ -18,6 +18,8 @@ export declare const MAX_TIMER_MS = 2147483647;
 export interface TimerDeps {
     queue: Queue;
     timers: Map<string, TimerHandle>;
+    assertActive: () => void;
+    isActive: () => boolean;
 }
 export interface WaitForDeps {
     store: WorkflowStore;
@@ -25,6 +27,8 @@ export interface WaitForDeps {
     advance: (exec: Execution, nextIdx: number, wf: Workflow) => Promise<void>;
     compensate: (exec: Execution, wf: Workflow) => Promise<void>;
     scheduleTimeoutCheck: (execId: string, workflowName: string, nodeIdx: number, ms: number) => void;
+    updateFn: (exec: Execution) => void;
+    assertActive: () => void;
 }
 /**
  * Arm the timer that re-enters a parked node once its wait budget elapses.