bunqueue 2.8.59 → 2.9.0

package/dist/client/forwarder.d.ts

@@ -5,11 +5,13 @@
  * The edge pattern: jobs buffer in the local queue (typically embedded
  * SQLite on a gateway); the Forwarder drains them to a central server over
  * TCP/TLS. A remote failure makes the local job fail → local retry/backoff →
- * local DLQ, so nothing is lost while the uplink is down.
+ * local DLQ. With a persistent local `dataPath`, queued work survives uplink
+ * outages and process restarts; memory-only sources provide no such guarantee.
  *
  * Idempotency: every forwarded job carries the deterministic remote jobId
- * `fwd:<localQueueKey>:<localJobId>`. The server dedupes custom jobIds, so a
- * re-forward after a crash or retry never duplicates the job remotely.
+ * `fwd:<localQueueKey>:<localJobId>`. The server dedupes custom jobIds while
+ * their ownership is retained; after bounded retention or removal, downstream
+ * effects must still tolerate at-least-once delivery.
  */
 import { EventEmitter } from 'events';
 import type { ConnectionOptions, QueueOptions } from './types';
@@ -21,7 +23,7 @@ export interface ForwardOptions {
     queue?: string;
     /** Parallel forwards (default: 4) */
     concurrency?: number;
-    /** Push to the remote with durable: true (immediate fsync server-side) */
+    /** Push with durable: true (bypasses SQLite buffering; PostgreSQL is already transactional). */
     durable?: boolean;
 }
 /** Source queue identity + config, provided by Queue.forward() */

package/dist/client/forwarder.js

@@ -5,11 +5,13 @@
  * The edge pattern: jobs buffer in the local queue (typically embedded
  * SQLite on a gateway); the Forwarder drains them to a central server over
  * TCP/TLS. A remote failure makes the local job fail → local retry/backoff →
- * local DLQ, so nothing is lost while the uplink is down.
+ * local DLQ. With a persistent local `dataPath`, queued work survives uplink
+ * outages and process restarts; memory-only sources provide no such guarantee.
  *
  * Idempotency: every forwarded job carries the deterministic remote jobId
- * `fwd:<localQueueKey>:<localJobId>`. The server dedupes custom jobIds, so a
- * re-forward after a crash or retry never duplicates the job remotely.
+ * `fwd:<localQueueKey>:<localJobId>`. The server dedupes custom jobIds while
+ * their ownership is retained; after bounded retention or removal, downstream
+ * effects must still tolerate at-least-once delivery.
  */
 import { EventEmitter } from 'events';
 import { Worker } from './worker';

package/dist/client/queue/dlq.d.ts

@@ -52,6 +52,8 @@ export declare function purgeDlq(ctx: DlqContext): number;
  * purge-then-assert-empty patterns need this variant.
  */
 export declare function purgeDlqAsync(ctx: DlqContext): Promise<number>;
+/** Remove one DLQ entry without re-enqueuing it. */
+export declare function removeDlqJobAsync(ctx: DlqContext, id: string): Promise<boolean>;
 /** Retry completed job */
 export declare function retryCompleted(ctx: DlqContext, id?: string): number;
 /** Retry completed job (async) */

package/dist/client/queue/dlq.js

@@ -197,6 +197,20 @@ export async function purgeDlqAsync(ctx) {
         return 0;
     return (response.count ?? 0);
 }
+/** Remove one DLQ entry without re-enqueuing it. */
+export async function removeDlqJobAsync(ctx, id) {
+    if (ctx.embedded)
+        return dlqOps.removeDlqJobEmbedded(ctx.name, id);
+    if (!ctx.tcp)
+        return false;
+    const response = await ctx.tcp.send({ cmd: 'RemoveDlqJob', queue: ctx.name, jobId: id });
+    if (!response.ok) {
+        const error = typeof response.error === 'string' ? response.error : 'Failed to remove the DLQ job';
+        throw new Error(error);
+    }
+    const payload = response;
+    return payload.data?.removed === true;
+}
 /** Retry completed job */
 export function retryCompleted(ctx, id) {
     if (ctx.embedded) {

package/dist/client/queue/dlqOps.d.ts

@@ -18,6 +18,8 @@ export declare function retryDlqByFilterEmbedded(queue: string, filter: DlqFilte
 export declare function retryDlqEmbedded(queue: string, id?: string): number;
 /** Purge DLQ (embedded) */
 export declare function purgeDlqEmbedded(queue: string): number;
+/** Remove one DLQ entry in embedded mode. */
+export declare function removeDlqJobEmbedded(queue: string, id: string): boolean;
 /** Set stall config (embedded only) */
 export declare function setStallConfigEmbedded(queue: string, config: Record<string, unknown>): void;
 /** Get stall config (embedded only) */

package/dist/client/queue/dlqOps.js

@@ -50,6 +50,10 @@ export function retryDlqEmbedded(queue, id) {
 export function purgeDlqEmbedded(queue) {
     return getSharedManager().purgeDlq(queue);
 }
+/** Remove one DLQ entry in embedded mode. */
+export function removeDlqJobEmbedded(queue, id) {
+    return getSharedManager().removeDlqJob(queue, jobId(id));
+}
 /** Set stall config (embedded only) */
 export function setStallConfigEmbedded(queue, config) {
     const manager = getSharedManager();

package/dist/client/queue/helpers.js

@@ -20,6 +20,8 @@ export function getDlqContext(manager) {
         shards: getShards(manager),
         jobIndex: manager.getJobIndex(),
         jobResults: manager.jobResults,
+        dependencyResults: manager.dependencyResults,
+        customIdMap: manager.customIdMap,
         jobLogs: manager.jobLogs,
         // #110-class: without storage, retryDlqByFilter's deleteDlqEntry/insertJob
         // silently no-op — filtered retries were never persisted in embedded mode

package/dist/client/queue/operations/add/single.js

@@ -57,7 +57,7 @@ export async function add(context, jobName, data, options = {}) {
             updateProgress: async (id, progress, message) => {
                 await manager.updateProgress(jobId(id), progress, message);
             },
-            // biome-ignore lint/suspicious/useAwait: public callback contract is asynchronous.
+            // oxlint-disable-next-line typescript/require-await -- public callback contract is asynchronous
             log: async (id, message) => {
                 manager.addLog(jobId(id), message);
             },

package/dist/client/queue/runtime/configuration.d.ts

@@ -21,6 +21,10 @@ export declare class QueueConfiguration<T> extends QueueControl<T> {
     retryDlqByFilterAsync(filter: DlqFilter): Promise<number>;
     purgeDlq(): number;
     purgeDlqAsync(): Promise<number>;
+    /** Remove one DLQ entry and resolve when the removal completes. */
+    removeDlqJob(id: string): Promise<boolean>;
+    /** Explicit async alias for removeDlqJob. */
+    removeDlqJobAsync(id: string): Promise<boolean>;
     retryCompleted(id?: string): number;
     retryCompletedAsync(id?: string): Promise<number>;
     setGlobalConcurrency(concurrency: number): void;

package/dist/client/queue/runtime/configuration.js

@@ -61,6 +61,14 @@ export class QueueConfiguration extends QueueControl {
     purgeDlqAsync() {
         return dlqOps.purgeDlqAsync(this.ctx);
     }
+    /** Remove one DLQ entry and resolve when the removal completes. */
+    removeDlqJob(id) {
+        return dlqOps.removeDlqJobAsync(this.ctx, id);
+    }
+    /** Explicit async alias for removeDlqJob. */
+    removeDlqJobAsync(id) {
+        return this.removeDlqJob(id);
+    }
     retryCompleted(id) {
         return dlqOps.retryCompleted(this.ctx, id);
     }

package/dist/client/sandboxed/runtime/state.js

@@ -3,11 +3,11 @@ import { getSharedManager } from '../../manager';
 import { getSharedPool } from '../../tcpPool';
 import { createEmbeddedOps, createTcpOps } from '../queueOps';
 export class SandboxedState extends EventEmitter {
-    // biome-ignore lint/suspicious/noExplicitAny: EventEmitter's fallback listener is intentionally untyped
+    // oxlint-disable-next-line typescript/no-explicit-any -- EventEmitter's fallback listener is intentionally untyped
     on(event, listener) {
         return super.on(event, listener);
     }
-    // biome-ignore lint/suspicious/noExplicitAny: EventEmitter's fallback listener is intentionally untyped
+    // oxlint-disable-next-line typescript/no-explicit-any -- EventEmitter's fallback listener is intentionally untyped
     once(event, listener) {
         return super.once(event, listener);
     }

package/dist/client/tcp/connection.d.ts

@@ -1,4 +1,4 @@
 /** Stable low-level TCP connection import surface. */
 export { CommandQueue } from './commandQueue';
-export { buildClientTls, createConnection, tlsRequiresVerification, } from './transport';
+export { buildClientTls, createConnection, tlsRequiresVerification } from './transport';
 export type { ConnectionEvents, ConnectionResult, ConnectionTarget } from './transport';

package/dist/client/tcp/connection.js

@@ -1,3 +1,3 @@
 /** Stable low-level TCP connection import surface. */
 export { CommandQueue } from './commandQueue';
-export { buildClientTls, createConnection, tlsRequiresVerification, } from './transport';
+export { buildClientTls, createConnection, tlsRequiresVerification } from './transport';

package/dist/client/tcp/runtime/state.js

@@ -5,11 +5,11 @@ import { ReconnectManager } from '../reconnect';
 import { DEFAULT_CONNECTION } from '../types';
 /** Shared TCP client state and event contract. */
 export class TcpClientState extends EventEmitter {
-    // biome-ignore lint/suspicious/noExplicitAny: EventEmitter's fallback overload requires any[]
+    // oxlint-disable-next-line typescript/no-explicit-any -- EventEmitter's fallback overload requires any[]
     on(event, listener) {
         return super.on(event, listener);
     }
-    // biome-ignore lint/suspicious/noExplicitAny: EventEmitter's fallback overload requires any[]
+    // oxlint-disable-next-line typescript/no-explicit-any -- EventEmitter's fallback overload requires any[]
     once(event, listener) {
         return super.once(event, listener);
     }

package/dist/client/types/metrics.d.ts

@@ -1 +1 @@
-export type { QueueMetrics, QueueMetricsMeta, QueueMetricType, } from '../../domain/types/metrics';
+export type { QueueMetrics, QueueMetricsMeta, QueueMetricType } from '../../domain/types/metrics';

package/dist/client/worker/runtime/control.js

@@ -152,7 +152,6 @@ export class WorkerControl extends WorkerState {
     async startStalledCheckTimer() {
         // No-op for API compatibility; stall detection is automatic.
     }
-    // biome-ignore lint/suspicious/useAwait: public compatibility contract is asynchronous
     async delay(milliseconds = 0, abortController) {
         if (milliseconds <= 0)
             return;

package/dist/client/worker/runtime/execution.js

@@ -39,15 +39,10 @@ export class WorkerExecution extends WorkerPolling {
             if (this.groupLimiter)
                 this.groupLimiter.decrement(job);
             if (this.running && !this._closing)
-                this.poll();
+                this.scheduleProcessing();
         });
-        if (this.activeJobs < this.opts.concurrency && !this._closing && !this.processingScheduled) {
-            this.processingScheduled = true;
-            setImmediate(() => {
-                this.processingScheduled = false;
-                void this.tryProcess();
-            });
-        }
+        if (this.activeJobs < this.opts.concurrency && !this._closing)
+            this.scheduleProcessing();
         return true;
     }
     registerWithServer() {

package/dist/client/worker/runtime/lifecycle.js

@@ -2,7 +2,6 @@ import { jobId } from '../../../domain/types/job';
 import { getSharedManager } from '../../manager';
 import { WorkerManual } from './manual';
 export class WorkerLifecycle extends WorkerManual {
-    // biome-ignore lint/suspicious/useAwait: preserves the public async close contract
     async close(force = false) {
         if (this.closed)
             return;

package/dist/client/worker/runtime/polling.d.ts

@@ -3,6 +3,7 @@ import { WorkerBuffer } from './buffer';
 import type { PulledJob, WorkerDelivery } from './state';
 export declare abstract class WorkerPolling<T = unknown, R = unknown> extends WorkerBuffer<T, R> {
     protected poll(): void;
+    protected scheduleProcessing(): void;
     protected tryProcess(): Promise<void>;
     protected doPullBatch(): Promise<PulledJob[]>;
     private scheduleRateLimitPoll;

package/dist/client/worker/runtime/polling.js

@@ -16,6 +16,15 @@ export class WorkerPolling extends WorkerBuffer {
         }
         void this.tryProcess();
     }
+    scheduleProcessing() {
+        if (!this.running || this._closing || this.processingScheduled)
+            return;
+        this.processingScheduled = true;
+        setImmediate(() => {
+            this.processingScheduled = false;
+            void this.tryProcess();
+        });
+    }
     async tryProcess() {
         if (!this.running || this._closing)
             return;

package/dist/client/worker/runtime/state.js

@@ -46,15 +46,15 @@ export class WorkerState extends EventEmitter {
     lastDrainedEmit = 0;
     stalledUnsubscribe = null;
     stalledSubscription = null;
-    // biome-ignore lint/suspicious/noExplicitAny: EventEmitter's fallback listener is intentionally untyped
+    // oxlint-disable-next-line typescript/no-explicit-any -- EventEmitter's fallback listener is intentionally untyped
     on(event, listener) {
         return super.on(event, listener);
     }
-    // biome-ignore lint/suspicious/noExplicitAny: EventEmitter's fallback listener is intentionally untyped
+    // oxlint-disable-next-line typescript/no-explicit-any -- EventEmitter's fallback listener is intentionally untyped
     once(event, listener) {
         return super.once(event, listener);
     }
-    // biome-ignore lint/suspicious/noExplicitAny: EventEmitter's fallback listener is intentionally untyped
+    // oxlint-disable-next-line typescript/no-explicit-any -- EventEmitter's fallback listener is intentionally untyped
     off(event, listener) {
         return super.off(event, listener);
     }

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

@@ -11,6 +11,7 @@ export interface ChildUnwindRequest {
     emitter: WorkflowEmitter | null;
     workflows?: Map<string, Workflow>;
     retryFailed?: boolean;
+    assertActive: () => void;
 }
 export type ChildUnwind = (request: ChildUnwindRequest) => Promise<'ran' | LostCompensationClaim>;
 export interface UnwindChildRequest {
@@ -20,6 +21,7 @@ export interface UnwindChildRequest {
     workflows?: Map<string, Workflow>;
     runChild: ChildUnwind;
     retryFailed?: boolean;
+    assertActive: () => void;
 }
 /** Run the child workflow's own unwind and propagate every uncertain outcome. */
 export declare function unwindChild(request: UnwindChildRequest): Promise<void>;

package/dist/client/workflow/compensationChild.js

@@ -2,7 +2,8 @@
 import { isLive } from './admission';
 /** Run the child workflow's own unwind and propagate every uncertain outcome. */
 export async function unwindChild(request) {
-    const { record, store, emitter, workflows, runChild, retryFailed } = request;
+    const { record, store, emitter, workflows, runChild, retryFailed, assertActive } = request;
+    assertActive();
     const childId = record.childExecutionId;
     if (!childId)
         throw new Error('sub-workflow record carries no child execution id');
@@ -29,6 +30,7 @@ export async function unwindChild(request) {
         emitter,
         workflows,
         retryFailed,
+        assertActive,
     });
     if (outcome !== 'ran') {
         throw new Error(`child "${child.workflowName}" (${childId}) is being rolled back by another driver; ` +

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

@@ -12,5 +12,6 @@ export interface UnwindPass {
     eligible: [string, StepRecord][];
     workflows?: Map<string, Workflow>;
     retryFailed?: boolean;
+    assertActive: () => void;
 }
 export declare function unwind(pass: UnwindPass, runChild: ChildUnwind): Promise<void>;

package/dist/client/workflow/compensationPass.js

@@ -1,14 +1,16 @@
 /** One checkpointed compensation pass. */
 import { compensationContext, settle } from './compensationSupport';
 import { unwindChild } from './compensationChild';
+import { isWorkflowExecutionClosed } from './executionFence';
 import { describeError } from './identity';
 import { buildContext, findStepDef, runWithTimeout } from './runner';
 import { decideUnwindAction } from './unwindPlan';
 export async function unwind(pass, runChild) {
-    const { exec, wf, store, emitter, eligible, workflows, retryFailed } = pass;
+    const { exec, wf, store, emitter, eligible, workflows, retryFailed, assertActive } = pass;
     const baseCtx = buildContext(exec);
     let haltedAt = null;
     let writeFailure;
+    assertActive();
     exec.state = 'compensating';
     try {
         store.update(exec);
@@ -20,8 +22,10 @@ export async function unwind(pass, runChild) {
     }
     if (writeFailure === undefined) {
         emitter?.emitWorkflow('workflow:compensating', exec.id, exec.workflowName, 'compensating');
+        assertActive();
     }
     for (const [name, record] of eligible) {
+        assertActive();
         if (writeFailure !== undefined)
             break;
         const action = decideUnwindAction(wf, name, record, haltedAt !== null, retryFailed);
@@ -39,12 +43,22 @@ export async function unwind(pass, runChild) {
             emitter?.emitStep('compensation:failed', exec.id, exec.workflowName, name, {
                 error: 'step no longer declared',
             });
+            assertActive();
             continue;
         }
         emitter?.emitStep('compensation:started', exec.id, exec.workflowName, name);
+        assertActive();
         try {
             if (action.kind === 'unwind-child') {
-                await unwindChild({ record, store, emitter, workflows, runChild, retryFailed });
+                await unwindChild({
+                    record,
+                    store,
+                    emitter,
+                    workflows,
+                    runChild,
+                    retryFailed,
+                    assertActive,
+                });
             }
             else {
                 const def = findStepDef(wf, name);
@@ -59,6 +73,8 @@ export async function unwind(pass, runChild) {
             emitter?.emitStep('compensation:completed', exec.id, exec.workflowName, name);
         }
         catch (error) {
+            if (isWorkflowExecutionClosed(error))
+                throw error;
             const message = describeError(error);
             settle(record, 'compensation-failed', message);
             emitter?.emitStep('compensation:failed', exec.id, exec.workflowName, name, {

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

@@ -25,9 +25,10 @@ export type UnwindOutcome = 'ran' | LostCompensationClaim;
 /** Run compensation handlers in reverse start order for every eligible step. */
 export declare function runCompensation(exec: Execution, wf: Workflow, store: WorkflowStore, emitter: WorkflowEmitter | null, workflows?: Map<string, Workflow>, opts?: {
     retryFailed?: boolean;
+    assertActive?: () => void;
 }): Promise<UnwindOutcome>;
 /**
  * Give up on a parked unwind and record an explicit skipped outcome for every
  * remaining eligible step.
  */
-export declare function abandonCompensation(exec: Execution, wf: Workflow, store: WorkflowStore, emitter: WorkflowEmitter | null): void;
+export declare function abandonCompensation(exec: Execution, wf: Workflow, store: WorkflowStore, emitter: WorkflowEmitter | null, assertActive?: () => void): void;

package/dist/client/workflow/compensator.js

@@ -9,6 +9,7 @@ import { unwind } from './compensationPass';
 import { AbandonedCompensationError } from './compensationChild';
 import { acquireCompensationClaim } from './compensationClaim';
 import { settle, unwindSet } from './compensationSupport';
+import { assertWorkflowActive } from './executionFence';
 import { owesOutcome } from './unwindPlan';
 export { AbandonedCompensationError, CommittedChildError } from './compensationChild';
 /** Sentinel thrown when an execution deliberately parks for a signal. */
@@ -20,8 +21,10 @@ export class WaitForSignalError extends Error {
     }
 }
 /** Run compensation handlers in reverse start order for every eligible step. */
-// biome-ignore lint/complexity/useMaxParams: registry and operator retry are independent inputs
+// oxlint-disable-next-line max-params -- registry and operator retry are independent inputs
 export async function runCompensation(exec, wf, store, emitter, workflows, opts = {}) {
+    const assertActive = opts.assertActive ?? assertWorkflowActive;
+    assertActive();
     // `failed` + `stuck` is the durable terminal form written by an explicit
     // abandon. No caller, including an ancestor retry, may reopen that decision.
     if (exec.state === 'failed' && exec.rollbackStatus === 'stuck') {
@@ -29,17 +32,19 @@ export async function runCompensation(exec, wf, store, emitter, workflows, opts
     }
     const eligible = unwindSet(exec, wf);
     if (eligible.length === 0) {
+        assertActive();
         exec.rollbackStatus = 'not-applicable';
         if (exec.state !== 'failed' && exec.state !== 'completed')
             exec.state = 'failed';
         store.update(exec);
         return 'ran';
     }
+    assertActive();
     const claim = acquireCompensationClaim(exec.id, store);
     if (claim.kind === 'claim-lost')
         return claim;
     try {
-        await unwind({ exec, wf, store, emitter, eligible, workflows, ...opts }, ({ exec, workflow, store, emitter, workflows, retryFailed }) => runCompensation(exec, workflow, store, emitter, workflows, { retryFailed }));
+        await unwind({ exec, wf, store, emitter, eligible, workflows, ...opts, assertActive }, ({ exec, workflow, store, emitter, workflows, retryFailed, assertActive }) => runCompensation(exec, workflow, store, emitter, workflows, { retryFailed, assertActive }));
     }
     finally {
         claim.release();
@@ -50,8 +55,9 @@ export async function runCompensation(exec, wf, store, emitter, workflows, opts
  * Give up on a parked unwind and record an explicit skipped outcome for every
  * remaining eligible step.
  */
-export function abandonCompensation(exec, wf, store, emitter) {
+export function abandonCompensation(exec, wf, store, emitter, assertActive = assertWorkflowActive) {
     for (const [name, record] of unwindSet(exec, wf)) {
+        assertActive();
         if (record.compensation)
             continue;
         if (!owesOutcome(wf, name, record))
@@ -59,7 +65,9 @@ export function abandonCompensation(exec, wf, store, emitter) {
         const reason = 'unwind abandoned by operator';
         settle(record, 'compensation-skipped', reason);
         emitter?.emitStep('compensation:skipped', exec.id, exec.workflowName, name, { error: reason });
+        assertActive();
     }
+    assertActive();
     exec.state = 'failed';
     exec.rollbackStatus = 'stuck';
     store.update(exec);

package/dist/client/workflow/engine.js

@@ -136,7 +136,7 @@ export class Engine {
         // Before the worker: a waitFor timer that fires during shutdown enqueues a step
         // job, and a queue closing underneath it turns an orderly shutdown into a rejected
         // add. Releasing the timers first makes the order irrelevant.
-        this.executor.close();
+        this.executor.close(force);
         await this.worker.close(force);
         this.queue.close();
         this.store.close();

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

@@ -0,0 +1,15 @@
+/** Lifecycle fence shared by every asynchronous workflow execution path. */
+/** Internal control-flow signal used to abandon work owned by a closed Engine. */
+export declare class WorkflowExecutionClosedError extends Error {
+    constructor();
+}
+export declare function isWorkflowExecutionClosed(error: unknown): boolean;
+/** A graceful close leaves this active; only close(true) aborts in-flight control flow. */
+export declare class WorkflowExecutionFence {
+    private readonly controller;
+    readonly assertActive: () => void;
+    isActive(): boolean;
+    close(force: boolean): void;
+}
+/** Default for isolated runner tests that do not own an Engine lifecycle. */
+export declare const assertWorkflowActive: () => void;

package/dist/client/workflow/executionFence.js

@@ -0,0 +1,29 @@
+/** Lifecycle fence shared by every asynchronous workflow execution path. */
+/** Internal control-flow signal used to abandon work owned by a closed Engine. */
+export class WorkflowExecutionClosedError extends Error {
+    constructor() {
+        super('Workflow execution belongs to a force-closed Engine');
+        this.name = 'WorkflowExecutionClosedError';
+    }
+}
+export function isWorkflowExecutionClosed(error) {
+    return (error instanceof WorkflowExecutionClosedError ||
+        (error instanceof AggregateError && error.errors.some(isWorkflowExecutionClosed)));
+}
+/** A graceful close leaves this active; only close(true) aborts in-flight control flow. */
+export class WorkflowExecutionFence {
+    controller = new AbortController();
+    assertActive = () => {
+        if (this.controller.signal.aborted)
+            throw new WorkflowExecutionClosedError();
+    };
+    isActive() {
+        return !this.controller.signal.aborted;
+    }
+    close(force) {
+        if (force)
+            this.controller.abort();
+    }
+}
+/** Default for isolated runner tests that do not own an Engine lifecycle. */
+export const assertWorkflowActive = () => undefined;

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

@@ -10,13 +10,14 @@ export declare class WorkflowExecutor {
     private readonly emitter;
     private readonly workflows;
     private readonly timeoutTimers;
+    private readonly fence;
     /**
      * Release every armed waitFor timer. The engine owns the executor's lifetime, so
      * `Engine.close()` must call this: an armed timer would otherwise fire into a
      * closing queue, and a caller that keeps the process alive after closing one engine
      * has no other handle on them.
      */
-    close(): void;
+    close(force?: boolean): void;
     private readonly updateFn;
     constructor(store: WorkflowStore, queue: Queue, emitter?: WorkflowEmitter | null);
     register(workflow: Workflow): void;
@@ -24,16 +25,9 @@ export declare class WorkflowExecutor {
     /**
      * Nodes this process is currently executing, keyed `<execution>:<nodeIndex>`.
      *
-     * The cursor guard below rejects a job for a node the run has already left, but not
-     * a SECOND job for the node it is on right now: both carry the same index. That is
-     * the reachable duplicate, because `recover()` re-enqueues the current node of every
-     * `running` execution and is documented as callable on a live engine. Without this
-     * claim the node runs twice and each copy advances the run independently, doubling
-     * every side effect after it while the run still ends `completed`.
-     *
-     * A claim, not a queue-level dedup: a deterministic `jobId` was tried and could
-     * swallow a LEGITIMATE later re-enqueue of the same node, wedging the run forever.
-     * This drops only a duplicate that overlaps in time.
+     * The cursor rejects stale jobs but not two overlapping deliveries for the current
+     * node. This process-local claim drops that overlap. Queue-level dedup is unsuitable:
+     * a retained ID can swallow a legitimate recovery enqueue and wedge the run.
      */
     private readonly nodesInFlight;
     processStep(data: StepJobData): Promise<unknown>;