@orkestrel/workflow 0.0.7 → 0.0.9

package/README.md

@@ -1,14 +1,8 @@
 # @orkestrel/workflow
 
-A typed workflow engine for the `@orkestrel` line — a serializable
-`Workflow → Phase → Task` tree that a UI or an LLM authors as pure JSON, and
-a PURE `WorkflowRunner` engine executes by COMPOSING the shipped substrate (a
-per-phase `Runner`, `Abort`, `Timeout`, `Budget`, and a cooperative
-cross-environment `Scheduler`) rather than re-implementing its own
-concurrency / retry / abort machinery. Each task's `run` is a plain
-behavior-name string resolved once into a `handler`; wiring a task to a tool
-or an agent is an opt-in adapter shipped by the separate `@orkestrel/tool`
-package, composed into the caller's own `functions` registry.
+A typed, host-independent workflow engine for the `@orkestrel` line. It keeps
+work as a serializable `Workflow → Phase → Task` tree and executes task behavior
+through a caller-supplied function registry on a cooperative scheduler.
 
 ## Install
 
@@ -25,30 +19,29 @@ npm install @orkestrel/workflow
 
 ## Status
 
-Pre-release (`0.0.1`): the definition contract, the live entity tree, the
-pure-engine runner (a `run`-string / `handler` model — the opt-in tool/agent
-adapters and the depth/cycle-bounded agent-native recursion now ship in the
-separate `@orkestrel/tool` package), the durable `WorkflowStore`
-(in-memory + driver-pluggable), and the cooperative `Scheduler` (the
-cross-environment default plus the browser and Node environment backends)
-are all implemented and tested, but the public API is still unstable and
-may change without notice. The live tree also supports runtime-only
-`pause` / `resume` / `wait` (at both the workflow and phase tiers) plus a
-gated `add` / `remove` / `move` / `update` structural-mutation API
-(pending-suffix positions, append-only on a running phase), a hard
-`destroy` teardown alongside the runner's existing graceful `stop`, and a
-`WorkflowRunnerInterface.execute` overload that drives an already-built,
-caller-owned live tree instead of only building one from a definition. See
-[guides/src/workflow.md](./guides/src/workflow.md) for the full documented
-surface.
+Pre-release: the definition contract, live entity tree, runner,
+cooperative schedulers, and durable stores are implemented and tested. A task
+can publish its current note, progress, operations, constraints, pulse, and
+signal; observers can derive silence without polling. Workflow, phase, and task
+execution can pause, resume, wait, skip, stop, and destroy according to the
+documented lifecycle.
+
+Snapshots are exact JSON values with owned nested data. Attempts, checkpoints,
+settlements, and final state can be persisted through memory or database-backed
+stores, then explicitly restored or recovered without reusing a consumed
+attempt. Runtime pause gates are intentionally not persisted.
+
+Provider sessions, external processes, MCP projection, journals, leases, and
+distributed fencing remain integration concerns rather than core workflow
+behavior. See [guides/src/workflow.md](./guides/src/workflow.md) for the complete
+shipped contract. The proposed integration architecture now lives with the
+package that implements it, as `plan/PROPOSAL.md` in `@orkestrel/supervisor`.
 
 ## Package
 
-Published as three environment-scoped entry points per the `exports` field
-in `package.json`: `.` (the shared, environment-agnostic core — the
-definition/entity/runner surface plus the cross-environment `Scheduler`
-default), `./browser` (adds the browser-native scheduler backends), and
-`./server` (adds the Node-native scheduler backend). Core ships dual
+Published as three environment-scoped entry points: `.` provides the shared
+environment-agnostic core and default scheduler, `./browser` adds browser-native
+schedulers, and `./server` adds the Node-native scheduler. Core ships dual
 ESM+CJS builds; `./browser` is ESM-only.
 
 ## License

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

@@ -16,23 +16,17 @@ import { SchedulerPriority } from '../core/index.ts';
  *   never an `as` (AGENTS §14). Where the API is absent (Firefox today, older engines),
  *   it **falls back** to a `setTimeout(0)` macrotask — still a real host-turn, just
  *   without priority. `delay(ms)` is always 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 scheduling; otherwise the host-turn is scheduled and a
- *   `{ once: true }` abort listener attached, and the two settle paths are mutually
- *   exclusive — the turn path removes the listener before resolving, and the abort path
- *   cancels the scheduled turn before rejecting. The promise settles exactly once, with no
- *   leaked task/timer and no leaked listener. The caller's `signal` is NOT handed to
- *   `postTask` (whose own abort would reject with a platform `AbortError`, not the
- *   caller's `reason`); instead an internal controller cancels the posted task while this
- *   scheduler rejects with the verbatim `signal.reason`.
+ * - **Abort fidelity is verbatim.** The shared `scheduleHost` lifecycle links an owned
+ *   settlement composite before scheduling, preserving the exact caller reason without
+ *   invoking caller-owned signal methods. The caller signal is NOT handed to `postTask`;
+ *   an internal controller cancels that native task. An unexpected native promise rejection
+ *   is routed back as the exact host failure instead of being discarded.
  * - **Event-free.** A pure functional primitive — no Emitter, no events.
  *
  * @example
  * ```ts
- * import { createAbort } from '@src/core'
- * import { BrowserScheduler } from '@src/browser'
+ * import { createAbort } from '@orkestrel/abort'
+ * import { BrowserScheduler } from '@orkestrel/workflow/browser'
  *
  * const abort = createAbort()
  * const scheduler = new BrowserScheduler()
@@ -73,15 +67,16 @@ export declare class BrowserScheduler implements SchedulerInterface {
  * The default browser scheduler: it honours `options.priority` (`user` /
  * `normal` / `background`) when `scheduler.postTask` is available and degrades to a plain
  * macrotask elsewhere. Both methods are abort-aware: pass `options.signal` and a pending
- * yield/delay rejects with the signal's `reason` verbatim, with full task/timer/listener
- * cleanup. Prefer {@link createFrameScheduler} for paint-aligned work or
+ * yield/delay rejects with the signal's exact `reason`; the shared owned-signal lifecycle
+ * cancels the native handle without invoking caller listener methods. Prefer
+ * {@link createFrameScheduler} for paint-aligned work or
  * {@link createIdleScheduler} for idle-time background work.
  *
  * @returns A {@link SchedulerInterface} backed by `scheduler.postTask` (or a macrotask)
  *
  * @example
  * ```ts
- * import { createBrowserScheduler } from '@src/browser'
+ * import { createBrowserScheduler } from '@orkestrel/workflow/browser'
  *
  * const scheduler = createBrowserScheduler()
  * await scheduler.yield({ priority: 'background' })
@@ -105,7 +100,7 @@ export declare function createBrowserScheduler(): SchedulerInterface;
  *
  * @example
  * ```ts
- * import { createFrameScheduler } from '@src/browser'
+ * import { createFrameScheduler } from '@orkestrel/workflow/browser'
  *
  * const scheduler = createFrameScheduler()
  * await scheduler.yield() // resumes before the next paint
@@ -129,7 +124,7 @@ export declare function createFrameScheduler(): SchedulerInterface;
  *
  * @example
  * ```ts
- * import { createIdleScheduler } from '@src/browser'
+ * import { createIdleScheduler } from '@orkestrel/workflow/browser'
  *
  * const scheduler = createIdleScheduler()
  * await scheduler.yield() // resumes when the host is idle
@@ -148,20 +143,15 @@ export declare function createIdleScheduler(): SchedulerInterface;
  *   is hidden (the host throttles rAF). `delay(ms)` is a real `setTimeout`, unaligned to
  *   frames. `options.priority` is accepted for contract compliance but a no-op — a frame
  *   callback has no priority dimension.
- * - **Abort fidelity is verbatim, with cleanup.** A pending `yield` / `delay` rejects with
- *   `signal.reason` exactly. The discipline mirrors the cross-environment default's
- *   `#sleep`: an already-aborted signal rejects immediately WITHOUT scheduling a frame;
- *   otherwise the frame is requested and a `{ once: true }` abort listener attached, and
- *   the two settle paths are mutually exclusive — the frame path removes the listener
- *   before resolving, and the abort path `cancelAnimationFrame`s the pending handle before
- *   rejecting. The promise settles exactly once, with no leaked frame request and no
- *   leaked listener.
+ * - **Abort fidelity is verbatim, with cleanup.** The shared `scheduleHost` lifecycle links
+ *   an owned settlement composite before requesting a frame, never invokes caller-owned
+ *   signal methods, and cancels the native handle when abort wins.
  * - **Event-free.** A pure functional primitive — no Emitter, no events.
  *
  * @example
  * ```ts
- * import { createAbort } from '@src/core'
- * import { FrameScheduler } from '@src/browser'
+ * import { createAbort } from '@orkestrel/abort'
+ * import { FrameScheduler } from '@orkestrel/workflow/browser'
  *
  * const abort = createAbort()
  * const scheduler = new FrameScheduler()
@@ -220,20 +210,15 @@ export declare interface IdleAPI {
  *   `setTimeout(0)` macrotask — still a real host-turn, just not idle-gated. `delay(ms)` is
  *   always a real `setTimeout`. `options.priority` is accepted for contract compliance but a
  *   no-op — idle scheduling has no priority dimension.
- * - **Abort fidelity is verbatim, with cleanup.** A pending `yield` / `delay` rejects with
- *   `signal.reason` exactly. The discipline mirrors the cross-environment default's
- *   `#sleep`: an already-aborted signal rejects immediately WITHOUT scheduling; otherwise
- *   the idle callback (or fallback timer) is requested and a `{ once: true }` abort listener
- *   attached, and the two settle paths are mutually exclusive — the resume path removes the
- *   listener before resolving, and the abort path `cancelIdleCallback`s (or `clearTimeout`s)
- *   the pending handle before rejecting. The promise settles exactly once, with no leaked
- *   callback/timer and no leaked listener.
+ * - **Abort fidelity is verbatim, with cleanup.** The shared `scheduleHost` lifecycle links
+ *   an owned settlement composite before scheduling, never invokes caller-owned signal
+ *   methods, and cancels the idle callback or fallback timer when abort wins.
  * - **Event-free.** A pure functional primitive — no Emitter, no events.
  *
  * @example
  * ```ts
- * import { createAbort } from '@src/core'
- * import { IdleScheduler } from '@src/browser'
+ * import { createAbort } from '@orkestrel/abort'
+ * import { IdleScheduler } from '@orkestrel/workflow/browser'
  *
  * const abort = createAbort()
  * const scheduler = new IdleScheduler()

package/dist/src/browser/index.js

@@ -1,4 +1,5 @@
-import { isFunction, isRecord } from "@orkestrel/contract";
+import { scheduleHost } from "../core/index.js";
+import { isFunction, isPromise, isRecord } from "@orkestrel/contract";
 //#region src/browser/constants.ts
 /**
 * The browser-native `postTask` priority for each portable {@link SchedulerPriority} — the
@@ -31,23 +32,17 @@ var POST_TASK_PRIORITY = Object.freeze({
 *   never an `as` (AGENTS §14). Where the API is absent (Firefox today, older engines),
 *   it **falls back** to a `setTimeout(0)` macrotask — still a real host-turn, just
 *   without priority. `delay(ms)` is always 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 scheduling; otherwise the host-turn is scheduled and a
-*   `{ once: true }` abort listener attached, and the two settle paths are mutually
-*   exclusive — the turn path removes the listener before resolving, and the abort path
-*   cancels the scheduled turn before rejecting. The promise settles exactly once, with no
-*   leaked task/timer and no leaked listener. The caller's `signal` is NOT handed to
-*   `postTask` (whose own abort would reject with a platform `AbortError`, not the
-*   caller's `reason`); instead an internal controller cancels the posted task while this
-*   scheduler rejects with the verbatim `signal.reason`.
+* - **Abort fidelity is verbatim.** The shared `scheduleHost` lifecycle links an owned
+*   settlement composite before scheduling, preserving the exact caller reason without
+*   invoking caller-owned signal methods. The caller signal is NOT handed to `postTask`;
+*   an internal controller cancels that native task. An unexpected native promise rejection
+*   is routed back as the exact host failure instead of being discarded.
 * - **Event-free.** A pure functional primitive — no Emitter, no events.
 *
 * @example
 * ```ts
-* import { createAbort } from '@src/core'
-* import { BrowserScheduler } from '@src/browser'
+* import { createAbort } from '@orkestrel/abort'
+* import { BrowserScheduler } from '@orkestrel/workflow/browser'
 *
 * const abort = createAbort()
 * const scheduler = new BrowserScheduler()
@@ -65,7 +60,7 @@ var BrowserScheduler = class {
 	*/
 	yield(options) {
 		const post = this.#postTask();
-		if (post === void 0) return this.#macrotask(options?.signal);
+		if (post === void 0) return this.#timer(0, options?.signal);
 		return this.#yieldVia(post, options?.priority ?? "normal", options?.signal);
 	}
 	/**
@@ -89,42 +84,21 @@ var BrowserScheduler = class {
 		return (callback, options) => Reflect.apply(post, candidate, [callback, options]);
 	}
 	#yieldVia(post, priority, signal) {
-		if (signal?.aborted === true) return Promise.reject(signal.reason);
-		return new Promise((resolve, reject) => {
+		return scheduleHost((complete, failure) => {
 			const internal = new AbortController();
-			const task = post(() => {
-				signal?.removeEventListener("abort", onAbort);
-				resolve();
-			}, {
+			const task = post(complete, {
 				priority: POST_TASK_PRIORITY[priority],
 				signal: internal.signal
 			});
-			const onAbort = this.#abortTask.bind(this, internal, reject, signal);
-			if (task instanceof Promise) task.catch(() => {});
-			signal?.addEventListener("abort", onAbort, { once: true });
-		});
-	}
-	#macrotask(signal) {
-		return this.#timer(0, signal);
+			if (isPromise(task)) task.catch(failure);
+			return () => internal.abort();
+		}, signal);
 	}
 	#timer(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 });
-		});
-	}
-	#abortTask(internal, reject, signal) {
-		internal.abort();
-		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
@@ -140,20 +114,15 @@ var BrowserScheduler = class {
 *   is hidden (the host throttles rAF). `delay(ms)` is a real `setTimeout`, unaligned to
 *   frames. `options.priority` is accepted for contract compliance but a no-op — a frame
 *   callback has no priority dimension.
-* - **Abort fidelity is verbatim, with cleanup.** A pending `yield` / `delay` rejects with
-*   `signal.reason` exactly. The discipline mirrors the cross-environment default's
-*   `#sleep`: an already-aborted signal rejects immediately WITHOUT scheduling a frame;
-*   otherwise the frame is requested and a `{ once: true }` abort listener attached, and
-*   the two settle paths are mutually exclusive — the frame path removes the listener
-*   before resolving, and the abort path `cancelAnimationFrame`s the pending handle before
-*   rejecting. The promise settles exactly once, with no leaked frame request and no
-*   leaked listener.
+* - **Abort fidelity is verbatim, with cleanup.** The shared `scheduleHost` lifecycle links
+*   an owned settlement composite before requesting a frame, never invokes caller-owned
+*   signal methods, and cancels the native handle when abort wins.
 * - **Event-free.** A pure functional primitive — no Emitter, no events.
 *
 * @example
 * ```ts
-* import { createAbort } from '@src/core'
-* import { FrameScheduler } from '@src/browser'
+* import { createAbort } from '@orkestrel/abort'
+* import { FrameScheduler } from '@orkestrel/workflow/browser'
 *
 * const abort = createAbort()
 * const scheduler = new FrameScheduler()
@@ -185,34 +154,16 @@ var FrameScheduler = class {
 		return this.#sleep(ms, options?.signal);
 	}
 	#frame(signal) {
-		if (signal?.aborted === true) return Promise.reject(signal.reason);
-		return new Promise((resolve, reject) => {
-			const handle = requestAnimationFrame(() => {
-				signal?.removeEventListener("abort", onAbort);
-				resolve();
-			});
-			const onAbort = this.#abortFrame.bind(this, handle, reject, signal);
-			signal?.addEventListener("abort", onAbort, { once: true });
-		});
+		return scheduleHost((complete) => {
+			const handle = requestAnimationFrame(complete);
+			return () => cancelAnimationFrame(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 });
-		});
-	}
-	#abortFrame(handle, reject, signal) {
-		cancelAnimationFrame(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
@@ -231,20 +182,15 @@ var FrameScheduler = class {
 *   `setTimeout(0)` macrotask — still a real host-turn, just not idle-gated. `delay(ms)` is
 *   always a real `setTimeout`. `options.priority` is accepted for contract compliance but a
 *   no-op — idle scheduling has no priority dimension.
-* - **Abort fidelity is verbatim, with cleanup.** A pending `yield` / `delay` rejects with
-*   `signal.reason` exactly. The discipline mirrors the cross-environment default's
-*   `#sleep`: an already-aborted signal rejects immediately WITHOUT scheduling; otherwise
-*   the idle callback (or fallback timer) is requested and a `{ once: true }` abort listener
-*   attached, and the two settle paths are mutually exclusive — the resume path removes the
-*   listener before resolving, and the abort path `cancelIdleCallback`s (or `clearTimeout`s)
-*   the pending handle before rejecting. The promise settles exactly once, with no leaked
-*   callback/timer and no leaked listener.
+* - **Abort fidelity is verbatim, with cleanup.** The shared `scheduleHost` lifecycle links
+*   an owned settlement composite before scheduling, never invokes caller-owned signal
+*   methods, and cancels the idle callback or fallback timer when abort wins.
 * - **Event-free.** A pure functional primitive — no Emitter, no events.
 *
 * @example
 * ```ts
-* import { createAbort } from '@src/core'
-* import { IdleScheduler } from '@src/browser'
+* import { createAbort } from '@orkestrel/abort'
+* import { IdleScheduler } from '@orkestrel/workflow/browser'
 *
 * const abort = createAbort()
 * const scheduler = new IdleScheduler()
@@ -288,26 +234,16 @@ var IdleScheduler = class {
 		};
 	}
 	#idle(idle, signal) {
-		if (signal?.aborted === true) return Promise.reject(signal.reason);
-		return new Promise((resolve, reject) => {
-			const handle = idle.request(() => {
-				signal?.removeEventListener("abort", onAbort);
-				resolve();
-			});
-			const onAbort = this.#abortIdle.bind(this, idle, handle, reject, signal);
-			signal?.addEventListener("abort", onAbort, { once: true });
-		});
+		return scheduleHost((complete) => {
+			const handle = idle.request(complete);
+			return () => idle.cancel(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 });
-		});
+		return scheduleHost((complete) => {
+			const handle = setTimeout(complete, ms);
+			return () => clearTimeout(handle);
+		}, signal);
 	}
 	#request(request, callback) {
 		return Number(Reflect.apply(request, globalThis, [callback]));
@@ -315,14 +251,6 @@ var IdleScheduler = class {
 	#cancel(cancel, handle) {
 		Reflect.apply(cancel, globalThis, [handle]);
 	}
-	#abortIdle(idle, handle, reject, signal) {
-		idle.cancel(handle);
-		reject(signal?.reason);
-	}
-	#abortTimeout(handle, reject, signal) {
-		clearTimeout(handle);
-		reject(signal?.reason);
-	}
 };
 //#endregion
 //#region src/browser/factories.ts
@@ -336,15 +264,16 @@ var IdleScheduler = class {
 * The default browser scheduler: it honours `options.priority` (`user` /
 * `normal` / `background`) when `scheduler.postTask` is available and degrades to a plain
 * macrotask elsewhere. Both methods are abort-aware: pass `options.signal` and a pending
-* yield/delay rejects with the signal's `reason` verbatim, with full task/timer/listener
-* cleanup. Prefer {@link createFrameScheduler} for paint-aligned work or
+* yield/delay rejects with the signal's exact `reason`; the shared owned-signal lifecycle
+* cancels the native handle without invoking caller listener methods. Prefer
+* {@link createFrameScheduler} for paint-aligned work or
 * {@link createIdleScheduler} for idle-time background work.
 *
 * @returns A {@link SchedulerInterface} backed by `scheduler.postTask` (or a macrotask)
 *
 * @example
 * ```ts
-* import { createBrowserScheduler } from '@src/browser'
+* import { createBrowserScheduler } from '@orkestrel/workflow/browser'
 *
 * const scheduler = createBrowserScheduler()
 * await scheduler.yield({ priority: 'background' })
@@ -369,7 +298,7 @@ function createBrowserScheduler() {
 *
 * @example
 * ```ts
-* import { createFrameScheduler } from '@src/browser'
+* import { createFrameScheduler } from '@orkestrel/workflow/browser'
 *
 * const scheduler = createFrameScheduler()
 * await scheduler.yield() // resumes before the next paint
@@ -394,7 +323,7 @@ function createFrameScheduler() {
 *
 * @example
 * ```ts
-* import { createIdleScheduler } from '@src/browser'
+* import { createIdleScheduler } from '@orkestrel/workflow/browser'
 *
 * const scheduler = createIdleScheduler()
 * await scheduler.yield() // resumes when the host is idle

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

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["#postTask","#macrotask","#yieldVia","#timer","#abortTask","#abortTimeout","#frame","#sleep","#abortFrame","#abortTimeout","#idleAPI","#sleep","#idle","#request","#cancel","#abortIdle","#abortTimeout"],"sources":["../../../src/browser/constants.ts","../../../src/browser/BrowserScheduler.ts","../../../src/browser/FrameScheduler.ts","../../../src/browser/IdleScheduler.ts","../../../src/browser/factories.ts"],"sourcesContent":["import type { SchedulerPriority } from '@src/core'\n\n/**\n * The browser-native `postTask` priority for each portable {@link SchedulerPriority} — the\n * Prioritized Task Scheduling API's three levels.\n *\n * @remarks\n * A `user` hint maps to the most urgent `'user-blocking'`, `normal` to the default\n * `'user-visible'`, and `background` to `'background'`. {@link BrowserScheduler} reads this\n * map to translate the caller's portable priority into the value passed to\n * `scheduler.postTask`, so the urgency hint is honoured by the host.\n */\nexport const POST_TASK_PRIORITY: Readonly<Record<SchedulerPriority, string>> = Object.freeze({\n\tuser: 'user-blocking',\n\tnormal: 'user-visible',\n\tbackground: 'background',\n})\n","import type { SchedulerInterface, SchedulerOptions, SchedulerPriority } from '@src/core'\nimport { isFunction, isRecord } from '@orkestrel/contract'\nimport { POST_TASK_PRIORITY } from './constants.js'\n\n/**\n * The browser {@link SchedulerInterface} — the browser-native cooperative-yield backend\n * built on the Prioritized Task Scheduling API (`scheduler.postTask`), falling back to a\n * zero-delay macrotask where it is absent.\n *\n * @remarks\n * - **`yield` prefers `scheduler.postTask`, honouring priority.** When `globalThis`\n *   exposes a `scheduler` with a `postTask` method, `yield()` posts a task at the mapped\n *   priority (`user` → `'user-blocking'`, `normal` → `'user-visible'`, `background` →\n *   `'background'`), so the host genuinely regains control and the urgency hint is\n *   honoured. The capability is feature-detected through guards (`isRecord` / `isFunction`),\n *   never an `as` (AGENTS §14). Where the API is absent (Firefox today, older engines),\n *   it **falls back** to a `setTimeout(0)` macrotask — still a real host-turn, just\n *   without priority. `delay(ms)` is always a real `setTimeout`.\n * - **Abort fidelity is verbatim.** A pending `yield` / `delay` rejects with `signal.reason`\n *   exactly — the value the caller passed, never wrapped or replaced. The discipline\n *   mirrors the cross-environment default's `#sleep`: an already-aborted signal rejects\n *   immediately WITHOUT scheduling; otherwise the host-turn is scheduled and a\n *   `{ once: true }` abort listener attached, and the two settle paths are mutually\n *   exclusive — the turn path removes the listener before resolving, and the abort path\n *   cancels the scheduled turn before rejecting. The promise settles exactly once, with no\n *   leaked task/timer and no leaked listener. The caller's `signal` is NOT handed to\n *   `postTask` (whose own abort would reject with a platform `AbortError`, not the\n *   caller's `reason`); instead an internal controller cancels the posted task while this\n *   scheduler rejects with the verbatim `signal.reason`.\n * - **Event-free.** A pure functional primitive — no Emitter, no events.\n *\n * @example\n * ```ts\n * import { createAbort } from '@src/core'\n * import { BrowserScheduler } from '@src/browser'\n *\n * const abort = createAbort()\n * const scheduler = new BrowserScheduler()\n * while (!abort.signal.aborted) {\n * \tdoSomeWork()\n * \tawait scheduler.yield({ priority: 'background', signal: abort.signal })\n * }\n * ```\n */\nexport class BrowserScheduler implements SchedulerInterface {\n\t/**\n\t * Yield control to the host via `scheduler.postTask` at the given priority (or a\n\t * `setTimeout(0)` macrotask where the API is absent), then resume; abort rejects with\n\t * `signal.reason`.\n\t */\n\tyield(options?: SchedulerOptions): Promise<void> {\n\t\tconst post = this.#postTask()\n\t\tif (post === undefined) return this.#macrotask(options?.signal)\n\t\treturn this.#yieldVia(post, options?.priority ?? 'normal', 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.#timer(ms, options?.signal)\n\t}\n\n\t// === Private\n\n\t// Feature-detect the Prioritized Task Scheduling API through guards (no `as`): the\n\t// global `scheduler` must be a record carrying a callable `postTask`. Returns the\n\t// narrowed `postTask` function, or `undefined` when the API is absent (the fallback).\n\t#postTask(): ((callback: () => void, options: Record<string, unknown>) => unknown) | undefined {\n\t\tconst candidate: unknown = Reflect.get(globalThis, 'scheduler')\n\t\tif (!isRecord(candidate)) return undefined\n\t\tconst post = candidate.postTask\n\t\tif (!isFunction(post)) return undefined\n\t\treturn (callback, options) => Reflect.apply(post, candidate, [callback, options])\n\t}\n\n\t// A `scheduler.postTask` host-turn at the mapped priority. The caller's signal is NOT\n\t// passed to `postTask` (its abort rejects with a platform `AbortError`, not the\n\t// caller's `reason`); instead an internal controller cancels the posted task on abort\n\t// while this rejects with the verbatim `signal.reason`. Settle-once, no leak: the task\n\t// path removes the abort listener before resolving; the abort path aborts the internal\n\t// controller (cancelling the task) before rejecting.\n\t#yieldVia(\n\t\tpost: (callback: () => void, options: Record<string, unknown>) => unknown,\n\t\tpriority: SchedulerPriority,\n\t\tsignal?: AbortSignal,\n\t): 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 internal = new AbortController()\n\t\t\tconst task = post(\n\t\t\t\t() => {\n\t\t\t\t\tsignal?.removeEventListener('abort', onAbort)\n\t\t\t\t\tresolve()\n\t\t\t\t},\n\t\t\t\t{ priority: POST_TASK_PRIORITY[priority], signal: internal.signal },\n\t\t\t)\n\t\t\tconst onAbort = this.#abortTask.bind(this, internal, reject, signal)\n\t\t\t// `postTask` returns a promise that rejects when the internal controller aborts;\n\t\t\t// swallow that rejection (the abort path already rejected with the real reason).\n\t\t\tif (task instanceof Promise) task.catch(() => {})\n\t\t\tsignal?.addEventListener('abort', onAbort, { once: true })\n\t\t})\n\t}\n\n\t// The `setTimeout(0)` macrotask fallback for `yield` when `postTask` is absent. Same\n\t// settle-once discipline as the core `#sleep`: an already-aborted signal rejects\n\t// without arming; otherwise the timer path removes the listener before resolving and\n\t// the abort path clears the timer before rejecting with `signal.reason`.\n\t#macrotask(signal?: AbortSignal): Promise<void> {\n\t\treturn this.#timer(0, signal)\n\t}\n\n\t// The abort-aware `setTimeout` sleep shared by `delay` and the `yield` macrotask\n\t// fallback. Settle-once, no leak (the core `#sleep` discipline): already-aborted →\n\t// reject without arming; the timer path removes the listener before resolving; the\n\t// abort path clears the timer before rejecting with the verbatim `signal.reason`.\n\t#timer(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#abortTask(\n\t\tinternal: AbortController,\n\t\treject: (reason?: unknown) => void,\n\t\tsignal?: AbortSignal,\n\t): void {\n\t\tinternal.abort()\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, SchedulerOptions } from '@src/core'\n\n/**\n * The frame-aligned {@link SchedulerInterface} — a browser cooperative-yield backend\n * whose `yield` resumes just before the next paint via `requestAnimationFrame`.\n *\n * @remarks\n * - **`yield` resumes before the next paint.** `yield()` waits on `requestAnimationFrame`,\n *   so the resumption is aligned to the browser's render loop — ideal for work that\n *   should batch per frame (animation, incremental DOM updates) and pause while the tab\n *   is hidden (the host throttles rAF). `delay(ms)` is a real `setTimeout`, unaligned to\n *   frames. `options.priority` is accepted for contract compliance but a no-op — a frame\n *   callback has no priority dimension.\n * - **Abort fidelity is verbatim, with cleanup.** A pending `yield` / `delay` rejects with\n *   `signal.reason` exactly. The discipline mirrors the cross-environment default's\n *   `#sleep`: an already-aborted signal rejects immediately WITHOUT scheduling a frame;\n *   otherwise the frame is requested and a `{ once: true }` abort listener attached, and\n *   the two settle paths are mutually exclusive — the frame path removes the listener\n *   before resolving, and the abort path `cancelAnimationFrame`s the pending handle before\n *   rejecting. The promise settles exactly once, with no leaked frame request and no\n *   leaked listener.\n * - **Event-free.** A pure functional primitive — no Emitter, no events.\n *\n * @example\n * ```ts\n * import { createAbort } from '@src/core'\n * import { FrameScheduler } from '@src/browser'\n *\n * const abort = createAbort()\n * const scheduler = new FrameScheduler()\n * while (!abort.signal.aborted) {\n * \trenderOneFrameOfWork()\n * \tawait scheduler.yield({ signal: abort.signal }) // resume before the next paint\n * }\n * ```\n */\nexport class FrameScheduler implements SchedulerInterface {\n\t/**\n\t * Yield control to the host until just before the next paint via\n\t * `requestAnimationFrame`, then resume; abort rejects with `signal.reason`.\n\t */\n\tyield(options?: SchedulerOptions): Promise<void> {\n\t\treturn this.#frame(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 `requestAnimationFrame` host-turn for `yield`. Resolves in the next frame\n\t// callback (before paint); rejects with `signal.reason` if already aborted (no frame\n\t// requested) or aborted while pending. Settle-once, no leak: the frame path removes the\n\t// abort listener before resolving; the abort path cancels the frame before rejecting.\n\t#frame(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 = requestAnimationFrame(() => {\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.#abortFrame.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 the\n\t// core `#sleep`: already-aborted → reject without arming; the timer path removes the\n\t// listener before resolving; the abort path clears the timer before rejecting with the\n\t// verbatim `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#abortFrame(handle: number, reject: (reason?: unknown) => void, signal?: AbortSignal): void {\n\t\tcancelAnimationFrame(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, SchedulerOptions } from '@src/core'\nimport type { AnyFunction } from '@orkestrel/contract'\nimport type { IdleAPI } from './types.js'\nimport { isFunction } from '@orkestrel/contract'\n\n/**\n * The idle-time {@link SchedulerInterface} — a browser cooperative-yield backend whose\n * `yield` resumes when the host is idle via `requestIdleCallback`, falling back to a\n * zero-delay macrotask where it is absent.\n *\n * @remarks\n * - **`yield` resumes during idle time.** When `globalThis` exposes `requestIdleCallback`,\n *   `yield()` waits on it, so the resumption happens when the browser has spare time after\n *   rendering and input — ideal for low-priority background work that must not contend with\n *   the user. The capability is feature-detected through a guard (`isFunction`), never an\n *   `as` (AGENTS §14). Where the API is absent (Safari today), it **falls back** to a\n *   `setTimeout(0)` macrotask — still a real host-turn, just not idle-gated. `delay(ms)` is\n *   always a real `setTimeout`. `options.priority` is accepted for contract compliance but a\n *   no-op — idle scheduling has no priority dimension.\n * - **Abort fidelity is verbatim, with cleanup.** A pending `yield` / `delay` rejects with\n *   `signal.reason` exactly. The discipline mirrors the cross-environment default's\n *   `#sleep`: an already-aborted signal rejects immediately WITHOUT scheduling; otherwise\n *   the idle callback (or fallback timer) is requested and a `{ once: true }` abort listener\n *   attached, and the two settle paths are mutually exclusive — the resume path removes the\n *   listener before resolving, and the abort path `cancelIdleCallback`s (or `clearTimeout`s)\n *   the pending handle before rejecting. The promise settles exactly once, with no leaked\n *   callback/timer and no leaked listener.\n * - **Event-free.** A pure functional primitive — no Emitter, no events.\n *\n * @example\n * ```ts\n * import { createAbort } from '@src/core'\n * import { IdleScheduler } from '@src/browser'\n *\n * const abort = createAbort()\n * const scheduler = new IdleScheduler()\n * while (!abort.signal.aborted) {\n * \tdoLowPriorityWork()\n * \tawait scheduler.yield({ signal: abort.signal }) // resume when the host is idle\n * }\n * ```\n */\nexport class IdleScheduler implements SchedulerInterface {\n\t/**\n\t * Yield control to the host until it is idle via `requestIdleCallback` (or a\n\t * `setTimeout(0)` macrotask where the API is absent), then resume; abort rejects with\n\t * `signal.reason`.\n\t */\n\tyield(options?: SchedulerOptions): Promise<void> {\n\t\tconst idle = this.#idleAPI()\n\t\tif (idle === undefined) return this.#sleep(0, options?.signal)\n\t\treturn this.#idle(idle, 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// Feature-detect `requestIdleCallback` / `cancelIdleCallback` off `globalThis` through\n\t// guards (no `as`): both must be callable. Returns the narrowed pair, or `undefined`\n\t// when the API is absent (the macrotask fallback).\n\t#idleAPI(): IdleAPI | undefined {\n\t\tconst request: unknown = Reflect.get(globalThis, 'requestIdleCallback')\n\t\tconst cancel: unknown = Reflect.get(globalThis, 'cancelIdleCallback')\n\t\tif (!isFunction(request) || !isFunction(cancel)) return undefined\n\t\treturn {\n\t\t\trequest: this.#request.bind(this, request),\n\t\t\tcancel: this.#cancel.bind(this, cancel),\n\t\t}\n\t}\n\n\t// The `requestIdleCallback` host-turn for `yield`. Resolves in the idle callback;\n\t// rejects with `signal.reason` if already aborted (nothing scheduled) or aborted while\n\t// pending. Settle-once, no leak: the resume path removes the abort listener before\n\t// resolving; the abort path cancels the idle callback before rejecting.\n\t#idle(idle: IdleAPI, 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 = idle.request(() => {\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.#abortIdle.bind(this, idle, 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 shared by `delay` and the `yield` macrotask\n\t// fallback. Same settle-once discipline as the core `#sleep`: already-aborted → reject\n\t// without arming; the timer path removes the listener before resolving; the abort path\n\t// clears the timer before rejecting with the verbatim `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#request(request: AnyFunction, callback: () => void): number {\n\t\treturn Number(Reflect.apply(request, globalThis, [callback]))\n\t}\n\n\t#cancel(cancel: AnyFunction, handle: number): void {\n\t\tReflect.apply(cancel, globalThis, [handle])\n\t}\n\n\t#abortIdle(\n\t\tidle: IdleAPI,\n\t\thandle: number,\n\t\treject: (reason?: unknown) => void,\n\t\tsignal?: AbortSignal,\n\t): void {\n\t\tidle.cancel(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 { BrowserScheduler } from './BrowserScheduler.js'\nimport { FrameScheduler } from './FrameScheduler.js'\nimport { IdleScheduler } from './IdleScheduler.js'\n\n/**\n * Create the browser-native cooperative-yield {@link SchedulerInterface} — `yield()` uses\n * the Prioritized Task Scheduling API (`scheduler.postTask`) at the requested priority\n * when present, falling back to a `setTimeout(0)` macrotask; `delay(ms)` is a real\n * `setTimeout`.\n *\n * @remarks\n * The default browser scheduler: it honours `options.priority` (`user` /\n * `normal` / `background`) when `scheduler.postTask` is available and degrades to a plain\n * macrotask elsewhere. Both methods are abort-aware: pass `options.signal` and a pending\n * yield/delay rejects with the signal's `reason` verbatim, with full task/timer/listener\n * cleanup. Prefer {@link createFrameScheduler} for paint-aligned work or\n * {@link createIdleScheduler} for idle-time background work.\n *\n * @returns A {@link SchedulerInterface} backed by `scheduler.postTask` (or a macrotask)\n *\n * @example\n * ```ts\n * import { createBrowserScheduler } from '@src/browser'\n *\n * const scheduler = createBrowserScheduler()\n * await scheduler.yield({ priority: 'background' })\n * ```\n */\nexport function createBrowserScheduler(): SchedulerInterface {\n\treturn new BrowserScheduler()\n}\n\n/**\n * Create the frame-aligned cooperative-yield {@link SchedulerInterface} — `yield()` resumes\n * just before the next paint via `requestAnimationFrame`; `delay(ms)` is a real\n * `setTimeout`.\n *\n * @remarks\n * Use it for work that should batch per render frame (animation, incremental DOM updates)\n * and naturally pause while the tab is hidden. `yield` is abort-aware: pass `options.signal`\n * and a pending yield rejects with the signal's `reason` verbatim, cancelling the pending\n * frame request. `options.priority` is accepted but a no-op — a frame callback has no\n * priority dimension.\n *\n * @returns A {@link SchedulerInterface} backed by `requestAnimationFrame`\n *\n * @example\n * ```ts\n * import { createFrameScheduler } from '@src/browser'\n *\n * const scheduler = createFrameScheduler()\n * await scheduler.yield() // resumes before the next paint\n * ```\n */\nexport function createFrameScheduler(): SchedulerInterface {\n\treturn new FrameScheduler()\n}\n\n/**\n * Create the idle-time cooperative-yield {@link SchedulerInterface} — `yield()` resumes when\n * the host is idle via `requestIdleCallback` when present, falling back to a `setTimeout(0)`\n * macrotask; `delay(ms)` is a real `setTimeout`.\n *\n * @remarks\n * Use it for low-priority background work that must not contend with rendering or input.\n * Where `requestIdleCallback` is absent (Safari today) it degrades to a plain macrotask.\n * `yield` is abort-aware: pass `options.signal` and a pending yield rejects with the\n * signal's `reason` verbatim, cancelling the pending idle callback. `options.priority` is\n * accepted but a no-op — idle scheduling has no priority dimension.\n *\n * @returns A {@link SchedulerInterface} backed by `requestIdleCallback` (or a macrotask)\n *\n * @example\n * ```ts\n * import { createIdleScheduler } from '@src/browser'\n *\n * const scheduler = createIdleScheduler()\n * await scheduler.yield() // resumes when the host is idle\n * ```\n */\nexport function createIdleScheduler(): SchedulerInterface {\n\treturn new IdleScheduler()\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.js","names":["#postTask","#timer","#yieldVia","#frame","#sleep","#idleAPI","#sleep","#idle","#request","#cancel"],"sources":["../../../src/browser/constants.ts","../../../src/browser/BrowserScheduler.ts","../../../src/browser/FrameScheduler.ts","../../../src/browser/IdleScheduler.ts","../../../src/browser/factories.ts"],"sourcesContent":["import type { SchedulerPriority } from '@src/core'\n\n/**\n * The browser-native `postTask` priority for each portable {@link SchedulerPriority} — the\n * Prioritized Task Scheduling API's three levels.\n *\n * @remarks\n * A `user` hint maps to the most urgent `'user-blocking'`, `normal` to the default\n * `'user-visible'`, and `background` to `'background'`. {@link BrowserScheduler} reads this\n * map to translate the caller's portable priority into the value passed to\n * `scheduler.postTask`, so the urgency hint is honoured by the host.\n */\nexport const POST_TASK_PRIORITY: Readonly<Record<SchedulerPriority, string>> = Object.freeze({\n\tuser: 'user-blocking',\n\tnormal: 'user-visible',\n\tbackground: 'background',\n})\n","import type { SchedulerInterface, SchedulerOptions, SchedulerPriority } from '@src/core'\nimport { scheduleHost } from '@src/core'\nimport { isFunction, isPromise, isRecord } from '@orkestrel/contract'\nimport { POST_TASK_PRIORITY } from './constants.js'\n\n/**\n * The browser {@link SchedulerInterface} — the browser-native cooperative-yield backend\n * built on the Prioritized Task Scheduling API (`scheduler.postTask`), falling back to a\n * zero-delay macrotask where it is absent.\n *\n * @remarks\n * - **`yield` prefers `scheduler.postTask`, honouring priority.** When `globalThis`\n *   exposes a `scheduler` with a `postTask` method, `yield()` posts a task at the mapped\n *   priority (`user` → `'user-blocking'`, `normal` → `'user-visible'`, `background` →\n *   `'background'`), so the host genuinely regains control and the urgency hint is\n *   honoured. The capability is feature-detected through guards (`isRecord` / `isFunction`),\n *   never an `as` (AGENTS §14). Where the API is absent (Firefox today, older engines),\n *   it **falls back** to a `setTimeout(0)` macrotask — still a real host-turn, just\n *   without priority. `delay(ms)` is always a real `setTimeout`.\n * - **Abort fidelity is verbatim.** The shared `scheduleHost` lifecycle links an owned\n *   settlement composite before scheduling, preserving the exact caller reason without\n *   invoking caller-owned signal methods. The caller signal is NOT handed to `postTask`;\n *   an internal controller cancels that native task. An unexpected native promise rejection\n *   is routed back as the exact host failure instead of being discarded.\n * - **Event-free.** A pure functional primitive — no Emitter, no events.\n *\n * @example\n * ```ts\n * import { createAbort } from '@orkestrel/abort'\n * import { BrowserScheduler } from '@orkestrel/workflow/browser'\n *\n * const abort = createAbort()\n * const scheduler = new BrowserScheduler()\n * while (!abort.signal.aborted) {\n * \tdoSomeWork()\n * \tawait scheduler.yield({ priority: 'background', signal: abort.signal })\n * }\n * ```\n */\nexport class BrowserScheduler implements SchedulerInterface {\n\t/**\n\t * Yield control to the host via `scheduler.postTask` at the given priority (or a\n\t * `setTimeout(0)` macrotask where the API is absent), then resume; abort rejects with\n\t * `signal.reason`.\n\t */\n\tyield(options?: SchedulerOptions): Promise<void> {\n\t\tconst post = this.#postTask()\n\t\tif (post === undefined) return this.#timer(0, options?.signal)\n\t\treturn this.#yieldVia(post, options?.priority ?? 'normal', 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.#timer(ms, options?.signal)\n\t}\n\n\t// === Private\n\n\t// Feature-detect the Prioritized Task Scheduling API through guards (no `as`): the\n\t// global `scheduler` must be a record carrying a callable `postTask`. Returns the\n\t// narrowed `postTask` function, or `undefined` when the API is absent (the fallback).\n\t#postTask(): ((callback: () => void, options: Record<string, unknown>) => unknown) | undefined {\n\t\tconst candidate: unknown = Reflect.get(globalThis, 'scheduler')\n\t\tif (!isRecord(candidate)) return undefined\n\t\tconst post = candidate.postTask\n\t\tif (!isFunction(post)) return undefined\n\t\treturn (callback, options) => Reflect.apply(post, candidate, [callback, options])\n\t}\n\n\t// A `scheduler.postTask` boundary with an internal cancellation controller; `scheduleHost`\n\t// owns caller linking and first-settlement arbitration, including native promise failure.\n\t#yieldVia(\n\t\tpost: (callback: () => void, options: Record<string, unknown>) => unknown,\n\t\tpriority: SchedulerPriority,\n\t\tsignal?: AbortSignal,\n\t): Promise<void> {\n\t\treturn scheduleHost((complete, failure) => {\n\t\t\tconst internal = new AbortController()\n\t\t\tconst task = post(complete, {\n\t\t\t\tpriority: POST_TASK_PRIORITY[priority],\n\t\t\t\tsignal: internal.signal,\n\t\t\t})\n\t\t\tif (isPromise(task)) void task.catch(failure)\n\t\t\treturn () => internal.abort()\n\t\t}, signal)\n\t}\n\n\t// The browser timer boundary shared by `delay` and fallback `yield`.\n\t#timer(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, SchedulerOptions } from '@src/core'\nimport { scheduleHost } from '@src/core'\n\n/**\n * The frame-aligned {@link SchedulerInterface} — a browser cooperative-yield backend\n * whose `yield` resumes just before the next paint via `requestAnimationFrame`.\n *\n * @remarks\n * - **`yield` resumes before the next paint.** `yield()` waits on `requestAnimationFrame`,\n *   so the resumption is aligned to the browser's render loop — ideal for work that\n *   should batch per frame (animation, incremental DOM updates) and pause while the tab\n *   is hidden (the host throttles rAF). `delay(ms)` is a real `setTimeout`, unaligned to\n *   frames. `options.priority` is accepted for contract compliance but a no-op — a frame\n *   callback has no priority dimension.\n * - **Abort fidelity is verbatim, with cleanup.** The shared `scheduleHost` lifecycle links\n *   an owned settlement composite before requesting a frame, never invokes caller-owned\n *   signal methods, and cancels the native handle when abort wins.\n * - **Event-free.** A pure functional primitive — no Emitter, no events.\n *\n * @example\n * ```ts\n * import { createAbort } from '@orkestrel/abort'\n * import { FrameScheduler } from '@orkestrel/workflow/browser'\n *\n * const abort = createAbort()\n * const scheduler = new FrameScheduler()\n * while (!abort.signal.aborted) {\n * \trenderOneFrameOfWork()\n * \tawait scheduler.yield({ signal: abort.signal }) // resume before the next paint\n * }\n * ```\n */\nexport class FrameScheduler implements SchedulerInterface {\n\t/**\n\t * Yield control to the host until just before the next paint via\n\t * `requestAnimationFrame`, then resume; abort rejects with `signal.reason`.\n\t */\n\tyield(options?: SchedulerOptions): Promise<void> {\n\t\treturn this.#frame(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 frame request boundary; `scheduleHost` owns cancellation lifecycle.\n\t#frame(signal?: AbortSignal): Promise<void> {\n\t\treturn scheduleHost((complete) => {\n\t\t\tconst handle = requestAnimationFrame(complete)\n\t\t\treturn () => cancelAnimationFrame(handle)\n\t\t}, signal)\n\t}\n\n\t// The browser 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, SchedulerOptions } from '@src/core'\nimport { scheduleHost } from '@src/core'\nimport type { AnyFunction } from '@orkestrel/contract'\nimport type { IdleAPI } from './types.js'\nimport { isFunction } from '@orkestrel/contract'\n\n/**\n * The idle-time {@link SchedulerInterface} — a browser cooperative-yield backend whose\n * `yield` resumes when the host is idle via `requestIdleCallback`, falling back to a\n * zero-delay macrotask where it is absent.\n *\n * @remarks\n * - **`yield` resumes during idle time.** When `globalThis` exposes `requestIdleCallback`,\n *   `yield()` waits on it, so the resumption happens when the browser has spare time after\n *   rendering and input — ideal for low-priority background work that must not contend with\n *   the user. The capability is feature-detected through a guard (`isFunction`), never an\n *   `as` (AGENTS §14). Where the API is absent (Safari today), it **falls back** to a\n *   `setTimeout(0)` macrotask — still a real host-turn, just not idle-gated. `delay(ms)` is\n *   always a real `setTimeout`. `options.priority` is accepted for contract compliance but a\n *   no-op — idle scheduling has no priority dimension.\n * - **Abort fidelity is verbatim, with cleanup.** The shared `scheduleHost` lifecycle links\n *   an owned settlement composite before scheduling, never invokes caller-owned signal\n *   methods, and cancels the idle callback or fallback timer when abort wins.\n * - **Event-free.** A pure functional primitive — no Emitter, no events.\n *\n * @example\n * ```ts\n * import { createAbort } from '@orkestrel/abort'\n * import { IdleScheduler } from '@orkestrel/workflow/browser'\n *\n * const abort = createAbort()\n * const scheduler = new IdleScheduler()\n * while (!abort.signal.aborted) {\n * \tdoLowPriorityWork()\n * \tawait scheduler.yield({ signal: abort.signal }) // resume when the host is idle\n * }\n * ```\n */\nexport class IdleScheduler implements SchedulerInterface {\n\t/**\n\t * Yield control to the host until it is idle via `requestIdleCallback` (or a\n\t * `setTimeout(0)` macrotask where the API is absent), then resume; abort rejects with\n\t * `signal.reason`.\n\t */\n\tyield(options?: SchedulerOptions): Promise<void> {\n\t\tconst idle = this.#idleAPI()\n\t\tif (idle === undefined) return this.#sleep(0, options?.signal)\n\t\treturn this.#idle(idle, 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// Feature-detect `requestIdleCallback` / `cancelIdleCallback` off `globalThis` through\n\t// guards (no `as`): both must be callable. Returns the narrowed pair, or `undefined`\n\t// when the API is absent (the macrotask fallback).\n\t#idleAPI(): IdleAPI | undefined {\n\t\tconst request: unknown = Reflect.get(globalThis, 'requestIdleCallback')\n\t\tconst cancel: unknown = Reflect.get(globalThis, 'cancelIdleCallback')\n\t\tif (!isFunction(request) || !isFunction(cancel)) return undefined\n\t\treturn {\n\t\t\trequest: this.#request.bind(this, request),\n\t\t\tcancel: this.#cancel.bind(this, cancel),\n\t\t}\n\t}\n\n\t// The idle callback boundary; `scheduleHost` owns cancellation lifecycle.\n\t#idle(idle: IdleAPI, signal?: AbortSignal): Promise<void> {\n\t\treturn scheduleHost((complete) => {\n\t\t\tconst handle = idle.request(complete)\n\t\t\treturn () => idle.cancel(handle)\n\t\t}, signal)\n\t}\n\n\t// The browser timer boundary shared by `delay` and fallback `yield`.\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\t#request(request: AnyFunction, callback: () => void): number {\n\t\treturn Number(Reflect.apply(request, globalThis, [callback]))\n\t}\n\n\t#cancel(cancel: AnyFunction, handle: number): void {\n\t\tReflect.apply(cancel, globalThis, [handle])\n\t}\n}\n","import type { SchedulerInterface } from '@src/core'\nimport { BrowserScheduler } from './BrowserScheduler.js'\nimport { FrameScheduler } from './FrameScheduler.js'\nimport { IdleScheduler } from './IdleScheduler.js'\n\n/**\n * Create the browser-native cooperative-yield {@link SchedulerInterface} — `yield()` uses\n * the Prioritized Task Scheduling API (`scheduler.postTask`) at the requested priority\n * when present, falling back to a `setTimeout(0)` macrotask; `delay(ms)` is a real\n * `setTimeout`.\n *\n * @remarks\n * The default browser scheduler: it honours `options.priority` (`user` /\n * `normal` / `background`) when `scheduler.postTask` is available and degrades to a plain\n * macrotask elsewhere. Both methods are abort-aware: pass `options.signal` and a pending\n * yield/delay rejects with the signal's exact `reason`; the shared owned-signal lifecycle\n * cancels the native handle without invoking caller listener methods. Prefer\n * {@link createFrameScheduler} for paint-aligned work or\n * {@link createIdleScheduler} for idle-time background work.\n *\n * @returns A {@link SchedulerInterface} backed by `scheduler.postTask` (or a macrotask)\n *\n * @example\n * ```ts\n * import { createBrowserScheduler } from '@orkestrel/workflow/browser'\n *\n * const scheduler = createBrowserScheduler()\n * await scheduler.yield({ priority: 'background' })\n * ```\n */\nexport function createBrowserScheduler(): SchedulerInterface {\n\treturn new BrowserScheduler()\n}\n\n/**\n * Create the frame-aligned cooperative-yield {@link SchedulerInterface} — `yield()` resumes\n * just before the next paint via `requestAnimationFrame`; `delay(ms)` is a real\n * `setTimeout`.\n *\n * @remarks\n * Use it for work that should batch per render frame (animation, incremental DOM updates)\n * and naturally pause while the tab is hidden. `yield` is abort-aware: pass `options.signal`\n * and a pending yield rejects with the signal's `reason` verbatim, cancelling the pending\n * frame request. `options.priority` is accepted but a no-op — a frame callback has no\n * priority dimension.\n *\n * @returns A {@link SchedulerInterface} backed by `requestAnimationFrame`\n *\n * @example\n * ```ts\n * import { createFrameScheduler } from '@orkestrel/workflow/browser'\n *\n * const scheduler = createFrameScheduler()\n * await scheduler.yield() // resumes before the next paint\n * ```\n */\nexport function createFrameScheduler(): SchedulerInterface {\n\treturn new FrameScheduler()\n}\n\n/**\n * Create the idle-time cooperative-yield {@link SchedulerInterface} — `yield()` resumes when\n * the host is idle via `requestIdleCallback` when present, falling back to a `setTimeout(0)`\n * macrotask; `delay(ms)` is a real `setTimeout`.\n *\n * @remarks\n * Use it for low-priority background work that must not contend with rendering or input.\n * Where `requestIdleCallback` is absent (Safari today) it degrades to a plain macrotask.\n * `yield` is abort-aware: pass `options.signal` and a pending yield rejects with the\n * signal's `reason` verbatim, cancelling the pending idle callback. `options.priority` is\n * accepted but a no-op — idle scheduling has no priority dimension.\n *\n * @returns A {@link SchedulerInterface} backed by `requestIdleCallback` (or a macrotask)\n *\n * @example\n * ```ts\n * import { createIdleScheduler } from '@orkestrel/workflow/browser'\n *\n * const scheduler = createIdleScheduler()\n * await scheduler.yield() // resumes when the host is idle\n * ```\n */\nexport function createIdleScheduler(): SchedulerInterface {\n\treturn new IdleScheduler()\n}\n"],"mappings":"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"}