@orkestrel/workflow 0.0.8 → 0.0.10

package/dist/src/server/index.cjs

@@ -1,4 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _src_core = require("../core/index.cjs");
 //#region src/server/NodeScheduler.ts
 /**
 * The Node {@link SchedulerInterface} — the server-native cooperative-yield backend.
@@ -10,17 +11,11 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 *   resuming (unlike a microtask, which drains within the current task). `delay(ms)`
 *   waits on a real `setTimeout`.
 * - **Abort fidelity is verbatim.** A pending `yield` / `delay` rejects with
-*   `signal.reason` exactly — the value the caller passed, never wrapped or replaced.
-*   The discipline mirrors the cross-environment default's `#sleep`: an already-aborted
-*   signal rejects immediately WITHOUT arming a timer; otherwise the timer is armed and
-*   a `{ once: true }` abort listener attached, and the two settle paths are mutually
-*   exclusive — the timer path removes the listener before resolving (so a later abort
-*   cannot reach `reject`), and the abort path clears the timer before rejecting (so the
-*   macrotask cannot reach `resolve`). The promise settles exactly once, with no leaked
-*   timer and no leaked listener. It deliberately does NOT use `node:timers/promises`,
-*   whose `{ signal }` option rejects with a Node `AbortError` (`code: 'ABORT_ERR'`)
-*   rather than the caller's `signal.reason` — that would break reason fidelity, so the
-*   timer and listener are hand-rolled to match the contract.
+*   `signal.reason` exactly. The shared `scheduleHost` lifecycle links an owned composite
+*   before arming either Node handle, so caller signal method mutation is harmless and the
+*   first completion, abort, or setup failure owns settlement and cleanup. It deliberately
+*   does NOT use `node:timers/promises`, whose `{ signal }` option replaces the caller reason
+*   with a Node `AbortError` (`code: 'ABORT_ERR'`).
 * - **Priority is accepted but a no-op.** Node has no priority primitive (no equivalent
 *   of the browser's `scheduler.postTask` priorities), so `options.priority` is accepted
 *   for contract compliance and ignored — every yield/delay is uniform.
@@ -28,8 +23,8 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 *
 * @example
 * ```ts
-* import { createAbort } from '@src/core'
-* import { NodeScheduler } from '@src/server'
+* import { createAbort } from '@orkestrel/abort'
+* import { NodeScheduler } from '@orkestrel/workflow/server'
 *
 * const abort = createAbort()
 * const scheduler = new NodeScheduler()
@@ -61,34 +56,16 @@ var NodeScheduler = class {
 		return this.#sleep(ms, options?.signal);
 	}
 	#immediate(signal) {
-		if (signal?.aborted === true) return Promise.reject(signal.reason);
-		return new Promise((resolve, reject) => {
-			const handle = setImmediate(() => {
-				signal?.removeEventListener("abort", onAbort);
-				resolve();
-			});
-			const onAbort = this.#abortImmediate.bind(this, handle, reject, signal);
-			signal?.addEventListener("abort", onAbort, { once: true });
-		});
+		return (0, _src_core.scheduleHost)((complete) => {
+			const handle = setImmediate(complete);
+			return () => clearImmediate(handle);
+		}, signal);
 	}
 	#sleep(ms, signal) {
-		if (signal?.aborted === true) return Promise.reject(signal.reason);
-		return new Promise((resolve, reject) => {
-			const handle = setTimeout(() => {
-				signal?.removeEventListener("abort", onAbort);
-				resolve();
-			}, ms);
-			const onAbort = this.#abortTimeout.bind(this, handle, reject, signal);
-			signal?.addEventListener("abort", onAbort, { once: true });
-		});
-	}
-	#abortImmediate(handle, reject, signal) {
-		clearImmediate(handle);
-		reject(signal?.reason);
-	}
-	#abortTimeout(handle, reject, signal) {
-		clearTimeout(handle);
-		reject(signal?.reason);
+		return (0, _src_core.scheduleHost)((complete) => {
+			const handle = setTimeout(complete, ms);
+			return () => clearTimeout(handle);
+		}, signal);
 	}
 };
 //#endregion
@@ -102,16 +79,17 @@ var NodeScheduler = class {
 * Use it on a server instead of the cross-environment `createScheduler` when a yield
 * should hand the event loop a full turn (after pending I/O) via `setImmediate` rather
 * than a zero-delay timer. Both methods are abort-aware: pass `options.signal` and a
-* pending yield/delay rejects with the signal's `reason` (verbatim, with full
-* timer/listener cleanup). `options.priority` is accepted for contract compliance but a
+* pending yield/delay rejects with the signal's exact `reason`; the shared owned-signal
+* lifecycle clears the native handle without invoking caller listener methods.
+* `options.priority` is accepted for contract compliance but a
 * no-op — Node has no priority primitive.
 *
 * @returns A {@link SchedulerInterface} backed by Node's `setImmediate` / `setTimeout`
 *
 * @example
 * ```ts
-* import { createAbort } from '@src/core'
-* import { createNodeScheduler } from '@src/server'
+* import { createAbort } from '@orkestrel/abort'
+* import { createNodeScheduler } from '@orkestrel/workflow/server'
 *
 * const abort = createAbort()
 * const scheduler = createNodeScheduler()

package/dist/src/server/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":["#immediate","#sleep","#abortImmediate","#abortTimeout"],"sources":["../../../src/server/NodeScheduler.ts","../../../src/server/factories.ts"],"sourcesContent":["import type { SchedulerInterface, SchedulerOptions } from '@src/core'\n\n/**\n * The Node {@link SchedulerInterface} — the server-native cooperative-yield backend.\n *\n * @remarks\n * - **`yield` is a `setImmediate` host-turn.** `yield()` waits on `setImmediate`, the\n *   canonical Node \"give the host a turn\" — it runs AFTER the current operation and\n *   any pending I/O callbacks, so the event loop genuinely regains control before\n *   resuming (unlike a microtask, which drains within the current task). `delay(ms)`\n *   waits on a real `setTimeout`.\n * - **Abort fidelity is verbatim.** A pending `yield` / `delay` rejects with\n *   `signal.reason` exactly — the value the caller passed, never wrapped or replaced.\n *   The discipline mirrors the cross-environment default's `#sleep`: an already-aborted\n *   signal rejects immediately WITHOUT arming a timer; otherwise the timer is armed and\n *   a `{ once: true }` abort listener attached, and the two settle paths are mutually\n *   exclusive — the timer path removes the listener before resolving (so a later abort\n *   cannot reach `reject`), and the abort path clears the timer before rejecting (so the\n *   macrotask cannot reach `resolve`). The promise settles exactly once, with no leaked\n *   timer and no leaked listener. It deliberately does NOT use `node:timers/promises`,\n *   whose `{ signal }` option rejects with a Node `AbortError` (`code: 'ABORT_ERR'`)\n *   rather than the caller's `signal.reason` — that would break reason fidelity, so the\n *   timer and listener are hand-rolled to match the contract.\n * - **Priority is accepted but a no-op.** Node has no priority primitive (no equivalent\n *   of the browser's `scheduler.postTask` priorities), so `options.priority` is accepted\n *   for contract compliance and ignored — every yield/delay is uniform.\n * - **Event-free.** A pure functional primitive — no Emitter, no events.\n *\n * @example\n * ```ts\n * import { createAbort } from '@src/core'\n * import { NodeScheduler } from '@src/server'\n *\n * const abort = createAbort()\n * const scheduler = new NodeScheduler()\n * while (!abort.signal.aborted) {\n * \tdoSomeWork()\n * \tawait scheduler.yield({ signal: abort.signal }) // a setImmediate host-turn\n * }\n * ```\n */\nexport class NodeScheduler implements SchedulerInterface {\n\t/**\n\t * Yield control back to the event loop via `setImmediate` so pending I/O and timers\n\t * can run, then resume; abort rejects with `signal.reason`.\n\t */\n\tyield(options?: SchedulerOptions): Promise<void> {\n\t\treturn this.#immediate(options?.signal)\n\t}\n\n\t/**\n\t * Resume after at least `ms` milliseconds via `setTimeout`; abort rejects with\n\t * `signal.reason`.\n\t *\n\t * @remarks\n\t * `ms` should be a non-negative finite number. The primitive does no validation: it\n\t * passes `ms` straight to the host `setTimeout`, which clamps a negative value or\n\t * `NaN` to ~0 — so an out-of-domain `ms` resolves on the next host turn rather than\n\t * throwing.\n\t */\n\tdelay(ms: number, options?: SchedulerOptions): Promise<void> {\n\t\treturn this.#sleep(ms, options?.signal)\n\t}\n\n\t// === Private\n\n\t// The `setImmediate` host-turn for `yield`. Resolves after the immediate callback\n\t// fires (after the current operation and pending I/O); rejects with `signal.reason`\n\t// if the signal is already aborted (no immediate armed) or aborts while pending.\n\t// The two settle paths disarm each other: the immediate path removes the abort\n\t// listener before resolving; the abort path clears the immediate before rejecting —\n\t// so it settles exactly once, with no leaked handle and no leaked listener.\n\t#immediate(signal?: AbortSignal): Promise<void> {\n\t\tif (signal?.aborted === true) return Promise.reject(signal.reason)\n\t\treturn new Promise<void>((resolve, reject) => {\n\t\t\tconst handle = setImmediate(() => {\n\t\t\t\tsignal?.removeEventListener('abort', onAbort) // load-bearing: prevents a post-resolve reject\n\t\t\t\tresolve()\n\t\t\t})\n\t\t\tconst onAbort = this.#abortImmediate.bind(this, handle, reject, signal)\n\t\t\tsignal?.addEventListener('abort', onAbort, { once: true })\n\t\t})\n\t}\n\n\t// The abort-aware `setTimeout` sleep for `delay`. Same settle-once discipline as\n\t// `#immediate`, with a timer in place of the immediate: an already-aborted signal\n\t// rejects without arming; otherwise the timer path removes the listener before\n\t// resolving and the abort path clears the timer before rejecting with `signal.reason`.\n\t#sleep(ms: number, signal?: AbortSignal): Promise<void> {\n\t\tif (signal?.aborted === true) return Promise.reject(signal.reason)\n\t\treturn new Promise<void>((resolve, reject) => {\n\t\t\tconst handle = setTimeout(() => {\n\t\t\t\tsignal?.removeEventListener('abort', onAbort) // load-bearing: prevents a post-resolve reject\n\t\t\t\tresolve()\n\t\t\t}, ms)\n\t\t\tconst onAbort = this.#abortTimeout.bind(this, handle, reject, signal)\n\t\t\tsignal?.addEventListener('abort', onAbort, { once: true })\n\t\t})\n\t}\n\n\t#abortImmediate(\n\t\thandle: ReturnType<typeof setImmediate>,\n\t\treject: (reason?: unknown) => void,\n\t\tsignal?: AbortSignal,\n\t): void {\n\t\tclearImmediate(handle)\n\t\treject(signal?.reason)\n\t}\n\n\t#abortTimeout(\n\t\thandle: ReturnType<typeof setTimeout>,\n\t\treject: (reason?: unknown) => void,\n\t\tsignal?: AbortSignal,\n\t): void {\n\t\tclearTimeout(handle)\n\t\treject(signal?.reason)\n\t}\n}\n","import type { SchedulerInterface } from '@src/core'\nimport { NodeScheduler } from './NodeScheduler.js'\n\n/**\n * Create the Node-native cooperative-yield {@link SchedulerInterface} — `yield()` is a\n * `setImmediate` host-turn (the canonical Node \"give the event loop a turn\"), `delay(ms)`\n * a real `setTimeout`.\n *\n * @remarks\n * Use it on a server instead of the cross-environment `createScheduler` when a yield\n * should hand the event loop a full turn (after pending I/O) via `setImmediate` rather\n * than a zero-delay timer. Both methods are abort-aware: pass `options.signal` and a\n * pending yield/delay rejects with the signal's `reason` (verbatim, with full\n * timer/listener cleanup). `options.priority` is accepted for contract compliance but a\n * no-op — Node has no priority primitive.\n *\n * @returns A {@link SchedulerInterface} backed by Node's `setImmediate` / `setTimeout`\n *\n * @example\n * ```ts\n * import { createAbort } from '@src/core'\n * import { createNodeScheduler } from '@src/server'\n *\n * const abort = createAbort()\n * const scheduler = createNodeScheduler()\n * while (!abort.signal.aborted) {\n * \tdoSomeWork()\n * \tawait scheduler.yield({ signal: abort.signal })\n * }\n * ```\n */\nexport function createNodeScheduler(): SchedulerInterface {\n\treturn new NodeScheduler()\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,IAAa,gBAAb,MAAyD;;;;;CAKxD,MAAM,SAA2C;EAChD,OAAO,KAAKA,WAAW,SAAS,MAAM;CACvC;;;;;;;;;;;CAYA,MAAM,IAAY,SAA2C;EAC5D,OAAO,KAAKC,OAAO,IAAI,SAAS,MAAM;CACvC;CAUA,WAAW,QAAqC;EAC/C,IAAI,QAAQ,YAAY,MAAM,OAAO,QAAQ,OAAO,OAAO,MAAM;EACjE,OAAO,IAAI,SAAe,SAAS,WAAW;GAC7C,MAAM,SAAS,mBAAmB;IACjC,QAAQ,oBAAoB,SAAS,OAAO;IAC5C,QAAQ;GACT,CAAC;GACD,MAAM,UAAU,KAAKC,gBAAgB,KAAK,MAAM,QAAQ,QAAQ,MAAM;GACtE,QAAQ,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK,CAAC;EAC1D,CAAC;CACF;CAMA,OAAO,IAAY,QAAqC;EACvD,IAAI,QAAQ,YAAY,MAAM,OAAO,QAAQ,OAAO,OAAO,MAAM;EACjE,OAAO,IAAI,SAAe,SAAS,WAAW;GAC7C,MAAM,SAAS,iBAAiB;IAC/B,QAAQ,oBAAoB,SAAS,OAAO;IAC5C,QAAQ;GACT,GAAG,EAAE;GACL,MAAM,UAAU,KAAKC,cAAc,KAAK,MAAM,QAAQ,QAAQ,MAAM;GACpE,QAAQ,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK,CAAC;EAC1D,CAAC;CACF;CAEA,gBACC,QACA,QACA,QACO;EACP,eAAe,MAAM;EACrB,OAAO,QAAQ,MAAM;CACtB;CAEA,cACC,QACA,QACA,QACO;EACP,aAAa,MAAM;EACnB,OAAO,QAAQ,MAAM;CACtB;AACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACtFA,SAAgB,sBAA0C;CACzD,OAAO,IAAI,cAAc;AAC1B"}
+{"version":3,"file":"index.cjs","names":["#immediate","#sleep"],"sources":["../../../src/server/NodeScheduler.ts","../../../src/server/factories.ts"],"sourcesContent":["import type { SchedulerInterface, SchedulerOptions } from '@src/core'\nimport { scheduleHost } from '@src/core'\n\n/**\n * The Node {@link SchedulerInterface} — the server-native cooperative-yield backend.\n *\n * @remarks\n * - **`yield` is a `setImmediate` host-turn.** `yield()` waits on `setImmediate`, the\n *   canonical Node \"give the host a turn\" — it runs AFTER the current operation and\n *   any pending I/O callbacks, so the event loop genuinely regains control before\n *   resuming (unlike a microtask, which drains within the current task). `delay(ms)`\n *   waits on a real `setTimeout`.\n * - **Abort fidelity is verbatim.** A pending `yield` / `delay` rejects with\n *   `signal.reason` exactly. The shared `scheduleHost` lifecycle links an owned composite\n *   before arming either Node handle, so caller signal method mutation is harmless and the\n *   first completion, abort, or setup failure owns settlement and cleanup. It deliberately\n *   does NOT use `node:timers/promises`, whose `{ signal }` option replaces the caller reason\n *   with a Node `AbortError` (`code: 'ABORT_ERR'`).\n * - **Priority is accepted but a no-op.** Node has no priority primitive (no equivalent\n *   of the browser's `scheduler.postTask` priorities), so `options.priority` is accepted\n *   for contract compliance and ignored — every yield/delay is uniform.\n * - **Event-free.** A pure functional primitive — no Emitter, no events.\n *\n * @example\n * ```ts\n * import { createAbort } from '@orkestrel/abort'\n * import { NodeScheduler } from '@orkestrel/workflow/server'\n *\n * const abort = createAbort()\n * const scheduler = new NodeScheduler()\n * while (!abort.signal.aborted) {\n * \tdoSomeWork()\n * \tawait scheduler.yield({ signal: abort.signal }) // a setImmediate host-turn\n * }\n * ```\n */\nexport class NodeScheduler implements SchedulerInterface {\n\t/**\n\t * Yield control back to the event loop via `setImmediate` so pending I/O and timers\n\t * can run, then resume; abort rejects with `signal.reason`.\n\t */\n\tyield(options?: SchedulerOptions): Promise<void> {\n\t\treturn this.#immediate(options?.signal)\n\t}\n\n\t/**\n\t * Resume after at least `ms` milliseconds via `setTimeout`; abort rejects with\n\t * `signal.reason`.\n\t *\n\t * @remarks\n\t * `ms` should be a non-negative finite number. The primitive does no validation: it\n\t * passes `ms` straight to the host `setTimeout`, which clamps a negative value or\n\t * `NaN` to ~0 — so an out-of-domain `ms` resolves on the next host turn rather than\n\t * throwing.\n\t */\n\tdelay(ms: number, options?: SchedulerOptions): Promise<void> {\n\t\treturn this.#sleep(ms, options?.signal)\n\t}\n\n\t// === Private\n\n\t// The Node-native immediate boundary; `scheduleHost` owns cancellation lifecycle.\n\t#immediate(signal?: AbortSignal): Promise<void> {\n\t\treturn scheduleHost((complete) => {\n\t\t\tconst handle = setImmediate(complete)\n\t\t\treturn () => clearImmediate(handle)\n\t\t}, signal)\n\t}\n\n\t// The Node timer boundary; `scheduleHost` owns cancellation lifecycle.\n\t#sleep(ms: number, signal?: AbortSignal): Promise<void> {\n\t\treturn scheduleHost((complete) => {\n\t\t\tconst handle = setTimeout(complete, ms)\n\t\t\treturn () => clearTimeout(handle)\n\t\t}, signal)\n\t}\n}\n","import type { SchedulerInterface } from '@src/core'\nimport { NodeScheduler } from './NodeScheduler.js'\n\n/**\n * Create the Node-native cooperative-yield {@link SchedulerInterface} — `yield()` is a\n * `setImmediate` host-turn (the canonical Node \"give the event loop a turn\"), `delay(ms)`\n * a real `setTimeout`.\n *\n * @remarks\n * Use it on a server instead of the cross-environment `createScheduler` when a yield\n * should hand the event loop a full turn (after pending I/O) via `setImmediate` rather\n * than a zero-delay timer. Both methods are abort-aware: pass `options.signal` and a\n * pending yield/delay rejects with the signal's exact `reason`; the shared owned-signal\n * lifecycle clears the native handle without invoking caller listener methods.\n * `options.priority` is accepted for contract compliance but a\n * no-op — Node has no priority primitive.\n *\n * @returns A {@link SchedulerInterface} backed by Node's `setImmediate` / `setTimeout`\n *\n * @example\n * ```ts\n * import { createAbort } from '@orkestrel/abort'\n * import { createNodeScheduler } from '@orkestrel/workflow/server'\n *\n * const abort = createAbort()\n * const scheduler = createNodeScheduler()\n * while (!abort.signal.aborted) {\n * \tdoSomeWork()\n * \tawait scheduler.yield({ signal: abort.signal })\n * }\n * ```\n */\nexport function createNodeScheduler(): SchedulerInterface {\n\treturn new NodeScheduler()\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCA,IAAa,gBAAb,MAAyD;;;;;CAKxD,MAAM,SAA2C;EAChD,OAAO,KAAKA,WAAW,SAAS,MAAM;CACvC;;;;;;;;;;;CAYA,MAAM,IAAY,SAA2C;EAC5D,OAAO,KAAKC,OAAO,IAAI,SAAS,MAAM;CACvC;CAKA,WAAW,QAAqC;EAC/C,QAAA,GAAO,UAAA,aAAA,EAAc,aAAa;GACjC,MAAM,SAAS,aAAa,QAAQ;GACpC,aAAa,eAAe,MAAM;EACnC,GAAG,MAAM;CACV;CAGA,OAAO,IAAY,QAAqC;EACvD,QAAA,GAAO,UAAA,aAAA,EAAc,aAAa;GACjC,MAAM,SAAS,WAAW,UAAU,EAAE;GACtC,aAAa,aAAa,MAAM;EACjC,GAAG,MAAM;CACV;AACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC5CA,SAAgB,sBAA0C;CACzD,OAAO,IAAI,cAAc;AAC1B"}

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

@@ -10,16 +10,17 @@ import { SchedulerOptions } from '../core/index.ts';
  * Use it on a server instead of the cross-environment `createScheduler` when a yield
  * should hand the event loop a full turn (after pending I/O) via `setImmediate` rather
  * than a zero-delay timer. Both methods are abort-aware: pass `options.signal` and a
- * pending yield/delay rejects with the signal's `reason` (verbatim, with full
- * timer/listener cleanup). `options.priority` is accepted for contract compliance but a
+ * pending yield/delay rejects with the signal's exact `reason`; the shared owned-signal
+ * lifecycle clears the native handle without invoking caller listener methods.
+ * `options.priority` is accepted for contract compliance but a
  * no-op — Node has no priority primitive.
  *
  * @returns A {@link SchedulerInterface} backed by Node's `setImmediate` / `setTimeout`
  *
  * @example
  * ```ts
- * import { createAbort } from '@src/core'
- * import { createNodeScheduler } from '@src/server'
+ * import { createAbort } from '@orkestrel/abort'
+ * import { createNodeScheduler } from '@orkestrel/workflow/server'
  *
  * const abort = createAbort()
  * const scheduler = createNodeScheduler()
@@ -41,17 +42,11 @@ export declare function createNodeScheduler(): SchedulerInterface;
  *   resuming (unlike a microtask, which drains within the current task). `delay(ms)`
  *   waits on a real `setTimeout`.
  * - **Abort fidelity is verbatim.** A pending `yield` / `delay` rejects with
- *   `signal.reason` exactly — the value the caller passed, never wrapped or replaced.
- *   The discipline mirrors the cross-environment default's `#sleep`: an already-aborted
- *   signal rejects immediately WITHOUT arming a timer; otherwise the timer is armed and
- *   a `{ once: true }` abort listener attached, and the two settle paths are mutually
- *   exclusive — the timer path removes the listener before resolving (so a later abort
- *   cannot reach `reject`), and the abort path clears the timer before rejecting (so the
- *   macrotask cannot reach `resolve`). The promise settles exactly once, with no leaked
- *   timer and no leaked listener. It deliberately does NOT use `node:timers/promises`,
- *   whose `{ signal }` option rejects with a Node `AbortError` (`code: 'ABORT_ERR'`)
- *   rather than the caller's `signal.reason` — that would break reason fidelity, so the
- *   timer and listener are hand-rolled to match the contract.
+ *   `signal.reason` exactly. The shared `scheduleHost` lifecycle links an owned composite
+ *   before arming either Node handle, so caller signal method mutation is harmless and the
+ *   first completion, abort, or setup failure owns settlement and cleanup. It deliberately
+ *   does NOT use `node:timers/promises`, whose `{ signal }` option replaces the caller reason
+ *   with a Node `AbortError` (`code: 'ABORT_ERR'`).
  * - **Priority is accepted but a no-op.** Node has no priority primitive (no equivalent
  *   of the browser's `scheduler.postTask` priorities), so `options.priority` is accepted
  *   for contract compliance and ignored — every yield/delay is uniform.
@@ -59,8 +54,8 @@ export declare function createNodeScheduler(): SchedulerInterface;
  *
  * @example
  * ```ts
- * import { createAbort } from '@src/core'
- * import { NodeScheduler } from '@src/server'
+ * import { createAbort } from '@orkestrel/abort'
+ * import { NodeScheduler } from '@orkestrel/workflow/server'
  *
  * const abort = createAbort()
  * const scheduler = new NodeScheduler()

package/dist/src/server/index.d.ts

@@ -10,16 +10,17 @@ import { SchedulerOptions } from '../core/index.ts';
  * Use it on a server instead of the cross-environment `createScheduler` when a yield
  * should hand the event loop a full turn (after pending I/O) via `setImmediate` rather
  * than a zero-delay timer. Both methods are abort-aware: pass `options.signal` and a
- * pending yield/delay rejects with the signal's `reason` (verbatim, with full
- * timer/listener cleanup). `options.priority` is accepted for contract compliance but a
+ * pending yield/delay rejects with the signal's exact `reason`; the shared owned-signal
+ * lifecycle clears the native handle without invoking caller listener methods.
+ * `options.priority` is accepted for contract compliance but a
  * no-op — Node has no priority primitive.
  *
  * @returns A {@link SchedulerInterface} backed by Node's `setImmediate` / `setTimeout`
  *
  * @example
  * ```ts
- * import { createAbort } from '@src/core'
- * import { createNodeScheduler } from '@src/server'
+ * import { createAbort } from '@orkestrel/abort'
+ * import { createNodeScheduler } from '@orkestrel/workflow/server'
  *
  * const abort = createAbort()
  * const scheduler = createNodeScheduler()
@@ -41,17 +42,11 @@ export declare function createNodeScheduler(): SchedulerInterface;
  *   resuming (unlike a microtask, which drains within the current task). `delay(ms)`
  *   waits on a real `setTimeout`.
  * - **Abort fidelity is verbatim.** A pending `yield` / `delay` rejects with
- *   `signal.reason` exactly — the value the caller passed, never wrapped or replaced.
- *   The discipline mirrors the cross-environment default's `#sleep`: an already-aborted
- *   signal rejects immediately WITHOUT arming a timer; otherwise the timer is armed and
- *   a `{ once: true }` abort listener attached, and the two settle paths are mutually
- *   exclusive — the timer path removes the listener before resolving (so a later abort
- *   cannot reach `reject`), and the abort path clears the timer before rejecting (so the
- *   macrotask cannot reach `resolve`). The promise settles exactly once, with no leaked
- *   timer and no leaked listener. It deliberately does NOT use `node:timers/promises`,
- *   whose `{ signal }` option rejects with a Node `AbortError` (`code: 'ABORT_ERR'`)
- *   rather than the caller's `signal.reason` — that would break reason fidelity, so the
- *   timer and listener are hand-rolled to match the contract.
+ *   `signal.reason` exactly. The shared `scheduleHost` lifecycle links an owned composite
+ *   before arming either Node handle, so caller signal method mutation is harmless and the
+ *   first completion, abort, or setup failure owns settlement and cleanup. It deliberately
+ *   does NOT use `node:timers/promises`, whose `{ signal }` option replaces the caller reason
+ *   with a Node `AbortError` (`code: 'ABORT_ERR'`).
  * - **Priority is accepted but a no-op.** Node has no priority primitive (no equivalent
  *   of the browser's `scheduler.postTask` priorities), so `options.priority` is accepted
  *   for contract compliance and ignored — every yield/delay is uniform.
@@ -59,8 +54,8 @@ export declare function createNodeScheduler(): SchedulerInterface;
  *
  * @example
  * ```ts
- * import { createAbort } from '@src/core'
- * import { NodeScheduler } from '@src/server'
+ * import { createAbort } from '@orkestrel/abort'
+ * import { NodeScheduler } from '@orkestrel/workflow/server'
  *
  * const abort = createAbort()
  * const scheduler = new NodeScheduler()

package/dist/src/server/index.js

@@ -1,3 +1,4 @@
+import { scheduleHost } from "../core/index.js";
 //#region src/server/NodeScheduler.ts
 /**
 * The Node {@link SchedulerInterface} — the server-native cooperative-yield backend.
@@ -9,17 +10,11 @@
 *   resuming (unlike a microtask, which drains within the current task). `delay(ms)`
 *   waits on a real `setTimeout`.
 * - **Abort fidelity is verbatim.** A pending `yield` / `delay` rejects with
-*   `signal.reason` exactly — the value the caller passed, never wrapped or replaced.
-*   The discipline mirrors the cross-environment default's `#sleep`: an already-aborted
-*   signal rejects immediately WITHOUT arming a timer; otherwise the timer is armed and
-*   a `{ once: true }` abort listener attached, and the two settle paths are mutually
-*   exclusive — the timer path removes the listener before resolving (so a later abort
-*   cannot reach `reject`), and the abort path clears the timer before rejecting (so the
-*   macrotask cannot reach `resolve`). The promise settles exactly once, with no leaked
-*   timer and no leaked listener. It deliberately does NOT use `node:timers/promises`,
-*   whose `{ signal }` option rejects with a Node `AbortError` (`code: 'ABORT_ERR'`)
-*   rather than the caller's `signal.reason` — that would break reason fidelity, so the
-*   timer and listener are hand-rolled to match the contract.
+*   `signal.reason` exactly. The shared `scheduleHost` lifecycle links an owned composite
+*   before arming either Node handle, so caller signal method mutation is harmless and the
+*   first completion, abort, or setup failure owns settlement and cleanup. It deliberately
+*   does NOT use `node:timers/promises`, whose `{ signal }` option replaces the caller reason
+*   with a Node `AbortError` (`code: 'ABORT_ERR'`).
 * - **Priority is accepted but a no-op.** Node has no priority primitive (no equivalent
 *   of the browser's `scheduler.postTask` priorities), so `options.priority` is accepted
 *   for contract compliance and ignored — every yield/delay is uniform.
@@ -27,8 +22,8 @@
 *
 * @example
 * ```ts
-* import { createAbort } from '@src/core'
-* import { NodeScheduler } from '@src/server'
+* import { createAbort } from '@orkestrel/abort'
+* import { NodeScheduler } from '@orkestrel/workflow/server'
 *
 * const abort = createAbort()
 * const scheduler = new NodeScheduler()
@@ -60,34 +55,16 @@ var NodeScheduler = class {
 		return this.#sleep(ms, options?.signal);
 	}
 	#immediate(signal) {
-		if (signal?.aborted === true) return Promise.reject(signal.reason);
-		return new Promise((resolve, reject) => {
-			const handle = setImmediate(() => {
-				signal?.removeEventListener("abort", onAbort);
-				resolve();
-			});
-			const onAbort = this.#abortImmediate.bind(this, handle, reject, signal);
-			signal?.addEventListener("abort", onAbort, { once: true });
-		});
+		return scheduleHost((complete) => {
+			const handle = setImmediate(complete);
+			return () => clearImmediate(handle);
+		}, signal);
 	}
 	#sleep(ms, signal) {
-		if (signal?.aborted === true) return Promise.reject(signal.reason);
-		return new Promise((resolve, reject) => {
-			const handle = setTimeout(() => {
-				signal?.removeEventListener("abort", onAbort);
-				resolve();
-			}, ms);
-			const onAbort = this.#abortTimeout.bind(this, handle, reject, signal);
-			signal?.addEventListener("abort", onAbort, { once: true });
-		});
-	}
-	#abortImmediate(handle, reject, signal) {
-		clearImmediate(handle);
-		reject(signal?.reason);
-	}
-	#abortTimeout(handle, reject, signal) {
-		clearTimeout(handle);
-		reject(signal?.reason);
+		return scheduleHost((complete) => {
+			const handle = setTimeout(complete, ms);
+			return () => clearTimeout(handle);
+		}, signal);
 	}
 };
 //#endregion
@@ -101,16 +78,17 @@ var NodeScheduler = class {
 * Use it on a server instead of the cross-environment `createScheduler` when a yield
 * should hand the event loop a full turn (after pending I/O) via `setImmediate` rather
 * than a zero-delay timer. Both methods are abort-aware: pass `options.signal` and a
-* pending yield/delay rejects with the signal's `reason` (verbatim, with full
-* timer/listener cleanup). `options.priority` is accepted for contract compliance but a
+* pending yield/delay rejects with the signal's exact `reason`; the shared owned-signal
+* lifecycle clears the native handle without invoking caller listener methods.
+* `options.priority` is accepted for contract compliance but a
 * no-op — Node has no priority primitive.
 *
 * @returns A {@link SchedulerInterface} backed by Node's `setImmediate` / `setTimeout`
 *
 * @example
 * ```ts
-* import { createAbort } from '@src/core'
-* import { createNodeScheduler } from '@src/server'
+* import { createAbort } from '@orkestrel/abort'
+* import { createNodeScheduler } from '@orkestrel/workflow/server'
 *
 * const abort = createAbort()
 * const scheduler = createNodeScheduler()

package/dist/src/server/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["#immediate","#sleep","#abortImmediate","#abortTimeout"],"sources":["../../../src/server/NodeScheduler.ts","../../../src/server/factories.ts"],"sourcesContent":["import type { SchedulerInterface, SchedulerOptions } from '@src/core'\n\n/**\n * The Node {@link SchedulerInterface} — the server-native cooperative-yield backend.\n *\n * @remarks\n * - **`yield` is a `setImmediate` host-turn.** `yield()` waits on `setImmediate`, the\n *   canonical Node \"give the host a turn\" — it runs AFTER the current operation and\n *   any pending I/O callbacks, so the event loop genuinely regains control before\n *   resuming (unlike a microtask, which drains within the current task). `delay(ms)`\n *   waits on a real `setTimeout`.\n * - **Abort fidelity is verbatim.** A pending `yield` / `delay` rejects with\n *   `signal.reason` exactly — the value the caller passed, never wrapped or replaced.\n *   The discipline mirrors the cross-environment default's `#sleep`: an already-aborted\n *   signal rejects immediately WITHOUT arming a timer; otherwise the timer is armed and\n *   a `{ once: true }` abort listener attached, and the two settle paths are mutually\n *   exclusive — the timer path removes the listener before resolving (so a later abort\n *   cannot reach `reject`), and the abort path clears the timer before rejecting (so the\n *   macrotask cannot reach `resolve`). The promise settles exactly once, with no leaked\n *   timer and no leaked listener. It deliberately does NOT use `node:timers/promises`,\n *   whose `{ signal }` option rejects with a Node `AbortError` (`code: 'ABORT_ERR'`)\n *   rather than the caller's `signal.reason` — that would break reason fidelity, so the\n *   timer and listener are hand-rolled to match the contract.\n * - **Priority is accepted but a no-op.** Node has no priority primitive (no equivalent\n *   of the browser's `scheduler.postTask` priorities), so `options.priority` is accepted\n *   for contract compliance and ignored — every yield/delay is uniform.\n * - **Event-free.** A pure functional primitive — no Emitter, no events.\n *\n * @example\n * ```ts\n * import { createAbort } from '@src/core'\n * import { NodeScheduler } from '@src/server'\n *\n * const abort = createAbort()\n * const scheduler = new NodeScheduler()\n * while (!abort.signal.aborted) {\n * \tdoSomeWork()\n * \tawait scheduler.yield({ signal: abort.signal }) // a setImmediate host-turn\n * }\n * ```\n */\nexport class NodeScheduler implements SchedulerInterface {\n\t/**\n\t * Yield control back to the event loop via `setImmediate` so pending I/O and timers\n\t * can run, then resume; abort rejects with `signal.reason`.\n\t */\n\tyield(options?: SchedulerOptions): Promise<void> {\n\t\treturn this.#immediate(options?.signal)\n\t}\n\n\t/**\n\t * Resume after at least `ms` milliseconds via `setTimeout`; abort rejects with\n\t * `signal.reason`.\n\t *\n\t * @remarks\n\t * `ms` should be a non-negative finite number. The primitive does no validation: it\n\t * passes `ms` straight to the host `setTimeout`, which clamps a negative value or\n\t * `NaN` to ~0 — so an out-of-domain `ms` resolves on the next host turn rather than\n\t * throwing.\n\t */\n\tdelay(ms: number, options?: SchedulerOptions): Promise<void> {\n\t\treturn this.#sleep(ms, options?.signal)\n\t}\n\n\t// === Private\n\n\t// The `setImmediate` host-turn for `yield`. Resolves after the immediate callback\n\t// fires (after the current operation and pending I/O); rejects with `signal.reason`\n\t// if the signal is already aborted (no immediate armed) or aborts while pending.\n\t// The two settle paths disarm each other: the immediate path removes the abort\n\t// listener before resolving; the abort path clears the immediate before rejecting —\n\t// so it settles exactly once, with no leaked handle and no leaked listener.\n\t#immediate(signal?: AbortSignal): Promise<void> {\n\t\tif (signal?.aborted === true) return Promise.reject(signal.reason)\n\t\treturn new Promise<void>((resolve, reject) => {\n\t\t\tconst handle = setImmediate(() => {\n\t\t\t\tsignal?.removeEventListener('abort', onAbort) // load-bearing: prevents a post-resolve reject\n\t\t\t\tresolve()\n\t\t\t})\n\t\t\tconst onAbort = this.#abortImmediate.bind(this, handle, reject, signal)\n\t\t\tsignal?.addEventListener('abort', onAbort, { once: true })\n\t\t})\n\t}\n\n\t// The abort-aware `setTimeout` sleep for `delay`. Same settle-once discipline as\n\t// `#immediate`, with a timer in place of the immediate: an already-aborted signal\n\t// rejects without arming; otherwise the timer path removes the listener before\n\t// resolving and the abort path clears the timer before rejecting with `signal.reason`.\n\t#sleep(ms: number, signal?: AbortSignal): Promise<void> {\n\t\tif (signal?.aborted === true) return Promise.reject(signal.reason)\n\t\treturn new Promise<void>((resolve, reject) => {\n\t\t\tconst handle = setTimeout(() => {\n\t\t\t\tsignal?.removeEventListener('abort', onAbort) // load-bearing: prevents a post-resolve reject\n\t\t\t\tresolve()\n\t\t\t}, ms)\n\t\t\tconst onAbort = this.#abortTimeout.bind(this, handle, reject, signal)\n\t\t\tsignal?.addEventListener('abort', onAbort, { once: true })\n\t\t})\n\t}\n\n\t#abortImmediate(\n\t\thandle: ReturnType<typeof setImmediate>,\n\t\treject: (reason?: unknown) => void,\n\t\tsignal?: AbortSignal,\n\t): void {\n\t\tclearImmediate(handle)\n\t\treject(signal?.reason)\n\t}\n\n\t#abortTimeout(\n\t\thandle: ReturnType<typeof setTimeout>,\n\t\treject: (reason?: unknown) => void,\n\t\tsignal?: AbortSignal,\n\t): void {\n\t\tclearTimeout(handle)\n\t\treject(signal?.reason)\n\t}\n}\n","import type { SchedulerInterface } from '@src/core'\nimport { NodeScheduler } from './NodeScheduler.js'\n\n/**\n * Create the Node-native cooperative-yield {@link SchedulerInterface} — `yield()` is a\n * `setImmediate` host-turn (the canonical Node \"give the event loop a turn\"), `delay(ms)`\n * a real `setTimeout`.\n *\n * @remarks\n * Use it on a server instead of the cross-environment `createScheduler` when a yield\n * should hand the event loop a full turn (after pending I/O) via `setImmediate` rather\n * than a zero-delay timer. Both methods are abort-aware: pass `options.signal` and a\n * pending yield/delay rejects with the signal's `reason` (verbatim, with full\n * timer/listener cleanup). `options.priority` is accepted for contract compliance but a\n * no-op — Node has no priority primitive.\n *\n * @returns A {@link SchedulerInterface} backed by Node's `setImmediate` / `setTimeout`\n *\n * @example\n * ```ts\n * import { createAbort } from '@src/core'\n * import { createNodeScheduler } from '@src/server'\n *\n * const abort = createAbort()\n * const scheduler = createNodeScheduler()\n * while (!abort.signal.aborted) {\n * \tdoSomeWork()\n * \tawait scheduler.yield({ signal: abort.signal })\n * }\n * ```\n */\nexport function createNodeScheduler(): SchedulerInterface {\n\treturn new NodeScheduler()\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,IAAa,gBAAb,MAAyD;;;;;CAKxD,MAAM,SAA2C;EAChD,OAAO,KAAKA,WAAW,SAAS,MAAM;CACvC;;;;;;;;;;;CAYA,MAAM,IAAY,SAA2C;EAC5D,OAAO,KAAKC,OAAO,IAAI,SAAS,MAAM;CACvC;CAUA,WAAW,QAAqC;EAC/C,IAAI,QAAQ,YAAY,MAAM,OAAO,QAAQ,OAAO,OAAO,MAAM;EACjE,OAAO,IAAI,SAAe,SAAS,WAAW;GAC7C,MAAM,SAAS,mBAAmB;IACjC,QAAQ,oBAAoB,SAAS,OAAO;IAC5C,QAAQ;GACT,CAAC;GACD,MAAM,UAAU,KAAKC,gBAAgB,KAAK,MAAM,QAAQ,QAAQ,MAAM;GACtE,QAAQ,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK,CAAC;EAC1D,CAAC;CACF;CAMA,OAAO,IAAY,QAAqC;EACvD,IAAI,QAAQ,YAAY,MAAM,OAAO,QAAQ,OAAO,OAAO,MAAM;EACjE,OAAO,IAAI,SAAe,SAAS,WAAW;GAC7C,MAAM,SAAS,iBAAiB;IAC/B,QAAQ,oBAAoB,SAAS,OAAO;IAC5C,QAAQ;GACT,GAAG,EAAE;GACL,MAAM,UAAU,KAAKC,cAAc,KAAK,MAAM,QAAQ,QAAQ,MAAM;GACpE,QAAQ,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK,CAAC;EAC1D,CAAC;CACF;CAEA,gBACC,QACA,QACA,QACO;EACP,eAAe,MAAM;EACrB,OAAO,QAAQ,MAAM;CACtB;CAEA,cACC,QACA,QACA,QACO;EACP,aAAa,MAAM;EACnB,OAAO,QAAQ,MAAM;CACtB;AACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACtFA,SAAgB,sBAA0C;CACzD,OAAO,IAAI,cAAc;AAC1B"}
+{"version":3,"file":"index.js","names":["#immediate","#sleep"],"sources":["../../../src/server/NodeScheduler.ts","../../../src/server/factories.ts"],"sourcesContent":["import type { SchedulerInterface, SchedulerOptions } from '@src/core'\nimport { scheduleHost } from '@src/core'\n\n/**\n * The Node {@link SchedulerInterface} — the server-native cooperative-yield backend.\n *\n * @remarks\n * - **`yield` is a `setImmediate` host-turn.** `yield()` waits on `setImmediate`, the\n *   canonical Node \"give the host a turn\" — it runs AFTER the current operation and\n *   any pending I/O callbacks, so the event loop genuinely regains control before\n *   resuming (unlike a microtask, which drains within the current task). `delay(ms)`\n *   waits on a real `setTimeout`.\n * - **Abort fidelity is verbatim.** A pending `yield` / `delay` rejects with\n *   `signal.reason` exactly. The shared `scheduleHost` lifecycle links an owned composite\n *   before arming either Node handle, so caller signal method mutation is harmless and the\n *   first completion, abort, or setup failure owns settlement and cleanup. It deliberately\n *   does NOT use `node:timers/promises`, whose `{ signal }` option replaces the caller reason\n *   with a Node `AbortError` (`code: 'ABORT_ERR'`).\n * - **Priority is accepted but a no-op.** Node has no priority primitive (no equivalent\n *   of the browser's `scheduler.postTask` priorities), so `options.priority` is accepted\n *   for contract compliance and ignored — every yield/delay is uniform.\n * - **Event-free.** A pure functional primitive — no Emitter, no events.\n *\n * @example\n * ```ts\n * import { createAbort } from '@orkestrel/abort'\n * import { NodeScheduler } from '@orkestrel/workflow/server'\n *\n * const abort = createAbort()\n * const scheduler = new NodeScheduler()\n * while (!abort.signal.aborted) {\n * \tdoSomeWork()\n * \tawait scheduler.yield({ signal: abort.signal }) // a setImmediate host-turn\n * }\n * ```\n */\nexport class NodeScheduler implements SchedulerInterface {\n\t/**\n\t * Yield control back to the event loop via `setImmediate` so pending I/O and timers\n\t * can run, then resume; abort rejects with `signal.reason`.\n\t */\n\tyield(options?: SchedulerOptions): Promise<void> {\n\t\treturn this.#immediate(options?.signal)\n\t}\n\n\t/**\n\t * Resume after at least `ms` milliseconds via `setTimeout`; abort rejects with\n\t * `signal.reason`.\n\t *\n\t * @remarks\n\t * `ms` should be a non-negative finite number. The primitive does no validation: it\n\t * passes `ms` straight to the host `setTimeout`, which clamps a negative value or\n\t * `NaN` to ~0 — so an out-of-domain `ms` resolves on the next host turn rather than\n\t * throwing.\n\t */\n\tdelay(ms: number, options?: SchedulerOptions): Promise<void> {\n\t\treturn this.#sleep(ms, options?.signal)\n\t}\n\n\t// === Private\n\n\t// The Node-native immediate boundary; `scheduleHost` owns cancellation lifecycle.\n\t#immediate(signal?: AbortSignal): Promise<void> {\n\t\treturn scheduleHost((complete) => {\n\t\t\tconst handle = setImmediate(complete)\n\t\t\treturn () => clearImmediate(handle)\n\t\t}, signal)\n\t}\n\n\t// The Node timer boundary; `scheduleHost` owns cancellation lifecycle.\n\t#sleep(ms: number, signal?: AbortSignal): Promise<void> {\n\t\treturn scheduleHost((complete) => {\n\t\t\tconst handle = setTimeout(complete, ms)\n\t\t\treturn () => clearTimeout(handle)\n\t\t}, signal)\n\t}\n}\n","import type { SchedulerInterface } from '@src/core'\nimport { NodeScheduler } from './NodeScheduler.js'\n\n/**\n * Create the Node-native cooperative-yield {@link SchedulerInterface} — `yield()` is a\n * `setImmediate` host-turn (the canonical Node \"give the event loop a turn\"), `delay(ms)`\n * a real `setTimeout`.\n *\n * @remarks\n * Use it on a server instead of the cross-environment `createScheduler` when a yield\n * should hand the event loop a full turn (after pending I/O) via `setImmediate` rather\n * than a zero-delay timer. Both methods are abort-aware: pass `options.signal` and a\n * pending yield/delay rejects with the signal's exact `reason`; the shared owned-signal\n * lifecycle clears the native handle without invoking caller listener methods.\n * `options.priority` is accepted for contract compliance but a\n * no-op — Node has no priority primitive.\n *\n * @returns A {@link SchedulerInterface} backed by Node's `setImmediate` / `setTimeout`\n *\n * @example\n * ```ts\n * import { createAbort } from '@orkestrel/abort'\n * import { createNodeScheduler } from '@orkestrel/workflow/server'\n *\n * const abort = createAbort()\n * const scheduler = createNodeScheduler()\n * while (!abort.signal.aborted) {\n * \tdoSomeWork()\n * \tawait scheduler.yield({ signal: abort.signal })\n * }\n * ```\n */\nexport function createNodeScheduler(): SchedulerInterface {\n\treturn new NodeScheduler()\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCA,IAAa,gBAAb,MAAyD;;;;;CAKxD,MAAM,SAA2C;EAChD,OAAO,KAAKA,WAAW,SAAS,MAAM;CACvC;;;;;;;;;;;CAYA,MAAM,IAAY,SAA2C;EAC5D,OAAO,KAAKC,OAAO,IAAI,SAAS,MAAM;CACvC;CAKA,WAAW,QAAqC;EAC/C,OAAO,cAAc,aAAa;GACjC,MAAM,SAAS,aAAa,QAAQ;GACpC,aAAa,eAAe,MAAM;EACnC,GAAG,MAAM;CACV;CAGA,OAAO,IAAY,QAAqC;EACvD,OAAO,cAAc,aAAa;GACjC,MAAM,SAAS,WAAW,UAAU,EAAE;GACtC,aAAa,aAAa,MAAM;EACjC,GAAG,MAAM;CACV;AACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC5CA,SAAgB,sBAA0C;CACzD,OAAO,IAAI,cAAc;AAC1B"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@orkestrel/workflow",
-	"version": "0.0.8",
+	"version": "0.0.10",
 	"description": "A typed workflow engine for the @orkestrel line — a serializable Workflow → Phase → Task tree run by a composed runner on a cooperative scheduler. Part of the @orkestrel line.",
 	"keywords": [
 		"orchestration",
@@ -85,22 +85,22 @@
 		"prepublishOnly": "npm run format:check && npm run lint:check && npm run check && npm run build && npm test"
 	},
 	"dependencies": {
-		"@orkestrel/abort": "^0.0.4",
-		"@orkestrel/budget": "^0.0.4",
+		"@orkestrel/abort": "^0.0.5",
+		"@orkestrel/budget": "^0.0.5",
 		"@orkestrel/contract": "^0.0.9",
 		"@orkestrel/database": "^0.0.7",
 		"@orkestrel/emitter": "^0.0.5",
-		"@orkestrel/queue": "^0.0.4",
-		"@orkestrel/timeout": "^0.0.4"
+		"@orkestrel/queue": "^0.0.7",
+		"@orkestrel/timeout": "^0.0.5"
 	},
 	"devDependencies": {
 		"@microsoft/api-extractor": "^7.58.12",
 		"@orkestrel/guide": "^0.0.8",
-		"@orkestrel/scaffold": "^0.0.13",
+		"@orkestrel/scaffold": "^0.0.18",
 		"@types/node": "^26.1.2",
 		"@vitest/browser-playwright": "^4.1.10",
-		"oxfmt": "^0.61.0",
-		"oxlint": "^1.76.0",
+		"oxfmt": "^0.62.0",
+		"oxlint": "^1.77.0",
 		"playwright": "^1.62.1",
 		"typescript": "^6.0.3",
 		"vite": "^8.2.0",