@orkestrel/workflow 0.0.17 → 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
 /**
-* Implements 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

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 { delayHost, scheduleHost } from '@src/core'\n\n/**\n * Implements 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 * 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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCA,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACnCA,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,5 +1,5 @@
-import { SchedulerInterface } from '@orkestrel/workflow';
-import { SchedulerOptions } from '@orkestrel/workflow';
+import type { SchedulerInterface } from '@orkestrel/workflow';
+import type { SchedulerOptions } from '@orkestrel/workflow';
 
 /**
  * Creates the Node-native cooperative-yield {@link SchedulerInterface} — `yield()` is a
@@ -33,11 +33,13 @@ import { SchedulerOptions } from '@orkestrel/workflow';
 export declare function createNodeScheduler(): SchedulerInterface;
 
 /**
- * Implements 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

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

@@ -1,5 +1,5 @@
-import { SchedulerInterface } from '@orkestrel/workflow';
-import { SchedulerOptions } from '@orkestrel/workflow';
+import type { SchedulerInterface } from '@orkestrel/workflow';
+import type { SchedulerOptions } from '@orkestrel/workflow';
 
 /**
  * Creates the Node-native cooperative-yield {@link SchedulerInterface} — `yield()` is a
@@ -33,11 +33,13 @@ import { SchedulerOptions } from '@orkestrel/workflow';
 export declare function createNodeScheduler(): SchedulerInterface;
 
 /**
- * Implements 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

package/dist/src/server/index.js

@@ -1,11 +1,13 @@
 import { delayHost, scheduleHost } from "../core/index.js";
 //#region src/server/NodeScheduler.ts
 /**
-* Implements 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 { delayHost, 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

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 { delayHost, scheduleHost } from '@src/core'\n\n/**\n * Implements 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 * 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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCA,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACnCA,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.17",
+	"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.9",
-		"@orkestrel/budget": "^0.0.9",
-		"@orkestrel/contract": "^0.0.16",
-		"@orkestrel/database": "^0.0.13",
-		"@orkestrel/emitter": "^0.0.9",
-		"@orkestrel/queue": "^0.0.12",
-		"@orkestrel/timeout": "^0.0.9"
+		"@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.17",
-		"@orkestrel/probe": "^0.0.11",
-		"@orkestrel/scaffold": "^0.0.62",
-		"@orkestrel/test": "^0.0.13",
-		"@types/node": "^26.4.1",
+		"@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.66.0",
-		"oxlint": "^1.81.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.1.0",
+		"vite": "^8.3.0",
 		"vitest": "^4.1.11"
 	},
 	"engines": {