react-inp-chunker 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Suprabhat Kumar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,115 @@
-# Temporary Holding Version
+# react-inp-chunker
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![npm version](https://img.shields.io/npm/v/react-inp-chunker.svg)](https://www.npmjs.com/package/react-inp-chunker)
+[![CI](https://github.com/suprabhat02/react-inp-chunker/actions/workflows/ci.yml/badge.svg)](https://github.com/suprabhat02/react-inp-chunker/actions/workflows/ci.yml)
+
+**Headless React/TypeScript hooks that chunk heavy synchronous work and yield to
+the main thread, so a long update never costs you Interaction to Next Paint (INP).**
+
+Processing a big array, running a multi-phase algorithm, or rendering a large
+canvas frame-by-frame inside a React update blocks the main thread for as long
+as it takes — every click, keypress, and tap queued behind it waits too. This
+package breaks that work into small slices and hands control back to the
+browser between them, using the best yielding primitive the current runtime
+actually has:
+
+1. [`scheduler.yield()`](https://developer.mozilla.org/en-US/docs/Web/API/Scheduler/yield) —
+   the purpose-built API, Baseline across Chromium and Firefox.
+2. `MessageChannel` — not clamped to the ~4ms floor nested `setTimeout` calls
+   get, so it yields sooner.
+3. `setTimeout(0)` — the universal fallback.
+
+No dependencies beyond React itself. Nothing here touches the DOM directly, so
+the scheduling engine (`react-inp-chunker/core`) works just as well outside
+React — a Node script, a Web Worker, anywhere a long synchronous task would
+otherwise block something else.
+
+## Install
+
+```sh
+npm install react-inp-chunker
+```
+
+Requires React 18 or 19 as a peer dependency.
+
+## Usage
+
+### Chunking an array — `useChunkedTask`
+
+```tsx
+import { useChunkedTask } from 'react-inp-chunker';
+
+function RowScorer({ rows }: { rows: Row[] }) {
+  const { status, processed, total, results, isDone, pause, resume, cancel } =
+    useChunkedTask(rows, (row) => expensiveScore(row));
+
+  if (!isDone) {
+    return (
+      <p>
+        Scoring… {processed}/{total}
+      </p>
+    );
+  }
+
+  return <ResultsTable rows={results} />;
+}
+```
+
+`processItem` is called once per item, each call in its own chunk, yielding to
+the browser whenever a time slice (5ms by default) runs out or the browser
+reports pending input. Pass a fresh closure every render — it's always the
+latest one that runs, without restarting the task. What _does_ restart it is
+`rows` becoming a new array reference, or `timeSliceMs`/`autoStart` changing.
+
+### Chunking arbitrary work — `useDeferredTask`
+
+For work that isn't "one function applied to every item of an array" — a
+multi-phase algorithm, a big canvas render — mark your own safe-to-pause
+checkpoints with a generator:
+
+```tsx
+import { useDeferredTask } from 'react-inp-chunker';
+
+function* renderFrames(frameCount: number) {
+  for (let i = 0; i < frameCount; i++) {
+    renderOneExpensiveFrame(i);
+    yield; // "it's safe to pause here if we're over budget"
+  }
+  return frameCount;
+}
+
+function FrameRenderer({ frameCount }: { frameCount: number }) {
+  const { isDone, value } = useDeferredTask(() => renderFrames(frameCount), [frameCount]);
+  return isDone ? <p>Rendered {value} frames.</p> : <p>Rendering…</p>;
+}
+```
+
+### Outside React — `react-inp-chunker/core`
+
+```ts
+import { createChunkScheduler } from 'react-inp-chunker/core';
+
+const scheduler = createChunkScheduler({
+  items: rows,
+  processItem: (row) => expensiveScore(row),
+});
+scheduler.start();
+const { status, results } = await scheduler.settled;
+```
+
+Both engines expose `start()`, `pause()`, `resume()`, `cancel()`, a
+`subscribe()`/`getSnapshot()` pair, and a `settled` promise that always
+resolves — never rejects — with `'done' | 'cancelled' | 'error'`. An
+`AbortSignal` can drive cancellation too.
+
+## Status
+
+Phase 1 — the core scheduling engine, both hooks, and an exhaustive test
+suite (state-machine truth table, every yield fallback path, pause/resume/
+cancel race conditions, reentrancy, SSR safety) at 100% statement, branch,
+function, and line coverage. See [CONTRIBUTING.md](CONTRIBUTING.md) for how
+the project is organised and verified.
+
+## License
+
+MIT © [Suprabhat Kumar](https://suprabhat-dev.com)

package/dist/core/index.cjs

@@ -0,0 +1,16 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_deferred_task = require("../deferred-task-BXVzapQg.cjs");
+exports.DEFAULT_TIME_SLICE_MS = require_deferred_task.DEFAULT_TIME_SLICE_MS;
+exports.createChunkScheduler = require_deferred_task.createChunkScheduler;
+exports.createDeferredTask = require_deferred_task.createDeferredTask;
+exports.initialChunkState = require_deferred_task.initialChunkState;
+exports.isInputPending = require_deferred_task.isInputPending;
+exports.isTerminal = require_deferred_task.isTerminal;
+exports.now = require_deferred_task.now;
+exports.resolveYieldStrategy = require_deferred_task.resolveYieldStrategy;
+exports.shouldYieldNow = require_deferred_task.shouldYieldNow;
+exports.supportsInputPending = require_deferred_task.supportsInputPending;
+exports.supportsMessageChannel = require_deferred_task.supportsMessageChannel;
+exports.supportsSchedulerYield = require_deferred_task.supportsSchedulerYield;
+exports.transition = require_deferred_task.transition;
+exports.yieldToMain = require_deferred_task.yieldToMain;

package/dist/core/index.d.cts

@@ -0,0 +1,2 @@
+import { C as yieldToMain, D as initialChunkState, E as ChunkStatus, O as isTerminal, S as supportsSchedulerYield, T as ChunkMachineState, _ as now, a as DeferredTaskSnapshot, b as supportsInputPending, c as ChunkSchedulerOptions, d as createChunkScheduler, f as DEFAULT_TIME_SLICE_MS, g as isInputPending, h as YieldToMainOptions, i as DeferredTaskResult, k as transition, l as ChunkSchedulerResult, m as YieldStrategy, n as DeferredTask, o as createDeferredTask, p as ShouldYieldOptions, r as DeferredTaskOptions, s as ChunkScheduler, t as DeferredGenerator, u as ChunkSnapshot, v as resolveYieldStrategy, w as ChunkEvent, x as supportsMessageChannel, y as shouldYieldNow } from "../index-C6B_Nm3i.cjs";
+export { type ChunkEvent, type ChunkMachineState, type ChunkScheduler, type ChunkSchedulerOptions, type ChunkSchedulerResult, type ChunkSnapshot, type ChunkStatus, DEFAULT_TIME_SLICE_MS, type DeferredGenerator, type DeferredTask, type DeferredTaskOptions, type DeferredTaskResult, type DeferredTaskSnapshot, type ShouldYieldOptions, type YieldStrategy, type YieldToMainOptions, createChunkScheduler, createDeferredTask, initialChunkState, isInputPending, isTerminal, now, resolveYieldStrategy, shouldYieldNow, supportsInputPending, supportsMessageChannel, supportsSchedulerYield, transition, yieldToMain };

package/dist/core/index.d.ts

@@ -0,0 +1,2 @@
+import { C as yieldToMain, D as initialChunkState, E as ChunkStatus, O as isTerminal, S as supportsSchedulerYield, T as ChunkMachineState, _ as now, a as DeferredTaskSnapshot, b as supportsInputPending, c as ChunkSchedulerOptions, d as createChunkScheduler, f as DEFAULT_TIME_SLICE_MS, g as isInputPending, h as YieldToMainOptions, i as DeferredTaskResult, k as transition, l as ChunkSchedulerResult, m as YieldStrategy, n as DeferredTask, o as createDeferredTask, p as ShouldYieldOptions, r as DeferredTaskOptions, s as ChunkScheduler, t as DeferredGenerator, u as ChunkSnapshot, v as resolveYieldStrategy, w as ChunkEvent, x as supportsMessageChannel, y as shouldYieldNow } from "../index-C6B_Nm3i.js";
+export { type ChunkEvent, type ChunkMachineState, type ChunkScheduler, type ChunkSchedulerOptions, type ChunkSchedulerResult, type ChunkSnapshot, type ChunkStatus, DEFAULT_TIME_SLICE_MS, type DeferredGenerator, type DeferredTask, type DeferredTaskOptions, type DeferredTaskResult, type DeferredTaskSnapshot, type ShouldYieldOptions, type YieldStrategy, type YieldToMainOptions, createChunkScheduler, createDeferredTask, initialChunkState, isInputPending, isTerminal, now, resolveYieldStrategy, shouldYieldNow, supportsInputPending, supportsMessageChannel, supportsSchedulerYield, transition, yieldToMain };

package/dist/core/index.js

@@ -0,0 +1 @@
+export { r as DEFAULT_TIME_SLICE_MS, n as createChunkScheduler, t as createDeferredTask, f as initialChunkState, i as isInputPending, p as isTerminal, a as now, o as resolveYieldStrategy, s as shouldYieldNow, c as supportsInputPending, l as supportsMessageChannel, u as supportsSchedulerYield, m as transition, d as yieldToMain } from "../deferred-task-5kfztF2G.js";

package/dist/deferred-task-5kfztF2G.js

@@ -0,0 +1,517 @@
+// src/core/chunk-machine.ts
+const initialChunkState = { status: "idle" };
+const TERMINAL_STATUSES = /* @__PURE__ */ new Set([
+	"done",
+	"cancelled",
+	"error"
+]);
+function isTerminal(status) {
+	return TERMINAL_STATUSES.has(status);
+}
+function transitionIdle(state, event) {
+	switch (event.type) {
+		case "START": return { status: "processing" };
+		case "CANCEL": return { status: "cancelled" };
+		case "PAUSE":
+		case "RESUME":
+		case "COMPLETE":
+		case "ERROR": return state;
+	}
+}
+function transitionProcessing(state, event) {
+	switch (event.type) {
+		case "PAUSE": return { status: "paused" };
+		case "CANCEL": return { status: "cancelled" };
+		case "COMPLETE": return { status: "done" };
+		case "ERROR": return {
+			status: "error",
+			error: event.error
+		};
+		case "START":
+		case "RESUME": return state;
+	}
+}
+function transitionPaused(state, event) {
+	switch (event.type) {
+		case "RESUME": return { status: "processing" };
+		case "CANCEL": return { status: "cancelled" };
+		case "START":
+		case "PAUSE":
+		case "COMPLETE":
+		case "ERROR": return state;
+	}
+}
+/**
+* Advances the machine by one event. Pure: same inputs always produce an
+* equal output, and the input state is never mutated.
+*/
+function transition(state, event) {
+	switch (state.status) {
+		case "idle": return transitionIdle(state, event);
+		case "processing": return transitionProcessing(state, event);
+		case "paused": return transitionPaused(state, event);
+		case "done":
+		case "cancelled":
+		case "error": return state;
+	}
+}
+// src/core/scheduler.ts
+/** Default time slice: roughly the granularity React's own scheduler uses. */
+const DEFAULT_TIME_SLICE_MS = 5;
+/** True when `scheduler.yield()` is present on this runtime. */
+function supportsSchedulerYield() {
+	return typeof globalThis.scheduler?.yield === "function";
+}
+/** True when the `MessageChannel` constructor is present on this runtime. */
+function supportsMessageChannel() {
+	return typeof MessageChannel === "function";
+}
+/** True when `navigator.scheduling.isInputPending()` is present. */
+function supportsInputPending() {
+	return typeof globalThis.navigator?.scheduling?.isInputPending === "function";
+}
+/**
+* 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.
+*/
+function isInputPending() {
+	try {
+		return globalThis.navigator?.scheduling?.isInputPending?.() ?? false;
+	} catch {
+		return false;
+	}
+}
+/** Picks the best strategy this runtime actually supports. */
+function resolveYieldStrategy() {
+	if (supportsSchedulerYield()) return "scheduler-yield";
+	if (supportsMessageChannel()) return "message-channel";
+	return "set-timeout";
+}
+function yieldViaMessageChannel() {
+	return new Promise((resolve) => {
+		const channel = new MessageChannel();
+		channel.port1.onmessage = () => {
+			resolve();
+		};
+		channel.port2.postMessage(null);
+	});
+}
+function yieldViaSetTimeout() {
+	return new Promise((resolve) => {
+		setTimeout(resolve, 0);
+	});
+}
+/**
+* Yields control back to the browser's main thread, resolving once the
+* browser has had a chance to handle any pending input, then resuming the
+* caller. Never rejects: a runtime that half-implements `scheduler.yield()`
+* (the property exists but the call throws, or the returned promise
+* rejects) falls through to the next strategy rather than propagating the
+* failure into unrelated application code.
+*/
+async function yieldToMain(options) {
+	const strategy = options?.strategy ?? resolveYieldStrategy();
+	if (strategy === "scheduler-yield") {
+		const schedulerGlobal = globalThis.scheduler;
+		if (typeof schedulerGlobal?.yield === "function") try {
+			await schedulerGlobal.yield();
+			return;
+		} catch {}
+		await (supportsMessageChannel() ? yieldViaMessageChannel() : yieldViaSetTimeout());
+		return;
+	}
+	if (strategy === "message-channel") {
+		if (supportsMessageChannel()) {
+			await yieldViaMessageChannel();
+			return;
+		}
+		await yieldViaSetTimeout();
+		return;
+	}
+	await yieldViaSetTimeout();
+}
+/** `performance.now()` when available, `Date.now()` otherwise. Never throws. */
+function now() {
+	try {
+		if (typeof performance !== "undefined" && typeof performance.now === "function") return performance.now();
+	} catch {}
+	return Date.now();
+}
+/**
+* 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).
+*/
+function shouldYieldNow(options) {
+	const timeSliceMs = options.timeSliceMs ?? 5;
+	if (now() - options.sliceStartedAt >= timeSliceMs) return true;
+	return isInputPending();
+}
+// src/core/chunk-scheduler.ts
+function normalizeTimeSliceMs$1(value) {
+	if (typeof value !== "number" || Number.isNaN(value) || value <= 0) return 5;
+	return value;
+}
+/**
+* Builds a one-shot, controllable scheduler that processes `items` through
+* `processItem`, yielding to the main thread on a time budget (and sooner,
+* if the browser reports pending input) so a large array never produces a
+* single long task.
+*
+* One-shot means exactly that: once the task reaches `done`, `cancelled` or
+* `error`, this instance is finished — start()/pause()/resume() on it are
+* no-ops from then on. To run another task, create another scheduler. For a
+* React hook, that falls out naturally: new deps → new effect → new
+* scheduler, which is the idiomatic React data-flow anyway.
+*/
+function createChunkScheduler(options) {
+	const { items, processItem, onItem, signal, yieldStrategy } = options;
+	const timeSliceMs = normalizeTimeSliceMs$1(options.timeSliceMs);
+	const total = items.length;
+	let machineState = initialChunkState;
+	let processed = 0;
+	let loopStarted = false;
+	let settledFlag = false;
+	const results = [];
+	let finalResults;
+	let snapshot = {
+		status: machineState.status,
+		processed,
+		total
+	};
+	const listeners = /* @__PURE__ */ new Set();
+	let settleFn;
+	const settledPromise = new Promise((resolve) => {
+		settleFn = resolve;
+	});
+	let pauseResolve;
+	let pausePromise;
+	function waitForWake() {
+		pausePromise ??= new Promise((resolve) => {
+			pauseResolve = resolve;
+		});
+		return pausePromise;
+	}
+	function openGate() {
+		pauseResolve?.();
+		pauseResolve = void 0;
+		pausePromise = void 0;
+	}
+	function notify() {
+		for (const listener of listeners) listener();
+	}
+	function refreshSnapshot() {
+		snapshot = {
+			status: machineState.status,
+			processed,
+			total,
+			...machineState.error !== void 0 ? { error: machineState.error } : {}
+		};
+	}
+	function dispatch(event) {
+		const next = transition(machineState, event);
+		const changed = next !== machineState;
+		if (changed) {
+			machineState = next;
+			refreshSnapshot();
+			notify();
+		}
+		return { changed };
+	}
+	function settle(result) {
+		/* v8 ignore next */
+		if (settledFlag) return;
+		settledFlag = true;
+		detachSignal();
+		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.
+	*/
+	function finish(status, error) {
+		const resultsCopy = [...results];
+		finalResults = resultsCopy;
+		settle(status === "error" ? {
+			status,
+			error,
+			results: resultsCopy
+		} : {
+			status,
+			results: resultsCopy
+		});
+	}
+	function settleIfNeverStarted() {
+		const { status, error } = machineState;
+		if (loopStarted || !isTerminal(status)) return;
+		loopStarted = true;
+		/* v8 ignore next */
+		if (status === "error") finish("error", error);
+		else finish(status);
+	}
+	function handleAbort() {
+		cancel();
+	}
+	function detachSignal() {
+		signal?.removeEventListener("abort", handleAbort);
+	}
+	if (signal?.aborted) dispatch({ type: "CANCEL" });
+	else signal?.addEventListener("abort", handleAbort);
+	async function runLoop() {
+		let sliceStartedAt = now();
+		itemLoop: for (const [index, item] of items.entries()) {
+			for (;;) {
+				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 (machineState.status === "cancelled") {
+			finish("cancelled");
+			return;
+		}
+		dispatch({ type: "COMPLETE" });
+		finish("done");
+	}
+	function start() {
+		dispatch({ type: "START" });
+		if (machineState.status === "processing" && !loopStarted) {
+			loopStarted = true;
+			runLoop();
+		}
+		settleIfNeverStarted();
+	}
+	function pause() {
+		dispatch({ type: "PAUSE" });
+	}
+	function resume() {
+		const { changed } = dispatch({ type: "RESUME" });
+		if (changed) openGate();
+	}
+	function cancel() {
+		dispatch({ type: "CANCEL" });
+		openGate();
+		settleIfNeverStarted();
+	}
+	return {
+		start,
+		pause,
+		resume,
+		cancel,
+		getSnapshot: () => snapshot,
+		getResults: () => finalResults,
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		settled: settledPromise
+	};
+}
+// 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".
+* Same state machine, same yield primitives, same one-shot-instance
+* contract — see that file's doc comment for the reasoning, which applies
+* here unchanged.
+*/
+function createDeferredTask(options) {
+	const { task, signal, yieldStrategy } = options;
+	const timeSliceMs = normalizeTimeSliceMs(options.timeSliceMs);
+	let machineState = initialChunkState;
+	let loopStarted = false;
+	let settledFlag = false;
+	let value;
+	let snapshot = { status: machineState.status };
+	const listeners = /* @__PURE__ */ new Set();
+	let settleFn;
+	const settledPromise = new Promise((resolve) => {
+		settleFn = resolve;
+	});
+	let pauseResolve;
+	let pausePromise;
+	function waitForWake() {
+		pausePromise ??= new Promise((resolve) => {
+			pauseResolve = resolve;
+		});
+		return pausePromise;
+	}
+	function openGate() {
+		pauseResolve?.();
+		pauseResolve = void 0;
+		pausePromise = void 0;
+	}
+	function notify() {
+		for (const listener of listeners) listener();
+	}
+	function refreshSnapshot() {
+		snapshot = {
+			status: machineState.status,
+			...machineState.error !== void 0 ? { error: machineState.error } : {}
+		};
+	}
+	function dispatch(event) {
+		const next = transition(machineState, event);
+		const changed = next !== machineState;
+		if (changed) {
+			machineState = next;
+			refreshSnapshot();
+			notify();
+		}
+		return { changed };
+	}
+	function settle(result) {
+		/* v8 ignore next */
+		if (settledFlag) return;
+		settledFlag = true;
+		detachSignal();
+		settleFn(result);
+	}
+	function finish(status, resolvedValue, error) {
+		if (status === "done") {
+			value = resolvedValue;
+			settle({
+				status,
+				...resolvedValue !== void 0 ? { value: resolvedValue } : {}
+			});
+			return;
+		}
+		settle(status === "error" ? {
+			status,
+			error
+		} : { status });
+	}
+	function settleIfNeverStarted() {
+		const { status, error } = machineState;
+		if (loopStarted || !isTerminal(status)) return;
+		loopStarted = true;
+		/* v8 ignore next */
+		if (status === "error") finish("error", void 0, error);
+		else finish(status);
+	}
+	function handleAbort() {
+		cancel();
+	}
+	function detachSignal() {
+		signal?.removeEventListener("abort", handleAbort);
+	}
+	if (signal?.aborted) dispatch({ type: "CANCEL" });
+	else signal?.addEventListener("abort", handleAbort);
+	async function runLoop() {
+		let sliceStartedAt = now();
+		const generator = task();
+		let step = {
+			done: false,
+			value: void 0
+		};
+		try {
+			for (;;) {
+				const status = machineState.status;
+				if (status === "cancelled") {
+					generator.return(void 0);
+					break;
+				}
+				if (status === "paused") {
+					await waitForWake();
+					sliceStartedAt = now();
+					continue;
+				}
+				step = generator.next();
+				if (step.done) break;
+				if (shouldYieldNow({
+					sliceStartedAt,
+					timeSliceMs
+				})) {
+					await yieldToMain(yieldStrategy !== void 0 ? { strategy: yieldStrategy } : void 0);
+					notify();
+					sliceStartedAt = now();
+				}
+			}
+		} catch (error) {
+			dispatch({
+				type: "ERROR",
+				error
+			});
+			finish("error", void 0, error);
+			return;
+		}
+		if (machineState.status === "cancelled") {
+			finish("cancelled");
+			return;
+		}
+		dispatch({ type: "COMPLETE" });
+		/* v8 ignore next */
+		finish("done", step.done ? step.value : void 0);
+	}
+	function start() {
+		dispatch({ type: "START" });
+		if (machineState.status === "processing" && !loopStarted) {
+			loopStarted = true;
+			runLoop();
+		}
+		settleIfNeverStarted();
+	}
+	function pause() {
+		dispatch({ type: "PAUSE" });
+	}
+	function resume() {
+		const { changed } = dispatch({ type: "RESUME" });
+		if (changed) openGate();
+	}
+	function cancel() {
+		dispatch({ type: "CANCEL" });
+		openGate();
+		settleIfNeverStarted();
+	}
+	return {
+		start,
+		pause,
+		resume,
+		cancel,
+		getSnapshot: () => snapshot,
+		getValue: () => value,
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		settled: settledPromise
+	};
+}
+export { now as a, supportsInputPending as c, yieldToMain as d, initialChunkState as f, isInputPending as i, supportsMessageChannel as l, transition as m, createChunkScheduler as n, resolveYieldStrategy as o, isTerminal as p, DEFAULT_TIME_SLICE_MS as r, shouldYieldNow as s, createDeferredTask as t, supportsSchedulerYield as u };
+
+//# sourceMappingURL=deferred-task-5kfztF2G.js.map