@ansh-ui/core 0.2.0

package/dist/chunk-BOQQHICI.js

@@ -0,0 +1,1036 @@
+import { clamp, percentileSorted, damp } from './chunk-KU2C6GEA.js';
+
+// src/kernel/types.ts
+var FRAME_PHASES = ["read", "compute", "write", "post"];
+
+// src/kernel/clock.ts
+var Clock = class {
+  maxDelta;
+  scale;
+  startTimestamp = 0;
+  lastTimestamp = 0;
+  accumulatedTime = 0;
+  frameIndex = 0;
+  running = false;
+  /** Leftover time for the fixed-step accumulator. */
+  fixedRemainder = 0;
+  constructor(options = {}) {
+    this.maxDelta = Math.max(1e-4, options.maxDelta ?? 1 / 15);
+    this.scale = options.timeScale ?? 1;
+  }
+  get timeScale() {
+    return this.scale;
+  }
+  set timeScale(value) {
+    this.scale = Math.max(0, value);
+  }
+  get isRunning() {
+    return this.running;
+  }
+  get elapsed() {
+    return this.accumulatedTime;
+  }
+  start(timestamp) {
+    this.startTimestamp = timestamp;
+    this.lastTimestamp = timestamp;
+    this.running = true;
+  }
+  /**
+   * Resume after a pause.
+   *
+   * Only `lastTimestamp` is reset, so the delta for the resumed frame is small rather than
+   * "however long the pause lasted". `accumulatedTime` continues from where it stopped, which
+   * is what makes pause/resume invisible to animations mid-flight.
+   */
+  resume(timestamp) {
+    this.lastTimestamp = timestamp;
+    this.running = true;
+  }
+  pause() {
+    this.running = false;
+  }
+  reset() {
+    this.startTimestamp = 0;
+    this.lastTimestamp = 0;
+    this.accumulatedTime = 0;
+    this.frameIndex = 0;
+    this.fixedRemainder = 0;
+    this.running = false;
+  }
+  /** Advance the clock and produce this frame's timing. */
+  tick(timestamp) {
+    const rawDelta = Math.max(0, (timestamp - this.lastTimestamp) / 1e3);
+    this.lastTimestamp = timestamp;
+    const delta = clamp(rawDelta, 0, this.maxDelta) * this.scale;
+    this.accumulatedTime += delta;
+    this.frameIndex++;
+    return {
+      time: this.accumulatedTime,
+      delta,
+      rawDelta,
+      frame: this.frameIndex,
+      timestamp
+    };
+  }
+  /**
+   * Number of fixed-size physics steps to run for a variable-length frame.
+   *
+   * Verlet and spring-constraint integrators are only stable at a fixed step; running them
+   * with a variable delta makes stiffness frame-rate dependent, so a 144 Hz monitor gets
+   * different physics from a 60 Hz one. This accumulates the leftover and reports whole steps.
+   *
+   * `maxSteps` bounds the work when a long frame has queued up many steps — better to fall
+   * slightly behind real time than to spiral into an ever-longer catch-up.
+   */
+  fixedSteps(delta, step, maxSteps = 4) {
+    this.fixedRemainder += delta;
+    const steps = Math.min(maxSteps, Math.floor(this.fixedRemainder / step));
+    this.fixedRemainder -= steps * step;
+    if (this.fixedRemainder > step * maxSteps) this.fixedRemainder = 0;
+    return steps;
+  }
+  /** Fraction of the way into the next fixed step, for interpolating rendered positions. */
+  get fixedAlpha() {
+    return this.fixedRemainder;
+  }
+  get totalWallTime() {
+    return (this.lastTimestamp - this.startTimestamp) / 1e3;
+  }
+};
+
+// src/kernel/budget.ts
+var FrameBudget = class {
+  share;
+  windowSize;
+  degradeRate;
+  recoverRate;
+  minQuality;
+  targetFrameMs;
+  explicitTarget;
+  costs;
+  cursor = 0;
+  filled = 0;
+  scratch = [];
+  qualityValue = 1;
+  fpsValue = 60;
+  p50Value = 0;
+  p95Value = 0;
+  /** Frame intervals used to detect the display refresh rate. */
+  intervalSamples = [];
+  refreshDetected = false;
+  constructor(options = {}) {
+    this.share = clamp(options.share ?? 0.5, 0.1, 1);
+    this.windowSize = Math.max(15, Math.floor(options.window ?? 90));
+    this.degradeRate = Math.max(0, options.degradeRate ?? 0.6);
+    this.recoverRate = Math.max(0, options.recoverRate ?? 0.12);
+    this.minQuality = clamp(options.minQuality ?? 0.25, 0.05, 1);
+    this.explicitTarget = options.targetFrameMs !== void 0;
+    this.targetFrameMs = options.targetFrameMs ?? 1e3 / 60;
+    this.costs = new Float32Array(this.windowSize);
+  }
+  get quality() {
+    return this.qualityValue;
+  }
+  get budgetMs() {
+    return this.targetFrameMs * this.share;
+  }
+  /**
+   * Record one frame.
+   *
+   * @param costMs   Milliseconds spent inside Ansh callbacks this frame.
+   * @param rawDelta Unscaled seconds since the previous frame, for FPS and refresh detection.
+   */
+  record(costMs, rawDelta) {
+    if (rawDelta > 0) {
+      const instantFps = 1 / rawDelta;
+      this.fpsValue += (instantFps - this.fpsValue) * 0.1;
+      if (!this.explicitTarget) this.detectRefreshRate(rawDelta * 1e3);
+    }
+    this.costs[this.cursor] = costMs;
+    this.cursor = (this.cursor + 1) % this.windowSize;
+    if (this.filled < this.windowSize) this.filled++;
+    this.recomputePercentiles();
+    this.adaptQuality(rawDelta);
+  }
+  /**
+   * Infer the display refresh rate from observed frame intervals.
+   *
+   * Assuming 60 Hz wastes half the available budget on a 120 Hz display and overspends on a
+   * 30 Hz one. We take the median of the first 40 intervals (median, not mean, so a couple of
+   * long startup frames don't skew it) and snap to the nearest common rate.
+   */
+  detectRefreshRate(intervalMs) {
+    if (this.refreshDetected) return;
+    if (intervalMs < 1 || intervalMs > 50) return;
+    this.intervalSamples.push(intervalMs);
+    if (this.intervalSamples.length < 40) return;
+    const sorted = this.intervalSamples.slice().sort((a, b) => a - b);
+    const median = percentileSorted(sorted, 0.5);
+    const hz = 1e3 / median;
+    const COMMON_RATES = [30, 48, 60, 72, 90, 120, 144, 165, 240];
+    let nearest = 60;
+    let bestDistance = Infinity;
+    for (const rate of COMMON_RATES) {
+      const distance = Math.abs(rate - hz);
+      if (distance < bestDistance) {
+        bestDistance = distance;
+        nearest = rate;
+      }
+    }
+    this.targetFrameMs = 1e3 / nearest;
+    this.refreshDetected = true;
+    this.intervalSamples = [];
+  }
+  recomputePercentiles() {
+    const n = this.filled;
+    if (n === 0) return;
+    if (this.scratch.length !== n) this.scratch = new Array(n);
+    for (let i = 0; i < n; i++) this.scratch[i] = this.costs[i];
+    this.scratch.sort(ascending);
+    this.p50Value = percentileSorted(this.scratch, 0.5);
+    this.p95Value = percentileSorted(this.scratch, 0.95);
+  }
+  adaptQuality(rawDelta) {
+    if (this.filled < 30) return;
+    const budget = this.budgetMs;
+    const dt = clamp(rawDelta, 0, 0.1);
+    if (this.p95Value > budget) {
+      const severity = clamp(this.p95Value / budget - 1, 0, 2);
+      this.qualityValue -= this.degradeRate * severity * dt;
+    } else if (this.p95Value < budget * 0.6) {
+      this.qualityValue += this.recoverRate * dt;
+    }
+    this.qualityValue = clamp(this.qualityValue, this.minQuality, 1);
+  }
+  report() {
+    return {
+      quality: this.qualityValue,
+      fps: this.fpsValue,
+      p50: this.p50Value,
+      p95: this.p95Value,
+      budgetMs: this.budgetMs,
+      degraded: this.qualityValue < 0.999
+    };
+  }
+  /** Force quality to a fixed value, disabling adaptation. Used by `performance="high"`. */
+  lockQuality(value) {
+    this.qualityValue = clamp(value, this.minQuality, 1);
+    this.filled = 0;
+    this.cursor = 0;
+    this.costs.fill(0);
+  }
+  reset() {
+    this.costs.fill(0);
+    this.cursor = 0;
+    this.filled = 0;
+    this.qualityValue = 1;
+    this.p50Value = 0;
+    this.p95Value = 0;
+  }
+};
+function ascending(a, b) {
+  return a - b;
+}
+
+// src/kernel/ticker.ts
+var MAX_CONSECUTIVE_ERRORS = 3;
+var Ticker = class {
+  clock;
+  budget;
+  phases = /* @__PURE__ */ new Map();
+  autoStart;
+  schedule;
+  cancel;
+  readTime;
+  handle = null;
+  nextId = 1;
+  paused = false;
+  pauseReasons = /* @__PURE__ */ new Set();
+  disposed = false;
+  /**
+   * Phase arrays are rebuilt lazily rather than re-sorted on every add/remove: components
+   * mount in bursts, and sorting once before the next frame is cheaper than sorting per call.
+   */
+  dirtyPhases = /* @__PURE__ */ new Set();
+  /** Callbacks queued to run exactly once on the next frame. */
+  onceQueue = [];
+  listeners = /* @__PURE__ */ new Set();
+  state = {
+    time: 0,
+    delta: 0,
+    rawDelta: 0,
+    frame: 0,
+    fps: 60,
+    quality: 1,
+    timestamp: 0
+  };
+  constructor(options = {}) {
+    this.clock = new Clock(options);
+    this.budget = new FrameBudget(options.budget);
+    this.autoStart = options.autoStart ?? true;
+    const raf = options.scheduler ?? (typeof requestAnimationFrame === "function" ? requestAnimationFrame.bind(globalThis) : (cb) => setTimeout(() => cb(now()), 16));
+    const caf = options.canceller ?? (typeof cancelAnimationFrame === "function" ? cancelAnimationFrame.bind(globalThis) : (h) => clearTimeout(h));
+    this.schedule = raf;
+    this.cancel = caf;
+    this.readTime = options.now ?? now;
+    for (const phase of FRAME_PHASES) this.phases.set(phase, []);
+  }
+  // -------------------------------------------------------------------------
+  // Subscription
+  // -------------------------------------------------------------------------
+  /**
+   * Register a per-frame callback.
+   *
+   * @returns An idempotent unsubscribe function. Always call it on unmount — the leak harness
+   *          in the test suite fails the build if a component forgets.
+   */
+  add(callback, options = {}) {
+    if (this.disposed) return noop;
+    const phase = options.phase ?? "write";
+    const subscriber = {
+      id: this.nextId++,
+      callback,
+      priority: options.priority ?? 0,
+      name: options.name ?? "anonymous",
+      errorCount: 0
+    };
+    const list = this.phases.get(phase);
+    if (!list) return noop;
+    list.push(subscriber);
+    this.dirtyPhases.add(phase);
+    if (this.autoStart) this.start();
+    let removed = false;
+    return () => {
+      if (removed) return;
+      removed = true;
+      const index = list.indexOf(subscriber);
+      if (index >= 0) list.splice(index, 1);
+      if (this.subscriberCount === 0) this.stop();
+    };
+  }
+  /** Run a callback on the next frame only. Useful for deferring a DOM read past a write. */
+  once(callback) {
+    if (this.disposed) return;
+    this.onceQueue.push(callback);
+    if (this.autoStart) this.start();
+  }
+  /** Resolve on the next frame. `await ticker.nextFrame()` reads well in setup code. */
+  nextFrame() {
+    return new Promise((resolve) => this.once(resolve));
+  }
+  get subscriberCount() {
+    let total = 0;
+    for (const list of this.phases.values()) total += list.length;
+    return total;
+  }
+  /** Per-phase subscriber counts. Consumed by the dev inspector and the leak harness. */
+  inspect() {
+    const out = {};
+    for (const phase of FRAME_PHASES) {
+      const list = this.phases.get(phase) ?? [];
+      out[phase] = { count: list.length, names: list.map((s) => s.name) };
+    }
+    return out;
+  }
+  // -------------------------------------------------------------------------
+  // Lifecycle
+  // -------------------------------------------------------------------------
+  start() {
+    if (this.disposed || this.handle !== null) return;
+    const timestamp = this.readTime();
+    if (this.clock.isRunning) this.clock.resume(timestamp);
+    else this.clock.start(timestamp);
+    this.handle = this.schedule(this.loop);
+  }
+  stop() {
+    if (this.handle === null) return;
+    this.cancel(this.handle);
+    this.handle = null;
+    this.clock.pause();
+  }
+  /**
+   * Pause the ticker, tagged with a reason.
+   *
+   * Reasons are reference-counted by name so that independent systems can pause without
+   * fighting: if the tab is hidden *and* the user prefers reduced motion, both hold a pause,
+   * and resuming one doesn't restart animation while the other still applies.
+   */
+  pause(reason = "manual") {
+    this.pauseReasons.add(reason);
+    this.paused = true;
+    this.stop();
+  }
+  resume(reason = "manual") {
+    this.pauseReasons.delete(reason);
+    if (this.pauseReasons.size > 0) return;
+    this.paused = false;
+    if (this.subscriberCount > 0 || this.onceQueue.length > 0) this.start();
+  }
+  get isPaused() {
+    return this.paused;
+  }
+  get pausedBecause() {
+    return [...this.pauseReasons];
+  }
+  get isRunning() {
+    return this.handle !== null;
+  }
+  get timeScale() {
+    return this.clock.timeScale;
+  }
+  set timeScale(value) {
+    this.clock.timeScale = value;
+  }
+  get time() {
+    return this.clock.elapsed;
+  }
+  /**
+   * Advance one frame manually.
+   *
+   * The escape hatch that makes the whole engine testable: a test can drive 100 deterministic
+   * frames without waiting on a real display, and a screenshot harness can seek to an exact
+   * frame index.
+   */
+  step(deltaMs = 1e3 / 60) {
+    const timestamp = this.state.timestamp + deltaMs;
+    if (!this.clock.isRunning) this.clock.start(timestamp - deltaMs);
+    this.runFrame(timestamp);
+    return this.state;
+  }
+  /** Release everything. The ticker cannot be restarted afterwards. */
+  dispose() {
+    this.stop();
+    this.disposed = true;
+    for (const list of this.phases.values()) list.length = 0;
+    this.onceQueue.length = 0;
+    this.listeners.clear();
+  }
+  // -------------------------------------------------------------------------
+  // Budget
+  // -------------------------------------------------------------------------
+  get quality() {
+    return this.budget.quality;
+  }
+  budgetReport() {
+    return this.budget.report();
+  }
+  /** Disable adaptation and pin quality. Backs the `performance="high" | "low"` prop. */
+  lockQuality(value) {
+    this.budget.lockQuality(value);
+  }
+  /** Subscribe to per-frame budget reports — powers the dev-mode FPS overlay. */
+  onBudget(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  // -------------------------------------------------------------------------
+  // The loop
+  // -------------------------------------------------------------------------
+  loop = (timestamp) => {
+    this.handle = null;
+    this.runFrame(timestamp);
+    if (!this.paused && !this.disposed && (this.subscriberCount > 0 || this.onceQueue.length > 0)) {
+      this.handle = this.schedule(this.loop);
+    }
+  };
+  runFrame(timestamp) {
+    const timing = this.clock.tick(timestamp);
+    const state = this.state;
+    state.time = timing.time;
+    state.delta = timing.delta;
+    state.rawDelta = timing.rawDelta;
+    state.frame = timing.frame;
+    state.timestamp = timing.timestamp;
+    state.quality = this.budget.quality;
+    state.fps = this.budget.report().fps;
+    const startedAt = this.readTime();
+    if (this.dirtyPhases.size > 0) this.sortDirtyPhases();
+    for (const phase of FRAME_PHASES) {
+      const list = this.phases.get(phase);
+      if (!list || list.length === 0) continue;
+      const snapshot = list.length === 1 ? list : list.slice();
+      for (let i = 0; i < snapshot.length; i++) {
+        this.invoke(snapshot[i], state, list);
+      }
+    }
+    if (this.onceQueue.length > 0) {
+      const queue = this.onceQueue;
+      this.onceQueue = [];
+      for (let i = 0; i < queue.length; i++) {
+        try {
+          queue[i](state);
+        } catch (error) {
+          reportError(error, "once callback");
+        }
+      }
+    }
+    this.budget.record(this.readTime() - startedAt, timing.rawDelta);
+    if (this.listeners.size > 0) {
+      const report = this.budget.report();
+      for (const listener of this.listeners) listener(report);
+    }
+  }
+  /**
+   * Run one subscriber, containing its failures.
+   *
+   * A throwing callback must not stop every other animation on the page — that turns one
+   * component's bug into a whole-page visual failure. We log, and after several consecutive
+   * throws we evict the subscriber, because 60 identical stack traces per second is not
+   * diagnostics, it's a denial of service on the console.
+   */
+  invoke(subscriber, state, list) {
+    try {
+      subscriber.callback(state);
+      if (subscriber.errorCount > 0) subscriber.errorCount = 0;
+    } catch (error) {
+      subscriber.errorCount++;
+      reportError(error, subscriber.name);
+      if (subscriber.errorCount >= MAX_CONSECUTIVE_ERRORS) {
+        const index = list.indexOf(subscriber);
+        if (index >= 0) list.splice(index, 1);
+        console.error(
+          `[ansh] Removed frame callback "${subscriber.name}" after ${MAX_CONSECUTIVE_ERRORS} consecutive errors. Other animations continue unaffected.`
+        );
+      }
+    }
+  }
+  sortDirtyPhases() {
+    for (const phase of this.dirtyPhases) {
+      const list = this.phases.get(phase);
+      if (list) list.sort((a, b) => a.priority - b.priority || a.id - b.id);
+    }
+    this.dirtyPhases.clear();
+  }
+};
+function reportError(error, source) {
+  console.error(`[ansh] Error in frame callback "${source}":`, error);
+}
+function noop() {
+}
+function now() {
+  return typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+}
+var sharedTicker = null;
+function getTicker() {
+  if (sharedTicker === null) sharedTicker = new Ticker();
+  return sharedTicker;
+}
+function setTicker(ticker) {
+  if (sharedTicker && sharedTicker !== ticker) sharedTicker.dispose();
+  sharedTicker = ticker;
+}
+function resetTicker() {
+  if (sharedTicker) sharedTicker.dispose();
+  sharedTicker = null;
+}
+
+// src/a11y/reduced-motion.ts
+var QUERY = "(prefers-reduced-motion: reduce)";
+var override = "auto";
+var mediaQuery = null;
+var systemPreference = false;
+var initialised = false;
+var listeners = /* @__PURE__ */ new Set();
+function initialise() {
+  if (initialised || typeof window === "undefined" || !window.matchMedia) return;
+  initialised = true;
+  mediaQuery = window.matchMedia(QUERY);
+  systemPreference = mediaQuery.matches;
+  const handler = (event) => {
+    systemPreference = event.matches;
+    notify();
+  };
+  if (typeof mediaQuery.addEventListener === "function") {
+    mediaQuery.addEventListener("change", handler);
+  } else if (typeof mediaQuery.addListener === "function") {
+    mediaQuery.addListener(handler);
+  }
+}
+function notify() {
+  const value = prefersReducedMotion();
+  for (const listener of listeners) listener(value);
+}
+function prefersReducedMotion() {
+  if (override === "always") return true;
+  if (override === "never") return false;
+  initialise();
+  return systemPreference;
+}
+function setReducedMotionMode(mode) {
+  if (override === mode) return;
+  override = mode;
+  notify();
+}
+function getReducedMotionMode() {
+  return override;
+}
+function onReducedMotionChange(listener) {
+  initialise();
+  listeners.add(listener);
+  listener(prefersReducedMotion());
+  return () => listeners.delete(listener);
+}
+function resolveMotion(strategy = "static", slowFactor = 0.25) {
+  if (!prefersReducedMotion() || strategy === "none") {
+    return { animate: true, renderOnce: false, timeScale: 1 };
+  }
+  switch (strategy) {
+    case "static":
+      return { animate: false, renderOnce: true, timeScale: 0 };
+    case "pause":
+      return { animate: false, renderOnce: false, timeScale: 0 };
+    case "slow":
+      return { animate: true, renderOnce: false, timeScale: slowFactor };
+  }
+}
+function resetReducedMotion() {
+  override = "auto";
+  listeners.clear();
+}
+
+// src/observers/pool.ts
+var intersectionPools = /* @__PURE__ */ new Map();
+function intersectionKey(config) {
+  const threshold = config.threshold ?? 0;
+  const thresholds = Array.isArray(threshold) ? [...threshold].sort((a, b) => a - b) : [threshold];
+  const rootTag = config.root ? rootIdentity(config.root) : "viewport";
+  return `${rootTag}|${config.rootMargin ?? "0px"}|${thresholds.join(",")}`;
+}
+var rootTags = /* @__PURE__ */ new WeakMap();
+var rootCounter = 0;
+function rootIdentity(root) {
+  let tag = rootTags.get(root);
+  if (!tag) {
+    tag = `root${++rootCounter}`;
+    rootTags.set(root, tag);
+  }
+  return tag;
+}
+function observeIntersection(element, callback, config = {}) {
+  if (typeof IntersectionObserver === "undefined") return () => {
+  };
+  const key = intersectionKey(config);
+  let pool = intersectionPools.get(key);
+  if (!pool) {
+    const callbacks = /* @__PURE__ */ new WeakMap();
+    const observer = new IntersectionObserver(
+      (entries) => {
+        for (const entry of entries) {
+          const set2 = callbacks.get(entry.target);
+          if (!set2) continue;
+          for (const cb of [...set2]) cb(entry);
+        }
+      },
+      {
+        root: config.root ?? null,
+        rootMargin: config.rootMargin ?? "0px",
+        threshold: config.threshold ?? 0
+      }
+    );
+    pool = { observer, callbacks, count: 0 };
+    intersectionPools.set(key, pool);
+  }
+  let set = pool.callbacks.get(element);
+  if (!set) {
+    set = /* @__PURE__ */ new Set();
+    pool.callbacks.set(element, set);
+    pool.observer.observe(element);
+    pool.count++;
+  }
+  set.add(callback);
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    const current = intersectionPools.get(key);
+    if (!current) return;
+    const callbackSet = current.callbacks.get(element);
+    if (!callbackSet) return;
+    callbackSet.delete(callback);
+    if (callbackSet.size > 0) return;
+    current.callbacks.delete(element);
+    current.observer.unobserve(element);
+    current.count--;
+    if (current.count <= 0) {
+      current.observer.disconnect();
+      intersectionPools.delete(key);
+    }
+  };
+}
+var resizePools = /* @__PURE__ */ new Map();
+function observeResize(element, callback, box = "content-box") {
+  if (typeof ResizeObserver === "undefined") return () => {
+  };
+  let pool = resizePools.get(box);
+  if (!pool) {
+    const callbacks = /* @__PURE__ */ new WeakMap();
+    const observer = new ResizeObserver((entries) => {
+      for (const entry of entries) {
+        const set2 = callbacks.get(entry.target);
+        if (!set2) continue;
+        const info = describeResize(entry);
+        for (const cb of [...set2]) cb(info);
+      }
+    });
+    pool = { observer, callbacks, count: 0 };
+    resizePools.set(box, pool);
+  }
+  let set = pool.callbacks.get(element);
+  if (!set) {
+    set = /* @__PURE__ */ new Set();
+    pool.callbacks.set(element, set);
+    try {
+      pool.observer.observe(element, { box });
+    } catch {
+      pool.observer.observe(element);
+    }
+    pool.count++;
+  }
+  set.add(callback);
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    const current = resizePools.get(box);
+    if (!current) return;
+    const callbackSet = current.callbacks.get(element);
+    if (!callbackSet) return;
+    callbackSet.delete(callback);
+    if (callbackSet.size > 0) return;
+    current.callbacks.delete(element);
+    current.observer.unobserve(element);
+    current.count--;
+    if (current.count <= 0) {
+      current.observer.disconnect();
+      resizePools.delete(box);
+    }
+  };
+}
+function describeResize(entry) {
+  const dpr = typeof devicePixelRatio === "number" ? devicePixelRatio : 1;
+  const contentBox = entry.contentBoxSize?.[0];
+  const width = contentBox?.inlineSize ?? entry.contentRect.width;
+  const height = contentBox?.blockSize ?? entry.contentRect.height;
+  const devicePixelBox = entry.devicePixelContentBoxSize?.[0];
+  return {
+    width,
+    height,
+    devicePixelWidth: devicePixelBox?.inlineSize ?? Math.round(width * dpr),
+    devicePixelHeight: devicePixelBox?.blockSize ?? Math.round(height * dpr),
+    entry
+  };
+}
+function observerPoolStats() {
+  return { intersection: intersectionPools.size, resize: resizePools.size };
+}
+function resetObserverPools() {
+  for (const pool of intersectionPools.values()) pool.observer.disconnect();
+  for (const pool of resizePools.values()) pool.observer.disconnect();
+  intersectionPools.clear();
+  resizePools.clear();
+}
+
+// src/observers/pointer.ts
+function trackPointer(element, options = {}) {
+  const smoothing = options.smoothing ?? 5e-3;
+  const trackOutside = options.trackOutside ?? false;
+  const originX = options.origin?.x ?? 0.5;
+  const originY = options.origin?.y ?? 0.5;
+  let rect = { left: 0, top: 0, width: 1, height: 1 };
+  const state = {
+    x: 0,
+    y: 0,
+    nx: originX,
+    ny: originY,
+    smoothX: 0,
+    smoothY: 0,
+    smoothNx: originX,
+    smoothNy: originY,
+    velocityX: 0,
+    velocityY: 0,
+    inside: false,
+    down: false,
+    pressure: 0.5,
+    type: "none",
+    everInside: false
+  };
+  let lastX = 0;
+  let lastY = 0;
+  let hasLast = false;
+  let targetX = 0;
+  let targetY = 0;
+  const refresh = () => {
+    const box = element.getBoundingClientRect();
+    rect = {
+      left: box.left,
+      top: box.top,
+      width: Math.max(1, box.width),
+      height: Math.max(1, box.height)
+    };
+    if (!state.everInside) {
+      targetX = rect.width * originX;
+      targetY = rect.height * originY;
+      state.smoothX = targetX;
+      state.smoothY = targetY;
+      state.x = targetX;
+      state.y = targetY;
+    }
+  };
+  refresh();
+  const onPointerMove = (event) => {
+    const x = event.clientX - rect.left;
+    const y = event.clientY - rect.top;
+    const inside = x >= 0 && x <= rect.width && y >= 0 && y <= rect.height;
+    if (!inside && !trackOutside && !state.down) {
+      state.inside = false;
+      return;
+    }
+    state.x = x;
+    state.y = y;
+    state.nx = clamp(x / rect.width, 0, 1);
+    state.ny = clamp(y / rect.height, 0, 1);
+    state.inside = inside;
+    state.pressure = event.pressure > 0 ? event.pressure : 0.5;
+    state.type = event.pointerType || "mouse";
+    if (inside) state.everInside = true;
+    targetX = x;
+    targetY = y;
+    if (hasLast) {
+      const dt = Math.max(1 / 1e3, (event.timeStamp - lastTimeStamp) / 1e3);
+      state.velocityX = (x - lastX) / dt;
+      state.velocityY = (y - lastY) / dt;
+    }
+    lastX = x;
+    lastY = y;
+    lastTimeStamp = event.timeStamp;
+    hasLast = true;
+  };
+  let lastTimeStamp = 0;
+  const onPointerEnter = (event) => {
+    state.inside = true;
+    state.everInside = true;
+    state.type = event.pointerType || "mouse";
+    hasLast = false;
+  };
+  const onPointerLeave = () => {
+    state.inside = false;
+    state.down = false;
+    state.velocityX = 0;
+    state.velocityY = 0;
+    hasLast = false;
+    targetX = rect.width * originX;
+    targetY = rect.height * originY;
+  };
+  const onPointerDown = (event) => {
+    state.down = true;
+    state.pressure = event.pressure > 0 ? event.pressure : 0.5;
+    onPointerMove(event);
+  };
+  const onPointerUp = (event) => {
+    state.down = false;
+    state.pressure = 0;
+    if (event.pointerType === "touch") onPointerLeave();
+  };
+  const passive = { passive: true };
+  element.addEventListener("pointerenter", onPointerEnter, passive);
+  element.addEventListener("pointerleave", onPointerLeave, passive);
+  element.addEventListener("pointerdown", onPointerDown, passive);
+  element.addEventListener("pointercancel", onPointerLeave, passive);
+  const moveTarget = trackOutside ? window : element;
+  moveTarget.addEventListener("pointermove", onPointerMove, passive);
+  window.addEventListener("pointerup", onPointerUp, passive);
+  const onScroll = () => refresh();
+  window.addEventListener("scroll", onScroll, { passive: true, capture: true });
+  window.addEventListener("resize", onScroll, passive);
+  const ticker = getTicker();
+  const stopRead = ticker.add(
+    () => {
+      const box = element.getBoundingClientRect();
+      if (box.left !== rect.left || box.top !== rect.top || box.width !== rect.width) {
+        rect = {
+          left: box.left,
+          top: box.top,
+          width: Math.max(1, box.width),
+          height: Math.max(1, box.height)
+        };
+      }
+    },
+    { phase: "read", name: "pointer:rect" }
+  );
+  const stopCompute = ticker.add(
+    ({ delta }) => {
+      state.smoothX = damp(state.smoothX, targetX, smoothing, delta);
+      state.smoothY = damp(state.smoothY, targetY, smoothing, delta);
+      state.smoothNx = clamp(state.smoothX / rect.width, 0, 1);
+      state.smoothNy = clamp(state.smoothY / rect.height, 0, 1);
+    },
+    { phase: "compute", name: "pointer:smooth" }
+  );
+  return {
+    state,
+    refresh,
+    destroy() {
+      element.removeEventListener("pointerenter", onPointerEnter);
+      element.removeEventListener("pointerleave", onPointerLeave);
+      element.removeEventListener("pointerdown", onPointerDown);
+      element.removeEventListener("pointercancel", onPointerLeave);
+      moveTarget.removeEventListener("pointermove", onPointerMove);
+      window.removeEventListener("pointerup", onPointerUp);
+      window.removeEventListener("scroll", onScroll, { capture: true });
+      window.removeEventListener("resize", onScroll);
+      stopRead();
+      stopCompute();
+    }
+  };
+}
+
+// src/plugins/registry.ts
+var CapabilityError = class extends Error {
+  constructor(capability, hint) {
+    super(
+      `[ansh] Missing capability "${capability}".` + (hint ? ` ${hint}` : "") + ` See https://ansh.dev/docs/capabilities for the full list.`
+    );
+    this.capability = capability;
+    this.name = "CapabilityError";
+  }
+  capability;
+};
+var Registry = class {
+  entries = /* @__PURE__ */ new Map();
+  plugins = /* @__PURE__ */ new Map();
+  capabilities = /* @__PURE__ */ new Set();
+  /** Human-readable reason a gated capability is unavailable, keyed by capability. */
+  gateHints = /* @__PURE__ */ new Map();
+  // -------------------------------------------------------------------------
+  // Namespaced value storage
+  // -------------------------------------------------------------------------
+  /**
+   * Store a value under `namespace:key`.
+   *
+   * Namespacing keeps effects, behaviours, renderers and easings from colliding, and lets
+   * `list('effect')` enumerate one kind without filtering.
+   */
+  register(namespace, key, value) {
+    let bucket = this.entries.get(namespace);
+    if (!bucket) {
+      bucket = /* @__PURE__ */ new Map();
+      this.entries.set(namespace, bucket);
+    }
+    if (bucket.has(key)) {
+      throw new Error(
+        `[ansh] "${key}" is already registered under "${namespace}". Call unregister("${namespace}", "${key}") first if replacement is intended.`
+      );
+    }
+    bucket.set(key, value);
+  }
+  get(namespace, key) {
+    return this.entries.get(namespace)?.get(key);
+  }
+  /** Like {@link get} but throws a helpful error rather than returning `undefined`. */
+  require(namespace, key) {
+    const value = this.get(namespace, key);
+    if (value === void 0) {
+      const available = this.list(namespace);
+      throw new Error(
+        `[ansh] No "${key}" registered under "${namespace}".` + (available.length > 0 ? ` Available: ${available.join(", ")}.` : "")
+      );
+    }
+    return value;
+  }
+  has(namespace, key) {
+    return this.entries.get(namespace)?.has(key) ?? false;
+  }
+  unregister(namespace, key) {
+    return this.entries.get(namespace)?.delete(key) ?? false;
+  }
+  list(namespace) {
+    return [...this.entries.get(namespace)?.keys() ?? []].sort();
+  }
+  entriesOf(namespace) {
+    return [...this.entries.get(namespace)?.entries() ?? []];
+  }
+  // -------------------------------------------------------------------------
+  // Capabilities
+  // -------------------------------------------------------------------------
+  provide(capability) {
+    this.capabilities.add(capability);
+    this.gateHints.delete(capability);
+  }
+  revoke(capability, hint) {
+    this.capabilities.delete(capability);
+    if (hint) this.gateHints.set(capability, hint);
+  }
+  supports(capability) {
+    return this.capabilities.has(capability);
+  }
+  /**
+   * Assert a capability is available.
+   *
+   * This is the edition gate. A Pro effect calls
+   * `registry.requireCapability('effect:pro')` in its setup, and in the Free edition that
+   * throws with a message explaining what to do — at mount time, with a stack trace pointing
+   * at the component, rather than as a mysteriously blank canvas.
+   */
+  requireCapability(capability) {
+    if (!this.capabilities.has(capability)) {
+      throw new CapabilityError(capability, this.gateHints.get(capability));
+    }
+  }
+  listCapabilities() {
+    return [...this.capabilities].sort();
+  }
+  // -------------------------------------------------------------------------
+  // Plugins
+  // -------------------------------------------------------------------------
+  use(plugin) {
+    if (this.plugins.has(plugin.name)) return this;
+    for (const required of plugin.requires ?? []) {
+      if (!this.capabilities.has(required)) {
+        throw new CapabilityError(
+          required,
+          `Plugin "${plugin.name}" requires it. Install the providing plugin first.`
+        );
+      }
+    }
+    plugin.install?.(this);
+    for (const capability of plugin.provides ?? []) this.provide(capability);
+    this.plugins.set(plugin.name, plugin);
+    return this;
+  }
+  remove(name) {
+    const plugin = this.plugins.get(name);
+    if (!plugin) return false;
+    plugin.uninstall?.(this);
+    for (const capability of plugin.provides ?? []) this.capabilities.delete(capability);
+    this.plugins.delete(name);
+    return true;
+  }
+  listPlugins() {
+    return [...this.plugins.values()].map((p) => ({ name: p.name, version: p.version ?? "0.0.0" }));
+  }
+  /** Wipe everything. Used between tests. */
+  clear() {
+    for (const name of [...this.plugins.keys()]) this.remove(name);
+    this.entries.clear();
+    this.capabilities.clear();
+    this.gateHints.clear();
+  }
+};
+var shared = null;
+function getRegistry() {
+  if (shared === null) {
+    shared = new Registry();
+    shared.provide("renderer:canvas2d");
+    shared.provide("effect:core");
+    shared.provide("behaviour:core");
+  }
+  return shared;
+}
+function resetRegistry() {
+  shared?.clear();
+  shared = null;
+}
+
+export { CapabilityError, Clock, FRAME_PHASES, FrameBudget, Registry, Ticker, getReducedMotionMode, getRegistry, getTicker, now, observeIntersection, observeResize, observerPoolStats, onReducedMotionChange, prefersReducedMotion, resetObserverPools, resetReducedMotion, resetRegistry, resetTicker, resolveMotion, setReducedMotionMode, setTicker, trackPointer };
+//# sourceMappingURL=chunk-BOQQHICI.js.map
+//# sourceMappingURL=chunk-BOQQHICI.js.map