phase 0.0.1-alpha.1 → 0.0.2

package/dist/ease.d.ts

@@ -0,0 +1,34 @@
+//#region src/ease/index.d.ts
+/** Cubic ease-out: decelerates to zero velocity. */
+declare function easeOutCubic(progress: number): number;
+/** Quartic ease-out: sharper deceleration than cubic. */
+declare function easeOutQuart(progress: number): number;
+/**
+ * Ease-out with overshoot (elastic snap-back).
+ * @param overshoot - Controls how far past the target the animation goes. Default 1.70158 (≈10% overshoot).
+ */
+declare function easeOutBack(progress: number, overshoot?: number): number;
+/** Cubic ease-in-out: accelerates then decelerates symmetrically. */
+declare function easeInOutCubic(progress: number): number;
+/** Linear (identity). No easing applied. */
+declare function linear(progress: number): number;
+/** Clamp a value between min and max. */
+declare function clamp(value: number, min: number, max: number): number;
+/** Clamp a value to the 0–1 range. */
+declare function clamp01(value: number): number;
+/** Linear interpolation between start and end by progress (0–1). */
+declare function lerp(start: number, end: number, progress: number): number;
+/** Inverse of lerp. Returns the progress (0–1) for a given value between start and end. */
+declare function inverseLerp(start: number, end: number, value: number): number;
+interface RemapOptions {
+  inMin: number;
+  inMax: number;
+  outMin: number;
+  outMax: number;
+  value: number;
+}
+/** Map a value from one range to another. */
+declare function remap(options: RemapOptions): number;
+//#endregion
+export { RemapOptions, clamp, clamp01, easeInOutCubic, easeOutBack, easeOutCubic, easeOutQuart, inverseLerp, lerp, linear, remap };
+//# sourceMappingURL=ease.d.ts.map

package/dist/ease.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ease.d.ts","names":[],"sources":["../src/ease/index.ts"],"mappings":";;iBACgB,YAAA,CAAa,QAAA;;iBAMb,YAAA,CAAa,QAAA;;;AAA7B;;iBASgB,WAAA,CAAY,QAAA,UAAkB,SAAA;;iBAM9B,cAAA,CAAe,QAAA;AAN/B;AAAA,iBAagB,MAAA,CAAO,QAAA;;iBAKP,KAAA,CAAM,KAAA,UAAe,GAAA,UAAa,GAAA;;iBAOlC,OAAA,CAAQ,KAAA;;iBAOR,IAAA,CAAK,KAAA,UAAe,GAAA,UAAa,QAAA;;iBAKjC,WAAA,CAAY,KAAA,UAAe,GAAA,UAAa,KAAA;AAAA,UAIvC,YAAA;EACf,KAAA;EACA,KAAA;EACA,MAAA;EACA,MAAA;EACA,KAAA;AAAA;;iBAIc,KAAA,CAAM,OAAA,EAAS,YAAA"}

package/dist/ease.js

@@ -0,0 +1,56 @@
+//#region src/ease/index.ts
+/** Cubic ease-out: decelerates to zero velocity. */
+function easeOutCubic(progress) {
+	const inv = progress - 1;
+	return inv * inv * inv + 1;
+}
+/** Quartic ease-out: sharper deceleration than cubic. */
+function easeOutQuart(progress) {
+	const inv = progress - 1;
+	return 1 - inv * inv * inv * inv;
+}
+/**
+* Ease-out with overshoot (elastic snap-back).
+* @param overshoot - Controls how far past the target the animation goes. Default 1.70158 (≈10% overshoot).
+*/
+function easeOutBack(progress, overshoot = 1.70158) {
+	const inv = progress - 1;
+	return inv * inv * ((overshoot + 1) * inv + overshoot) + 1;
+}
+/** Cubic ease-in-out: accelerates then decelerates symmetrically. */
+function easeInOutCubic(progress) {
+	return progress < .5 ? 4 * progress * progress * progress : 1 - (-2 * progress + 2) ** 3 / 2;
+}
+/** Linear (identity). No easing applied. */
+function linear(progress) {
+	return progress;
+}
+/** Clamp a value between min and max. */
+function clamp(value, min, max) {
+	if (value < min) return min;
+	if (value > max) return max;
+	return value;
+}
+/** Clamp a value to the 0–1 range. */
+function clamp01(value) {
+	if (value < 0) return 0;
+	if (value > 1) return 1;
+	return value;
+}
+/** Linear interpolation between start and end by progress (0–1). */
+function lerp(start, end, progress) {
+	return start + (end - start) * progress;
+}
+/** Inverse of lerp. Returns the progress (0–1) for a given value between start and end. */
+function inverseLerp(start, end, value) {
+	return start === end ? 0 : (value - start) / (end - start);
+}
+/** Map a value from one range to another. */
+function remap(options) {
+	const progress = inverseLerp(options.inMin, options.inMax, options.value);
+	return lerp(options.outMin, options.outMax, progress);
+}
+//#endregion
+export { clamp, clamp01, easeInOutCubic, easeOutBack, easeOutCubic, easeOutQuart, inverseLerp, lerp, linear, remap };
+
+//# sourceMappingURL=ease.js.map

package/dist/ease.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ease.js","names":[],"sources":["../src/ease/index.ts"],"sourcesContent":["/** Cubic ease-out: decelerates to zero velocity. */\nexport function easeOutCubic(progress: number): number {\n  const inv = progress - 1;\n  return inv * inv * inv + 1;\n}\n\n/** Quartic ease-out: sharper deceleration than cubic. */\nexport function easeOutQuart(progress: number): number {\n  const inv = progress - 1;\n  return 1 - inv * inv * inv * inv;\n}\n\n/**\n * Ease-out with overshoot (elastic snap-back).\n * @param overshoot - Controls how far past the target the animation goes. Default 1.70158 (≈10% overshoot).\n */\nexport function easeOutBack(progress: number, overshoot = 1.70158): number {\n  const inv = progress - 1;\n  return inv * inv * ((overshoot + 1) * inv + overshoot) + 1;\n}\n\n/** Cubic ease-in-out: accelerates then decelerates symmetrically. */\nexport function easeInOutCubic(progress: number): number {\n  return progress < 0.5\n    ? 4 * progress * progress * progress\n    : 1 - (-2 * progress + 2) ** 3 / 2;\n}\n\n/** Linear (identity). No easing applied. */\nexport function linear(progress: number): number {\n  return progress;\n}\n\n/** Clamp a value between min and max. */\nexport function clamp(value: number, min: number, max: number): number {\n  if (value < min) return min;\n  if (value > max) return max;\n  return value;\n}\n\n/** Clamp a value to the 0–1 range. */\nexport function clamp01(value: number): number {\n  if (value < 0) return 0;\n  if (value > 1) return 1;\n  return value;\n}\n\n/** Linear interpolation between start and end by progress (0–1). */\nexport function lerp(start: number, end: number, progress: number): number {\n  return start + (end - start) * progress;\n}\n\n/** Inverse of lerp. Returns the progress (0–1) for a given value between start and end. */\nexport function inverseLerp(start: number, end: number, value: number): number {\n  return start === end ? 0 : (value - start) / (end - start);\n}\n\nexport interface RemapOptions {\n  inMin: number;\n  inMax: number;\n  outMin: number;\n  outMax: number;\n  value: number;\n}\n\n/** Map a value from one range to another. */\nexport function remap(options: RemapOptions): number {\n  const progress = inverseLerp(options.inMin, options.inMax, options.value);\n  return lerp(options.outMin, options.outMax, progress);\n}\n"],"mappings":";;AACA,SAAgB,aAAa,UAA0B;CACrD,MAAM,MAAM,WAAW;AACvB,QAAO,MAAM,MAAM,MAAM;;;AAI3B,SAAgB,aAAa,UAA0B;CACrD,MAAM,MAAM,WAAW;AACvB,QAAO,IAAI,MAAM,MAAM,MAAM;;;;;;AAO/B,SAAgB,YAAY,UAAkB,YAAY,SAAiB;CACzE,MAAM,MAAM,WAAW;AACvB,QAAO,MAAM,QAAQ,YAAY,KAAK,MAAM,aAAa;;;AAI3D,SAAgB,eAAe,UAA0B;AACvD,QAAO,WAAW,KACd,IAAI,WAAW,WAAW,WAC1B,KAAK,KAAK,WAAW,MAAM,IAAI;;;AAIrC,SAAgB,OAAO,UAA0B;AAC/C,QAAO;;;AAIT,SAAgB,MAAM,OAAe,KAAa,KAAqB;AACrE,KAAI,QAAQ,IAAK,QAAO;AACxB,KAAI,QAAQ,IAAK,QAAO;AACxB,QAAO;;;AAIT,SAAgB,QAAQ,OAAuB;AAC7C,KAAI,QAAQ,EAAG,QAAO;AACtB,KAAI,QAAQ,EAAG,QAAO;AACtB,QAAO;;;AAIT,SAAgB,KAAK,OAAe,KAAa,UAA0B;AACzE,QAAO,SAAS,MAAM,SAAS;;;AAIjC,SAAgB,YAAY,OAAe,KAAa,OAAuB;AAC7E,QAAO,UAAU,MAAM,KAAK,QAAQ,UAAU,MAAM;;;AAYtD,SAAgB,MAAM,SAA+B;CACnD,MAAM,WAAW,YAAY,QAAQ,OAAO,QAAQ,OAAO,QAAQ,MAAM;AACzE,QAAO,KAAK,QAAQ,QAAQ,QAAQ,QAAQ,SAAS"}

package/dist/index-D3epuj2x.d.ts

@@ -0,0 +1,249 @@
+//#region src/core/tick/index.d.ts
+interface FrameState {
+  /** Current timestamp from performance.now(). */
+  time: number;
+  /** Milliseconds since last tick, clamped to 40ms. */
+  delta: number;
+  /** Milliseconds since start, excluding paused time. */
+  elapsed: number;
+  /** Frame count since start. */
+  frame: number;
+}
+type TickerPhase = 'idle' | 'running' | 'paused' | 'stopped';
+type TickerReason = 'initial' | 'started' | 'resumed' | 'manual' | 'disposed';
+interface TickerOptions {
+  /** Cap frame rate. Default: uncapped (display refresh rate). */
+  fps?: number;
+  /**
+   * Called every frame with the current frame state. Write to refs or DOM
+   * directly. Never call React `setState` here (60 state updates/sec = 60 re-renders/sec).
+   */
+  onTick: (frame: FrameState) => void;
+  /** Abort signal that stops the ticker when aborted. */
+  signal?: AbortSignal;
+}
+interface Ticker {
+  start(): void;
+  stop(): void;
+  pause(): void;
+  resume(): void;
+  readonly phase: TickerPhase;
+  readonly phaseReason: TickerReason;
+}
+/**
+ * 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.
+ */
+declare function createTicker(options: TickerOptions): Ticker;
+//#endregion
+//#region src/core/sight/index.d.ts
+type SightPhase = 'unknown' | 'visible' | 'hidden';
+type SightReason = 'initial' | 'viewport' | 'document' | 'bfcache' | 'all-hidden';
+interface SightOptions {
+  element: Element;
+  intersectionOptions?: IntersectionObserverInit;
+  onPhaseChange?: (phase: SightPhase, reason: SightReason) => void;
+  /** Abort signal that stops the observer when aborted. */
+  signal?: AbortSignal;
+}
+interface Sight {
+  readonly phase: SightPhase;
+  readonly phaseReason: SightReason;
+  stop(): void;
+}
+/**
+ * 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.
+ */
+declare function createSight(options: SightOptions): Sight;
+//#endregion
+//#region src/core/lifecycle/index.d.ts
+type LifecyclePhase = 'idle' | 'active' | 'paused' | 'stopped';
+type LifecycleReason = 'initial' | 'started' | 'resumed' | 'sight' | 'reduced-motion' | 'manual' | 'disposed';
+/** Whether reduced motion pauses the lifecycle. Default `'pause'`. */
+type LifecycleReducedMotion = 'pause' | 'ignore';
+interface LifecycleOptions {
+  element: Element;
+  reducedMotion?: LifecycleReducedMotion;
+  intersectionOptions?: IntersectionObserverInit;
+  start?: 'auto' | 'manual';
+  onPhaseChange?: (phase: LifecyclePhase, reason: LifecycleReason) => void;
+  /** Abort signal that stops the lifecycle when aborted. */
+  signal?: AbortSignal;
+}
+interface Lifecycle {
+  /** Begin honoring signals. Called automatically unless `start: 'manual'`. */
+  start(): void;
+  /** Terminal. Disposes observers and listeners. Cannot be restarted. */
+  stop(): void;
+  /** Manually pause (e.g. a panel opened over the animation). Lowest priority. */
+  pause(): void;
+  /** Clear a manual pause. */
+  resume(): void;
+  readonly phase: LifecyclePhase;
+  readonly phaseReason: LifecycleReason;
+}
+/**
+ * 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();
+ */
+declare function createLifecycle(options: LifecycleOptions): Lifecycle;
+//#endregion
+//#region src/core/loop/index.d.ts
+type ReducedMotionBehavior = 'pause' | 'complete' | 'ignore';
+type DegradedBehavior = 'throttle' | 'pause' | 'ignore';
+type LoopPhase = 'idle' | 'running' | 'paused' | 'stopped';
+type LoopReason = 'initial' | 'started' | 'resumed' | 'sight' | 'reduced-motion' | 'degraded' | 'manual' | 'disposed';
+type Quality = 'full' | 'degraded';
+type DegradedReason = 'unfocused' | 'frame-budget';
+interface LoopOptionsBase {
+  element: Element;
+  /**
+   * Called every frame. Write to refs or DOM directly. Never call React
+   * `setState` here (60 calls/sec = 60 re-renders/sec).
+   */
+  onTick: (frame: FrameState) => void;
+  fps?: number;
+  reducedMotion?: ReducedMotionBehavior;
+  intersectionOptions?: IntersectionObserverInit;
+  start?: 'auto' | 'manual';
+  onPhaseChange?: (phase: LoopPhase, reason: LoopReason) => void;
+  /** Abort signal that stops the loop when aborted. */
+  signal?: AbortSignal;
+}
+type DegradedOptions = {
+  degraded?: 'throttle';
+  degradedFps?: number;
+} | {
+  degraded: 'pause';
+} | {
+  degraded: 'ignore';
+};
+type LoopOptions = LoopOptionsBase & DegradedOptions;
+interface Loop {
+  start(): void;
+  stop(): void;
+  readonly phase: LoopPhase;
+  readonly phaseReason: LoopReason;
+  readonly quality: Quality;
+  readonly qualityReason: DegradedReason | undefined;
+}
+/**
+ * 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();
+ */
+declare function createLoop(options: LoopOptions): Loop;
+//#endregion
+//#region src/core/render-state/index.d.ts
+type RenderPhase = 'rendered' | 'skipped';
+interface RenderStateOptions {
+  element: Element;
+  onPhaseChange?: (phase: RenderPhase) => void;
+  /** Abort signal that stops the observer when aborted. */
+  signal?: AbortSignal;
+}
+interface RenderState {
+  /** Whether the browser is currently rendering the element or skipping it. */
+  readonly phase: RenderPhase;
+  stop(): void;
+}
+/**
+ * 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.
+ */
+declare function createRenderState(options: RenderStateOptions): RenderState;
+//#endregion
+//#region src/core/idle/index.d.ts
+interface IdleOptions {
+  /** Max ms to wait before running the callback even if no idle period occurs. */
+  timeout?: number;
+  /** Abort signal that cancels the scheduled callback when aborted. */
+  signal?: AbortSignal;
+}
+/**
+ * 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();
+ */
+declare function whenIdle(callback: () => void, options?: IdleOptions): () => void;
+//#endregion
+export { TickerPhase as A, SightOptions as C, FrameState as D, createSight as E, createTicker as M, Ticker as O, Sight as S, SightReason as T, LifecycleOptions as _, RenderStateOptions as a, LifecycleReducedMotion as b, DegradedReason as c, LoopPhase as d, LoopReason as f, Lifecycle as g, createLoop as h, RenderState as i, TickerReason as j, TickerOptions as k, Loop as l, ReducedMotionBehavior as m, whenIdle as n, createRenderState as o, Quality as p, RenderPhase as r, DegradedBehavior as s, IdleOptions as t, LoopOptions as u, LifecyclePhase as v, SightPhase as w, createLifecycle as x, LifecycleReason as y };
+//# sourceMappingURL=index-D3epuj2x.d.ts.map

package/dist/index-D3epuj2x.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-D3epuj2x.d.ts","names":[],"sources":["../src/core/tick/index.ts","../src/core/sight/index.ts","../src/core/lifecycle/index.ts","../src/core/loop/index.ts","../src/core/render-state/index.ts","../src/core/idle/index.ts"],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,99 @@
+import { RemapOptions, clamp, clamp01, easeInOutCubic, easeOutBack, easeOutCubic, easeOutQuart, inverseLerp, lerp, linear, remap } from "./ease.js";
+import { A as TickerPhase, C as SightOptions, D as FrameState, E as createSight, M as createTicker, O as Ticker, S as Sight, T as SightReason, _ as LifecycleOptions, a as RenderStateOptions, b as LifecycleReducedMotion, c as DegradedReason, d as LoopPhase, f as LoopReason, g as Lifecycle, h as createLoop, i as RenderState, j as TickerReason, k as TickerOptions, l as Loop, m as ReducedMotionBehavior, n as whenIdle, o as createRenderState, p as Quality, r as RenderPhase, s as DegradedBehavior, t as IdleOptions, u as LoopOptions, v as LifecyclePhase, w as SightPhase, x as createLifecycle, y as LifecycleReason } from "./index-D3epuj2x.js";
+
+//#region src/core/scroll-progress/index.d.ts
+interface ScrollProgressOptions {
+  element: Element;
+  /** Called when the intersection ratio changes at a threshold crossing. */
+  onProgress: (ratio: number) => void;
+  /** Number of evenly-spaced thresholds. Default 20 (~5% granularity). */
+  steps?: number;
+  root?: Element | Document | null;
+  rootMargin?: string;
+  /** Abort signal that stops the observer when aborted. */
+  signal?: AbortSignal;
+}
+interface ScrollProgress {
+  /** Current intersection ratio (0–1). Synchronous read of the last-reported value. */
+  readonly ratio: number;
+  stop(): void;
+}
+/**
+ * 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();
+ */
+declare function createScrollProgress(options: ScrollProgressOptions): ScrollProgress;
+//#endregion
+//#region src/core/device-pixel-ratio/index.d.ts
+interface DevicePixelRatioOptions {
+  /** Called when devicePixelRatio changes (e.g. window moved between monitors). */
+  onChange: (dpr: number) => void;
+  /** Abort signal that stops the watcher when aborted. */
+  signal?: AbortSignal;
+}
+interface DevicePixelRatio {
+  /** Current devicePixelRatio. Synchronous read of the last-reported value. */
+  readonly dpr: number;
+  stop(): void;
+}
+/**
+ * Track devicePixelRatio changes (e.g. user drags the window between monitors
+ * with different pixel densities).
+ *
+ * Uses a shared `matchMedia` subscription that re-subscribes on every change,
+ * so chained monitor switches (A -> B -> C) are all caught. Multiple instances
+ * share one underlying subscription.
+ *
+ * @example
+ * const watcher = createDevicePixelRatio({
+ *   onChange: (dpr) => bridge.setDpr(dpr),
+ * });
+ * watcher.dpr;   // current value
+ * // cleanup:
+ * watcher.stop();
+ */
+declare function createDevicePixelRatio(options: DevicePixelRatioOptions): DevicePixelRatio;
+//#endregion
+//#region src/core/reduced-motion/index.d.ts
+/**
+ * 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.
+ */
+declare function prefersReducedMotion(): boolean;
+//#endregion
+//#region src/core/_internal/errors/index.d.ts
+type PhaseErrorCode = 'server_context' | 'no_element' | 'invalid_duration' | 'ticker_stopped' | 'missing_context';
+interface PhaseErrorOptions {
+  code: PhaseErrorCode;
+  reason?: string;
+  fix?: string;
+  link?: string;
+}
+/** Lightweight structured error for phase. */
+declare class PhaseError extends Error {
+  readonly code: PhaseErrorCode;
+  readonly reason: string | undefined;
+  readonly fix: string | undefined;
+  readonly link: string | undefined;
+  constructor(message: string, options: PhaseErrorOptions);
+}
+/** Check if a value is a PhaseError instance. */
+declare function isPhaseError(error: unknown): error is PhaseError;
+//#endregion
+export { type DegradedBehavior, type DegradedReason, type DevicePixelRatio, type DevicePixelRatioOptions, type FrameState, type IdleOptions, type Lifecycle, type LifecycleOptions, type LifecyclePhase, type LifecycleReason, type LifecycleReducedMotion, type Loop, type LoopOptions, type LoopPhase, type LoopReason, PhaseError, type PhaseErrorCode, type Quality, type ReducedMotionBehavior, type RemapOptions, type RenderPhase, type RenderState, type RenderStateOptions, type ScrollProgress, type ScrollProgressOptions, type Sight, type SightOptions, type SightPhase, type SightReason, type Ticker, type TickerOptions, type TickerPhase, type TickerReason, clamp, clamp01, createDevicePixelRatio, createLifecycle, createLoop, createRenderState, createScrollProgress, createSight, createTicker, easeInOutCubic, easeOutBack, easeOutCubic, easeOutQuart, inverseLerp, isPhaseError, lerp, linear, prefersReducedMotion, remap, whenIdle };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/core/scroll-progress/index.ts","../src/core/device-pixel-ratio/index.ts","../src/core/reduced-motion/index.ts","../src/core/_internal/errors/index.ts"],"mappings":";;;;UAQiB,qBAAA;EACf,OAAA,EAAS,OAAA;;EAET,UAAA,GAAa,KAAA;EAHE;EAKf,KAAA;EACA,IAAA,GAAO,OAAA,GAAU,QAAA;EACjB,UAAA;EADO;EAGP,MAAA,GAAS,WAAA;AAAA;AAAA,UAGM,cAAA;EAHK;EAAA,SAKX,KAAA;EACT,IAAA;AAAA;;;;;;;;;;;AAHF;;;;;AAqDA;iBAAgB,oBAAA,CACd,OAAA,EAAS,qBAAA,GACR,cAAA;;;UCnEc,uBAAA;;EAEf,QAAA,GAAW,GAAA;;EAEX,MAAA,GAAS,WAAA;AAAA;AAAA,UAGM,gBAAA;EDNN;EAAA,SCQA,GAAA;EACT,IAAA;AAAA;;;;;;;;;;;;;;;;ADEF;iBCqBgB,sBAAA,CACd,OAAA,EAAS,uBAAA,GACR,gBAAA;;;;;;ADnCH;;;;iBEGgB,oBAAA,CAAA;;;KCXJ,cAAA;AAAA,UAOF,iBAAA;EACR,IAAA,EAAM,cAAA;EACN,MAAA;EACA,GAAA;EACA,IAAA;AAAA;;cAIW,UAAA,SAAmB,KAAA;EAAA,SACrB,IAAA,EAAM,cAAA;EAAA,SACN,MAAA;EAAA,SACA,GAAA;EAAA,SACA,IAAA;cAEG,OAAA,UAAiB,OAAA,EAAS,iBAAA;AAAA;;iBAWxB,YAAA,CAAa,KAAA,YAAiB,KAAA,IAAS,UAAA"}

package/dist/index.js

@@ -0,0 +1,47 @@
+import { clamp, clamp01, easeInOutCubic, easeOutBack, easeOutCubic, easeOutQuart, inverseLerp, lerp, linear, remap } from "./ease.js";
+import { a as subscribeDpr, c as createLoop, f as createSight, g as isPhaseError, i as readDpr, l as createLifecycle, m as PhaseError, n as prefersReducedMotion, o as createRenderState, p as createTicker, r as whenIdle, s as createScrollProgress, v as serverContextError, y as linkAbortSignal } from "./reduced-motion-CEJtegNG.js";
+//#region src/core/device-pixel-ratio/index.ts
+/**
+* Track devicePixelRatio changes (e.g. user drags the window between monitors
+* with different pixel densities).
+*
+* Uses a shared `matchMedia` subscription that re-subscribes on every change,
+* so chained monitor switches (A -> B -> C) are all caught. Multiple instances
+* share one underlying subscription.
+*
+* @example
+* const watcher = createDevicePixelRatio({
+*   onChange: (dpr) => bridge.setDpr(dpr),
+* });
+* watcher.dpr;   // current value
+* // cleanup:
+* watcher.stop();
+*/
+function createDevicePixelRatio(options) {
+	if (typeof matchMedia === "undefined") serverContextError("createDevicePixelRatio");
+	const { onChange, signal } = options;
+	let _dpr = readDpr();
+	let stopped = false;
+	const unsubscribe = subscribeDpr((dpr) => {
+		_dpr = dpr;
+		onChange(dpr);
+	});
+	let unlinkAbort;
+	function stop() {
+		if (stopped) return;
+		stopped = true;
+		unlinkAbort?.();
+		unsubscribe();
+	}
+	unlinkAbort = linkAbortSignal(signal, stop);
+	return {
+		get dpr() {
+			return _dpr;
+		},
+		stop
+	};
+}
+//#endregion
+export { PhaseError, clamp, clamp01, createDevicePixelRatio, createLifecycle, createLoop, createRenderState, createScrollProgress, createSight, createTicker, easeInOutCubic, easeOutBack, easeOutCubic, easeOutQuart, inverseLerp, isPhaseError, lerp, linear, prefersReducedMotion, remap, whenIdle };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/core/device-pixel-ratio/index.ts"],"sourcesContent":["import { linkAbortSignal } from '../_internal/abort';\nimport { serverContextError } from '../_internal/errors';\nimport { subscribeDpr, readDpr } from '../_internal/pool/dpr';\n\n// ---------------------------------------------------------------------------\n// Types\n// ---------------------------------------------------------------------------\n\nexport interface DevicePixelRatioOptions {\n  /** Called when devicePixelRatio changes (e.g. window moved between monitors). */\n  onChange: (dpr: number) => void;\n  /** Abort signal that stops the watcher when aborted. */\n  signal?: AbortSignal;\n}\n\nexport interface DevicePixelRatio {\n  /** Current devicePixelRatio. Synchronous read of the last-reported value. */\n  readonly dpr: number;\n  stop(): void;\n}\n\n// ---------------------------------------------------------------------------\n// createDevicePixelRatio\n// ---------------------------------------------------------------------------\n\n/**\n * Track devicePixelRatio changes (e.g. user drags the window between monitors\n * with different pixel densities).\n *\n * Uses a shared `matchMedia` subscription that re-subscribes on every change,\n * so chained monitor switches (A -> B -> C) are all caught. Multiple instances\n * share one underlying subscription.\n *\n * @example\n * const watcher = createDevicePixelRatio({\n *   onChange: (dpr) => bridge.setDpr(dpr),\n * });\n * watcher.dpr;   // current value\n * // cleanup:\n * watcher.stop();\n */\nexport function createDevicePixelRatio(\n  options: DevicePixelRatioOptions,\n): DevicePixelRatio {\n  if (typeof matchMedia === 'undefined') {\n    serverContextError('createDevicePixelRatio');\n  }\n\n  const { onChange, signal } = options;\n\n  let _dpr: number = readDpr();\n  let stopped = false;\n\n  const unsubscribe: () => void = subscribeDpr((dpr) => {\n    _dpr = dpr;\n    onChange(dpr);\n  });\n\n  let unlinkAbort: (() => void) | undefined;\n\n  function stop(): void {\n    if (stopped) return;\n    stopped = true;\n    unlinkAbort?.();\n    unsubscribe();\n  }\n\n  unlinkAbort = linkAbortSignal(signal, stop);\n\n  return {\n    get dpr(): number {\n      return _dpr;\n    },\n    stop,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAyCA,SAAgB,uBACd,SACkB;AAClB,KAAI,OAAO,eAAe,YACxB,oBAAmB,yBAAyB;CAG9C,MAAM,EAAE,UAAU,WAAW;CAE7B,IAAI,OAAe,SAAS;CAC5B,IAAI,UAAU;CAEd,MAAM,cAA0B,cAAc,QAAQ;AACpD,SAAO;AACP,WAAS,IAAI;GACb;CAEF,IAAI;CAEJ,SAAS,OAAa;AACpB,MAAI,QAAS;AACb,YAAU;AACV,iBAAe;AACf,eAAa;;AAGf,eAAc,gBAAgB,QAAQ,KAAK;AAE3C,QAAO;EACL,IAAI,MAAc;AAChB,UAAO;;EAET;EACD"}