@orkestrel/workflow 0.0.16 → 0.0.18

package/dist/src/server/index.cjs

@@ -2,11 +2,13 @@ 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.
+* Implements the Node {@link SchedulerInterface} — the server-native cooperative-yield backend
+* whose `yield` waits on `setImmediate` and whose abort rejects with the caller's own reason.
+* A `priority` hint is accepted and does nothing, because Node has no priority primitive.
 *
 * @remarks
 * - **`yield` is a `setImmediate` host-turn.** `yield()` waits on `setImmediate`, the
-*   canonical Node "give the host a turn" — it runs AFTER the current operation and
+*   canonical Node "give the host a turn" — it runs after the current operation and
 *   any pending I/O callbacks, so the event loop genuinely regains control before
 *   resuming (unlike a microtask, which drains within the current task). `delay(ms)`
 *   waits on a real `setTimeout`.
@@ -14,7 +16,7 @@ let _src_core = require("../core/index.cjs");
 *   `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
+*   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
@@ -36,24 +38,23 @@ let _src_core = require("../core/index.cjs");
 */
 var NodeScheduler = class {
 	/**
-	* Yield control back to the event loop via `setImmediate` so pending I/O and timers
-	* can run, then resume; abort rejects with `signal.reason`.
+	* Yields control back to the event loop through `setImmediate` so pending I/O and timers
+	* can run, then resumes; abort rejects with `signal.reason`.
 	*/
 	yield(options) {
 		return this.#immediate(options?.signal);
 	}
 	/**
-	* Resume after at least `ms` milliseconds via `setTimeout`; abort rejects with
+	* Resumes after at least `ms` milliseconds through `setTimeout`; abort rejects with
 	* `signal.reason`.
 	*
 	* @remarks
-	* `ms` should be a non-negative finite number. The primitive does no validation: it
-	* passes `ms` straight to the host `setTimeout`, which clamps a negative value or
-	* `NaN` to ~0 — so an out-of-domain `ms` resolves on the next host turn rather than
-	* throwing.
+	* Pass a non-negative finite `ms`. The primitive does no validation: it passes `ms`
+	* straight to the host `setTimeout`, which clamps a negative value or `NaN` to ~0 — so an
+	* out-of-domain `ms` resolves on the next host turn rather than throwing.
 	*/
 	delay(ms, options) {
-		return this.#sleep(ms, options?.signal);
+		return (0, _src_core.delayHost)(ms, options?.signal);
 	}
 	#immediate(signal) {
 		return (0, _src_core.scheduleHost)((complete) => {
@@ -61,24 +62,18 @@ var NodeScheduler = class {
 			return () => clearImmediate(handle);
 		}, signal);
 	}
-	#sleep(ms, signal) {
-		return (0, _src_core.scheduleHost)((complete) => {
-			const handle = setTimeout(complete, ms);
-			return () => clearTimeout(handle);
-		}, signal);
-	}
 };
 //#endregion
 //#region src/server/factories.ts
 /**
-* Create the Node-native cooperative-yield {@link SchedulerInterface} — `yield()` is a
+* Creates the Node-native cooperative-yield {@link SchedulerInterface} — `yield()` is a
 * `setImmediate` host-turn (the canonical Node "give the event loop a turn"), `delay(ms)`
 * a real `setTimeout`.
 *
 * @remarks
-* 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
+* Use it on a server instead of the cross-environment `createScheduler` when a yield must
+* hand the event loop a full turn (after pending I/O) through `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 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

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

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":[],"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,KAAK,WAAW,SAAS,MAAM;CACvC;;;;;;;;;;;CAYA,MAAM,IAAY,SAA2C;EAC5D,OAAO,KAAK,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"}
+{"version":3,"file":"index.cjs","names":[],"sources":["../../../src/server/NodeScheduler.ts","../../../src/server/factories.ts"],"sourcesContent":["import type { SchedulerInterface, SchedulerOptions } from '@src/core'\nimport { delayHost, scheduleHost } from '@src/core'\n\n/**\n * Implements the Node {@link SchedulerInterface} — the server-native cooperative-yield backend\n * whose `yield` waits on `setImmediate` and whose abort rejects with the caller's own reason.\n * A `priority` hint is accepted and does nothing, because Node has no priority primitive.\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 * Yields control back to the event loop through `setImmediate` so pending I/O and timers\n\t * can run, then resumes; 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 * Resumes after at least `ms` milliseconds through `setTimeout`; abort rejects with\n\t * `signal.reason`.\n\t *\n\t * @remarks\n\t * Pass a non-negative finite `ms`. The primitive does no validation: it passes `ms`\n\t * straight to the host `setTimeout`, which clamps a negative value or `NaN` to ~0 — so an\n\t * out-of-domain `ms` resolves on the next host turn rather than throwing.\n\t */\n\tdelay(ms: number, options?: SchedulerOptions): Promise<void> {\n\t\treturn delayHost(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","import type { SchedulerInterface } from '@src/core'\nimport { NodeScheduler } from './NodeScheduler.js'\n\n/**\n * Creates 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 must\n * hand the event loop a full turn (after pending I/O) through `setImmediate` rather than a\n * 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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,IAAa,gBAAb,MAAyD;;;;;CAKxD,MAAM,SAA2C;EAChD,OAAO,KAAK,WAAW,SAAS,MAAM;CACvC;;;;;;;;;;CAWA,MAAM,IAAY,SAA2C;EAC5D,QAAA,GAAO,UAAA,UAAA,CAAU,IAAI,SAAS,MAAM;CACrC;CAKA,WAAW,QAAqC;EAC/C,QAAA,GAAO,UAAA,aAAA,EAAc,aAAa;GACjC,MAAM,SAAS,aAAa,QAAQ;GACpC,aAAa,eAAe,MAAM;EACnC,GAAG,MAAM;CACV;AACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACrCA,SAAgB,sBAA0C;CACzD,OAAO,IAAI,cAAc;AAC1B"}

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

@@ -1,15 +1,15 @@
-import { SchedulerInterface } from '@orkestrel/workflow';
-import { SchedulerOptions } from '@orkestrel/workflow';
+import type { SchedulerInterface } from '@orkestrel/workflow';
+import type { SchedulerOptions } from '@orkestrel/workflow';
 
 /**
- * Create the Node-native cooperative-yield {@link SchedulerInterface} — `yield()` is a
+ * Creates the Node-native cooperative-yield {@link SchedulerInterface} — `yield()` is a
  * `setImmediate` host-turn (the canonical Node "give the event loop a turn"), `delay(ms)`
  * a real `setTimeout`.
  *
  * @remarks
- * 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
+ * Use it on a server instead of the cross-environment `createScheduler` when a yield must
+ * hand the event loop a full turn (after pending I/O) through `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 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
@@ -33,11 +33,13 @@ import { SchedulerOptions } from '@orkestrel/workflow';
 export declare function createNodeScheduler(): SchedulerInterface;
 
 /**
- * The Node {@link SchedulerInterface} — the server-native cooperative-yield backend.
+ * Implements the Node {@link SchedulerInterface} — the server-native cooperative-yield backend
+ * whose `yield` waits on `setImmediate` and whose abort rejects with the caller's own reason.
+ * A `priority` hint is accepted and does nothing, because Node has no priority primitive.
  *
  * @remarks
  * - **`yield` is a `setImmediate` host-turn.** `yield()` waits on `setImmediate`, the
- *   canonical Node "give the host a turn" — it runs AFTER the current operation and
+ *   canonical Node "give the host a turn" — it runs after the current operation and
  *   any pending I/O callbacks, so the event loop genuinely regains control before
  *   resuming (unlike a microtask, which drains within the current task). `delay(ms)`
  *   waits on a real `setTimeout`.
@@ -45,7 +47,7 @@ export declare function createNodeScheduler(): SchedulerInterface;
  *   `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
+ *   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
@@ -68,19 +70,18 @@ export declare function createNodeScheduler(): SchedulerInterface;
 export declare class NodeScheduler implements SchedulerInterface {
     #private;
     /**
-     * Yield control back to the event loop via `setImmediate` so pending I/O and timers
-     * can run, then resume; abort rejects with `signal.reason`.
+     * Yields control back to the event loop through `setImmediate` so pending I/O and timers
+     * can run, then resumes; abort rejects with `signal.reason`.
      */
     yield(options?: SchedulerOptions): Promise<void>;
     /**
-     * Resume after at least `ms` milliseconds via `setTimeout`; abort rejects with
+     * Resumes after at least `ms` milliseconds through `setTimeout`; abort rejects with
      * `signal.reason`.
      *
      * @remarks
-     * `ms` should be a non-negative finite number. The primitive does no validation: it
-     * passes `ms` straight to the host `setTimeout`, which clamps a negative value or
-     * `NaN` to ~0 — so an out-of-domain `ms` resolves on the next host turn rather than
-     * throwing.
+     * Pass a non-negative finite `ms`. The primitive does no validation: it passes `ms`
+     * straight to the host `setTimeout`, which clamps a negative value or `NaN` to ~0 — so an
+     * out-of-domain `ms` resolves on the next host turn rather than throwing.
      */
     delay(ms: number, options?: SchedulerOptions): Promise<void>;
 }

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

@@ -1,15 +1,15 @@
-import { SchedulerInterface } from '@orkestrel/workflow';
-import { SchedulerOptions } from '@orkestrel/workflow';
+import type { SchedulerInterface } from '@orkestrel/workflow';
+import type { SchedulerOptions } from '@orkestrel/workflow';
 
 /**
- * Create the Node-native cooperative-yield {@link SchedulerInterface} — `yield()` is a
+ * Creates the Node-native cooperative-yield {@link SchedulerInterface} — `yield()` is a
  * `setImmediate` host-turn (the canonical Node "give the event loop a turn"), `delay(ms)`
  * a real `setTimeout`.
  *
  * @remarks
- * 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
+ * Use it on a server instead of the cross-environment `createScheduler` when a yield must
+ * hand the event loop a full turn (after pending I/O) through `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 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
@@ -33,11 +33,13 @@ import { SchedulerOptions } from '@orkestrel/workflow';
 export declare function createNodeScheduler(): SchedulerInterface;
 
 /**
- * The Node {@link SchedulerInterface} — the server-native cooperative-yield backend.
+ * Implements the Node {@link SchedulerInterface} — the server-native cooperative-yield backend
+ * whose `yield` waits on `setImmediate` and whose abort rejects with the caller's own reason.
+ * A `priority` hint is accepted and does nothing, because Node has no priority primitive.
  *
  * @remarks
  * - **`yield` is a `setImmediate` host-turn.** `yield()` waits on `setImmediate`, the
- *   canonical Node "give the host a turn" — it runs AFTER the current operation and
+ *   canonical Node "give the host a turn" — it runs after the current operation and
  *   any pending I/O callbacks, so the event loop genuinely regains control before
  *   resuming (unlike a microtask, which drains within the current task). `delay(ms)`
  *   waits on a real `setTimeout`.
@@ -45,7 +47,7 @@ export declare function createNodeScheduler(): SchedulerInterface;
  *   `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
+ *   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
@@ -68,19 +70,18 @@ export declare function createNodeScheduler(): SchedulerInterface;
 export declare class NodeScheduler implements SchedulerInterface {
     #private;
     /**
-     * Yield control back to the event loop via `setImmediate` so pending I/O and timers
-     * can run, then resume; abort rejects with `signal.reason`.
+     * Yields control back to the event loop through `setImmediate` so pending I/O and timers
+     * can run, then resumes; abort rejects with `signal.reason`.
      */
     yield(options?: SchedulerOptions): Promise<void>;
     /**
-     * Resume after at least `ms` milliseconds via `setTimeout`; abort rejects with
+     * Resumes after at least `ms` milliseconds through `setTimeout`; abort rejects with
      * `signal.reason`.
      *
      * @remarks
-     * `ms` should be a non-negative finite number. The primitive does no validation: it
-     * passes `ms` straight to the host `setTimeout`, which clamps a negative value or
-     * `NaN` to ~0 — so an out-of-domain `ms` resolves on the next host turn rather than
-     * throwing.
+     * Pass a non-negative finite `ms`. The primitive does no validation: it passes `ms`
+     * straight to the host `setTimeout`, which clamps a negative value or `NaN` to ~0 — so an
+     * out-of-domain `ms` resolves on the next host turn rather than throwing.
      */
     delay(ms: number, options?: SchedulerOptions): Promise<void>;
 }

package/dist/src/server/index.js

@@ -1,11 +1,13 @@
-import { scheduleHost } from "../core/index.js";
+import { delayHost, scheduleHost } from "../core/index.js";
 //#region src/server/NodeScheduler.ts
 /**
-* The Node {@link SchedulerInterface} — the server-native cooperative-yield backend.
+* Implements the Node {@link SchedulerInterface} — the server-native cooperative-yield backend
+* whose `yield` waits on `setImmediate` and whose abort rejects with the caller's own reason.
+* A `priority` hint is accepted and does nothing, because Node has no priority primitive.
 *
 * @remarks
 * - **`yield` is a `setImmediate` host-turn.** `yield()` waits on `setImmediate`, the
-*   canonical Node "give the host a turn" — it runs AFTER the current operation and
+*   canonical Node "give the host a turn" — it runs after the current operation and
 *   any pending I/O callbacks, so the event loop genuinely regains control before
 *   resuming (unlike a microtask, which drains within the current task). `delay(ms)`
 *   waits on a real `setTimeout`.
@@ -13,7 +15,7 @@ import { scheduleHost } from "../core/index.js";
 *   `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
+*   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
@@ -35,24 +37,23 @@ import { scheduleHost } from "../core/index.js";
 */
 var NodeScheduler = class {
 	/**
-	* Yield control back to the event loop via `setImmediate` so pending I/O and timers
-	* can run, then resume; abort rejects with `signal.reason`.
+	* Yields control back to the event loop through `setImmediate` so pending I/O and timers
+	* can run, then resumes; abort rejects with `signal.reason`.
 	*/
 	yield(options) {
 		return this.#immediate(options?.signal);
 	}
 	/**
-	* Resume after at least `ms` milliseconds via `setTimeout`; abort rejects with
+	* Resumes after at least `ms` milliseconds through `setTimeout`; abort rejects with
 	* `signal.reason`.
 	*
 	* @remarks
-	* `ms` should be a non-negative finite number. The primitive does no validation: it
-	* passes `ms` straight to the host `setTimeout`, which clamps a negative value or
-	* `NaN` to ~0 — so an out-of-domain `ms` resolves on the next host turn rather than
-	* throwing.
+	* Pass a non-negative finite `ms`. The primitive does no validation: it passes `ms`
+	* straight to the host `setTimeout`, which clamps a negative value or `NaN` to ~0 — so an
+	* out-of-domain `ms` resolves on the next host turn rather than throwing.
 	*/
 	delay(ms, options) {
-		return this.#sleep(ms, options?.signal);
+		return delayHost(ms, options?.signal);
 	}
 	#immediate(signal) {
 		return scheduleHost((complete) => {
@@ -60,24 +61,18 @@ var NodeScheduler = class {
 			return () => clearImmediate(handle);
 		}, signal);
 	}
-	#sleep(ms, signal) {
-		return scheduleHost((complete) => {
-			const handle = setTimeout(complete, ms);
-			return () => clearTimeout(handle);
-		}, signal);
-	}
 };
 //#endregion
 //#region src/server/factories.ts
 /**
-* Create the Node-native cooperative-yield {@link SchedulerInterface} — `yield()` is a
+* Creates the Node-native cooperative-yield {@link SchedulerInterface} — `yield()` is a
 * `setImmediate` host-turn (the canonical Node "give the event loop a turn"), `delay(ms)`
 * a real `setTimeout`.
 *
 * @remarks
-* 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
+* Use it on a server instead of the cross-environment `createScheduler` when a yield must
+* hand the event loop a full turn (after pending I/O) through `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 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

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

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"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,KAAK,WAAW,SAAS,MAAM;CACvC;;;;;;;;;;;CAYA,MAAM,IAAY,SAA2C;EAC5D,OAAO,KAAK,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"}
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/server/NodeScheduler.ts","../../../src/server/factories.ts"],"sourcesContent":["import type { SchedulerInterface, SchedulerOptions } from '@src/core'\nimport { delayHost, scheduleHost } from '@src/core'\n\n/**\n * Implements the Node {@link SchedulerInterface} — the server-native cooperative-yield backend\n * whose `yield` waits on `setImmediate` and whose abort rejects with the caller's own reason.\n * A `priority` hint is accepted and does nothing, because Node has no priority primitive.\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 * Yields control back to the event loop through `setImmediate` so pending I/O and timers\n\t * can run, then resumes; 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 * Resumes after at least `ms` milliseconds through `setTimeout`; abort rejects with\n\t * `signal.reason`.\n\t *\n\t * @remarks\n\t * Pass a non-negative finite `ms`. The primitive does no validation: it passes `ms`\n\t * straight to the host `setTimeout`, which clamps a negative value or `NaN` to ~0 — so an\n\t * out-of-domain `ms` resolves on the next host turn rather than throwing.\n\t */\n\tdelay(ms: number, options?: SchedulerOptions): Promise<void> {\n\t\treturn delayHost(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","import type { SchedulerInterface } from '@src/core'\nimport { NodeScheduler } from './NodeScheduler.js'\n\n/**\n * Creates 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 must\n * hand the event loop a full turn (after pending I/O) through `setImmediate` rather than a\n * 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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,IAAa,gBAAb,MAAyD;;;;;CAKxD,MAAM,SAA2C;EAChD,OAAO,KAAK,WAAW,SAAS,MAAM;CACvC;;;;;;;;;;CAWA,MAAM,IAAY,SAA2C;EAC5D,OAAO,UAAU,IAAI,SAAS,MAAM;CACrC;CAKA,WAAW,QAAqC;EAC/C,OAAO,cAAc,aAAa;GACjC,MAAM,SAAS,aAAa,QAAQ;GACpC,aAAa,eAAe,MAAM;EACnC,GAAG,MAAM;CACV;AACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACrCA,SAAgB,sBAA0C;CACzD,OAAO,IAAI,cAAc;AAC1B"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@orkestrel/workflow",
-	"version": "0.0.16",
+	"version": "0.0.18",
 	"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",
@@ -61,7 +61,7 @@
 		"clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\"",
 		"copy": "node -e \"const fs=require('node:fs'),p=require('node:path'),a=process.argv[1],b=process.argv[2];fs.mkdirSync(p.dirname(b),{recursive:true});fs.cpSync(a,b,{force:true});console.log('Copied: '+a+' to '+b)\"",
 		"scaffold": "scaffold",
-		"lint": "oxlint --config .oxlintrc.json --fix --deny-warnings .",
+		"lint": "oxlint --config .oxlintrc.json --fix .",
 		"check": "tsc --noEmit --project tsconfig.json && npm run check:src",
 		"check:src": "npm run check:src:core && npm run check:src:browser && npm run check:src:server",
 		"check:src:core": "tsc --noEmit -p configs/src/tsconfig.core.json",
@@ -77,7 +77,7 @@
 		"test:src:server": "vitest run --config vite.config.ts --no-cache --reporter=dot --project src:server",
 		"test:policy": "vitest run --config vite.config.ts --no-cache --reporter=dot --project policy",
 		"test:config": "vitest run --config vite.config.ts --no-cache --reporter=dot --project config",
-		"test:guides": "vitest run --config vite.config.ts --no-cache --reporter=dot --project guides",
+		"test:guides": "node --experimental-strip-types tests/guides.test.ts",
 		"build": "npm run clean && npm run build:src",
 		"build:src": "npm run build:src:core && npm run build:src:browser && npm run build:src:server",
 		"build:src:core": "vite build --config configs/src/vite.core.config.ts && npm run copy dist/src/core/index.d.ts dist/src/core/index.d.cts",
@@ -91,28 +91,27 @@
 		"test:setup": "vitest run --config vite.config.ts --no-cache --reporter=dot --project setup"
 	},
 	"dependencies": {
-		"@orkestrel/abort": "^0.0.8",
-		"@orkestrel/budget": "^0.0.8",
-		"@orkestrel/contract": "^0.0.13",
-		"@orkestrel/database": "^0.0.12",
-		"@orkestrel/emitter": "^0.0.8",
-		"@orkestrel/queue": "^0.0.11",
-		"@orkestrel/timeout": "^0.0.8"
+		"@orkestrel/abort": "^0.0.10",
+		"@orkestrel/budget": "^0.0.10",
+		"@orkestrel/contract": "^0.0.17",
+		"@orkestrel/database": "^0.0.14",
+		"@orkestrel/emitter": "^0.0.10",
+		"@orkestrel/queue": "^0.0.13",
+		"@orkestrel/timeout": "^0.0.10"
 	},
 	"devDependencies": {
-		"@microsoft/api-extractor": "^7.59.0",
-		"@orkestrel/guide": "^0.0.15",
-		"@orkestrel/probe": "^0.0.9",
-		"@orkestrel/scaffold": "^0.0.57",
-		"@orkestrel/test": "^0.0.11",
-		"@types/node": "^26.4.0",
+		"@microsoft/api-extractor": "^7.59.1",
+		"@orkestrel/guide": "^0.0.18",
+		"@orkestrel/probe": "^0.0.12",
+		"@orkestrel/scaffold": "^0.0.64",
+		"@orkestrel/test": "^0.0.14",
+		"@types/node": "^26.5.1",
 		"@vitest/browser-playwright": "^4.1.11",
-		"oxfmt": "^0.65.0",
-		"oxlint": "^1.80.0",
-		"playwright": "^1.62.1",
+		"oxfmt": "^0.67.0",
+		"oxlint": "^1.82.0",
+		"playwright": "^1.63.0",
 		"typescript": "^6.0.3",
-		"vite": "^8.2.2",
-		"vite-plugin-dts": "^5.0.3",
+		"vite": "^8.3.0",
 		"vitest": "^4.1.11"
 	},
 	"engines": {