@orkestrel/workflow 0.0.10 → 0.0.12

package/dist/src/core/index.d.cts

@@ -19,28 +19,6 @@ import { Success } from '@orkestrel/contract';
 import { TableInterface } from '@orkestrel/database';
 import { TokenUsage } from '@orkestrel/budget';
 
-/**
- * Assert that a {@link WorkflowSnapshot} carries a `boolean` `bail` — at the workflow tier AND
- * on every phase — and that its every node's status (and its `override`, when present) is drawn
- * from the lifecycle vocabulary, throwing a `RESTORE` {@link WorkflowError} otherwise.
- *
- * @remarks
- * The boundary-narrowing guard (AGENTS §14) for {@link restoreWorkflow}: a snapshot is
- * untrusted JSON, so a status (or an override) outside
- * {@link import('./constants.js').WORKFLOW_STATUSES} /
- * {@link import('./constants.js').PHASE_STATUSES} / {@link import('./constants.js').TASK_STATUSES},
- * a non-boolean `bail` (the workflow's OR any phase's — both are REQUIRED persisted policy), a
- * present-but-invalid phase `concurrency` (not a positive integer), or a present-but-invalid task
- * `run` (an empty string) / `retries` / `timeout` (not a non-negative integer),
- * is rejected loudly (naming the offending node) rather than silently producing a broken tree.
- * The `override` / `concurrency` / `run` / `retries` / `timeout` are optional, so each is only
- * checked WHEN present. Structural shape beyond these fields is the contract's concern; this
- * guards exactly the fields the live state machine reads back.
- *
- * @param snapshot - The snapshot to validate
- */
-export declare function assertSnapshot(snapshot: unknown): void;
-
 /**
  * Build a {@link PhaseContext} — a phase's own identity plus a back-reference to its
  * workflow — from the parent {@link WorkflowContext} and the phase node's identity.
@@ -152,7 +130,7 @@ export declare function cloneWorkflowSnapshot(input: unknown, id?: string): Work
  * @param phases - The per-phase result lists, in phase order
  * @returns One flattened {@link TaskResult} list, in positional order
  */
-export declare function collectResults(phases: readonly (readonly TaskResult[])[]): readonly TaskResult[];
+export declare function collectResults(phases: ReadonlyArray<readonly TaskResult[]>): readonly TaskResult[];
 
 /**
  * The per-unit handle a runner handler receives — wraps the unit's identity,
@@ -282,13 +260,13 @@ export declare interface ControllerInterface<TInput, TResult> {
  * @example
  * ```ts
  * import { createMemoryDriver } from '@orkestrel/database'
- * import { createDatabaseWorkflowStore, createWorkflow, restoreWorkflow } from '@orkestrel/workflow'
+ * import { createDatabaseWorkflowStore, createWorkflow, createRestoredWorkflow } from '@orkestrel/workflow'
  *
  * const store = createDatabaseWorkflowStore(createMemoryDriver()) // a durable driver swaps in here
  * const workflow = createWorkflow(definition)
  * await store.set(workflow.snapshot())          // persist the run state (one JSON column)
  * const snapshot = await store.get(definition.id)
- * const restored = snapshot && restoreWorkflow(snapshot)       // an identical live tree
+ * const restored = snapshot && createRestoredWorkflow(snapshot)       // an identical live tree
  * ```
  */
 export declare function createDatabaseWorkflowStore(driver?: DriverInterface): WorkflowStoreInterface;
@@ -315,23 +293,79 @@ export declare function createDeferred<T>(): DeferredInterface<T>;
  * {@link createDatabaseWorkflowStore} (the snapshot as one opaque JSON column over a `databases`
  * table) — for a DURABLE store (run-state surviving a restart) pass it a JSON / SQLite / IndexedDB
  * driver, and it swaps in WITHOUT touching the runner or the entity tree. Restore stays a caller
- * concern: read a snapshot back and rebuild the live tree with {@link restoreWorkflow}.
+ * concern: read a snapshot back and rebuild the live tree with {@link createRestoredWorkflow}.
  *
  * @returns A memory-backed {@link WorkflowStoreInterface}
  *
  * @example
  * ```ts
- * import { createMemoryWorkflowStore, createWorkflow, restoreWorkflow } from '@orkestrel/workflow'
+ * import { createMemoryWorkflowStore, createWorkflow, createRestoredWorkflow } from '@orkestrel/workflow'
  *
  * const store = createMemoryWorkflowStore()
  * const workflow = createWorkflow(definition)
  * await store.set(workflow.snapshot())          // persist the run state
  * const snapshot = await store.get(definition.id)
- * const restored = snapshot && restoreWorkflow(snapshot)       // an identical live tree
+ * const restored = snapshot && createRestoredWorkflow(snapshot)       // an identical live tree
  * ```
  */
 export declare function createMemoryWorkflowStore(): WorkflowStoreInterface;
 
+/**
+ * Build an interrupted workflow back to life at its remaining retry budget.
+ *
+ * @remarks
+ * Each phase captures every unique initial `run` binding once before constructing tasks. Recovery
+ * validates those live tasks' captured callable handlers without rereading the registry, while the
+ * retained registry identity remains available to resolve future live additions at their mint time.
+ *
+ * @param snapshot - The hostile persisted snapshot
+ * @param options - Runtime handlers and entity options
+ * @returns A recoverable live {@link WorkflowInterface} root
+ *
+ * @example
+ * ```ts
+ * import { createRecoveredWorkflow } from '@orkestrel/workflow'
+ *
+ * const recovered = createRecoveredWorkflow(snapshot, { functions })
+ * recovered.status // 'pending' — interrupted running work returned to its remaining budget
+ * ```
+ */
+export declare function createRecoveredWorkflow(snapshot: unknown, options?: WorkflowOptions): WorkflowInterface;
+
+/**
+ * Build an equivalent live W-b entity tree from a {@link WorkflowSnapshot} — the
+ * inverse of {@link WorkflowInterface.snapshot}, restoring structure + each node's status
+ * + recorded results + positional order + the persisted `#override`.
+ *
+ * @remarks
+ * Round-trip fidelity is paramount: a `snapshot()` → `createRestoredWorkflow()` reproduces the
+ * same status at every node (each `#override` restored DIRECTLY from the snapshot's own
+ * `override` field, not guessed from a status divergence), the same recorded
+ * {@link import('./types.js').TaskResult}s, and the same positional order (an interior
+ * `skip` / `remove` survives). The snapshot is SELF-CONTAINED — it persists the `bail`
+ * policy it ran under, so the restore re-derives status IDENTICALLY without a silent
+ * default; the snapshot's `bail` is the source of truth, while an explicit `options.bail`
+ * still wins when supplied (to deliberately re-run under a different policy). A structurally
+ * invalid snapshot (a status — or override — outside the lifecycle vocabulary, or a
+ * non-boolean `bail`) throws a `RESTORE` {@link WorkflowError}.
+ * Runtime handlers are optional: without a matching `functions` entry, a persisted `run`
+ * remains visible with an undefined `handler` so the exact state is inspectable. The runner
+ * rejects that unresolved tree if execution is attempted.
+ *
+ * @param snapshot - The snapshot to restore (carries its own `bail` + `override`)
+ * @param options - Runtime options (initial listeners, an optional `bail` override, per-node options)
+ * @returns The restored live {@link WorkflowInterface} root
+ *
+ * @example
+ * ```ts
+ * import { createRestoredWorkflow } from '@orkestrel/workflow'
+ *
+ * const restored = createRestoredWorkflow(workflow.snapshot()) // bail comes from the snapshot
+ * restored.status === workflow.status // true
+ * ```
+ */
+export declare function createRestoredWorkflow(snapshot: unknown, options?: WorkflowOptions): WorkflowInterface;
+
 /**
  * Create a thin generic orchestrator that drives declared units — and any they
  * `spawn` — through a bounded-concurrency queue, collecting their results in order.
@@ -496,11 +530,11 @@ export declare function createWorkflowContract(): ContractInterface<WorkflowDefi
  * @remarks
  * `options.functions` flows into every workflow the manager mints (`add`, via
  * {@link createWorkflow}) or hydrates (`open`'s registry-miss path, via
- * {@link restoreWorkflow}), so a hydrated workflow is RUNNABLE rather than a dead snapshot
+ * {@link createRestoredWorkflow}), so a hydrated workflow is RUNNABLE rather than a dead snapshot
  * mirror. `options.store` is the EXACT analogue of the twins' `store` seam — omitted ⇒ the
  * manager is registry-only (`open` resolves only what is registered, `save` is a no-op). This
  * is PURELY ADDITIVE: direct {@link WorkflowStoreInterface} use and
- * {@link restoreWorkflow} remain valid — the manager is one more caller-driven persistence
+ * {@link createRestoredWorkflow} remain valid — the manager is one more caller-driven persistence
  * seam, not a replacement.
  *
  * @param options - The optional `store` seam and the `functions` registry threaded into every mint/hydrate
@@ -603,18 +637,18 @@ export declare function createWorkflowRunner(options?: WorkflowRunnerOptions): W
  * idle-TTL / eviction — a persisted run-state is durable orchestration state that lives until an
  * explicit `delete`. The public surface is EXACTLY `get` / `set` / `delete` — no extra members (the
  * §22 method bijection with {@link WorkflowStoreInterface}). Restore stays a caller concern: read a
- * snapshot back and rebuild the live tree with {@link import('../factories.js').restoreWorkflow}.
+ * snapshot back and rebuild the live tree with {@link import('../factories.js').createRestoredWorkflow}.
  *
  * @example
  * ```ts
  * import { createMemoryDriver } from '@orkestrel/database'
- * import { createDatabaseWorkflowStore, createWorkflow, restoreWorkflow } from '@orkestrel/workflow'
+ * import { createDatabaseWorkflowStore, createWorkflow, createRestoredWorkflow } from '@orkestrel/workflow'
  *
  * const store = createDatabaseWorkflowStore(createMemoryDriver()) // a durable driver swaps in here
  * const workflow = createWorkflow(definition)
  * await store.set(workflow.snapshot())            // persist the run state (one JSON column)
  * const snapshot = await store.get(definition.id)
- * const restored = snapshot && restoreWorkflow(snapshot) // an identical live tree
+ * const restored = snapshot && createRestoredWorkflow(snapshot) // an identical live tree
  * await store.delete(definition.id)                // drop it
  * ```
  */
@@ -865,7 +899,7 @@ export declare function hasWorkflowHandlers(workflow: WorkflowSnapshot, function
  * insertEntry([['a', 1], ['b', 2]], 1, 'c', 3) // [['a', 1], ['c', 3], ['b', 2]]
  * ```
  */
-export declare function insertEntry<T>(entries: readonly (readonly [string, T])[], index: number, key: string, value: T): readonly (readonly [string, T])[];
+export declare function insertEntry<T>(entries: ReadonlyArray<readonly [string, T]>, index: number, key: string, value: T): ReadonlyArray<readonly [string, T]>;
 
 /** Test the workflow lifecycle vocabulary. */
 export declare function isLifecycleStatus(value: unknown): value is LifecycleStatus;
@@ -943,8 +977,9 @@ export declare function isWorkflowSnapshot(value: unknown): value is WorkflowSna
  * name + doc while the vocabulary lives in one place (AGENTS §4.4 "one concept = one
  * word"). It also types the single runtime terminal check
  * {@link import('./helpers.js').isTerminalStatus} — every tier's value is a
- * `LifecycleStatus`, so the one predicate accepts them all. The tiers stay distinct
- * types (a phase status is not a task status) even though they currently share a body.
+ * `LifecycleStatus`, so the one predicate accepts them all. The three tiers are direct
+ * aliases, not branded types, so TypeScript accepts any one of them wherever another is
+ * expected. Each name documents which tier a value came from; it does not enforce it.
  */
 export declare type LifecycleStatus = 'pending' | 'running' | 'completed' | 'failed' | 'skipped' | 'stopped';
 
@@ -980,17 +1015,17 @@ export declare const MAX_TIMER_MS = 2147483647;
  *
  * The public surface is EXACTLY `get` / `set` / `delete` — no extra members (the §22 method
  * bijection with {@link WorkflowStoreInterface}). Restore is a caller concern: read a snapshot
- * back and rebuild the live tree with {@link import('../factories.js').restoreWorkflow}.
+ * back and rebuild the live tree with {@link import('../factories.js').createRestoredWorkflow}.
  *
  * @example
  * ```ts
- * import { createMemoryWorkflowStore, createWorkflow, restoreWorkflow } from '@orkestrel/workflow'
+ * import { createMemoryWorkflowStore, createWorkflow, createRestoredWorkflow } from '@orkestrel/workflow'
  *
  * const store = createMemoryWorkflowStore()
  * const workflow = createWorkflow(definition)
  * await store.set(workflow.snapshot())      // persist the run state
  * const snapshot = await store.get(definition.id)
- * const restored = snapshot && restoreWorkflow(snapshot) // an identical live tree
+ * const restored = snapshot && createRestoredWorkflow(snapshot) // an identical live tree
  * await store.delete(definition.id)          // drop it
  * ```
  */
@@ -1024,7 +1059,7 @@ export declare class MemoryWorkflowStore implements WorkflowStoreInterface {
  * moveEntry([['a', 1], ['b', 2], ['c', 3]], 'a', 2) // [['b', 2], ['c', 3], ['a', 1]]
  * ```
  */
-export declare function moveEntry<T>(entries: readonly (readonly [string, T])[], key: string, index: number): readonly (readonly [string, T])[];
+export declare function moveEntry<T>(entries: ReadonlyArray<readonly [string, T]>, key: string, index: number): ReadonlyArray<readonly [string, T]>;
 
 /**
  * Park until `signal` aborts — a promise-parked wait (AGENTS §21), never a timer or
@@ -1687,20 +1722,6 @@ export declare const phaseUpdateShape: ObjectShape<{
     bail: OptionalShape<LiteralShape<readonly [true, false]>>;
 }, false>;
 
-/**
- * Rebuild an interrupted workflow at its remaining retry budget.
- *
- * @remarks
- * Each phase captures every unique initial `run` binding once before constructing tasks. Recovery
- * validates those live tasks' captured callable handlers without rereading the registry, while the
- * retained registry identity remains available to resolve future live additions at their mint time.
- *
- * @param snapshot - The hostile persisted snapshot
- * @param options - Runtime handlers and entity options
- * @returns A recoverable live workflow
- */
-export declare function recoverWorkflow(snapshot: unknown, options?: WorkflowOptions): WorkflowInterface;
-
 /**
  * Convert interrupted running work into a recoverable pending suffix or an
  * exhausted recovery failure without replenishing attempts.
@@ -1719,40 +1740,6 @@ export declare function recoverWorkflowSnapshot(snapshot: WorkflowSnapshot): Wor
  */
 export declare function resolveTaskSilence(value: number | undefined, fallback: number | undefined): number | undefined;
 
-/**
- * Rebuild an equivalent live W-b entity tree from a {@link WorkflowSnapshot} — the
- * inverse of {@link WorkflowInterface.snapshot}, restoring structure + each node's status
- * + recorded results + positional order + the persisted `#override`.
- *
- * @remarks
- * Round-trip fidelity is paramount: a `snapshot()` → `restoreWorkflow()` reproduces the
- * same status at every node (each `#override` restored DIRECTLY from the snapshot's own
- * `override` field, not guessed from a status divergence), the same recorded
- * {@link import('./types.js').TaskResult}s, and the same positional order (an interior
- * `skip` / `remove` survives). The snapshot is SELF-CONTAINED — it persists the `bail`
- * policy it ran under, so the restore re-derives status IDENTICALLY without a silent
- * default; the snapshot's `bail` is the source of truth, while an explicit `options.bail`
- * still wins when supplied (to deliberately re-run under a different policy). A structurally
- * invalid snapshot (a status — or override — outside the lifecycle vocabulary, or a
- * non-boolean `bail`) throws a `RESTORE` {@link WorkflowError}.
- * Runtime handlers are optional: without a matching `functions` entry, a persisted `run`
- * remains visible with an undefined `handler` so the exact state is inspectable. The runner
- * rejects that unresolved tree if execution is attempted.
- *
- * @param snapshot - The snapshot to restore (carries its own `bail` + `override`)
- * @param options - Runtime options (initial listeners, an optional `bail` override, per-node options)
- * @returns The restored live {@link WorkflowInterface} root
- *
- * @example
- * ```ts
- * import { restoreWorkflow } from '@orkestrel/workflow'
- *
- * const restored = restoreWorkflow(workflow.snapshot()) // bail comes from the snapshot
- * restored.status === workflow.status // true
- * ```
- */
-export declare function restoreWorkflow(snapshot: unknown, options?: WorkflowOptions): WorkflowInterface;
-
 /**
  * A thin generic orchestrator that drives declared units — and any they `spawn` —
  * through a bounded-concurrency {@link createQueue}, collecting ordered results.
@@ -2104,6 +2091,16 @@ export declare interface RunnerUnit<TInput> {
  * Schedule one cancellable host operation behind an owned settlement signal.
  *
  * @remarks
+ * A defined `signal` that is not a native `AbortSignal` is refused before anything is armed, as a
+ * rejected promise carrying a {@link import('./errors.js').WorkflowError} with the `SCHEDULE` code.
+ * Rejecting rather than throwing keeps every caller on one settlement path, so a backend never has
+ * to guard the call itself.
+ *
+ * The guard is necessary but not sufficient, so linking stays contained. A `Proxy` over a native
+ * signal passes the guard and can still make linking throw from a trap, and that escape would be
+ * synchronous — the one shape every caller here is built not to expect. Containment turns it into
+ * the same `SCHEDULE` rejection, so setup has exactly one failure shape however hostile the input.
+ *
  * The completion and failure paths each own an {@link AbortController}; their native composite is
  * linked to the optional caller signal before `start` can arm host work. Scheduler backends attach
  * only to that safe composite, so caller mutation of `addEventListener` or `removeEventListener`
@@ -2115,7 +2112,8 @@ export declare interface RunnerUnit<TInput> {
  *
  * @param start - Arm host work and return its cancellation closure
  * @param signal - Optional caller cancellation signal
- * @returns A promise settled exactly once by completion, host failure, or caller abort
+ * @returns A promise settled exactly once by an invalid-signal refusal, completion, host failure,
+ *   or caller abort
  */
 export declare function scheduleHost(start: (complete: () => void, failure: (error: unknown) => void) => () => void, signal?: AbortSignal): Promise<void>;
 
@@ -2492,7 +2490,7 @@ export declare interface TaskDefinition {
      * Extra attempts after the first on failure (a non-negative integer); the runner threads it
      * to this task's substrate unit, OVERRIDING the phase Runner's `retries` default. Omitted ⇒
      * the default (no extra attempts). PERSISTED in a {@link TaskSnapshot} (like `bail` and
-     * `concurrency`), so `restoreWorkflow(snapshot, { functions })` resumes with the same
+     * `concurrency`), so `createRestoredWorkflow(snapshot, { functions })` resumes with the same
      * reliability config; only the resolved handler itself is runtime-only.
      */
     readonly retries?: number;
@@ -2500,7 +2498,7 @@ export declare interface TaskDefinition {
      * @remarks
      * The workflow-owned per-attempt deadline in milliseconds, an integer from `0` through
      * `MAX_TIMER_MS`. Zero or omission means no deadline. PERSISTED in a {@link TaskSnapshot},
-     * so `restoreWorkflow(snapshot, { functions })` resumes with the same reliability config;
+     * so `createRestoredWorkflow(snapshot, { functions })` resumes with the same reliability config;
      * only the resolved handler itself is runtime-only.
      */
     readonly timeout?: number;
@@ -2914,7 +2912,7 @@ export declare const taskShape: ObjectShape<{
  * like a {@link PhaseSnapshot}'s `bail` / `concurrency`, so a restore reinstates the same
  * behavior reference and reliability overrides (`run` re-resolves against the
  * {@link WorkflowOptions.functions} registry supplied to
- * {@link import('./factories.js').restoreWorkflow}); each omitted ⇒ the corresponding
+ * {@link import('./factories.js').createRestoredWorkflow}); each omitted ⇒ the corresponding
  * unset default.
  */
 export declare interface TaskSnapshot {
@@ -3025,7 +3023,7 @@ export declare type UnitOutcome<TResult> = {
  * @remarks
  * - **Construction.** Built from a {@link WorkflowSnapshot} (the unified input —
  *   {@link import('./factories.js').createWorkflow} seeds an initial snapshot from a
- *   {@link import('./types.js').WorkflowDefinition}, {@link import('./factories.js').restoreWorkflow}
+ *   {@link import('./types.js').WorkflowDefinition}, {@link import('./factories.js').createRestoredWorkflow}
  *   passes a persisted one). Each child {@link Phase} is wired to escalate to `#recompute`.
  * - **Derived status.** `status` is `#override` when forced, else
  *   {@link deriveWorkflowStatus} over the live phases' statuses feeding `bail`. `failed` is
@@ -3040,7 +3038,7 @@ export declare type UnitOutcome<TResult> = {
  *   workflow tier; `phase(id)` + each `phase.task(id)` navigate DOWN, a task's `phase` / `workflow`
  *   navigate UP.
  * - **Snapshot.** `snapshot()` serializes the whole live tree to a {@link WorkflowSnapshot} (pure
- *   JSON); {@link import('./factories.js').restoreWorkflow} rebuilds an equivalent live tree.
+ *   JSON); {@link import('./factories.js').createRestoredWorkflow} rebuilds an equivalent live tree.
  * - **Observable (AGENTS §13).** The owned {@link emitter} ({@link WorkflowEventMap}) fires
  *   `start` / `complete` / `fail` / `pause` / `resume` / `skip` / `stop` after the
  *   corresponding status or runtime-gate change; the emitter isolates a listener throw and
@@ -3138,9 +3136,11 @@ export declare interface WorkflowDefinition {
  *
  * @remarks
  * Carries a {@link WorkflowErrorCode} and an optional `context` bag naming the
- * offending node id / status. Raised for an illegal lifecycle transition
+ * offending node id / status / parameter. Raised for an illegal lifecycle transition
  * (`TRANSITION`), a structurally invalid {@link import('./types.js').WorkflowSnapshot}
- * boundary (`RESTORE`), or a refused structural/activity edit (`MUTATION`).
+ * boundary (`RESTORE`), a refused structural/activity edit (`MUTATION`), or a host
+ * schedule refused before arming because the caller's `signal` is not a native
+ * `AbortSignal` (`SCHEDULE`, delivered as a rejected promise).
  */
 export declare class WorkflowError extends Error {
     readonly code: WorkflowErrorCode;
@@ -3156,7 +3156,7 @@ export declare class WorkflowError extends Error {
  * - `TRANSITION` — an illegal state-machine transition (e.g. `start`ing a task that is
  *   not `pending`, or `complete`/`fail`ing one that is not `running`); the guard names
  *   the offending current status + requested transition in the error `context`.
- * - `RESTORE` — a {@link import('./factories.js').restoreWorkflow} given a structurally
+ * - `RESTORE` — a {@link import('./factories.js').createRestoredWorkflow} given a structurally
  *   invalid {@link WorkflowSnapshot} (a status outside the lifecycle vocabulary).
  * - `MUTATION` — a GATED structural or patch edit was refused: a duplicate id on
  *   `append`/`add`, a target that does not exist or is not `pending`, an out-of-bounds
@@ -3170,8 +3170,13 @@ export declare class WorkflowError extends Error {
  *   {@link TaskManagerInterface.append} / {@link PhaseManagerInterface.append} duplicate-id
  *   guard (both genuine programmer-error paths, AGENTS §12). The error `context` names
  *   the offending id / index / status.
+ * - `SCHEDULE` — {@link import('./helpers.js').scheduleHost} refused to arm host work
+ *   because the caller passed a `signal` that is not a native `AbortSignal`. The refusal
+ *   is a REJECTED promise, never a synchronous throw, so every scheduler backend settles
+ *   the same way whatever the caller passed. The error `context` names the offending
+ *   parameter (`signal`) and the `typeof` the caller supplied.
  */
-export declare type WorkflowErrorCode = 'TRANSITION' | 'RESTORE' | 'MUTATION';
+export declare type WorkflowErrorCode = 'TRANSITION' | 'RESTORE' | 'MUTATION' | 'SCHEDULE';
 
 /**
  * The push observation surface (AGENTS §13) of the workflow entity (W-b) — the
@@ -3279,7 +3284,7 @@ export declare type WorkflowInput = Partial<WorkflowContext>;
  *   may force only a task-free, otherwise-pending tree. The override survives a snapshot.
  * - **Snapshot.** `snapshot()` serializes the whole live tree to a {@link WorkflowSnapshot}
  *   (pure JSON — structure + each node's status + recorded results + positional order);
- *   {@link restoreWorkflow} rebuilds an equivalent live tree.
+ *   {@link createRestoredWorkflow} rebuilds an equivalent live tree.
  * - **Observable (AGENTS §13).** The owned {@link emitter} ({@link WorkflowEventMap}) fires
  *   `start` / `complete` / `fail` / `pause` / `resume` / `stop` after the corresponding
  *   status or runtime-gate change; the emitter isolates a listener throw and routes it to
@@ -3540,7 +3545,7 @@ export declare class WorkflowManager implements WorkflowManagerInterface {
  *   is supplied (the `store` option), `open(id)` resolves an already-registered workflow
  *   directly (no store hit); same-id registry misses share one in-flight hydration. On a MISS
  *   it HYDRATES one from `store.get(id)` through
- *   {@link import('./factories.js').restoreWorkflow} — flowing this manager's `functions`
+ *   {@link import('./factories.js').createRestoredWorkflow} — flowing this manager's `functions`
  *   registry in so the rehydrated tree is RUNNABLE — registers it, and returns it. Registry
  *   mutation wins over an earlier pending hydration: `add` supplies the live result, while
  *   `remove` (even for an absent id) and `clear` invalidate the earlier read. Missed and failed
@@ -3554,7 +3559,7 @@ export declare class WorkflowManager implements WorkflowManagerInterface {
  *   `ConversationManagerInterface.open` / `.save` and `WorkspaceManagerInterface.open` /
  *   `.save` — this is the workflow line's caller-driven persistence gaining the standard
  *   open/save seam, ADDITIVE alongside direct {@link WorkflowStoreInterface} use and
- *   {@link import('./factories.js').restoreWorkflow} (both remain valid).
+ *   {@link import('./factories.js').createRestoredWorkflow} (both remain valid).
  * - **Removal.** `remove` drops one by id, or a batch (§9.2, array overload FIRST) — `true`
  *   when any was removed. `clear` empties the registry.
  * - **Event-free.** A purely registry store — no `Emitter`, no events (each
@@ -3599,7 +3604,7 @@ export declare interface WorkflowManagerInterface {
      * - Same-id registry misses share one in-flight `store.get(id)` and resolve to the same live
      *   object. On a HIT the snapshot is
      *   rehydrated into a fresh {@link WorkflowInterface} via
-     *   {@link import('./factories.js').restoreWorkflow}, flowing this manager's `functions`
+     *   {@link import('./factories.js').createRestoredWorkflow}, flowing this manager's `functions`
      *   registry in (so the rehydrated tree carries real resolved `handler`s and can RESUME
      *   real work), registers it, and returns it. A payload whose own id differs from `id` rejects
      *   with a normalized `RESTORE` error carrying the requested and payload ids.
@@ -3644,7 +3649,7 @@ export declare interface WorkflowManagerInterface {
  * already registered, and {@link WorkflowManagerInterface.save} is a no-op (`false`). `functions`
  * is the workflow-specific addition: the SAME {@link WorkflowFunctions} registry threaded into
  * every {@link import('./factories.js').createWorkflow} ({@link WorkflowManagerInterface.add})
- * and every {@link import('./factories.js').restoreWorkflow}
+ * and every {@link import('./factories.js').createRestoredWorkflow}
  * ({@link WorkflowManagerInterface.open}'s hydration path) the manager performs — so a
  * hydrated workflow carries real resolved `handler`s and is RUNNABLE. Omitted ⇒ named work
  * remains inspectable but cannot be driven; omitted-`run` tasks remain deliberate no-ops.
@@ -3661,7 +3666,7 @@ export declare interface WorkflowManagerOptions {
     /**
      * The {@link WorkflowFunctions} registry threaded into every workflow this manager mints
      * (`add`, via {@link import('./factories.js').createWorkflow}) or hydrates (`open`'s
-     * registry-miss path, via {@link import('./factories.js').restoreWorkflow}) — so a
+     * registry-miss path, via {@link import('./factories.js').createRestoredWorkflow}) — so a
      * hydrated workflow is RUNNABLE, its tasks carrying real resolved `handler`s. Omitted ⇒
      * named tasks remain inspectable but execution rejects them.
      */
@@ -3685,7 +3690,7 @@ export declare interface WorkflowOptions {
      * The failure policy (AGENTS §4.4) the live tree applies — the same boolean toggle as
      * {@link WorkflowDefinition.bail}, fed to {@link import('./helpers.js').deriveWorkflowStatus}.
      * {@link import('./factories.js').createWorkflow} defaults it to the definition's `bail`. A
-     * {@link WorkflowSnapshot} PERSISTS the policy, so {@link import('./factories.js').restoreWorkflow}
+     * {@link WorkflowSnapshot} PERSISTS the policy, so {@link import('./factories.js').createRestoredWorkflow}
      * takes it from the snapshot (the source of truth); an explicit `options.bail` on restore still
      * wins when supplied. Omitted on a fresh build ⇒ the graceful {@link import('./constants.js').DEFAULT_BAIL}.
      */
@@ -3699,7 +3704,7 @@ export declare interface WorkflowOptions {
      * {@link TaskDefinition.run} / {@link TaskSnapshot.run} name resolves against ONCE at
      * construction into its runtime {@link TaskInterface.handler} — the SAME registry a
      * fresh build ({@link import('./factories.js').createWorkflow}) and a restore
-     * ({@link import('./factories.js').restoreWorkflow}) both consume, and the same shape a
+     * ({@link import('./factories.js').createRestoredWorkflow}) both consume, and the same shape a
      * live {@link WorkflowInterface.add} / {@link PhaseInterface.add} mint resolves a newly
      * minted task against. An omitted `run` resolves to no handler and is the deliberate
      * no-op form. A present name absent from `functions` also has no handler so exact restore
@@ -4027,7 +4032,7 @@ export declare interface WorkflowRunnerInterface {
      * does not apply, since the tree already exists.
      *
      * **Run round-trips through the snapshot.** Driving a tree rebuilt by
-     * {@link import('./factories.js').restoreWorkflow} behaves according to whether a
+     * {@link import('./factories.js').createRestoredWorkflow} behaves according to whether a
      * {@link WorkflowFunctions} registry was supplied at that build: WITH a registry,
      * each task's `run` name is re-resolved against it, so a matched task carries a real
      * handler and this overload actually DISPATCHES it, resuming real work. Without a registry,
@@ -4139,7 +4144,7 @@ export declare const workflowShape: ObjectShape<{
  * designed in full at W-a so its shape is fixed from the start. It can be written to disk,
  * sent to a prompt companion, loaded across conversations, or reviewed by an agent. Because
  * it is self-contained, it carries the policy it ran under: `bail` (AGENTS §4.4) is the
- * failure policy, so {@link import('./factories.js').restoreWorkflow} re-derives status
+ * failure policy, so {@link import('./factories.js').createRestoredWorkflow} re-derives status
  * IDENTICALLY without a silent default. `status` is the EFFECTIVE status (override-or-derived)
  * at snapshot time; `override` is the forced status of a whole-workflow `skip` / `stop` or
  * vacuous `completed`. The completed override is valid only for an otherwise-derived pending
@@ -4209,7 +4214,7 @@ export declare type WorkflowStatus = LifecycleStatus;
  * {@link import('./stores/MemoryWorkflowStore.js').MemoryWorkflowStore} and its driver-pluggable
  * twin {@link import('./stores/DatabaseWorkflowStore.js').DatabaseWorkflowStore} (the snapshot as
  * one opaque JSON column) share THIS one interface. Restore is NOT a store concern — a caller reads
- * a snapshot back and rebuilds the live tree with the shipped {@link import('./factories.js').restoreWorkflow}.
+ * a snapshot back and rebuilds the live tree with the shipped {@link import('./factories.js').createRestoredWorkflow}.
  *
  * Every primitive is async (a `Promise`), so a durable backend (a database round-trip) fits the
  * same shape as the memory one. The snapshot carries its OWN id, so `set` takes no separate id