react-inp-chunker 0.1.2 → 0.2.0

package/dist/{deferred-task-BXVzapQg.cjs → production/deferred-task-zVnq18IN.cjs}

@@ -71,6 +71,19 @@ function supportsInputPending() {
 	return typeof globalThis.navigator?.scheduling?.isInputPending === "function";
 }
 /**
+* Resolves the input-pending probe once, for callers that would otherwise
+* run the feature detection on every item of a long task: walking
+* `navigator.scheduling.isInputPending` through optional calls is wasted
+* work a million times over. Returns a function that always answers
+* `false` where the API is missing, so callers need no second branch.
+*/
+function resolveInputPending() {
+	return supportsInputPending() ? isInputPending : returnsFalse;
+}
+function returnsFalse() {
+	return false;
+}
+/**
 * Best-effort read of whether the browser has pending input right now.
 * Returns `false` — never throws — when the API is unavailable or errors,
 * since the caller's fallback (a plain time budget) is always safe.
@@ -92,6 +105,7 @@ function yieldViaMessageChannel() {
 	return new Promise((resolve) => {
 		const channel = new MessageChannel();
 		channel.port1.onmessage = () => {
+			channel.port1.close();
 			resolve();
 		};
 		channel.port2.postMessage(null);
@@ -139,6 +153,23 @@ function now() {
 	return Date.now();
 }
 /**
+* A time slice of zero, a negative number or NaN is meaningless, so those
+* fall back to the default rather than producing a task that yields after
+* every item (or never).
+*/
+function normalizeTimeSliceMs(value) {
+	if (typeof value !== "number" || Number.isNaN(value) || value <= 0) return 5;
+	return value;
+}
+/**
+* Batch sizes are whole items, at least one. Anything else — a fraction,
+* zero, a negative, NaN — falls back to 1, the safe default.
+*/
+function normalizeBatchSize(value) {
+	if (typeof value !== "number" || !Number.isFinite(value) || value < 1) return 1;
+	return Math.floor(value);
+}
+/**
 * Whether the caller should yield right now: either the time slice has run
 * out, or the browser is reporting pending input (a stronger, earlier
 * signal than the clock — used only when the runtime exposes it).
@@ -149,9 +180,17 @@ function shouldYieldNow(options) {
 	return isInputPending();
 }
 // src/core/chunk-scheduler.ts
-function normalizeTimeSliceMs$1(value) {
-	if (typeof value !== "number" || Number.isNaN(value) || value <= 0) return 5;
-	return value;
+/**
+* `items[index]` for an index the caller has already bounds-checked.
+*
+* The loop below only ever indexes below `items.length`, but
+* `noUncheckedIndexedAccess` widens every index read to `T | undefined`,
+* and `T` may itself include `undefined` — so no runtime check can narrow
+* it. This states the invariant in one place instead of asserting at each
+* use, and compiles to a plain index read.
+*/
+function at(items, index) {
+	return items[index];
 }
 /**
 * Builds a one-shot, controllable scheduler that processes `items` through
@@ -167,8 +206,11 @@ function normalizeTimeSliceMs$1(value) {
 */
 function createChunkScheduler(options) {
 	const { items, processItem, onItem, signal, yieldStrategy } = options;
-	const timeSliceMs = normalizeTimeSliceMs$1(options.timeSliceMs);
+	const timeSliceMs = normalizeTimeSliceMs(options.timeSliceMs);
+	const batchSize = normalizeBatchSize(options.batchSize);
+	const collectResults = options.collectResults ?? true;
 	const total = items.length;
+	const inputPending = resolveInputPending();
 	let machineState = initialChunkState;
 	let processed = 0;
 	let loopStarted = false;
@@ -180,6 +222,7 @@ function createChunkScheduler(options) {
 		processed,
 		total
 	};
+	let snapshotStale = false;
 	const listeners = /* @__PURE__ */ new Set();
 	let settleFn;
 	const settledPromise = new Promise((resolve) => {
@@ -201,20 +244,25 @@ function createChunkScheduler(options) {
 	function notify() {
 		for (const listener of listeners) listener();
 	}
-	function refreshSnapshot() {
-		snapshot = {
-			status: machineState.status,
-			processed,
-			total,
-			...machineState.error !== void 0 ? { error: machineState.error } : {}
-		};
+	function getSnapshot() {
+		if (snapshotStale) {
+			snapshotStale = false;
+			snapshot = {
+				status: machineState.status,
+				processed,
+				total,
+				...machineState.error !== void 0 ? { error: machineState.error } : {},
+				...finalResults !== void 0 ? { results: finalResults } : {}
+			};
+		}
+		return snapshot;
 	}
 	function dispatch(event) {
 		const next = transition(machineState, event);
 		const changed = next !== machineState;
 		if (changed) {
 			machineState = next;
-			refreshSnapshot();
+			snapshotStale = true;
 			notify();
 		}
 		return { changed };
@@ -227,30 +275,42 @@ function createChunkScheduler(options) {
 		settleFn(result);
 	}
 	/**
-	* The single path every terminal transition goes through: snapshots the
-	* results array exactly once (not per item), publishes it via
-	* getResults(), and settles the public promise with the same reference —
-	* no redundant second copy.
+	* Publishes the accumulated results exactly once, at the moment the task
+	* settles — not per item, and never as a second copy. Always called
+	* *before* the terminal status is announced, so the notification that
+	* reports `done` already carries the results: a subscriber can never
+	* observe one without the other.
 	*/
-	function finish(status, error) {
-		const resultsCopy = [...results];
-		finalResults = resultsCopy;
+	function publishResults() {
+		finalResults = results;
+		snapshotStale = true;
+		return finalResults;
+	}
+	function settleWith(status, published, error) {
 		settle(status === "error" ? {
 			status,
 			error,
-			results: resultsCopy
+			results: published
 		} : {
 			status,
-			results: resultsCopy
+			results: published
 		});
 	}
+	/**
+	* Settling as cancelled, for both places that can do it: the loop
+	* noticing, and cancel() on a task whose loop never ran. The CANCEL
+	* transition was announced earlier, before there were any results to
+	* carry, so this notifies again now that there are.
+	*/
+	function finishCancelled() {
+		settleWith("cancelled", publishResults());
+		notify();
+	}
 	function settleIfNeverStarted() {
-		const { status, error } = machineState;
+		const { status } = machineState;
 		if (loopStarted || !isTerminal(status)) return;
 		loopStarted = true;
-		/* v8 ignore next */
-		if (status === "error") finish("error", error);
-		else finish(status);
+		finishCancelled();
 	}
 	function handleAbort() {
 		cancel();
@@ -262,43 +322,48 @@ function createChunkScheduler(options) {
 	else signal?.addEventListener("abort", handleAbort);
 	async function runLoop() {
 		let sliceStartedAt = now();
-		itemLoop: for (const [index, item] of items.entries()) {
-			for (;;) {
+		let index = 0;
+		try {
+			while (index < total) {
 				const status = machineState.status;
-				if (status === "cancelled") break itemLoop;
-				if (status !== "paused") break;
-				await waitForWake();
-				sliceStartedAt = now();
-			}
-			try {
-				const result = processItem(item, index);
-				results.push(result);
-				processed = index + 1;
-				refreshSnapshot();
-				onItem?.(result, item, index);
-			} catch (error) {
-				dispatch({
-					type: "ERROR",
-					error
-				});
-				finish("error", error);
-				return;
-			}
-			if (shouldYieldNow({
-				sliceStartedAt,
-				timeSliceMs
-			})) {
-				await yieldToMain(yieldStrategy !== void 0 ? { strategy: yieldStrategy } : void 0);
-				notify();
-				sliceStartedAt = now();
+				if (status === "cancelled") break;
+				if (status === "paused") {
+					await waitForWake();
+					sliceStartedAt = now();
+					continue;
+				}
+				const batchEnd = index + batchSize <= total ? index + batchSize : total;
+				while (index < batchEnd) {
+					const item = at(items, index);
+					const result = processItem(item, index);
+					if (collectResults) results.push(result);
+					processed = index + 1;
+					onItem?.(result, item, index);
+					index += 1;
+				}
+				snapshotStale = true;
+				if (now() - sliceStartedAt >= timeSliceMs || inputPending()) {
+					await yieldToMain(yieldStrategy !== void 0 ? { strategy: yieldStrategy } : void 0);
+					notify();
+					sliceStartedAt = now();
+				}
 			}
+		} catch (error) {
+			const published = publishResults();
+			dispatch({
+				type: "ERROR",
+				error
+			});
+			settleWith("error", published, error);
+			return;
 		}
 		if (machineState.status === "cancelled") {
-			finish("cancelled");
+			finishCancelled();
 			return;
 		}
+		const published = publishResults();
 		dispatch({ type: "COMPLETE" });
-		finish("done");
+		settleWith("done", published);
 	}
 	function start() {
 		dispatch({ type: "START" });
@@ -325,7 +390,7 @@ function createChunkScheduler(options) {
 		pause,
 		resume,
 		cancel,
-		getSnapshot: () => snapshot,
+		getSnapshot,
 		getResults: () => finalResults,
 		subscribe(listener) {
 			listeners.add(listener);
@@ -337,10 +402,6 @@ function createChunkScheduler(options) {
 	};
 }
 // src/core/deferred-task.ts
-function normalizeTimeSliceMs(value) {
-	if (typeof value !== "number" || Number.isNaN(value) || value <= 0) return 5;
-	return value;
-}
 /**
 * The generator-driven sibling of `createChunkScheduler`, for heavy work
 * that isn't shaped like "one function applied to each item of an array".
@@ -351,11 +412,14 @@ function normalizeTimeSliceMs(value) {
 function createDeferredTask(options) {
 	const { task, signal, yieldStrategy } = options;
 	const timeSliceMs = normalizeTimeSliceMs(options.timeSliceMs);
+	const batchSize = normalizeBatchSize(options.batchSize);
+	const inputPending = resolveInputPending();
 	let machineState = initialChunkState;
 	let loopStarted = false;
 	let settledFlag = false;
-	let value;
+	let settledValue;
 	let snapshot = { status: machineState.status };
+	let snapshotStale = false;
 	const listeners = /* @__PURE__ */ new Set();
 	let settleFn;
 	const settledPromise = new Promise((resolve) => {
@@ -377,18 +441,23 @@ function createDeferredTask(options) {
 	function notify() {
 		for (const listener of listeners) listener();
 	}
-	function refreshSnapshot() {
-		snapshot = {
-			status: machineState.status,
-			...machineState.error !== void 0 ? { error: machineState.error } : {}
-		};
+	function getSnapshot() {
+		if (snapshotStale) {
+			snapshotStale = false;
+			snapshot = {
+				status: machineState.status,
+				...machineState.error !== void 0 ? { error: machineState.error } : {},
+				...settledValue !== void 0 ? { value: settledValue } : {}
+			};
+		}
+		return snapshot;
 	}
 	function dispatch(event) {
 		const next = transition(machineState, event);
 		const changed = next !== machineState;
 		if (changed) {
 			machineState = next;
-			refreshSnapshot();
+			snapshotStale = true;
 			notify();
 		}
 		return { changed };
@@ -400,9 +469,16 @@ function createDeferredTask(options) {
 		detachSignal();
 		settleFn(result);
 	}
-	function finish(status, resolvedValue, error) {
+	/**
+	* Publishes the returned value before the terminal status is announced,
+	* so the notification that reports `done` already carries it.
+	*/
+	function publishValue(resolvedValue) {
+		settledValue = resolvedValue;
+		snapshotStale = true;
+	}
+	function settleWith(status, resolvedValue, error) {
 		if (status === "done") {
-			value = resolvedValue;
 			settle({
 				status,
 				...resolvedValue !== void 0 ? { value: resolvedValue } : {}
@@ -414,13 +490,20 @@ function createDeferredTask(options) {
 			error
 		} : { status });
 	}
+	/**
+	* Settling as cancelled, for both places that can do it. The CANCEL
+	* transition was announced earlier, so this notifies again now that the
+	* task has actually settled.
+	*/
+	function finishCancelled() {
+		settleWith("cancelled");
+		notify();
+	}
 	function settleIfNeverStarted() {
-		const { status, error } = machineState;
+		const { status } = machineState;
 		if (loopStarted || !isTerminal(status)) return;
 		loopStarted = true;
-		/* v8 ignore next */
-		if (status === "error") finish("error", void 0, error);
-		else finish(status);
+		finishCancelled();
 	}
 	function handleAbort() {
 		cancel();
@@ -432,6 +515,7 @@ function createDeferredTask(options) {
 	else signal?.addEventListener("abort", handleAbort);
 	async function runLoop() {
 		let sliceStartedAt = now();
+		let segment = 0;
 		const generator = task();
 		let step = {
 			done: false,
@@ -449,12 +533,17 @@ function createDeferredTask(options) {
 					sliceStartedAt = now();
 					continue;
 				}
-				step = generator.next();
-				if (step.done) break;
-				if (shouldYieldNow({
-					sliceStartedAt,
-					timeSliceMs
-				})) {
+				let done = false;
+				for (let inBatch = 0; inBatch < batchSize; inBatch++) {
+					step = generator.next();
+					segment += 1;
+					if (step.done) {
+						done = true;
+						break;
+					}
+				}
+				if (done) break;
+				if (now() - sliceStartedAt >= timeSliceMs || inputPending()) {
 					await yieldToMain(yieldStrategy !== void 0 ? { strategy: yieldStrategy } : void 0);
 					notify();
 					sliceStartedAt = now();
@@ -465,16 +554,18 @@ function createDeferredTask(options) {
 				type: "ERROR",
 				error
 			});
-			finish("error", void 0, error);
+			settleWith("error", void 0, error);
 			return;
 		}
 		if (machineState.status === "cancelled") {
-			finish("cancelled");
+			finishCancelled();
 			return;
 		}
-		dispatch({ type: "COMPLETE" });
 		/* v8 ignore next */
-		finish("done", step.done ? step.value : void 0);
+		const returned = step.done ? step.value : void 0;
+		publishValue(returned);
+		dispatch({ type: "COMPLETE" });
+		settleWith("done", returned);
 	}
 	function start() {
 		dispatch({ type: "START" });
@@ -501,8 +592,8 @@ function createDeferredTask(options) {
 		pause,
 		resume,
 		cancel,
-		getSnapshot: () => snapshot,
-		getValue: () => value,
+		getSnapshot,
+		getValue: () => settledValue,
 		subscribe(listener) {
 			listeners.add(listener);
 			return () => {
@@ -597,4 +688,4 @@ Object.defineProperty(exports, "yieldToMain", {
 	}
 });
 
-//# sourceMappingURL=deferred-task-BXVzapQg.cjs.map
+//# sourceMappingURL=deferred-task-zVnq18IN.cjs.map

package/dist/production/deferred-task-zVnq18IN.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"deferred-task-zVnq18IN.cjs","names":[],"sources":["../../src/core/chunk-machine.ts","../../src/core/diagnostics.production.ts","../../src/core/scheduler.ts","../../src/core/chunk-scheduler.ts","../../src/core/deferred-task.ts"],"sourcesContent":["/**\n * The state machine a chunk task moves through. Deliberately separate from\n * `chunk-scheduler.ts`'s async orchestration: this file is pure, synchronous,\n * and has nothing to fake-timer around, which is what makes it possible to\n * exhaustively test every (state, event) pair — all of them, not a sample.\n *\n *          START                    CANCEL\n *   idle ---------> processing ----------------> cancelled\n *                    |      ^                   ^         ^\n *              PAUSE |      | RESUME      CANCEL|         | CANCEL\n *                    v      |                   |         |\n *                   paused -+-------------------+         |\n *                    |                                    |\n *          COMPLETE  |  ERROR                              |\n *                    v                                     |\n *                   done / error  (terminal, absorb everything)\n *\n * `done`, `cancelled` and `error` are terminal: once reached, every further\n * event is a no-op that returns the same state object (referentially equal,\n * so a React reducer built on this never re-renders for a dead task). A\n * scheduler is one-shot by design — to run another task, create another\n * scheduler. That one rule is what keeps this table small enough to verify\n * completely instead of \"pretty thoroughly\".\n */\n\nexport type ChunkStatus =\n  'idle' | 'processing' | 'paused' | 'done' | 'cancelled' | 'error';\n\nexport type ChunkEvent =\n  | { readonly type: 'START' }\n  | { readonly type: 'PAUSE' }\n  | { readonly type: 'RESUME' }\n  | { readonly type: 'CANCEL' }\n  | { readonly type: 'COMPLETE' }\n  | { readonly type: 'ERROR'; readonly error: unknown };\n\nexport interface ChunkMachineState {\n  readonly status: ChunkStatus;\n  readonly error?: unknown;\n}\n\nexport const initialChunkState: ChunkMachineState = { status: 'idle' };\n\nexport type TerminalChunkStatus = 'done' | 'cancelled' | 'error';\n\nconst TERMINAL_STATUSES: ReadonlySet<ChunkStatus> = new Set<ChunkStatus>([\n  'done',\n  'cancelled',\n  'error',\n]);\n\nexport function isTerminal(status: ChunkStatus): status is TerminalChunkStatus {\n  return TERMINAL_STATUSES.has(status);\n}\n\nfunction transitionIdle(state: ChunkMachineState, event: ChunkEvent): ChunkMachineState {\n  switch (event.type) {\n    case 'START':\n      return { status: 'processing' };\n    case 'CANCEL':\n      return { status: 'cancelled' };\n    case 'PAUSE':\n    case 'RESUME':\n    case 'COMPLETE':\n    case 'ERROR':\n      return state;\n  }\n}\n\nfunction transitionProcessing(\n  state: ChunkMachineState,\n  event: ChunkEvent,\n): ChunkMachineState {\n  switch (event.type) {\n    case 'PAUSE':\n      return { status: 'paused' };\n    case 'CANCEL':\n      return { status: 'cancelled' };\n    case 'COMPLETE':\n      return { status: 'done' };\n    case 'ERROR':\n      return { status: 'error', error: event.error };\n    case 'START':\n    case 'RESUME':\n      return state;\n  }\n}\n\nfunction transitionPaused(\n  state: ChunkMachineState,\n  event: ChunkEvent,\n): ChunkMachineState {\n  switch (event.type) {\n    case 'RESUME':\n      return { status: 'processing' };\n    case 'CANCEL':\n      return { status: 'cancelled' };\n    case 'START':\n    case 'PAUSE':\n    case 'COMPLETE':\n    case 'ERROR':\n      return state;\n  }\n}\n\n/**\n * Advances the machine by one event. Pure: same inputs always produce an\n * equal output, and the input state is never mutated.\n */\nexport function transition(\n  state: ChunkMachineState,\n  event: ChunkEvent,\n): ChunkMachineState {\n  switch (state.status) {\n    case 'idle':\n      return transitionIdle(state, event);\n    case 'processing':\n      return transitionProcessing(state, event);\n    case 'paused':\n      return transitionPaused(state, event);\n    case 'done':\n    case 'cancelled':\n    case 'error':\n      // Terminal: absorb every event and return the same reference, so a\n      // React reducer built on this never re-renders for a dead task.\n      return state;\n  }\n}\n","import type * as RealDiagnostics from './diagnostics.js';\nimport type { Diagnostics } from './diagnostics.js';\n\n/**\n * The production twin of `diagnostics.ts`, swapped in at build time for the\n * files behind this package's `production` export condition (see\n * tsdown.config.ts). Development guidance is worth about a kilobyte of\n * message strings, which is a quarter of this package — worth paying while\n * building, not worth shipping to users.\n *\n * Relying on a bundler to prove `process.env.NODE_ENV !== 'production'`\n * false and drop the branch does not work: the guard that keeps the check\n * safe outside Node (`typeof process !== 'undefined'`) is not a constant,\n * so esbuild — and therefore Vite — leaves the whole thing in. Swapping the\n * module removes the question.\n */\nexport const isDevelopment = false;\n\nconst NOTHING: Diagnostics = {\n  check: () => undefined,\n  sliceEnded: () => undefined,\n  resumed: () => undefined,\n};\n\nexport function createDiagnostics(): Diagnostics {\n  return NOTHING;\n}\n\n/**\n * Fails the build if this stops being a drop-in replacement for the real\n * module — a missing export, or a signature that drifted.\n */\nconst _sameShape: typeof RealDiagnostics = { isDevelopment, createDiagnostics };\nexport type { _sameShape };\n","/**\n * The main-thread yielding primitives this package is built around.\n *\n * Framework-agnostic on purpose: nothing here imports React, so it works\n * just as well inside a Node CLI script chewing through a big array as it\n * does inside a browser tab. The React bindings in `src/react/` are a thin\n * layer on top of this.\n *\n * Strategy, in priority order:\n *  1. `scheduler.yield()` — the purpose-built API (Baseline across Chromium\n *     and Firefox as of 2026; continuations resume ahead of same-priority\n *     work queued elsewhere on the page).\n *  2. `MessageChannel` — posts a message to a dedicated port and resolves on\n *     delivery. Not clamped to the ~4ms floor `setTimeout` gets once timers\n *     are nested, so it yields sooner than (2).\n *  3. `setTimeout(0)` — universally available, the floor of the floor.\n *\n * Every feature check below is written so it can never throw on a global\n * that doesn't exist — `typeof x` on an undeclared identifier is safe in\n * JS, and every property access goes through optional chaining. That's what\n * makes this file safe to import under SSR, in a test environment with no\n * DOM, or in a browser that only half-implements one of these APIs.\n */\n\nexport type YieldStrategy = 'scheduler-yield' | 'message-channel' | 'set-timeout';\n\n/** Default time slice: roughly the granularity React's own scheduler uses. */\nexport const DEFAULT_TIME_SLICE_MS = 5;\n\ninterface SchedulerYieldGlobal {\n  scheduler?: {\n    yield?: () => Promise<void>;\n  };\n}\n\ninterface NavigatorSchedulingGlobal {\n  navigator?: {\n    scheduling?: {\n      isInputPending?: () => boolean;\n    };\n  };\n}\n\n/** True when `scheduler.yield()` is present on this runtime. */\nexport function supportsSchedulerYield(): boolean {\n  const schedulerGlobal = (globalThis as SchedulerYieldGlobal).scheduler;\n  return typeof schedulerGlobal?.yield === 'function';\n}\n\n/** True when the `MessageChannel` constructor is present on this runtime. */\nexport function supportsMessageChannel(): boolean {\n  return typeof MessageChannel === 'function';\n}\n\n/** True when `navigator.scheduling.isInputPending()` is present. */\nexport function supportsInputPending(): boolean {\n  const navigatorGlobal = (globalThis as NavigatorSchedulingGlobal).navigator;\n  return typeof navigatorGlobal?.scheduling?.isInputPending === 'function';\n}\n\n/**\n * Resolves the input-pending probe once, for callers that would otherwise\n * run the feature detection on every item of a long task: walking\n * `navigator.scheduling.isInputPending` through optional calls is wasted\n * work a million times over. Returns a function that always answers\n * `false` where the API is missing, so callers need no second branch.\n */\nexport function resolveInputPending(): () => boolean {\n  return supportsInputPending() ? isInputPending : returnsFalse;\n}\n\nfunction returnsFalse(): boolean {\n  return false;\n}\n\n/**\n * Best-effort read of whether the browser has pending input right now.\n * Returns `false` — never throws — when the API is unavailable or errors,\n * since the caller's fallback (a plain time budget) is always safe.\n */\nexport function isInputPending(): boolean {\n  try {\n    const navigatorGlobal = (globalThis as NavigatorSchedulingGlobal).navigator;\n    return navigatorGlobal?.scheduling?.isInputPending?.() ?? false;\n  } catch {\n    return false;\n  }\n}\n\n/** Picks the best strategy this runtime actually supports. */\nexport function resolveYieldStrategy(): YieldStrategy {\n  if (supportsSchedulerYield()) return 'scheduler-yield';\n  if (supportsMessageChannel()) return 'message-channel';\n  return 'set-timeout';\n}\n\nfunction yieldViaMessageChannel(): Promise<void> {\n  return new Promise((resolve) => {\n    // A fresh channel per call, deliberately — not a shared module-level\n    // singleton. Two chunk schedulers can easily be yielding in the same\n    // tick (two independent useChunkedTask calls on one page is a normal\n    // app, not an edge case), and a shared port's onmessage handler would\n    // get clobbered by whichever call registered second, permanently\n    // hanging the first caller's promise. A new MessageChannel is a few\n    // microseconds; a silently-hung promise is a production incident.\n    const channel = new MessageChannel();\n    channel.port1.onmessage = () => {\n      // Closed the moment its one message lands. A port with a listener is\n      // a live handle: in Node it keeps the process from ever exiting (a\n      // CLI script would finish its work and then hang), and in a browser\n      // without scheduler.yield() a long task opens hundreds of these.\n      channel.port1.close();\n      resolve();\n    };\n    channel.port2.postMessage(null);\n  });\n}\n\nfunction yieldViaSetTimeout(): Promise<void> {\n  return new Promise((resolve) => {\n    setTimeout(resolve, 0);\n  });\n}\n\nexport interface YieldToMainOptions {\n  /**\n   * Force a specific strategy instead of auto-detecting one. Exists for\n   * deterministic tests of each fallback path; application code should\n   * leave this unset.\n   */\n  strategy?: YieldStrategy;\n}\n\n/**\n * Yields control back to the browser's main thread, resolving once the\n * browser has had a chance to handle any pending input, then resuming the\n * caller. Never rejects: a runtime that half-implements `scheduler.yield()`\n * (the property exists but the call throws, or the returned promise\n * rejects) falls through to the next strategy rather than propagating the\n * failure into unrelated application code.\n */\nexport async function yieldToMain(options?: YieldToMainOptions): Promise<void> {\n  const strategy = options?.strategy ?? resolveYieldStrategy();\n\n  if (strategy === 'scheduler-yield') {\n    const schedulerGlobal = (globalThis as SchedulerYieldGlobal).scheduler;\n    if (typeof schedulerGlobal?.yield === 'function') {\n      try {\n        await schedulerGlobal.yield();\n        return;\n      } catch {\n        // Fall through to the next strategy below.\n      }\n    }\n    await (supportsMessageChannel() ? yieldViaMessageChannel() : yieldViaSetTimeout());\n    return;\n  }\n\n  if (strategy === 'message-channel') {\n    if (supportsMessageChannel()) {\n      await yieldViaMessageChannel();\n      return;\n    }\n    await yieldViaSetTimeout();\n    return;\n  }\n\n  await yieldViaSetTimeout();\n}\n\n/** `performance.now()` when available, `Date.now()` otherwise. Never throws. */\nexport function now(): number {\n  try {\n    if (typeof performance !== 'undefined' && typeof performance.now === 'function') {\n      return performance.now();\n    }\n  } catch {\n    // fall through\n  }\n  return Date.now();\n}\n\n/**\n * A time slice of zero, a negative number or NaN is meaningless, so those\n * fall back to the default rather than producing a task that yields after\n * every item (or never).\n */\nexport function normalizeTimeSliceMs(value: number | undefined): number {\n  if (typeof value !== 'number' || Number.isNaN(value) || value <= 0) {\n    return DEFAULT_TIME_SLICE_MS;\n  }\n  return value;\n}\n\n/**\n * Batch sizes are whole items, at least one. Anything else — a fraction,\n * zero, a negative, NaN — falls back to 1, the safe default.\n */\nexport function normalizeBatchSize(value: number | undefined): number {\n  if (typeof value !== 'number' || !Number.isFinite(value) || value < 1) return 1;\n  return Math.floor(value);\n}\n\nexport interface ShouldYieldOptions {\n  /** `now()` timestamp when the current uninterrupted run of work began. */\n  sliceStartedAt: number;\n  /** Max ms to run before yielding regardless of input-pending state. */\n  timeSliceMs?: number;\n}\n\n/**\n * Whether the caller should yield right now: either the time slice has run\n * out, or the browser is reporting pending input (a stronger, earlier\n * signal than the clock — used only when the runtime exposes it).\n */\nexport function shouldYieldNow(options: ShouldYieldOptions): boolean {\n  const timeSliceMs = options.timeSliceMs ?? DEFAULT_TIME_SLICE_MS;\n  const elapsed = now() - options.sliceStartedAt;\n  if (elapsed >= timeSliceMs) return true;\n  return isInputPending();\n}\n","import {\n  type ChunkEvent,\n  type ChunkMachineState,\n  type ChunkStatus,\n  initialChunkState,\n  isTerminal,\n  transition,\n} from './chunk-machine.js';\nimport { createDiagnostics, isDevelopment } from './diagnostics.js';\nimport {\n  type YieldStrategy,\n  normalizeBatchSize,\n  normalizeTimeSliceMs,\n  now,\n  resolveInputPending,\n  yieldToMain,\n} from './scheduler.js';\n\nexport interface ChunkSchedulerOptions<T, R> {\n  readonly items: readonly T[];\n  readonly processItem: (item: T, index: number) => R;\n  /** Max ms of uninterrupted work before yielding. Default 5. */\n  readonly timeSliceMs?: number;\n  /**\n   * Items to process between clock checks. Default 1, which bounds a slice\n   * at one item: the safe choice, and the right one unless profiling says\n   * otherwise.\n   *\n   * Reading the clock costs around 300ns in a browser (where it is also\n   * coarsened to 0.1ms), so for items measured in nanoseconds that read,\n   * not the work, dominates. Raising this amortizes it — at the cost of\n   * checking the clock, pause and cancel only at batch boundaries, so a\n   * slice can run up to `batchSize` items past its budget. Pick a value\n   * whose worst-case cost you know: `batchSize * your slowest item` is the\n   * overshoot you are accepting.\n   */\n  readonly batchSize?: number;\n  /**\n   * Keep every result for `getResults()`. Default true. Set false when\n   * results are consumed through `onItem`: the array is then never built,\n   * which matters when `items` is large enough for retaining one result\n   * per item to cost real memory. `getResults()` then returns an empty\n   * array once the task settles.\n   */\n  readonly collectResults?: boolean;\n  /** Called after each item is successfully processed. */\n  readonly onItem?: (result: R, item: T, index: number) => void;\n  /** External cancellation source — aborting it is equivalent to calling cancel(). */\n  readonly signal?: AbortSignal;\n  /** Testing-only: forces a specific yield strategy instead of auto-detecting one. */\n  readonly yieldStrategy?: YieldStrategy;\n}\n\nexport interface ChunkSchedulerResult<R> {\n  readonly status: 'done' | 'cancelled' | 'error';\n  readonly results: readonly R[];\n  readonly error?: unknown;\n}\n\nexport interface ChunkSnapshot<R = unknown> {\n  readonly status: ChunkStatus;\n  readonly processed: number;\n  readonly total: number;\n  readonly error?: unknown;\n  /**\n   * Present only once the task has settled, and always in the same\n   * snapshot that first reports a terminal status — so a reader can never\n   * observe `status: 'done'` without the results that go with it.\n   */\n  readonly results?: readonly R[];\n}\n\nexport interface ChunkScheduler<R> {\n  start(): void;\n  pause(): void;\n  resume(): void;\n  cancel(): void;\n  getSnapshot(): ChunkSnapshot<R>;\n  /**\n   * The accumulated results, but only once the task has reached a terminal\n   * state — `undefined` while idle/processing/paused. Computed once, cheaply,\n   * at the moment of that transition; never recomputed on every item, so\n   * reading it (e.g. every time the snapshot changes) never costs an O(n)\n   * array copy per item for a large task. For incremental consumption while\n   * the task is still running, use the `onItem` option instead.\n   */\n  getResults(): readonly R[] | undefined;\n  subscribe(listener: () => void): () => void;\n  /** Resolves exactly once, when the task reaches a terminal state. Never rejects. */\n  readonly settled: Promise<ChunkSchedulerResult<R>>;\n}\n\n/**\n * `items[index]` for an index the caller has already bounds-checked.\n *\n * The loop below only ever indexes below `items.length`, but\n * `noUncheckedIndexedAccess` widens every index read to `T | undefined`,\n * and `T` may itself include `undefined` — so no runtime check can narrow\n * it. This states the invariant in one place instead of asserting at each\n * use, and compiles to a plain index read.\n */\nfunction at<T>(items: readonly T[], index: number): T {\n  return items[index] as T;\n}\n\n/**\n * Builds a one-shot, controllable scheduler that processes `items` through\n * `processItem`, yielding to the main thread on a time budget (and sooner,\n * if the browser reports pending input) so a large array never produces a\n * single long task.\n *\n * One-shot means exactly that: once the task reaches `done`, `cancelled` or\n * `error`, this instance is finished — start()/pause()/resume() on it are\n * no-ops from then on. To run another task, create another scheduler. For a\n * React hook, that falls out naturally: new deps → new effect → new\n * scheduler, which is the idiomatic React data-flow anyway.\n */\nexport function createChunkScheduler<T, R>(\n  options: ChunkSchedulerOptions<T, R>,\n): ChunkScheduler<R> {\n  const { items, processItem, onItem, signal, yieldStrategy } = options;\n  const timeSliceMs = normalizeTimeSliceMs(options.timeSliceMs);\n  const batchSize = normalizeBatchSize(options.batchSize);\n  const collectResults = options.collectResults ?? true;\n  const total = items.length;\n\n  // Resolved once per scheduler, not per item: the feature detection behind\n  // it walks `navigator.scheduling.isInputPending` through optional calls,\n  // which is wasted work on every item of a million-item task.\n  const inputPending = resolveInputPending();\n  const diagnostics = createDiagnostics('item', batchSize);\n\n  let machineState: ChunkMachineState = initialChunkState;\n  let processed = 0;\n  let loopStarted = false;\n  let settledFlag = false;\n  const results: R[] = [];\n  let finalResults: readonly R[] | undefined;\n\n  // Built on demand rather than after every item. useSyncExternalStore\n  // requires repeated calls between notifications to return the *same*\n  // reference, which `snapshot` holds until something actually changes;\n  // `snapshotStale` is what marks it as needing a rebuild. Allocating a\n  // fresh snapshot per item (as this once did) is pure garbage for a task\n  // that only publishes progress at slice boundaries.\n  let snapshot: ChunkSnapshot<R> = { status: machineState.status, processed, total };\n  let snapshotStale = false;\n  const listeners = new Set<() => void>();\n\n  let settleFn!: (result: ChunkSchedulerResult<R>) => void;\n  const settledPromise = new Promise<ChunkSchedulerResult<R>>((resolve) => {\n    settleFn = resolve;\n  });\n\n  // The gate a paused loop blocks on. Recreated per pause; opened by either\n  // resume() or cancel() so a cancelled-while-paused task can never hang.\n  let pauseResolve: (() => void) | undefined;\n  let pausePromise: Promise<void> | undefined;\n\n  function waitForWake(): Promise<void> {\n    pausePromise ??= new Promise((resolve) => {\n      pauseResolve = resolve;\n    });\n    return pausePromise;\n  }\n\n  function openGate(): void {\n    pauseResolve?.();\n    pauseResolve = undefined;\n    pausePromise = undefined;\n  }\n\n  function notify(): void {\n    for (const listener of listeners) listener();\n  }\n\n  function getSnapshot(): ChunkSnapshot<R> {\n    if (snapshotStale) {\n      snapshotStale = false;\n      snapshot = {\n        status: machineState.status,\n        processed,\n        total,\n        ...(machineState.error !== undefined ? { error: machineState.error } : {}),\n        ...(finalResults !== undefined ? { results: finalResults } : {}),\n      };\n    }\n    return snapshot;\n  }\n\n  function dispatch(event: ChunkEvent): { changed: boolean } {\n    const next = transition(machineState, event);\n    const changed = next !== machineState;\n    if (changed) {\n      machineState = next;\n      snapshotStale = true;\n      notify();\n    }\n    return { changed };\n  }\n\n  function settle(result: ChunkSchedulerResult<R>): void {\n    // Structurally unreachable, not merely untested: `finish()` — the only\n    // caller of `settle()` — is itself only ever reached from one of two\n    // mutually exclusive places, each gated by `loopStarted`: runLoop()'s\n    // own completion (which only runs after `loopStarted` was already set\n    // true by start()) or settleIfNeverStarted() (which refuses to run\n    // once `loopStarted` is true). Either way, by the time this instance\n    // can ever reach a terminal state the second time, there is no longer\n    // any code path left that would call settle() again. Kept anyway as\n    // defense-in-depth against a future refactor breaking that invariant.\n    /* v8 ignore next */\n    if (settledFlag) return;\n    settledFlag = true;\n    detachSignal();\n    settleFn(result);\n  }\n\n  /**\n   * Publishes the accumulated results exactly once, at the moment the task\n   * settles — not per item, and never as a second copy. Always called\n   * *before* the terminal status is announced, so the notification that\n   * reports `done` already carries the results: a subscriber can never\n   * observe one without the other.\n   */\n  function publishResults(): readonly R[] {\n    finalResults = results;\n    snapshotStale = true;\n    return finalResults;\n  }\n\n  function settleWith(\n    status: 'done' | 'cancelled' | 'error',\n    published: readonly R[],\n    error?: unknown,\n  ): void {\n    settle(\n      status === 'error'\n        ? { status, error, results: published }\n        : { status, results: published },\n    );\n  }\n\n  /**\n   * Settling as cancelled, for both places that can do it: the loop\n   * noticing, and cancel() on a task whose loop never ran. The CANCEL\n   * transition was announced earlier, before there were any results to\n   * carry, so this notifies again now that there are.\n   */\n  function finishCancelled(): void {\n    settleWith('cancelled', publishResults());\n    notify();\n  }\n\n  // If the machine reached a terminal state without the processing loop\n  // ever running (e.g. cancel() called before start(), or the signal was\n  // already aborted), the loop will never call finish() itself — so this\n  // does it. Guarded by !loopStarted, which this also sets, so it can never\n  // race with (or double-finish against) the loop's own completion path.\n  function settleIfNeverStarted(): void {\n    const { status } = machineState;\n    if (loopStarted || !isTerminal(status)) return;\n    loopStarted = true;\n    // 'cancelled' is the only status reachable here: 'done' and 'error'\n    // both require the loop to have run, and that sets `loopStarted`,\n    // which short-circuits this function above.\n    finishCancelled();\n  }\n\n  function handleAbort(): void {\n    cancel();\n  }\n\n  function detachSignal(): void {\n    signal?.removeEventListener('abort', handleAbort);\n  }\n\n  if (signal?.aborted) {\n    dispatch({ type: 'CANCEL' });\n  } else {\n    signal?.addEventListener('abort', handleAbort);\n  }\n\n  async function runLoop(): Promise<void> {\n    let sliceStartedAt = now();\n    let index = 0;\n\n    try {\n      while (index < total) {\n        // Re-read on every pass rather than trusting a single wake from the\n        // pause gate: a resume() can be undone by a *reentrant* pause()\n        // triggered synchronously from a subscriber's own notification\n        // (resume() dispatches, notify() runs listeners synchronously, a\n        // listener calls pause() before resume() returns). Continuing the\n        // loop instead of falling through is what lets this see that and\n        // block again on a fresh gate, without consuming an item.\n        const status: ChunkStatus = machineState.status;\n        if (status === 'cancelled') break;\n        if (status === 'paused') {\n          await waitForWake();\n          sliceStartedAt = now();\n          if (isDevelopment) diagnostics.resumed(sliceStartedAt, index);\n          continue;\n        }\n\n        // One batch between clock checks. At the default batchSize of 1\n        // this is exactly \"one item, then check\", and the inner loop costs\n        // nothing beyond the comparison.\n        const batchEnd = index + batchSize <= total ? index + batchSize : total;\n        while (index < batchEnd) {\n          const item = at(items, index);\n          const result = processItem(item, index);\n          if (collectResults) results.push(result);\n          processed = index + 1;\n          onItem?.(result, item, index);\n          index += 1;\n        }\n        snapshotStale = true;\n\n        // One clock read per batch, shared by the budget check and the\n        // development diagnostics. Both diagnostic calls compile away in a\n        // production build, along with this module.\n        const checkedAt = now();\n        if (isDevelopment) diagnostics.check(checkedAt, index);\n\n        if (checkedAt - sliceStartedAt >= timeSliceMs || inputPending()) {\n          if (isDevelopment) diagnostics.sliceEnded(checkedAt, index);\n          await yieldToMain(\n            yieldStrategy !== undefined ? { strategy: yieldStrategy } : undefined,\n          );\n          notify(); // surface the progress made during this slice\n          sliceStartedAt = now();\n          if (isDevelopment) diagnostics.resumed(sliceStartedAt, index);\n        }\n      }\n    } catch (error) {\n      const published = publishResults();\n      dispatch({ type: 'ERROR', error });\n      settleWith('error', published, error);\n      return;\n    }\n\n    if (machineState.status === 'cancelled') {\n      finishCancelled();\n      return;\n    }\n\n    const published = publishResults();\n    dispatch({ type: 'COMPLETE' });\n    settleWith('done', published);\n  }\n\n  function start(): void {\n    dispatch({ type: 'START' });\n    if (machineState.status === 'processing' && !loopStarted) {\n      loopStarted = true;\n      void runLoop();\n    }\n    settleIfNeverStarted();\n  }\n\n  function pause(): void {\n    dispatch({ type: 'PAUSE' });\n  }\n\n  function resume(): void {\n    const { changed } = dispatch({ type: 'RESUME' });\n    if (changed) openGate();\n  }\n\n  function cancel(): void {\n    dispatch({ type: 'CANCEL' });\n    openGate();\n    settleIfNeverStarted();\n  }\n\n  return {\n    start,\n    pause,\n    resume,\n    cancel,\n    getSnapshot,\n    getResults: () => finalResults,\n    subscribe(listener) {\n      listeners.add(listener);\n      return () => {\n        listeners.delete(listener);\n      };\n    },\n    settled: settledPromise,\n  };\n}\n","import {\n  type ChunkEvent,\n  type ChunkMachineState,\n  type ChunkStatus,\n  initialChunkState,\n  isTerminal,\n  transition,\n} from './chunk-machine.js';\nimport { createDiagnostics, isDevelopment } from './diagnostics.js';\nimport {\n  type YieldStrategy,\n  normalizeBatchSize,\n  normalizeTimeSliceMs,\n  now,\n  resolveInputPending,\n  yieldToMain,\n} from './scheduler.js';\n\n/**\n * A generator is how you tell `createDeferredTask` where it's safe to yield\n * — arbitrary heavy work (a multi-phase algorithm, a big canvas render)\n * doesn't have a natural \"array of items\" shape the way `createChunkScheduler`\n * expects, so instead you mark checkpoints yourself:\n *\n * ```ts\n * function* renderFrames(frameCount: number) {\n *   for (let i = 0; i < frameCount; i++) {\n *     renderOneExpensiveFrame(i);\n *     yield; // \"it's safe to pause here if we're over budget\"\n *   }\n *   return frameCount;\n * }\n * ```\n *\n * Everything between two `yield`s runs as one uninterruptible synchronous\n * segment — put them wherever your function can safely stop, the same way\n * you'd think about chunk boundaries by hand, just without writing the\n * scheduling code yourself.\n */\nexport type DeferredGenerator<T> = Generator<void, T, void>;\n\nexport interface DeferredTaskOptions<T> {\n  readonly task: () => DeferredGenerator<T>;\n  /** Max ms of uninterrupted work before yielding. Default 5. */\n  readonly timeSliceMs?: number;\n  /**\n   * Segments (the code between two `yield`s) to run between clock checks.\n   * Default 1, which bounds a slice at one segment.\n   *\n   * Reading the clock costs around 300ns in a browser, so a generator that\n   * yields after a few nanoseconds of work spends most of its time asking\n   * the time. Raising this amortizes that — at the cost of checking the\n   * clock, pause and cancel only at batch boundaries, so a slice can run up\n   * to `batchSize` segments past its budget.\n   */\n  readonly batchSize?: number;\n  readonly signal?: AbortSignal;\n  /** Testing-only: forces a specific yield strategy instead of auto-detecting one. */\n  readonly yieldStrategy?: YieldStrategy;\n}\n\nexport interface DeferredTaskResult<T> {\n  readonly status: 'done' | 'cancelled' | 'error';\n  readonly value?: T;\n  readonly error?: unknown;\n}\n\nexport interface DeferredTaskSnapshot<T = unknown> {\n  readonly status: ChunkStatus;\n  readonly error?: unknown;\n  /**\n   * Present only once the task has settled with `done`, and always in the\n   * same snapshot that first reports it — so a reader can never observe\n   * `status: 'done'` without the value that goes with it.\n   */\n  readonly value?: T;\n}\n\nexport interface DeferredTask<T> {\n  start(): void;\n  pause(): void;\n  resume(): void;\n  cancel(): void;\n  getSnapshot(): DeferredTaskSnapshot<T>;\n  /** The returned value once the task has settled with `done` — `undefined` otherwise. */\n  getValue(): T | undefined;\n  subscribe(listener: () => void): () => void;\n  readonly settled: Promise<DeferredTaskResult<T>>;\n}\n\n/**\n * The generator-driven sibling of `createChunkScheduler`, for heavy work\n * that isn't shaped like \"one function applied to each item of an array\".\n * Same state machine, same yield primitives, same one-shot-instance\n * contract — see that file's doc comment for the reasoning, which applies\n * here unchanged.\n */\nexport function createDeferredTask<T>(options: DeferredTaskOptions<T>): DeferredTask<T> {\n  const { task, signal, yieldStrategy } = options;\n  const timeSliceMs = normalizeTimeSliceMs(options.timeSliceMs);\n  const batchSize = normalizeBatchSize(options.batchSize);\n  // Resolved once per task rather than per segment; see chunk-scheduler.ts.\n  const inputPending = resolveInputPending();\n  const diagnostics = createDiagnostics('segment', batchSize);\n\n  let machineState: ChunkMachineState = initialChunkState;\n  let loopStarted = false;\n  let settledFlag = false;\n  let settledValue: T | undefined;\n\n  // Built on demand, and only when something has actually changed.\n  // useSyncExternalStore requires repeated calls between notifications to\n  // return the *same* reference; a fresh object literal on every call (as\n  // this used to be) reads as \"changed every render\" and sends React into\n  // an infinite re-render loop. Mirrors chunk-scheduler.ts exactly.\n  let snapshot: DeferredTaskSnapshot<T> = { status: machineState.status };\n  let snapshotStale = false;\n\n  const listeners = new Set<() => void>();\n\n  let settleFn!: (result: DeferredTaskResult<T>) => void;\n  const settledPromise = new Promise<DeferredTaskResult<T>>((resolve) => {\n    settleFn = resolve;\n  });\n\n  let pauseResolve: (() => void) | undefined;\n  let pausePromise: Promise<void> | undefined;\n\n  function waitForWake(): Promise<void> {\n    pausePromise ??= new Promise((resolve) => {\n      pauseResolve = resolve;\n    });\n    return pausePromise;\n  }\n\n  function openGate(): void {\n    pauseResolve?.();\n    pauseResolve = undefined;\n    pausePromise = undefined;\n  }\n\n  function notify(): void {\n    for (const listener of listeners) listener();\n  }\n\n  function getSnapshot(): DeferredTaskSnapshot<T> {\n    if (snapshotStale) {\n      snapshotStale = false;\n      snapshot = {\n        status: machineState.status,\n        ...(machineState.error !== undefined ? { error: machineState.error } : {}),\n        ...(settledValue !== undefined ? { value: settledValue } : {}),\n      };\n    }\n    return snapshot;\n  }\n\n  function dispatch(event: ChunkEvent): { changed: boolean } {\n    const next = transition(machineState, event);\n    const changed = next !== machineState;\n    if (changed) {\n      machineState = next;\n      snapshotStale = true;\n      notify();\n    }\n    return { changed };\n  }\n\n  function settle(result: DeferredTaskResult<T>): void {\n    // Structurally unreachable, not merely untested — see the identical\n    // guard in chunk-scheduler.ts's settle() for the full invariant: the\n    // only caller, finish(), is reached from exactly one of two mutually\n    // exclusive, `loopStarted`-gated paths per instance, so there is never\n    // a second call left to make once this instance has settled once.\n    // Kept as defense-in-depth against a future refactor breaking that.\n    /* v8 ignore next */\n    if (settledFlag) return;\n    settledFlag = true;\n    detachSignal();\n    settleFn(result);\n  }\n\n  /**\n   * Publishes the returned value before the terminal status is announced,\n   * so the notification that reports `done` already carries it.\n   */\n  function publishValue(resolvedValue: T | undefined): void {\n    settledValue = resolvedValue;\n    snapshotStale = true;\n  }\n\n  function settleWith(\n    status: 'done' | 'cancelled' | 'error',\n    resolvedValue?: T,\n    error?: unknown,\n  ): void {\n    if (status === 'done') {\n      settle({\n        status,\n        ...(resolvedValue !== undefined ? { value: resolvedValue } : {}),\n      });\n      return;\n    }\n    settle(status === 'error' ? { status, error } : { status });\n  }\n\n  /**\n   * Settling as cancelled, for both places that can do it. The CANCEL\n   * transition was announced earlier, so this notifies again now that the\n   * task has actually settled.\n   */\n  function finishCancelled(): void {\n    settleWith('cancelled');\n    notify();\n  }\n\n  function settleIfNeverStarted(): void {\n    const { status } = machineState;\n    if (loopStarted || !isTerminal(status)) return;\n    loopStarted = true;\n    // 'cancelled' is the only status reachable here: 'done' and 'error'\n    // both require the loop to have run, and that sets `loopStarted`,\n    // which short-circuits this function above.\n    finishCancelled();\n  }\n\n  function handleAbort(): void {\n    cancel();\n  }\n\n  function detachSignal(): void {\n    signal?.removeEventListener('abort', handleAbort);\n  }\n\n  if (signal?.aborted) {\n    dispatch({ type: 'CANCEL' });\n  } else {\n    signal?.addEventListener('abort', handleAbort);\n  }\n\n  async function runLoop(): Promise<void> {\n    let sliceStartedAt = now();\n    let segment = 0;\n    const generator = task();\n\n    // `step` always holds the result of the *last* generator.next() call —\n    // including, on an early break below, a stale not-done step from before\n    // that break, which the post-loop checks account for explicitly.\n    let step: IteratorResult<void, T> = { done: false, value: undefined };\n    try {\n      for (;;) {\n        // Captured once per iteration and compared via this local, not via\n        // repeated `machineState.status` property reads — narrowing a\n        // direct property access to a literal here would otherwise survive\n        // (in TS's eyes) across the `await` below, even though the whole\n        // point of that await is that `machineState` can change out from\n        // under us while it's pending.\n        const status: ChunkStatus = machineState.status;\n        if (status === 'cancelled') {\n          generator.return(undefined as unknown as T);\n          break;\n        }\n\n        if (status === 'paused') {\n          await waitForWake();\n          sliceStartedAt = now();\n          if (isDevelopment) diagnostics.resumed(sliceStartedAt, segment);\n          // Don't fall through to generator.next() just because the gate\n          // opened — re-enter the loop and read machineState.status fresh.\n          // A resume() can be undone by a *reentrant* pause() triggered\n          // synchronously from a subscriber's own notification (resume()\n          // dispatches, notify() runs listeners synchronously, a listener\n          // calls pause() before resume() returns) — so waking from one\n          // gate is not proof we're actually clear to proceed. Looping\n          // back here is what lets the top-of-loop checks see that and\n          // either re-block on a fresh gate (status is paused again) or\n          // notice cancellation, instead of blindly running one more\n          // generator step first.\n          continue;\n        }\n\n        // The cancellation check above MUST run before this call, not\n        // after: calling the generator is where its actual (synchronous)\n        // work for this segment happens. An earlier draft called\n        // generator.next() at the *bottom* of the loop, right after the\n        // yieldToMain() await below — so a cancel() landing during that\n        // await would still let one more segment's worth of work run\n        // before the next loop iteration finally noticed. Checking first,\n        // every time, closes that race: nothing the generator does can run\n        // once cancellation has been observed.\n        // One batch of segments between clock checks. At the default\n        // batchSize of 1 this runs exactly one segment, then checks.\n        let done = false;\n        for (let inBatch = 0; inBatch < batchSize; inBatch++) {\n          step = generator.next();\n          segment += 1;\n          if (step.done) {\n            done = true;\n            break;\n          }\n        }\n        if (done) break;\n\n        // One clock read per batch, shared by the budget check and the\n        // development diagnostics, which compile away in production.\n        const checkedAt = now();\n        if (isDevelopment) diagnostics.check(checkedAt, segment);\n\n        if (checkedAt - sliceStartedAt >= timeSliceMs || inputPending()) {\n          if (isDevelopment) diagnostics.sliceEnded(checkedAt, segment);\n          await yieldToMain(\n            yieldStrategy !== undefined ? { strategy: yieldStrategy } : undefined,\n          );\n          notify();\n          sliceStartedAt = now();\n          if (isDevelopment) diagnostics.resumed(sliceStartedAt, segment);\n        }\n      }\n    } catch (error) {\n      dispatch({ type: 'ERROR', error });\n      settleWith('error', undefined, error);\n      return;\n    }\n\n    if (machineState.status === 'cancelled') {\n      finishCancelled();\n      return;\n    }\n\n    // step.done is always true by the time we get here: the only ways out\n    // of the loop above are the top-of-loop 'cancelled' break (handled by\n    // the early return just above, before this line) and the batch loop's\n    // own `done` break — so the \": undefined\" side of this ternary can't\n    // actually run. It stays only because it's what makes TypeScript\n    // narrow step.value's type correctly; the real type is kept rather\n    // than cast away.\n    /* v8 ignore next */\n    const returned = step.done ? step.value : undefined;\n    publishValue(returned);\n    dispatch({ type: 'COMPLETE' });\n    settleWith('done', returned);\n  }\n\n  function start(): void {\n    dispatch({ type: 'START' });\n    if (machineState.status === 'processing' && !loopStarted) {\n      loopStarted = true;\n      void runLoop();\n    }\n    settleIfNeverStarted();\n  }\n\n  function pause(): void {\n    dispatch({ type: 'PAUSE' });\n  }\n\n  function resume(): void {\n    const { changed } = dispatch({ type: 'RESUME' });\n    if (changed) openGate();\n  }\n\n  function cancel(): void {\n    dispatch({ type: 'CANCEL' });\n    openGate();\n    settleIfNeverStarted();\n  }\n\n  return {\n    start,\n    pause,\n    resume,\n    cancel,\n    getSnapshot,\n    getValue: () => settledValue,\n    subscribe(listener) {\n      listeners.add(listener);\n      return () => {\n        listeners.delete(listener);\n      };\n    },\n    settled: settledPromise,\n  };\n}\n"],"mappings":"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"}