phase 0.0.1-alpha.1 → 0.0.2

package/dist/reduced-motion-CEJtegNG.js

@@ -0,0 +1,948 @@
+//#region src/core/_internal/abort/index.ts
+/**
+* Link an optional `AbortSignal` to a primitive's `stop`/cancel function.
+*
+* When the signal aborts, `stop` runs once. If the signal is already aborted,
+* `stop` runs synchronously. Returns an unlink function that removes the abort
+* listener. Call it from inside `stop` so a manual stop does not leave a
+* dangling listener on a long-lived controller.
+*
+* The listener is registered with `{ once: true }`, so abort and manual stop
+* are safe to interleave: whichever fires first wins, the other is a no-op.
+*/
+function linkAbortSignal(signal, stop) {
+	if (!signal) return unlinkNoop;
+	if (signal.aborted) {
+		stop();
+		return unlinkNoop;
+	}
+	signal.addEventListener("abort", stop, { once: true });
+	return () => signal.removeEventListener("abort", stop);
+}
+/** Shared empty unlink for the no-signal and already-aborted paths. */
+function unlinkNoop() {}
+//#endregion
+//#region src/core/_internal/errors/index.ts
+/** Lightweight structured error for phase. */
+var PhaseError = class extends Error {
+	code;
+	reason;
+	fix;
+	link;
+	constructor(message, options) {
+		super(message);
+		this.name = "PhaseError";
+		this.code = options.code;
+		this.reason = options.reason;
+		this.fix = options.fix;
+		this.link = options.link;
+	}
+};
+/** Check if a value is a PhaseError instance. */
+function isPhaseError(error) {
+	return error instanceof PhaseError;
+}
+function serverContextError(fn) {
+	throw new PhaseError(`${fn}() cannot be called on the server.`, {
+		code: "server_context",
+		reason: "Browser APIs are unavailable during SSR.",
+		fix: "Move into a useEffect or client-only module."
+	});
+}
+function noElementError(fn) {
+	throw new PhaseError(`${fn}() requires a DOM element.`, {
+		code: "no_element",
+		reason: "The element was null or undefined.",
+		fix: "Pass a mounted Element, or use the React hook which manages the ref."
+	});
+}
+function invalidDurationError(fn, value) {
+	throw new PhaseError(`${fn}() received an invalid duration: ${value}`, {
+		code: "invalid_duration",
+		reason: "Duration must be a finite positive number.",
+		fix: "Pass a positive number (e.g., 300 for 300ms)."
+	});
+}
+function tickerStoppedError() {
+	throw new PhaseError("Cannot resume a stopped ticker.", {
+		code: "ticker_stopped",
+		reason: "stop() is terminal, so a stopped ticker cannot be resumed.",
+		fix: "Create a new ticker instance instead of resuming a stopped one."
+	});
+}
+function missingContextError(child, parent) {
+	throw new PhaseError(`<${child}> must be used inside <${parent}>.`, {
+		code: "missing_context",
+		reason: `<${child}> reads from a context that <${parent}> provides.`,
+		fix: `Wrap <${child}> with <${parent}>.`
+	});
+}
+//#endregion
+//#region src/core/tick/index.ts
+/** Prevents teleportation on resume. Matches motion's maxElapsed. */
+const MAX_DELTA_MS = 40;
+/** Default first-frame delta when no previous tick exists. */
+const DEFAULT_FIRST_DELTA_MS = 16.67;
+let sharedTime = 0;
+let sharedRafId = 0;
+const sharedSubscribers = /* @__PURE__ */ new Set();
+function sharedTick() {
+	sharedTime = performance.now();
+	for (const callback of sharedSubscribers) callback();
+	if (sharedSubscribers.size > 0) sharedRafId = requestAnimationFrame(sharedTick);
+}
+function joinSharedClock(callback) {
+	const wasEmpty = sharedSubscribers.size === 0;
+	sharedSubscribers.add(callback);
+	if (wasEmpty) {
+		sharedTime = performance.now();
+		sharedRafId = requestAnimationFrame(sharedTick);
+	}
+	return () => {
+		sharedSubscribers.delete(callback);
+		if (sharedSubscribers.size === 0 && sharedRafId) {
+			cancelAnimationFrame(sharedRafId);
+			sharedRafId = 0;
+		}
+	};
+}
+function resetFrameState(state) {
+	state.time = 0;
+	state.delta = 0;
+	state.elapsed = 0;
+	state.frame = 0;
+}
+/**
+* Core rAF loop primitive with FPS cap, delta clamping, and strong pause.
+*
+* @remarks
+* `FrameState` is reused across frames. Do not store a reference to it.
+* Read values immediately in your `onTick` callback.
+*/
+function createTicker(options) {
+	if (typeof requestAnimationFrame === "undefined") serverContextError("createTicker");
+	const { onTick, fps, signal } = options;
+	const minFrameTime = fps ? 1e3 / fps : 0;
+	let _phase = "idle";
+	let _reason = "initial";
+	let leaveSharedClock = null;
+	let lastTickTime = 0;
+	let pauseStartTime = 0;
+	let totalPausedTime = 0;
+	let startTime = 0;
+	const frame = {
+		time: 0,
+		delta: 0,
+		elapsed: 0,
+		frame: 0
+	};
+	function tick() {
+		const now = sharedTime;
+		if (minFrameTime > 0 && now - lastTickTime < minFrameTime) return;
+		const rawDelta = lastTickTime === 0 ? DEFAULT_FIRST_DELTA_MS : now - lastTickTime;
+		lastTickTime = now;
+		frame.time = now;
+		frame.delta = rawDelta > MAX_DELTA_MS ? MAX_DELTA_MS : rawDelta;
+		frame.elapsed = now - startTime - totalPausedTime;
+		frame.frame++;
+		onTick(frame);
+	}
+	function start() {
+		if (_phase === "running") return;
+		if (_phase === "stopped") tickerStoppedError();
+		if (_phase === "paused") {
+			resume();
+			return;
+		}
+		_phase = "running";
+		_reason = "started";
+		startTime = performance.now();
+		lastTickTime = 0;
+		totalPausedTime = 0;
+		resetFrameState(frame);
+		leaveSharedClock = joinSharedClock(tick);
+	}
+	function pause() {
+		if (_phase !== "running") return;
+		_phase = "paused";
+		_reason = "manual";
+		pauseStartTime = performance.now();
+		leaveSharedClock?.();
+		leaveSharedClock = null;
+	}
+	function resume() {
+		if (_phase === "stopped") tickerStoppedError();
+		if (_phase !== "paused") return;
+		totalPausedTime += performance.now() - pauseStartTime;
+		lastTickTime = 0;
+		_phase = "running";
+		_reason = "resumed";
+		leaveSharedClock = joinSharedClock(tick);
+	}
+	function stop() {
+		if (_phase === "stopped") return;
+		_phase = "stopped";
+		_reason = _reason === "initial" ? "disposed" : "manual";
+		unlinkAbort?.();
+		leaveSharedClock?.();
+		leaveSharedClock = null;
+	}
+	let unlinkAbort;
+	unlinkAbort = linkAbortSignal(signal, stop);
+	return {
+		start,
+		stop,
+		pause,
+		resume,
+		get phase() {
+			return _phase;
+		},
+		get phaseReason() {
+			return _reason;
+		}
+	};
+}
+//#endregion
+//#region src/core/_internal/pool/io-pool.ts
+const pool$1 = /* @__PURE__ */ new Map();
+/**
+* Observe an element via a shared IntersectionObserver pool.
+* Elements with identical options share one IO instance.
+*
+* @returns Cleanup function that unobserves the element and removes the IO if empty.
+*/
+function observeIntersection(options) {
+	const { element, onIntersect, root, rootMargin, threshold } = options;
+	const ioInit = {
+		root,
+		rootMargin,
+		threshold
+	};
+	const key = getPoolKey(ioInit);
+	const entry = getOrCreatePoolEntry(key, ioInit);
+	entry.callbacks.set(element, onIntersect);
+	entry.observer.observe(element);
+	let disposed = false;
+	return () => {
+		if (disposed) return;
+		disposed = true;
+		const poolEntry = pool$1.get(key);
+		if (!poolEntry) return;
+		if (poolEntry.callbacks.get(element) === onIntersect) {
+			poolEntry.observer.unobserve(element);
+			poolEntry.callbacks.delete(element);
+		}
+		if (poolEntry.callbacks.size === 0) {
+			poolEntry.observer.disconnect();
+			pool$1.delete(key);
+		}
+	};
+}
+/**
+* Produces a stable string key from IO options to group observers in the pool.
+* IO options are immutable after construction, so identical options can share.
+*/
+function getPoolKey(opts) {
+	const root = opts.root ? "custom" : "null";
+	const margin = opts.rootMargin ?? "0px";
+	const threshold = Array.isArray(opts.threshold) ? opts.threshold.join(",") : String(opts.threshold ?? 0);
+	return root + "|" + margin + "|" + threshold;
+}
+/** Return an existing pool entry for this key, or create and register a new one. */
+function getOrCreatePoolEntry(key, options) {
+	const existing = pool$1.get(key);
+	if (existing) return existing;
+	const entry = createPoolEntry$1(options);
+	pool$1.set(key, entry);
+	return entry;
+}
+/** Create a new pool entry for the given options. */
+const createPoolEntry$1 = (options) => {
+	const callbacks = /* @__PURE__ */ new Map();
+	return {
+		observer: new IntersectionObserver((entries) => {
+			for (const ioEntry of entries) {
+				const cb = callbacks.get(ioEntry.target);
+				if (cb) cb(ioEntry);
+			}
+		}, options),
+		callbacks
+	};
+};
+//#endregion
+//#region src/core/sight/index.ts
+/**
+* Visibility observer combining document focus and viewport intersection.
+*
+* `phase` is `'visible'` only when both the document is visible (not backgrounded)
+* and the element is within the viewport. Uses a shared IntersectionObserver
+* pool. Multiple `createSight` calls with the same options share one observer.
+*
+* @example
+* const sight = createSight({
+*   element: el,
+*   onPhaseChange: (phase) => phase === 'visible' ? loop.start() : loop.pause(),
+* });
+* // cleanup:
+* sight.stop();
+*
+* @remarks
+* `onPhaseChange` fires only on phase transitions, not on every IntersectionObserver callback.
+*/
+function createSight(options) {
+	if (typeof document === "undefined") serverContextError("createSight");
+	const { element, intersectionOptions, onPhaseChange, signal } = options;
+	if (!element) noElementError("createSight");
+	let _phase = "unknown";
+	let _reason = "initial";
+	let stopped = false;
+	let documentVisible = !document.hidden;
+	let elementInView = false;
+	function recompute(trigger) {
+		if (stopped) return;
+		const prev = _phase;
+		const next = documentVisible && elementInView ? "visible" : "hidden";
+		_reason = next === "hidden" && !documentVisible && !elementInView ? "all-hidden" : trigger;
+		if (next === prev) return;
+		_phase = next;
+		onPhaseChange?.(_phase, _reason);
+	}
+	function onVisibilityChange() {
+		documentVisible = !document.hidden;
+		recompute("document");
+	}
+	function onPageShow(event) {
+		if (!event.persisted) return;
+		documentVisible = true;
+		recompute("bfcache");
+	}
+	function onIntersection(entry) {
+		elementInView = entry.isIntersecting;
+		recompute("viewport");
+	}
+	document.addEventListener("visibilitychange", onVisibilityChange);
+	window.addEventListener("pageshow", onPageShow);
+	const unobserveIO = observeIntersection({
+		element,
+		onIntersect: onIntersection,
+		...intersectionOptions
+	});
+	let unlinkAbort;
+	function stop() {
+		if (stopped) return;
+		stopped = true;
+		unlinkAbort?.();
+		document.removeEventListener("visibilitychange", onVisibilityChange);
+		window.removeEventListener("pageshow", onPageShow);
+		unobserveIO();
+		_phase = "hidden";
+		_reason = "initial";
+	}
+	unlinkAbort = linkAbortSignal(signal, stop);
+	return {
+		get phase() {
+			return stopped ? "hidden" : _phase;
+		},
+		get phaseReason() {
+			return _reason;
+		},
+		stop
+	};
+}
+//#endregion
+//#region src/core/_internal/pool/mql-pool.ts
+const pool = /* @__PURE__ */ new Map();
+/**
+* Subscribe to a media query via a shared MediaQueryList pool.
+* Multiple subscribers to the same query share one MQL and one change listener.
+*
+* @returns Cleanup function that removes the subscriber.
+*/
+function subscribeMediaQuery(query, callback) {
+	getOrCreateEntry(query).listeners.add(callback);
+	let disposed = false;
+	return () => {
+		if (disposed) return;
+		disposed = true;
+		const poolEntry = pool.get(query);
+		if (!poolEntry) return;
+		poolEntry.listeners.delete(callback);
+		if (poolEntry.listeners.size === 0) {
+			poolEntry.mql.removeEventListener("change", poolEntry.handler);
+			pool.delete(query);
+		}
+	};
+}
+/**
+* Synchronous read of a media query via the shared pool.
+* Uses the existing pool entry if available, otherwise reads directly.
+*/
+function readMediaQuery(query) {
+	const entry = pool.get(query);
+	if (entry) return entry.mql.matches;
+	return matchMedia(query).matches;
+}
+/** Return an existing pool entry for this query, or create and register a new one. */
+function getOrCreateEntry(query) {
+	const existing = pool.get(query);
+	if (existing) return existing;
+	const entry = createPoolEntry(query);
+	entry.mql.addEventListener("change", entry.handler);
+	pool.set(query, entry);
+	return entry;
+}
+const createPoolEntry = (query) => {
+	const mql = matchMedia(query);
+	const listeners = /* @__PURE__ */ new Set();
+	const handler = (event) => {
+		for (const cb of listeners) cb(event.matches);
+	};
+	return {
+		mql,
+		listeners,
+		handler
+	};
+};
+//#endregion
+//#region src/core/lifecycle/index.ts
+const REDUCED_MOTION_QUERY$1 = "(prefers-reduced-motion: reduce)";
+/**
+* The activation decision for an animation, decoupled from who drives the frames.
+*
+* Composes visibility (`createSight`), reduced motion, and a manual pause into a
+* single `active` / `paused` phase. Use when you own your render loop (WebGL,
+* three.js, a Web Worker, or non-rAF work that should still pause off-screen or
+* under reduced motion). For loops `phase` should drive, use `createLoop` instead.
+*
+* @example
+* const lifecycle = createLifecycle({
+*   element: canvas,
+*   onPhaseChange: (phase) => {
+*     if (phase === 'active') renderer.start();
+*     else renderer.stop();
+*   },
+* });
+* // cleanup:
+* lifecycle.stop();
+*/
+function createLifecycle(options) {
+	if (typeof document === "undefined") serverContextError("createLifecycle");
+	const { element, reducedMotion = "pause", intersectionOptions, start: startMode = "auto", onPhaseChange, signal } = options;
+	if (!element) noElementError("createLifecycle");
+	let _phase = "idle";
+	let _reason = "initial";
+	let sightVisible = false;
+	let reducedMotionActive = false;
+	let manualPaused = false;
+	let intentStarted = false;
+	let hasBeenActive = false;
+	function setPhase(phase, reason) {
+		if (_phase === phase && _reason === reason) return;
+		_phase = phase;
+		_reason = reason;
+		onPhaseChange?.(phase, reason);
+	}
+	/** Highest-priority active pause signal, or null when nothing should pause. */
+	function pauseReason() {
+		if (reducedMotionActive && reducedMotion === "pause") return "reduced-motion";
+		if (!sightVisible) return "sight";
+		if (manualPaused) return "manual";
+		return null;
+	}
+	function reconcile() {
+		if (_phase === "stopped" || !intentStarted) return;
+		const reason = pauseReason();
+		if (reason) {
+			setPhase("paused", reason);
+			return;
+		}
+		setPhase("active", hasBeenActive ? "resumed" : "started");
+		hasBeenActive = true;
+	}
+	function onSightChange(phase) {
+		sightVisible = phase === "visible";
+		reconcile();
+	}
+	function onReducedMotionChange(matches) {
+		reducedMotionActive = matches;
+		reconcile();
+	}
+	const sight = createSight({
+		element,
+		intersectionOptions,
+		onPhaseChange: onSightChange
+	});
+	let unsubReducedMotion = null;
+	if (reducedMotion !== "ignore") {
+		reducedMotionActive = readMediaQuery(REDUCED_MOTION_QUERY$1);
+		unsubReducedMotion = subscribeMediaQuery(REDUCED_MOTION_QUERY$1, onReducedMotionChange);
+	}
+	function start() {
+		if (_phase === "stopped") return;
+		intentStarted = true;
+		reconcile();
+	}
+	function stop() {
+		if (_phase === "stopped") return;
+		unlinkAbort?.();
+		sight.stop();
+		unsubReducedMotion?.();
+		unsubReducedMotion = null;
+		setPhase("stopped", "disposed");
+	}
+	function pause() {
+		if (manualPaused) return;
+		manualPaused = true;
+		reconcile();
+	}
+	function resume() {
+		if (!manualPaused) return;
+		manualPaused = false;
+		reconcile();
+	}
+	let unlinkAbort;
+	unlinkAbort = linkAbortSignal(signal, stop);
+	if (startMode === "auto") start();
+	return {
+		start,
+		stop,
+		pause,
+		resume,
+		get phase() {
+			return _phase;
+		},
+		get phaseReason() {
+			return _reason;
+		}
+	};
+}
+//#endregion
+//#region src/core/loop/index.ts
+/** How many consecutive over-budget frames before degrading quality. */
+const OVER_BUDGET_THRESHOLD = 3;
+/** FPS cap applied when quality is degraded (throttle mode). */
+const DEGRADED_FPS_CAP = 30;
+/**
+* In `degraded: 'pause'` mode a frame-budget degrade pauses the loop, so no
+* further frames tick to clear it. Without a timer the loop would stay paused
+* forever after a transient spike. After this delay the loop optimistically
+* un-pauses and re-measures, rescheduling on each subsequent degrade. (Throttle
+* mode keeps ticking, so it does not use this.)
+*/
+const RECOVERY_RETRY_MS = 2e3;
+/**
+* Lifecycle-aware animation loop composing ticker, visibility, and reduced motion.
+*
+* Pass an element and get a loop that pauses when the element leaves the viewport
+* or the tab is backgrounded, resumes when it returns, and cleans up with `stop()`.
+*
+* @remarks
+* The loop is signal-driven and exposes only `start()` and `stop()`. There is no
+* imperative `pause()`/`resume()`. Pausing is decided by visibility, reduced
+* motion, and quality, so an imperative pause would compete with those signals.
+* For manual control, use `useLoop`'s `enabled` option (React) or `createLifecycle`,
+* which exposes `pause()`/`resume()` for loops you drive yourself.
+*
+* @example
+* const loop = createLoop({
+*   element: el,
+*   onTick: (frame) => draw(ctx, frame),
+* });
+* // cleanup:
+* loop.stop();
+*/
+function createLoop(options) {
+	if (typeof requestAnimationFrame === "undefined") serverContextError("createLoop");
+	const { element, onTick, fps: baseFps, reducedMotion = "pause", degraded = "throttle", degradedFps: configuredDegradedFps, intersectionOptions, start: startMode = "auto", onPhaseChange, signal } = options;
+	if (!element) noElementError("createLoop");
+	const degradedFps = degraded === "throttle" ? configuredDegradedFps : void 0;
+	let _phase = "idle";
+	let _reason = "initial";
+	let _quality = "full";
+	let _qualityReason;
+	let intentStarted = false;
+	let overBudgetCount = 0;
+	let ticker = null;
+	let focusDegraded = false;
+	let recoveryTimer = null;
+	function setPhase(phase, reason) {
+		if (_phase === phase && _reason === reason) return;
+		_phase = phase;
+		_reason = reason;
+		onPhaseChange?.(phase, reason);
+	}
+	function setQuality(quality, reason) {
+		const changed = _quality !== quality;
+		_quality = quality;
+		_qualityReason = reason;
+		if (!changed) return;
+		if (degraded === "throttle") {
+			if (ticker && _phase === "running") queueMicrotask(rebuildTicker);
+		} else if (degraded === "pause") reconcile();
+	}
+	/** Evaluate all quality signals and pick the highest-priority active one. */
+	function reconcileQuality() {
+		if (focusDegraded) {
+			setQuality("degraded", "unfocused");
+			return;
+		}
+		if (overBudgetCount >= OVER_BUDGET_THRESHOLD) {
+			setQuality("degraded", "frame-budget");
+			return;
+		}
+		setQuality("full");
+	}
+	/**
+	* Un-pause and re-measure after a pause-mode frame-budget degrade. If frames
+	* are still over budget, the next degrade reschedules this.
+	*/
+	function scheduleBudgetRecovery() {
+		if (recoveryTimer !== null) return;
+		recoveryTimer = setTimeout(() => {
+			recoveryTimer = null;
+			overBudgetCount = 0;
+			reconcileQuality();
+		}, RECOVERY_RETRY_MS);
+	}
+	function clearBudgetRecovery() {
+		if (recoveryTimer === null) return;
+		clearTimeout(recoveryTimer);
+		recoveryTimer = null;
+	}
+	function getEffectiveFps() {
+		if (_quality !== "degraded") return baseFps;
+		const cap = degradedFps ?? DEGRADED_FPS_CAP;
+		if (baseFps === void 0) return cap;
+		return Math.min(baseFps, cap);
+	}
+	function destroyTicker() {
+		if (!ticker) return;
+		ticker.stop();
+		ticker = null;
+	}
+	function buildTicker() {
+		const targetFps = getEffectiveFps();
+		const budget = 1e3 / (targetFps ?? 60);
+		destroyTicker();
+		ticker = createTicker({
+			fps: targetFps,
+			onTick: (frame) => {
+				checkFrameBudget(frame.delta, budget);
+				onTick(frame);
+			}
+		});
+		ticker.start();
+	}
+	function rebuildTicker() {
+		if (_phase !== "running" || !ticker) return;
+		buildTicker();
+	}
+	function checkFrameBudget(delta, budget) {
+		if (delta <= budget * 1.5) {
+			overBudgetCount = 0;
+			return;
+		}
+		overBudgetCount++;
+		if (overBudgetCount < OVER_BUDGET_THRESHOLD) return;
+		reconcileQuality();
+		if (degraded === "pause") scheduleBudgetRecovery();
+	}
+	/** Check if any signal requires the loop to be paused. */
+	function shouldPause() {
+		if (lifecycle.phase === "paused") return lifecycle.phaseReason;
+		if (degraded === "pause" && _quality === "degraded") return "degraded";
+		return null;
+	}
+	/** Evaluate all signals and transition to the correct phase. */
+	function reconcile() {
+		if (_phase === "stopped" || !intentStarted) return;
+		const pauseReason = shouldPause();
+		if (pauseReason) {
+			if (ticker && _phase === "running") ticker.pause();
+			setPhase("paused", pauseReason);
+			return;
+		}
+		if (!ticker) {
+			buildTicker();
+			setPhase("running", _reason === "initial" ? "started" : "resumed");
+		} else if (_phase === "paused") {
+			ticker.resume();
+			setPhase("running", "resumed");
+		}
+	}
+	function onFocusChange() {
+		focusDegraded = !document.hasFocus();
+		reconcileQuality();
+	}
+	const lifecycle = createLifecycle({
+		element,
+		reducedMotion: reducedMotion === "pause" ? "pause" : "ignore",
+		intersectionOptions,
+		start: "manual",
+		onPhaseChange: reconcile
+	});
+	const unsubFocus = subscribeFocusTracking(onFocusChange);
+	function start() {
+		if (_phase === "stopped") return;
+		intentStarted = true;
+		lifecycle.start();
+		reconcile();
+	}
+	function stop() {
+		if (_phase === "stopped") return;
+		unlinkAbort?.();
+		clearBudgetRecovery();
+		destroyTicker();
+		lifecycle.stop();
+		unsubFocus();
+		setPhase("stopped", "disposed");
+	}
+	let unlinkAbort;
+	unlinkAbort = linkAbortSignal(signal, stop);
+	if (startMode === "auto") start();
+	return {
+		start,
+		stop,
+		get phase() {
+			return _phase;
+		},
+		get phaseReason() {
+			return _reason;
+		},
+		get quality() {
+			return _quality;
+		},
+		get qualityReason() {
+			return _qualityReason;
+		}
+	};
+}
+function subscribeFocusTracking(onChange) {
+	window.addEventListener("focus", onChange);
+	window.addEventListener("blur", onChange);
+	return () => {
+		window.removeEventListener("focus", onChange);
+		window.removeEventListener("blur", onChange);
+	};
+}
+//#endregion
+//#region src/core/scroll-progress/index.ts
+const DEFAULT_STEPS = 20;
+const thresholdCache = /* @__PURE__ */ new Map();
+function buildThresholds(steps) {
+	const cached = thresholdCache.get(steps);
+	if (cached) return cached;
+	const thresholds = [];
+	for (let i = 0; i <= steps; i++) thresholds.push(i / steps);
+	thresholdCache.set(steps, thresholds);
+	return thresholds;
+}
+/**
+* Observe what fraction of an element is visible in the viewport (0–1).
+*
+* Uses the shared IntersectionObserver pool with multi-threshold options.
+* Multiple instances with the same `steps` share a single IO.
+*
+* @example
+* const progress = createScrollProgress({
+*   element: el,
+*   onProgress: (ratio) => {
+*     el.style.opacity = String(ratio);
+*   },
+* });
+* // cleanup:
+* progress.stop();
+*/
+function createScrollProgress(options) {
+	if (typeof IntersectionObserver === "undefined") serverContextError("createScrollProgress");
+	const { element, onProgress, steps = DEFAULT_STEPS, root, rootMargin, signal } = options;
+	if (!element) noElementError("createScrollProgress");
+	let _ratio = 0;
+	let stopped = false;
+	const unobserve = observeIntersection({
+		element,
+		onIntersect: (entry) => {
+			const newRatio = entry.intersectionRatio;
+			if (newRatio === _ratio) return;
+			_ratio = newRatio;
+			onProgress(newRatio);
+		},
+		root,
+		rootMargin,
+		threshold: buildThresholds(steps)
+	});
+	let unlinkAbort;
+	function stop() {
+		if (stopped) return;
+		stopped = true;
+		unlinkAbort?.();
+		unobserve();
+	}
+	unlinkAbort = linkAbortSignal(signal, stop);
+	return {
+		get ratio() {
+			return _ratio;
+		},
+		stop
+	};
+}
+//#endregion
+//#region src/core/render-state/index.ts
+/**
+* Report whether the browser is rendering an element or skipping it under
+* `content-visibility`. Listens to the `contentvisibilityautostatechange`
+* event, the browser's ground-truth paint decision.
+*
+* Use it to pause raw, non-phase work (a hand-written rAF loop, `setInterval`,
+* expensive effects) when a `Defer` subtree stops painting. phase's own loops
+* already self-pause off-screen, so they do not need this.
+*
+* Listening and reacting has zero layout effect. It never breaks the
+* no-layout-shift guarantee of `content-visibility`.
+*
+* @example
+* const render = createRenderState({
+*   element: el,
+*   onPhaseChange: (phase) => phase === 'skipped' ? clock.pause() : clock.resume(),
+* });
+* // cleanup:
+* render.stop();
+*
+* @remarks
+* Where `content-visibility` is unsupported, `phase` stays `'rendered'`.
+*
+* Per the CSS Containment spec, `ResizeObserver` callbacks pause for elements
+* inside a skipped `content-visibility: auto` subtree. Use this primitive to
+* detect that transition when your code depends on size observations resuming.
+*/
+function createRenderState(options) {
+	if (typeof document === "undefined") serverContextError("createRenderState");
+	const { element, onPhaseChange, signal } = options;
+	if (!element) noElementError("createRenderState");
+	let _phase = "rendered";
+	let stopped = false;
+	function onStateChange(event) {
+		if (stopped) return;
+		const next = event.skipped ? "skipped" : "rendered";
+		if (next === _phase) return;
+		_phase = next;
+		onPhaseChange?.(_phase);
+	}
+	element.addEventListener("contentvisibilityautostatechange", onStateChange);
+	let unlinkAbort;
+	function stop() {
+		if (stopped) return;
+		stopped = true;
+		unlinkAbort?.();
+		element.removeEventListener("contentvisibilityautostatechange", onStateChange);
+	}
+	unlinkAbort = linkAbortSignal(signal, stop);
+	return {
+		get phase() {
+			return _phase;
+		},
+		stop
+	};
+}
+//#endregion
+//#region src/core/_internal/pool/dpr.ts
+const listeners = /* @__PURE__ */ new Set();
+let currentDpr = 1;
+let mql = null;
+let handler = null;
+/**
+* Subscribe to devicePixelRatio changes (e.g. user drags window between monitors).
+*
+* Uses a single shared `matchMedia` query that re-subscribes on every DPR change,
+* so chained monitor switches (A -> B -> C) are all caught.
+*
+* @returns Cleanup function that removes the subscriber.
+*/
+function subscribeDpr(callback) {
+	listeners.add(callback);
+	if (listeners.size === 1) bind();
+	let disposed = false;
+	return () => {
+		if (disposed) return;
+		disposed = true;
+		listeners.delete(callback);
+		if (listeners.size === 0) unbind();
+	};
+}
+/** Read the current devicePixelRatio. */
+function readDpr() {
+	if (typeof window === "undefined") return 1;
+	return window.devicePixelRatio || 1;
+}
+function bind() {
+	if (typeof matchMedia === "undefined") return;
+	currentDpr = window.devicePixelRatio || 1;
+	mql = matchMedia(`(resolution: ${currentDpr}dppx)`);
+	handler = onDprChange;
+	mql.addEventListener("change", handler);
+}
+function unbind() {
+	if (mql && handler) mql.removeEventListener("change", handler);
+	mql = null;
+	handler = null;
+}
+function onDprChange() {
+	const newDpr = window.devicePixelRatio || 1;
+	if (newDpr === currentDpr) return;
+	currentDpr = newDpr;
+	unbind();
+	bind();
+	for (const cb of listeners) cb(newDpr);
+}
+//#endregion
+//#region src/core/idle/index.ts
+/** Fallback delay when `requestIdleCallback` is unavailable (e.g. Safari). */
+const FALLBACK_DELAY = 1;
+/**
+* Run a callback once the browser is idle. Wraps `requestIdleCallback`, falling
+* back to a near-immediate `setTimeout` where it is unavailable (Safari).
+*
+* Returns a cancel function. Calling it before the callback runs prevents it.
+*
+* @example
+* const cancel = whenIdle(() => warmCache(), { timeout: 2000 });
+* // later, if no longer needed:
+* cancel();
+*/
+function whenIdle(callback, options) {
+	if (typeof window === "undefined") serverContextError("whenIdle");
+	const { timeout, signal } = options ?? {};
+	if (signal?.aborted) return () => {};
+	let cancel;
+	if (typeof window.requestIdleCallback === "function") {
+		const cancelIdle = window.cancelIdleCallback.bind(window);
+		const handle = window.requestIdleCallback(() => callback(), timeout === void 0 ? void 0 : { timeout });
+		cancel = () => cancelIdle(handle);
+	} else {
+		const handle = setTimeout(callback, FALLBACK_DELAY);
+		cancel = () => clearTimeout(handle);
+	}
+	const unlinkAbort = linkAbortSignal(signal, cancel);
+	return () => {
+		unlinkAbort();
+		cancel();
+	};
+}
+//#endregion
+//#region src/core/reduced-motion/index.ts
+const REDUCED_MOTION_QUERY = "(prefers-reduced-motion: reduce)";
+/**
+* Synchronous check for `prefers-reduced-motion: reduce`.
+*
+* Returns `false` on the server (no `matchMedia`). On the client, reads from
+* the shared MQL pool so the underlying `MediaQueryList` is reused across
+* all callers.
+*/
+function prefersReducedMotion() {
+	if (typeof matchMedia === "undefined") return false;
+	return readMediaQuery(REDUCED_MOTION_QUERY);
+}
+//#endregion
+export { missingContextError as _, subscribeDpr as a, createLoop as c, subscribeMediaQuery as d, createSight as f, isPhaseError as g, invalidDurationError as h, readDpr as i, createLifecycle as l, PhaseError as m, prefersReducedMotion as n, createRenderState as o, createTicker as p, whenIdle as r, createScrollProgress as s, REDUCED_MOTION_QUERY as t, readMediaQuery as u, serverContextError as v, linkAbortSignal as y };
+
+//# sourceMappingURL=reduced-motion-CEJtegNG.js.map