bunqueue 2.8.49 → 2.8.51

package/dist/client/workflow/storeListing.js

@@ -0,0 +1,45 @@
+import { decodeExecution } from './storeExecutionCodec';
+const DEFAULT_LIMIT = 100;
+const MAX_LIMIT = 1000;
+const ORDER_AND_PAGE = 'ORDER BY created_at DESC, id DESC LIMIT ? OFFSET ?';
+/** Prepared, consistently ordered execution-list queries. */
+export class ExecutionListing {
+    all;
+    byName;
+    byState;
+    byBoth;
+    constructor(db) {
+        this.all = db.prepare(`SELECT * FROM workflow_executions ${ORDER_AND_PAGE}`);
+        this.byName = db.prepare(`SELECT * FROM workflow_executions WHERE workflow_name = ? ${ORDER_AND_PAGE}`);
+        this.byState = db.prepare(`SELECT * FROM workflow_executions WHERE state = ? ${ORDER_AND_PAGE}`);
+        this.byBoth = db.prepare(`SELECT * FROM workflow_executions WHERE workflow_name = ? AND state = ? ${ORDER_AND_PAGE}`);
+    }
+    list(workflowName, state, options = {}) {
+        const { limit, offset } = pageBounds(options);
+        let rows;
+        if (workflowName !== undefined && state !== undefined) {
+            rows = this.byBoth.all(workflowName, state, limit, offset);
+        }
+        else if (workflowName !== undefined) {
+            rows = this.byName.all(workflowName, limit, offset);
+        }
+        else if (state !== undefined) {
+            rows = this.byState.all(state, limit, offset);
+        }
+        else {
+            rows = this.all.all(limit, offset);
+        }
+        return rows.map(decodeExecution);
+    }
+}
+function pageBounds(options) {
+    const limit = options.limit ?? DEFAULT_LIMIT;
+    const offset = options.offset ?? 0;
+    if (!Number.isSafeInteger(limit) || limit < 1 || limit > MAX_LIMIT) {
+        throw new RangeError(`Workflow execution list limit must be an integer from 1 to ${MAX_LIMIT}`);
+    }
+    if (!Number.isSafeInteger(offset) || offset < 0) {
+        throw new RangeError('Workflow execution list offset must be a non-negative integer');
+    }
+    return { limit, offset };
+}

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

@@ -0,0 +1,4 @@
+import type { Database } from 'bun:sqlite';
+export declare function cleanupExecutions(db: Database, maxAgeMs: number, states?: string[]): number;
+export declare function archiveExecutions(db: Database, maxAgeMs: number, states?: string[]): number;
+export declare function archivedExecutionCount(db: Database): number;

package/dist/client/workflow/storeMaintenance.js

@@ -0,0 +1,40 @@
+import { clock } from './clock';
+export function cleanupExecutions(db, maxAgeMs, states = ['completed', 'failed']) {
+    const cutoff = clock().now() - maxAgeMs;
+    const placeholders = states.map(() => '?').join(',');
+    const stmt = db.prepare(`DELETE FROM workflow_executions WHERE updated_at <= ? AND state IN (${placeholders})`);
+    const result = stmt.run(cutoff, ...states);
+    return result.changes;
+}
+export function archiveExecutions(db, maxAgeMs, states = ['completed', 'failed']) {
+    const cutoff = clock().now() - maxAgeMs;
+    const now = clock().now();
+    const placeholders = states.map(() => '?').join(',');
+    const rows = db
+        .prepare(`SELECT * FROM workflow_executions
+       WHERE updated_at <= ? AND state IN (${placeholders})
+       ORDER BY updated_at ASC, id ASC
+       LIMIT 1000`)
+        .all(cutoff, ...states);
+    if (rows.length === 0)
+        return 0;
+    const insertArchive = db.prepare(`
+    INSERT OR REPLACE INTO workflow_executions_archive
+    (id, workflow_name, state, input, steps, current_node_index, resolved_steps,
+     signals, created_at, updated_at, archived_at, meta)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+    const deleteOriginal = db.prepare(`DELETE FROM workflow_executions WHERE id = ?`);
+    const tx = db.transaction(() => {
+        for (const row of rows) {
+            insertArchive.run(row.id, row.workflow_name, row.state, row.input, row.steps, row.current_node_index, row.resolved_steps, row.signals, row.created_at, row.updated_at, now, row.meta ?? null);
+            deleteOriginal.run(row.id);
+        }
+    });
+    tx();
+    return rows.length;
+}
+export function archivedExecutionCount(db) {
+    const row = db.prepare(`SELECT COUNT(*) as cnt FROM workflow_executions_archive`).get();
+    return row.cnt;
+}

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

@@ -41,6 +41,7 @@ export declare class SignalCoordinator {
     private readonly read;
     private readonly write;
     private readonly claimResume;
+    private readonly restoreWait;
     private readonly claimPark;
     constructor(db: Database);
     /**
@@ -48,6 +49,14 @@ export declare class SignalCoordinator {
      * claim the single resume for this caller.
      */
     record(id: string, event: string, payload: unknown): SignalOutcome;
+    /**
+     * Put a claimed wait back when publishing its resume job failed.
+     *
+     * The signal stays recorded: recovery sees the waiting row plus the signal key and
+     * retries the resume. The cursor predicate prevents a delayed enqueue rejection
+     * from parking an execution that another driver has already advanced.
+     */
+    restoreWaiting(id: string, event: string, nodeIndex: number): boolean;
     /**
      * Park a running execution at a `waitFor`, unless the awaited signal has already
      * been recorded.

package/dist/client/workflow/storeSignals.js

@@ -57,12 +57,16 @@ export class SignalCoordinator {
     read;
     write;
     claimResume;
+    restoreWait;
     claimPark;
     constructor(db) {
         this.db = db;
         this.read = db.prepare(`SELECT workflow_name, state, current_node_index, signals FROM workflow_executions WHERE id = ?`);
         this.write = db.prepare(`UPDATE workflow_executions SET signals = ?, updated_at = ? WHERE id = ?`);
         this.claimResume = db.prepare(`UPDATE workflow_executions SET state = 'running', updated_at = ? WHERE id = ? AND state = 'waiting'`);
+        this.restoreWait = db.prepare(`UPDATE workflow_executions
+       SET state = 'waiting', updated_at = ?
+       WHERE id = ? AND state = 'running' AND current_node_index = ?`);
         // 'waiting' is accepted as a source state so re-parking is idempotent: a clamped
         // or partial timeout re-arm re-enters the same waitFor node while the row is
         // still 'waiting', and must be allowed to park (and re-arm) again.
@@ -77,7 +81,14 @@ export class SignalCoordinator {
             const row = this.read.get(id);
             if (!row)
                 return { found: false, resumed: false, workflowName: '', currentNodeIndex: 0 };
+            const state = row.state;
+            if (state !== 'running' && state !== 'waiting') {
+                throw new Error(`Execution "${id}" is "${state}" and cannot receive the signal "${event}"`);
+            }
             const signals = this.decode(row);
+            if (hasSignal(signals, event)) {
+                throw new Error(`Signal "${event}" was already received for execution "${id}"`);
+            }
             signals[event] = payload;
             const now = clock().now();
             this.write.run(pack(signals), now, id);
@@ -89,7 +100,30 @@ export class SignalCoordinator {
                 currentNodeIndex: row.current_node_index,
             };
         });
-        return tx();
+        // A signal key lives inside one msgpack blob, so there is no SQL UNIQUE
+        // constraint that can arbitrate two writers. Taking the write reservation before
+        // the read makes the read/check/write sequence first-writer-wins across database
+        // connections as well as within this process.
+        return tx.immediate();
+    }
+    /**
+     * Put a claimed wait back when publishing its resume job failed.
+     *
+     * The signal stays recorded: recovery sees the waiting row plus the signal key and
+     * retries the resume. The cursor predicate prevents a delayed enqueue rejection
+     * from parking an execution that another driver has already advanced.
+     */
+    restoreWaiting(id, event, nodeIndex) {
+        const tx = this.db.transaction(() => {
+            const row = this.read.get(id);
+            if (!row || row.current_node_index !== nodeIndex || row.state !== 'running')
+                return false;
+            if (!hasSignal(this.decode(row), event))
+                return false;
+            const restored = this.restoreWait.run(clock().now(), id, nodeIndex);
+            return restored.changes === 1;
+        });
+        return tx.immediate();
     }
     /**
      * Park a running execution at a `waitFor`, unless the awaited signal has already
@@ -110,7 +144,9 @@ export class SignalCoordinator {
             const claimed = this.claimPark.run(clock().now(), id);
             return { signalPresent: false, parked: claimed.changes === 1, signals };
         });
-        return tx();
+        // Serialize the signal check with record(): a deferred transaction can let both
+        // sides read first and then surface SQLITE_BUSY while upgrading their locks.
+        return tx.immediate();
     }
     decode(row) {
         return unpack(row?.signals) ?? {};

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

@@ -0,0 +1,13 @@
+import type { Execution } from './types';
+export interface SubWorkflowRunOptions {
+    pollIntervalMs?: number;
+    maxWaitMs?: number;
+    existingChildId?: string;
+}
+/** 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<{
+    id: string;
+}>, getFn: (id: string) => Execution | null, options?: SubWorkflowRunOptions): Promise<{
+    results: Record<string, unknown>;
+    executionId: string;
+}>;

package/dist/client/workflow/subWorkflowRunner.js

@@ -0,0 +1,40 @@
+import { clock } from './clock';
+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;
+    if (!Number.isFinite(pollIntervalMs) || pollIntervalMs <= 0) {
+        throw new Error('Sub-workflow pollIntervalMs must be finite and greater than 0');
+    }
+    if (!Number.isFinite(maxWaitMs) || maxWaitMs <= 0) {
+        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.
+    const existing = options.existingChildId ? getFn(options.existingChildId) : null;
+    const handle = existing ? { id: existing.id } : await startFn(workflowName, input);
+    const startedAt = existing?.createdAt ?? getFn(handle.id)?.createdAt ?? clock().now();
+    for (;;) {
+        const subExec = getFn(handle.id);
+        if (subExec?.state === 'completed') {
+            const results = {};
+            for (const [name, record] of Object.entries(subExec.steps)) {
+                if (record.status === 'completed')
+                    results[name] = record.result;
+            }
+            return { results, executionId: handle.id };
+        }
+        if (subExec?.state === 'failed') {
+            throw new Error(`Sub-workflow "${workflowName}" (${handle.id}) failed`);
+        }
+        if (subExec?.state === 'compensation-stuck') {
+            throw new Error(`Sub-workflow "${workflowName}" (${handle.id}) is parked mid-rollback ` +
+                '(compensation-stuck); resolve it with resumeCompensation or abandonCompensation');
+        }
+        const remaining = maxWaitMs - (clock().now() - startedAt);
+        if (remaining <= 0) {
+            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)));
+    }
+}

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

@@ -1,356 +1,4 @@
-/**
- * Workflow Engine Types
- */
-import type { ConnectionOptions } from '../types';
-/** Context passed to step handlers */
-export interface StepContext<TInput = unknown, TSteps extends Record<string, unknown> = Record<string, unknown>> {
-    /** Original workflow input */
-    readonly input: TInput;
-    /** Results from completed steps (step name → result) */
-    readonly steps: Readonly<TSteps>;
-    /** Signals received via engine.signal() */
-    readonly signals: Readonly<Record<string, unknown>>;
-    /** Current execution ID */
-    readonly executionId: string;
-    /**
-     * Idempotency key for THIS execution of the step. Stable across automatic retries
-     * and across crash-resume; different for a different run. Pass it straight to the
-     * provider so a repeat lands on the same operation instead of a new one.
-     */
-    readonly idempotencyKey?: string;
-    /**
-     * Compensation only: the key the FORWARD step used. When the forward outcome is
-     * in doubt, this is what lets a rollback ask the provider "did this actually
-     * happen?" instead of depending on an output that may never have been persisted.
-     */
-    readonly forwardIdempotencyKey?: string;
-}
-/** Step handler function (type-erased for internal storage) */
-export type StepHandler<TInput = unknown, TResult = unknown> = (ctx: StepContext<TInput, any>) => Promise<TResult> | TResult;
-/** Typed step handler — preserves accumulated step types */
-export type TypedStepHandler<TInput, TSteps extends Record<string, unknown>, TResult> = (ctx: StepContext<TInput, TSteps>) => Promise<TResult> | TResult;
-/** Compensate handler (type-erased for internal storage) */
-export type CompensateHandler<TInput = unknown> = (ctx: StepContext<TInput, any>) => Promise<void> | void;
-/** Typed compensate handler — preserves accumulated step types */
-export type TypedCompensateHandler<TInput, TSteps extends Record<string, unknown>> = (ctx: StepContext<TInput, TSteps>) => Promise<void> | void;
-/** Schema-like object — any object with a .parse() method (Zod, ArkType, Valibot, etc.) */
-export interface SchemaLike {
-    parse(data: unknown): unknown;
-}
-/**
- * Options for a single step.
- *
- * `TSteps` is part of the signature for source compatibility and for symmetry with
- * `TypedStepHandler`, even though `compensate` no longer narrows on it (see below).
- * Removing the parameter would break every explicit `StepOptions<In, Steps>` in
- * user code.
- */
-export interface StepOptions<TInput = unknown, TSteps extends Record<string, unknown> = Record<string, unknown>> {
-    retry?: number;
-    timeout?: number;
-    /**
-     * A METHOD taking a permissively-typed context, and every part of that is load
-     * bearing. Three forms were measured against real handler shapes:
-     *
-     *   shape                                     union   method<TSteps>   method<any>
-     *   compensate: async (ctx) => ...            TS7006  ok               ok
-     *   annotated with steps it reads             ok      ok               ok
-     *   annotated with a step that does not exist ok      TS2322           ok
-     *   CompensateHandler<TInput> alias           ok      ok               ok
-     *
-     * Not a union (`TypedCompensateHandler | CompensateHandler`): TypeScript cannot
-     * contextually type a parameter against a union of signatures, so the inline arrow
-     * every documented example uses was an implicit `any` and failed `noImplicitAny`.
-     *
-     * A method rather than a property so parameters stay bivariant under
-     * `strictFunctionTypes`, which is what lets an explicitly annotated handler through.
-     *
-     * `any` rather than `TSteps` for the step map, deliberately: with `TSteps` an
-     * annotation naming a step this workflow does not declare is rejected, and the
-     * published union accepted it. Keeping the looser map costs typed access to
-     * `ctx.steps` inside a rollback, which handlers already narrow with a cast in
-     * practice, and buys source compatibility with every handler written before.
-     */
-    compensate?(ctx: StepContext<TInput, TSteps extends never ? never : any>): Promise<void> | void;
-    /** Validate step input before execution */
-    inputSchema?: SchemaLike;
-    /** Validate step output after execution */
-    outputSchema?: SchemaLike;
-}
-/** Internal step definition */
-export interface StepDefinition {
-    name: string;
-    handler: StepHandler;
-    compensate?: CompensateHandler;
-    retry: number;
-    timeout: number;
-    inputSchema?: SchemaLike;
-    outputSchema?: SchemaLike;
-}
-/** Branch condition function */
-export type BranchCondition<TInput = unknown, TSteps extends Record<string, unknown> = Record<string, unknown>> = (ctx: StepContext<TInput, TSteps>) => string;
-/** Internal branch definition (type-erased) */
-export interface BranchDefinition {
-    condition: BranchCondition<any, any>;
-    paths: Map<string, StepDefinition[]>;
-}
-/** Definition of a parallel step group */
-export interface ParallelDefinition {
-    steps: StepDefinition[];
-}
-/** Input mapper for sub-workflows */
-export type SubWorkflowInputMapper<TInput = unknown, TSteps extends Record<string, unknown> = Record<string, unknown>> = (ctx: StepContext<TInput, TSteps>) => unknown;
-/** Loop condition: receives context + iteration count, returns boolean */
-export type LoopCondition<TInput = unknown, TSteps extends Record<string, unknown> = Record<string, unknown>> = (ctx: StepContext<TInput, TSteps>, iteration: number) => boolean | Promise<boolean>;
-/** Definition of a doUntil/doWhile loop (type-erased) */
-export interface LoopDefinition {
-    condition: LoopCondition<any, any>;
-    steps: StepDefinition[];
-    maxIterations: number;
-}
-/** Item extractor for forEach */
-export type ForEachItemsExtractor<TInput = unknown, TSteps extends Record<string, unknown> = Record<string, unknown>> = (ctx: StepContext<TInput, TSteps>) => unknown[];
-/** Definition of a forEach loop (type-erased) */
-export interface ForEachDefinition {
-    items: ForEachItemsExtractor<any, any>;
-    step: StepDefinition;
-    maxIterations: number;
-}
-/** Transform function for map */
-export type MapTransformFn<TInput = unknown, TSteps extends Record<string, unknown> = Record<string, unknown>> = (ctx: StepContext<TInput, TSteps>) => unknown;
-/** Definition of a map node (type-erased) */
-export interface MapDefinition {
-    name: string;
-    transform: MapTransformFn<any, any>;
-}
-/** Workflow node (discriminated union) */
-export type WorkflowNode = {
-    type: 'step';
-    def: StepDefinition;
-} | {
-    type: 'branch';
-    def: BranchDefinition;
-} | {
-    type: 'waitFor';
-    event: string;
-    timeout?: number;
-} | {
-    type: 'parallel';
-    def: ParallelDefinition;
-} | {
-    type: 'subWorkflow';
-    name: string;
-    inputMapper: SubWorkflowInputMapper<any, any>;
-} | {
-    type: 'doUntil';
-    def: LoopDefinition;
-} | {
-    type: 'doWhile';
-    def: LoopDefinition;
-} | {
-    type: 'forEach';
-    def: ForEachDefinition;
-} | {
-    type: 'map';
-    def: MapDefinition;
-} | {
-    type: 'pivot';
-};
-/** Execution state */
-export type ExecutionState = 'running' | 'waiting' | 'completed' | 'failed' | 'compensating'
-/**
- * A compensation failed definitively and the unwind stopped. Deliberately NOT
- * terminal: halting and calling it done leaves the operator nothing to act on,
- * and ploughing on would undo work whose dependencies are still standing. The run
- * parks here until someone retries the failed handler or abandons the unwind.
- */
- | 'compensation-stuck';
-/**
- * What the engine did AFTER a failure. Deliberately a separate axis from the
- * failure reason: the rollback is not the cause of the failure, and collapsing the
- * two makes it impossible to alert on the right thing — "the payment failed" and
- * "the refund never went through" need different pagers.
- *
- * Absent means no unwind was attempted, which is the case for a run that has not
- * failed. There is deliberately no `'not-started'` member: it was documented in three
- * places and never once assigned, so anything branching on it was dead code.
- */
-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; the remaining ones were not attempted. */
- | 'stuck';
-/** Step execution state */
-export type StepState = 'pending' | 'running' | 'completed' | 'failed';
-/** Record of a step's execution */
-export interface StepRecord {
-    status: StepState;
-    result?: unknown;
-    error?: string;
-    startedAt?: number;
-    completedAt?: number;
-    attempts?: number;
-    /**
-     * Did this step declare a `compensate` handler when it ran?
-     *
-     * Persisted because a later deploy can remove or rename the step, and then nothing
-     * else can tell "this step never owed a reversal" from "this step owed one and the
-     * handler is gone". Without it a renamed step that had not been reversed yet was
-     * silently dropped from the unwind and the run reported a clean rollback.
-     */
-    compensatable?: boolean;
-    /** forEach iteration item — persisted so compensation can restore __item */
-    loopItem?: unknown;
-    /** forEach iteration index — persisted so compensation can restore __index */
-    loopIndex?: number;
-    /**
-     * Outcome of this step's rollback. Written exactly once per unwind, for every
-     * eligible step — including the ones the unwind never reached, which are recorded
-     * as 'compensation-skipped' rather than left blank. "Never zero, never two" is
-     * only checkable if success is recorded as loudly as failure.
-     */
-    compensation?: CompensationOutcome;
-    /** Idempotency key of the FORWARD execution, persisted before the body runs. */
-    idempotencyKey?: string;
-    /**
-     * For a `sub:<name>` record: the child execution this step started. Rolling back a
-     * nested workflow means running the CHILD's own unwind, so the parent has to keep
-     * a handle on it — otherwise a child that succeeded before the parent failed is
-     * left standing, with every resource it created orphaned.
-     */
-    childExecutionId?: string;
-    /** Occurrence of this step name within the run — loops reuse a single name. */
-    occurrence?: number;
-}
-/** 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;
-}
-/** Full execution state */
-export interface Execution {
-    id: string;
-    workflowName: string;
-    state: ExecutionState;
-    input: unknown;
-    steps: Record<string, StepRecord>;
-    currentNodeIndex: number;
-    /** Flattened step list for branch resolution */
-    resolvedSteps?: 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, if it was reached.
-     *
-     * Once set, the saga is committed and backward recovery is OFF ENTIRELY — not just
-     * for the steps after it. That is what "point of no return" means: releasing the
-     * subdomain of a tenant who has already been sent a welcome email is precisely the
-     * outcome the pivot exists to prevent. After it, the only correct recovery is
-     * forward.
-     */
-    committedAt?: number;
-    signals: Record<string, unknown>;
-    /**
-     * Set when this run was started BY a `subWorkflow` node, naming the parent that owns
-     * it. A child is a row like any other, so without this nothing distinguishes it from
-     * a top-level run and `recover()` drives it on its own, re-running its steps and
-     * re-arming its rollback behind the parent's back
-     * (`test/repro-model-child-recovered-alone.test.ts`).
-     */
-    parentExecutionId?: string;
-    createdAt: number;
-    updatedAt: number;
-}
-/** All workflow event types */
-export type WorkflowEventType = 'step:started' | 'step:completed' | 'step:failed' | 'step:retry' | 'workflow:started' | 'workflow:completed' | 'workflow:failed' | 'workflow:compensating' | 'workflow:waiting' | 'signal:received' | 'signal:timeout' | 'compensation:started' | 'compensation:completed' | 'compensation:failed' | 'compensation:skipped';
-/** Base event payload */
-export interface WorkflowEvent {
-    type: WorkflowEventType;
-    executionId: string;
-    workflowName: string;
-    timestamp: number;
-}
-/** Step-level event payload */
-export interface StepEvent extends WorkflowEvent {
-    stepName: string;
-    result?: unknown;
-    error?: string;
-    attempt?: number;
-    maxAttempts?: number;
-}
-/** Workflow lifecycle event payload */
-export interface WorkflowLifecycleEvent extends WorkflowEvent {
-    state: ExecutionState;
-    input?: unknown;
-}
-/** Signal event payload */
-export interface SignalEvent extends WorkflowEvent {
-    event: string;
-    payload?: unknown;
-}
-/** Event listener function */
-export type WorkflowEventListener = (event: WorkflowEvent | StepEvent | WorkflowLifecycleEvent | SignalEvent) => void;
-/** Engine configuration */
-export interface EngineOptions {
-    embedded?: boolean;
-    dataPath?: string;
-    connection?: ConnectionOptions;
-    /** Internal queue name (default: __wf:steps) */
-    queueName?: string;
-    /** Worker concurrency (default: 5) */
-    concurrency?: number;
-    /** Global event listener for observability */
-    onEvent?: WorkflowEventListener;
-}
-/** Handle returned from engine.start() */
-export interface RunHandle {
-    id: string;
-    workflowName: string;
-}
-/** 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[];
-}
+/** Stable public barrel for workflow types. */
+export type * from './stepTypes';
+export type * from './executionTypes';
+export type * from './eventTypes';

package/dist/client/workflow/types.js

@@ -1,4 +1,2 @@
-/**
- * Workflow Engine Types
- */
+/** Stable public barrel for workflow types. */
 export {};