@surdeddd/bottom-sheet 0.1.0

package/dist/qwik.cjs

@@ -0,0 +1,3046 @@
+'use strict';
+
+var qwik = require('@builder.io/qwik');
+var jsxRuntime = require('@builder.io/qwik/jsx-runtime');
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/core/lifecycle/sheetStack.ts
+var BASE_Z = 100;
+var STEP = 10;
+var SheetStack = class {
+  constructor() {
+    __publicField(this, "entries", []);
+  }
+  push(entry) {
+    this.entries.push(entry);
+    this.recompute();
+    return () => this.remove(entry.id);
+  }
+  remove(id) {
+    const idx = this.entries.findIndex((e) => e.id === id);
+    if (idx === -1) return;
+    this.entries.splice(idx, 1);
+    this.recompute();
+  }
+  size() {
+    return this.entries.length;
+  }
+  clear() {
+    this.entries = [];
+  }
+  recompute() {
+    this.entries.forEach((entry, i) => {
+      entry.setZIndex(BASE_Z + i * STEP);
+      entry.setIsTop(i === this.entries.length - 1);
+    });
+  }
+};
+var sheetStack = new SheetStack();
+
+// src/core/primitives/transform.ts
+function buildTransformTemplate(axis) {
+  switch (axis) {
+    case "bottom":
+      return (offset) => `translate3d(0, ${offset}px, 0)`;
+    case "top":
+      return (offset) => `translate3d(0, ${-offset}px, 0)`;
+    case "left":
+      return (offset) => `translate3d(${-offset}px, 0, 0)`;
+    case "right":
+      return (offset) => `translate3d(${offset}px, 0, 0)`;
+  }
+}
+var layoutAxis = (axis) => axis === "left" || axis === "right" ? "width" : "height";
+
+// src/core/primitives/instance-id.ts
+var counters = {};
+function nextInstanceId(prefix) {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return `${prefix}-${crypto.randomUUID()}`;
+  }
+  counters[prefix] = (counters[prefix] ?? 0) + 1;
+  return `${prefix}-${counters[prefix]}`;
+}
+
+// src/core/primitives/event-bus.ts
+function createEventBus() {
+  const listeners = /* @__PURE__ */ new Map();
+  return {
+    on(event, fn) {
+      let set = listeners.get(event);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        listeners.set(event, set);
+      }
+      set.add(fn);
+      return () => {
+        set.delete(fn);
+      };
+    },
+    emit(event, payload) {
+      const set = listeners.get(event);
+      if (!set) return;
+      for (const fn of [...set]) {
+        fn(payload);
+      }
+    },
+    listenerCount(event) {
+      return listeners.get(event)?.size ?? 0;
+    },
+    clear() {
+      listeners.clear();
+    }
+  };
+}
+
+// src/core/primitives/cssLength.ts
+var probe = null;
+var PROBE_ATTR = "data-bs-probe";
+var ensureProbe = (axis) => {
+  if (typeof document === "undefined") return null;
+  if (!probe || !probe.isConnected) {
+    const existing = document.querySelector(`[${PROBE_ATTR}]`);
+    if (existing) {
+      probe = existing;
+    } else {
+      probe = document.createElement("div");
+      probe.setAttribute("aria-hidden", "true");
+      probe.setAttribute(PROBE_ATTR, "");
+      probe.style.cssText = "position:absolute;visibility:hidden;pointer-events:none;contain:strict;left:0;top:0;width:0;height:0;";
+      document.body.appendChild(probe);
+    }
+  }
+  if (axis === "vertical") {
+    probe.style.width = "0";
+    probe.style.height = "";
+  } else {
+    probe.style.height = "0";
+    probe.style.width = "";
+  }
+  return probe;
+};
+var isViewportAxisVertical = (mode) => mode === "bottom" || mode === "top";
+var viewportSize = (mode) => {
+  if (typeof window === "undefined") return 0;
+  return isViewportAxisVertical(mode) ? window.innerHeight : window.innerWidth;
+};
+var PERCENT = /^(-?\d+(?:\.\d+)?)%$/;
+var resolveSnap = (point, mode, measureFit) => {
+  if (typeof point === "number") return Math.max(0, point);
+  if (point === "full") return viewportSize(mode);
+  if (point === "fit") return Math.max(0, measureFit?.() ?? 0);
+  const pctMatch = point.match(PERCENT);
+  if (pctMatch) {
+    const pct = parseFloat(pctMatch[1]) / 100;
+    return Math.max(0, viewportSize(mode) * pct);
+  }
+  const axis = isViewportAxisVertical(mode) ? "vertical" : "horizontal";
+  const el = ensureProbe(axis);
+  if (!el) return 0;
+  if (axis === "vertical") {
+    el.style.height = point;
+    return Math.max(0, el.getBoundingClientRect().height);
+  }
+  el.style.width = point;
+  return Math.max(0, el.getBoundingClientRect().width);
+};
+
+// src/core/primitives/snap-points.ts
+var resolveSnapList = (points, mode, measureFit) => points.map((p) => {
+  const raw = resolveSnap(p.size, mode, measureFit);
+  if (!Number.isFinite(raw) || raw < 0) {
+    console.warn(
+      `[BottomSheet] snap "${p.id}" resolved to invalid size (${String(p.size)} \u2192 ${raw}); clamped to 0.`
+    );
+    return { id: p.id, size: 0 };
+  }
+  return { id: p.id, size: raw };
+}).sort((a, b) => a.size - b.size);
+var VH_NOT_DVH = /(^|[^a-z])vh\b/i;
+var auditVhUsage = (points) => {
+  for (const p of points) {
+    if (typeof p.size !== "string") continue;
+    if (!VH_NOT_DVH.test(p.size)) continue;
+    console.warn(
+      `[BottomSheet] snap "${p.id}" uses "vh" \u2014 prefer "dvh" on mobile (iOS Safari URL bar makes vh unstable). See https://web.dev/blog/viewport-units`
+    );
+  }
+};
+var findNearest = (size, resolved, allowed, direction = 0, bias = 0) => {
+  const pool = resolved.filter((p) => allowed.includes(p.id));
+  if (pool.length === 0) return null;
+  const target = size + direction * bias;
+  let best = pool[0];
+  let bestDist = Math.abs(target - best.size);
+  for (let i = 1; i < pool.length; i++) {
+    const cand = pool[i];
+    const dist = Math.abs(target - cand.size);
+    if (dist < bestDist) {
+      best = cand;
+      bestDist = dist;
+    }
+  }
+  return best;
+};
+var allowedRange = (resolved, allowed) => {
+  const pool = resolved.filter((p) => allowed.includes(p.id));
+  if (pool.length === 0) return { min: 0, max: 0 };
+  return {
+    min: pool[0].size,
+    max: pool[pool.length - 1].size
+  };
+};
+var findById = (id, resolved) => resolved.find((p) => p.id === id) ?? null;
+var MOUSE_FLICK_VELOCITY = 0.4;
+var MOUSE_DRAG_THRESHOLD = 12;
+var DIRECTIONAL_INTENT_VELOCITY = 0.15;
+var findDragSettleTarget = (input) => {
+  const speed = Math.abs(input.velocity);
+  const flickThreshold = input.pointerKind === "mouse" ? MOUSE_FLICK_VELOCITY : input.flickVelocity;
+  const dragThresh = input.pointerKind === "mouse" ? MOUSE_DRAG_THRESHOLD : input.dragThreshold;
+  let direction = 0;
+  if (speed > flickThreshold || speed > DIRECTIONAL_INTENT_VELOCITY) {
+    direction = input.velocity > 0 ? 1 : -1;
+  }
+  if (Math.abs(input.delta) < dragThresh && direction === 0) {
+    return findById(input.activeId, input.resolved);
+  }
+  const speedBias = speed > flickThreshold ? Math.min(speed * 180, input.maxAxisSize) : 0;
+  return findNearest(
+    input.size,
+    input.resolved,
+    input.allowed,
+    direction,
+    speedBias
+  );
+};
+
+// src/core/primitives/snap-resolver.ts
+var SnapResolver = class {
+  constructor(raw, allowed, mode, measureFit, onMaxAxisSizeChange) {
+    __publicField(this, "mode", mode);
+    __publicField(this, "measureFit", measureFit);
+    __publicField(this, "onMaxAxisSizeChange", onMaxAxisSizeChange);
+    __publicField(this, "raw");
+    __publicField(this, "allowedIds");
+    __publicField(this, "resolved", []);
+    __publicField(this, "maxAxisSize", 0);
+    __publicField(this, "rangeCache", null);
+    this.raw = raw;
+    this.allowedIds = allowed ?? raw.map((p) => p.id);
+    this.recompute();
+  }
+  /**
+   * Re-resolve raw → resolved against the current viewport / fit-measure,
+   * recompute maxAxisSize, invalidate range cache, notify engine. Called on
+   * resize, orientationchange, visualViewport changes, and snap-list swaps.
+   */
+  recompute() {
+    this.resolved = resolveSnapList(this.raw, this.mode, this.measureFit);
+    this.maxAxisSize = this.resolved.reduce(
+      (m, s) => s.size > m ? s.size : m,
+      0
+    );
+    this.rangeCache = null;
+    this.onMaxAxisSizeChange?.(this.maxAxisSize);
+  }
+  /** Replace the raw snap list and recompute. Engine calls on `setSnapPoints`. */
+  setRaw(raw) {
+    this.raw = raw;
+    this.recompute();
+  }
+  /**
+   * Replace the allow-list. Range cache depends on `(resolvedSnaps ×
+   * allowedIds)` so flipping ids alone invalidates without a full recompute.
+   */
+  setAllowedIds(ids) {
+    this.allowedIds = ids;
+    this.rangeCache = null;
+  }
+  findById(id) {
+    return findById(id, this.resolved);
+  }
+  /**
+   * Pure drag-settle target resolution. Engine passes the gesture-specific
+   * fields (delta, velocity, pointerKind, flickVelocity, dragThreshold) plus
+   * `size`/`activeId` since those are still engine-owned.
+   */
+  findDragSettleTarget(args) {
+    return findDragSettleTarget({
+      ...args,
+      resolved: this.resolved,
+      allowed: this.allowedIds,
+      maxAxisSize: this.maxAxisSize
+    });
+  }
+  /**
+   * Memoised allowed-range query. Twice-per-drag-frame (gesture onMove +
+   * applySize→computeProgress); cache collapses 2× iteration of resolvedSnaps
+   * to one recompute per geometry/allow-list change.
+   */
+  getAllowedRange() {
+    return this.rangeCache ?? (this.rangeCache = allowedRange(this.resolved, this.allowedIds));
+  }
+  /**
+   * Read-only view of resolved snaps. Returned as `readonly` to discourage
+   * accidental mutation by feature install sites that close over this list.
+   */
+  getResolvedSnaps() {
+    return this.resolved;
+  }
+  getAllowedIds() {
+    return this.allowedIds;
+  }
+  getMaxAxisSize() {
+    return this.maxAxisSize;
+  }
+  /**
+   * External clamp override. The resize-observer feature compares
+   * `getMaxAxisSize()` against the live viewport and shrinks if the largest
+   * resolved snap exceeds it (mobile address-bar collapse / soft-keyboard
+   * window resize). The next `recompute()` overwrites this clamp from the
+   * resolved-snap reduction.
+   *
+   * Does NOT invalidate the range cache — viewport clamping doesn't change
+   * `(resolvedSnaps × allowedIds) → range`. DOES fire `onMaxAxisSizeChange`
+   * so the resolver owns the layout-axis style write end-to-end (symmetric
+   * with `recompute()` — feature call sites no longer duplicate the write).
+   */
+  setMaxAxisSize(n) {
+    this.maxAxisSize = n;
+    this.onMaxAxisSizeChange?.(n);
+  }
+};
+
+// src/core/features/persist.ts
+function readPersistedId(key) {
+  if (!key) return null;
+  if (typeof window === "undefined") return null;
+  if (typeof localStorage === "undefined") return null;
+  try {
+    return localStorage.getItem(key);
+  } catch {
+    return null;
+  }
+}
+function installPersist(engine, key) {
+  const unsubscribe = engine.on("snap", ({ id }) => {
+    if (typeof window === "undefined") return;
+    if (typeof localStorage === "undefined") return;
+    try {
+      localStorage.setItem(key, id);
+    } catch {
+    }
+  });
+  return unsubscribe;
+}
+
+// src/core/features/auto-collapse.ts
+function installAutoCollapse(deps) {
+  const { ms } = deps;
+  if (ms === void 0 || ms <= 0) {
+    return () => {
+    };
+  }
+  let timer = null;
+  const clearTimer = () => {
+    if (timer !== null) {
+      clearTimeout(timer);
+      timer = null;
+    }
+  };
+  const fire = () => {
+    if (deps.isDestroyed()) return;
+    if (deps.isDragging()) return;
+    const allowed = deps.getAllowedIds();
+    const target = allowed.find((id) => {
+      const snap = deps.resolveSnap(id);
+      return snap !== null && snap.size > 0;
+    });
+    if (!target) return;
+    if (target === deps.getActiveId()) return;
+    deps.snapTo(target);
+  };
+  const reset = () => {
+    clearTimer();
+    if (deps.isDestroyed()) return;
+    timer = setTimeout(() => {
+      timer = null;
+      fire();
+    }, ms);
+  };
+  const unsubscribe = deps.on("snap", () => reset());
+  return () => {
+    clearTimer();
+    unsubscribe();
+  };
+}
+
+// src/core/features/linked-sheets.ts
+function notifyLinkedSheets(sheets, self) {
+  if (sheets.length === 0) return;
+  for (const linked of sheets) {
+    if (linked === self) continue;
+    try {
+      const ids = linked.getAllowedIds();
+      const target = ids.find((id) => id !== "closed");
+      if (target && target !== linked.state.activeId) {
+        void linked.snapTo(target);
+      }
+    } catch (err) {
+      queueMicrotask(() => {
+        throw err;
+      });
+    }
+  }
+}
+
+// src/core/features/route.ts
+function installRoute(deps) {
+  if (typeof window === "undefined") {
+    return () => {
+    };
+  }
+  if (!deps.routedTo && !deps.closeOnBack) {
+    return () => {
+    };
+  }
+  let routePushed = false;
+  let closeOnBackPushed = false;
+  let detachPopstate = null;
+  const popOurMarker = (key, expected) => {
+    const state = history.state;
+    if (state && state[key] === expected) {
+      try {
+        history.back();
+      } catch {
+      }
+    }
+  };
+  const onOpen = () => {
+    if (deps.routedTo && !detachPopstate) {
+      const target = deps.routedTo;
+      try {
+        history.pushState({ __bsRouted: target }, "", target);
+        routePushed = true;
+      } catch {
+      }
+      const onPop = (event) => {
+        if (deps.isDestroyed()) return;
+        const state = event.state;
+        if (state && state.__bsRouted === target && deps.getSize() > 0) {
+          routePushed = false;
+          void deps.close();
+        }
+      };
+      window.addEventListener("popstate", onPop);
+      detachPopstate = () => window.removeEventListener("popstate", onPop);
+    } else if (deps.closeOnBack && !detachPopstate) {
+      try {
+        history.pushState({ __bsSheet: deps.sheetId }, "");
+        closeOnBackPushed = true;
+      } catch {
+      }
+      const onPop = () => {
+        if (deps.isDestroyed()) return;
+        if (deps.getSize() > 0 && deps.isTopSheet()) {
+          const state = history.state;
+          if (state?.__bsSheet !== deps.sheetId) closeOnBackPushed = false;
+          void deps.close();
+        }
+      };
+      window.addEventListener("popstate", onPop);
+      detachPopstate = () => window.removeEventListener("popstate", onPop);
+    }
+  };
+  const onClose = () => {
+    detachPopstate?.();
+    detachPopstate = null;
+    if (routePushed) {
+      routePushed = false;
+      if (deps.routedTo !== void 0) popOurMarker("__bsRouted", deps.routedTo);
+    }
+    if (closeOnBackPushed) {
+      closeOnBackPushed = false;
+      popOurMarker("__bsSheet", deps.sheetId);
+    }
+  };
+  const unsubscribeOpen = deps.on("open", onOpen);
+  const unsubscribeClose = deps.on("close", onClose);
+  if (deps.getSize() > 0) onOpen();
+  return () => {
+    unsubscribeOpen();
+    unsubscribeClose();
+    detachPopstate?.();
+    detachPopstate = null;
+    if (routePushed) {
+      routePushed = false;
+      if (deps.routedTo !== void 0) popOurMarker("__bsRouted", deps.routedTo);
+    }
+    if (closeOnBackPushed) {
+      closeOnBackPushed = false;
+      popOurMarker("__bsSheet", deps.sheetId);
+    }
+  };
+}
+
+// src/core/features/content-swipe.ts
+var CONTENT_PULL_THRESHOLD = 60;
+function installContentSwipe(deps) {
+  const { container } = deps;
+  let startY = 0;
+  let moved = false;
+  const onTouchStart = (e) => {
+    const t = e.touches[0];
+    if (!t) return;
+    startY = t.clientY;
+    moved = false;
+  };
+  const onTouchMove = (e) => {
+    const t = e.touches[0];
+    if (!t) return;
+    if (Math.abs(t.clientY - startY) > CONTENT_PULL_THRESHOLD) moved = true;
+  };
+  const onTouchEnd = (e) => {
+    if (!moved) return;
+    if (deps.isDragging() || deps.isAnimating()) return;
+    const t = e.changedTouches[0];
+    if (!t) return;
+    const deltaY = t.clientY - startY;
+    const atTop = container.scrollTop <= 0;
+    const allowed = deps.getAllowedIds();
+    const idx = allowed.indexOf(deps.getActiveId());
+    if (idx === -1) return;
+    if (atTop && deltaY > CONTENT_PULL_THRESHOLD && idx > 0) {
+      deps.snapTo(allowed[idx - 1]);
+    } else if (deltaY < -CONTENT_PULL_THRESHOLD && idx < allowed.length - 1) {
+      deps.snapTo(allowed[idx + 1]);
+    }
+  };
+  container.addEventListener("touchstart", onTouchStart, { passive: true });
+  container.addEventListener("touchmove", onTouchMove, { passive: true });
+  container.addEventListener("touchend", onTouchEnd, { passive: true });
+  return () => {
+    container.removeEventListener("touchstart", onTouchStart);
+    container.removeEventListener("touchmove", onTouchMove);
+    container.removeEventListener("touchend", onTouchEnd);
+  };
+}
+
+// src/core/features/visual-viewport.ts
+var SAFETY_PAD = 8;
+function installVisualViewport(deps) {
+  if (typeof window === "undefined" || !window.visualViewport) {
+    return () => {
+    };
+  }
+  const vv = window.visualViewport;
+  let rafId = null;
+  const onResize = () => {
+    if (rafId !== null) return;
+    rafId = requestAnimationFrame(() => {
+      rafId = null;
+      if (deps.isDestroyed()) return;
+      deps.recomputeSnaps();
+      const isVertical = deps.isVerticalAxis();
+      const visible = isVertical ? vv.height : vv.width;
+      const windowSize = isVertical ? window.innerHeight : window.innerWidth;
+      const clamp = Math.max(0, Math.min(windowSize, visible) - SAFETY_PAD);
+      if (clamp < deps.getMaxAxisSize()) {
+        deps.setMaxAxisSize(clamp);
+      }
+      const max = deps.getMaxAxisSize();
+      deps.setSize(Math.min(deps.getSize(), max));
+      const current = deps.resolveActiveSnap();
+      if (current && !deps.isDragging()) {
+        deps.applySize(Math.min(current.size, max));
+      } else {
+        deps.applySize(deps.getSize());
+      }
+    });
+  };
+  vv.addEventListener("resize", onResize);
+  return () => {
+    vv.removeEventListener("resize", onResize);
+    if (rafId !== null) cancelAnimationFrame(rafId);
+  };
+}
+
+// src/core/features/resize-observer.ts
+function installResizeObserver(deps) {
+  if (typeof window === "undefined") {
+    return () => {
+    };
+  }
+  const onResize = () => {
+    if (deps.isDestroyed()) return;
+    deps.recomputeSnaps();
+    const mode = deps.getMode();
+    const isVerticalAxis = mode === "bottom" || mode === "top";
+    const viewportSize2 = isVerticalAxis ? window.innerHeight : window.innerWidth;
+    const max = deps.getMaxAxisSize();
+    if (viewportSize2 > 0 && viewportSize2 < max) {
+      deps.setMaxAxisSize(viewportSize2);
+    }
+    deps.cancelInFlight();
+    deps.newCycle();
+    const current = deps.resolveActiveSnap();
+    const newMax = deps.getMaxAxisSize();
+    const targetSize = current ? Math.min(current.size, newMax) : Math.min(deps.getSize(), newMax);
+    deps.setSize(targetSize);
+    if (current && !deps.isDragging()) deps.applySize(targetSize);
+  };
+  let resizeObserver = null;
+  if (typeof ResizeObserver !== "undefined") {
+    resizeObserver = new ResizeObserver(onResize);
+    resizeObserver.observe(document.documentElement);
+  } else {
+    window.addEventListener("resize", onResize);
+  }
+  window.addEventListener("orientationchange", onResize);
+  const onVisibility = () => {
+    if (deps.isDestroyed()) return;
+    if (document.hidden) deps.cancelInFlight();
+  };
+  document.addEventListener("visibilitychange", onVisibility);
+  return () => {
+    resizeObserver?.disconnect();
+    window.removeEventListener("resize", onResize);
+    window.removeEventListener("orientationchange", onResize);
+    document.removeEventListener("visibilitychange", onVisibility);
+  };
+}
+
+// src/core/features/slider-keyboard.ts
+function installSliderKeyboard(deps) {
+  const isVerticalAxis = deps.mode === "bottom" || deps.mode === "top";
+  const stepUp = isVerticalAxis ? "ArrowUp" : "ArrowRight";
+  const stepDown = isVerticalAxis ? "ArrowDown" : "ArrowLeft";
+  const sheetExpandsKey = deps.mode === "top" ? stepDown : stepUp;
+  const sheetCollapsesKey = deps.mode === "top" ? stepUp : stepDown;
+  const onHandleKey = (e) => {
+    if (deps.isDestroyed()) return;
+    const allowed = deps.getAllowedIds();
+    const idx = allowed.indexOf(deps.getActiveId());
+    if (idx === -1) return;
+    if (e.key === sheetExpandsKey && idx < allowed.length - 1) {
+      e.preventDefault();
+      deps.snapTo(allowed[idx + 1]);
+    } else if (e.key === sheetCollapsesKey && idx > 0) {
+      e.preventDefault();
+      deps.snapTo(allowed[idx - 1]);
+    } else if (e.key === "Home") {
+      e.preventDefault();
+      deps.snapTo(allowed[0]);
+    } else if (e.key === "End") {
+      e.preventDefault();
+      deps.snapTo(allowed[allowed.length - 1]);
+    }
+  };
+  deps.handle.addEventListener("keydown", onHandleKey);
+  return () => deps.handle.removeEventListener("keydown", onHandleKey);
+}
+
+// src/core/types.ts
+var SCRIM_PRESETS = Object.freeze({
+  subtle: {
+    color: "rgba(0,0,0,0.2)",
+    blur: void 0,
+    range: [0.3, 1],
+    interactive: false
+  },
+  standard: {
+    color: "rgba(0,0,0,0.4)",
+    blur: void 0,
+    range: [0, 1],
+    interactive: false
+  },
+  monitoring: {
+    color: "rgba(15,15,20,0.55)",
+    blur: "4px",
+    range: [0, 1],
+    interactive: false
+  },
+  cinematic: {
+    color: "rgba(0,0,0,0.7)",
+    blur: "12px",
+    range: [0, 1],
+    interactive: false
+  }
+});
+
+// src/core/primitives/hot-path-thresholds.ts
+var SIZE_WRITE_EPSILON = 0.5;
+var OPACITY_WRITE_EPSILON = 5e-3;
+var POINTER_EVENTS_OPACITY_THRESHOLD = 0.05;
+var RANGE_DIVISION_EPSILON = 1e-4;
+
+// src/core/primitives/opacity-dedup.ts
+var WriteSentinel = class {
+  constructor() {
+    __publicField(this, "last", -1);
+  }
+  /**
+   * Returns `true` (and updates the cached value) if `next` differs from the
+   * cached `last` by more than `epsilon`. Returns `false` (and leaves the
+   * cache untouched) when the delta is within epsilon — caller skips the
+   * CSSOM write.
+   */
+  shouldWrite(next, epsilon) {
+    if (Math.abs(next - this.last) <= epsilon) return false;
+    this.last = next;
+    return true;
+  }
+  /**
+   * Force the next `shouldWrite` to pass. Resets the cache to `-1` so any
+   * non-negative `next` exceeds the epsilon comparison. Called from setters
+   * that mutate state under the cache (range/mode/enabled flips that change
+   * the progress→opacity mapping but don't move `progress` itself).
+   */
+  invalidate() {
+    this.last = -1;
+  }
+  /**
+   * Record `value` as the last-written without performing a write. Used
+   * when a setter writes a literal value through a different path (e.g.
+   * `setScrimMode("off")` writes `opacity: "0"` inline) and wants future
+   * `shouldWrite` calls to short-circuit against that known cached state.
+   */
+  setLastWritten(value) {
+    this.last = value;
+  }
+  /** Read-only accessor for diagnostic / dedup-aware peek. */
+  get value() {
+    return this.last;
+  }
+};
+
+// src/core/controllers/scrim-controller.ts
+var ScrimController = class {
+  constructor(deps, opts) {
+    // ── DOM refs (mirror engine's; cached for hot path) ─────────────────
+    __publicField(this, "screenComponent");
+    __publicField(this, "backdrop");
+    __publicField(this, "mode");
+    // ── Engine callbacks ────────────────────────────────────────────────
+    __publicField(this, "isDestroyed");
+    __publicField(this, "isTopSheet");
+    __publicField(this, "getAllowedIds");
+    __publicField(this, "getResolvedSnaps");
+    __publicField(this, "snapToFn");
+    // ── Mode + state ────────────────────────────────────────────────────
+    __publicField(this, "scrimMode");
+    __publicField(this, "backdropRange");
+    __publicField(this, "screenRange");
+    // setScrimEnabled toggle — gated through `scrimEnabled` rather than nuking
+    // ranges so re-enable can restore prior values without a remount. Public
+    // so tests / introspection can read it without an `as any` cast.
+    __publicField(this, "scrimEnabled", true);
+    __publicField(this, "savedScrimRanges", null);
+    // ── Tap-to-close ────────────────────────────────────────────────────
+    __publicField(this, "scrimTapToCloseEnabled", false);
+    __publicField(this, "detachScrimTap", null);
+    // ── Scrim overlay slot (positioned floating element) ────────────────
+    __publicField(this, "scrimOverlayTeardown", null);
+    // ── Hot-path opacity dedup caches (per-frame writes) ────────────────
+    // Numeric sentinels migrated to WriteSentinel primitive — single
+    // invalidation surface, shared with the engine's size/progress sentinels.
+    // The two string-typed sentinels (`Pointer`, `Display`) keep their inline
+    // pattern: equality on string union, no epsilon, different reset semantics.
+    __publicField(this, "backdropOpacitySentinel", new WriteSentinel());
+    __publicField(this, "screenOpacitySentinel", new WriteSentinel());
+    __publicField(this, "lastBackdropPointer", "");
+    __publicField(this, "lastScreenDisplay", "");
+    this.screenComponent = deps.screenComponent;
+    this.backdrop = deps.backdrop;
+    this.mode = deps.mode;
+    this.isDestroyed = deps.isDestroyed;
+    this.isTopSheet = deps.isTopSheet;
+    this.getAllowedIds = deps.getAllowedIds;
+    this.getResolvedSnaps = deps.getResolvedSnaps;
+    this.snapToFn = deps.snapTo;
+    this.scrimMode = opts.scrimMode ?? "full";
+    const preset = opts.scrimPreset ? SCRIM_PRESETS[opts.scrimPreset] : null;
+    this.backdropRange = opts.backdropRange ?? preset?.range ?? [0, 1];
+    this.screenRange = opts.screenRange ?? preset?.range ?? [0, 1];
+    this.scrimTapToCloseEnabled = opts.scrimTapToClose ?? false;
+    if (this.screenComponent) {
+      this.applyScrimStyles({
+        color: opts.scrimColor ?? preset?.color,
+        blur: opts.scrimBlur ?? preset?.blur,
+        interactive: opts.scrimInteractive ?? preset?.interactive ?? false
+      });
+      if (this.scrimMode === "above-sheet") {
+        this.applyAboveSheetInset();
+      } else if (this.scrimMode === "off") {
+        const s = this.screenComponent.style;
+        s.opacity = "0";
+        s.display = "none";
+        this.screenOpacitySentinel.setLastWritten(0);
+        this.lastScreenDisplay = "none";
+      }
+    }
+  }
+  /**
+   * Invalidate the opacity dedup caches. Called from any setter that mutates
+   * range/mode/enabled — opacity is a pure function of (progress, range,
+   * enabled), so a config change makes the cached values stale even if
+   * `progress` itself didn't move. Next `applyOpacity(progress, false)` call
+   * sees the -1 sentinel and re-runs the math instead of short-circuiting.
+   *
+   * Public for the engine: `setSnapPoints` mutates resolved geometry which
+   * shifts `progress→opacity` mapping under the cache; engine calls this to
+   * keep the next render frame correct on a static sheet.
+   * @internal
+   */
+  invalidateOpacityCache() {
+    this.backdropOpacitySentinel.invalidate();
+    this.screenOpacitySentinel.invalidate();
+  }
+  /** Engine calls this when its `attach()` runs — installs scrim-tap-click if requested. */
+  attach() {
+    if (this.scrimTapToCloseEnabled) {
+      this.setScrimTapToClose(true);
+    }
+  }
+  // ── Hot-path: opacity computation called per-frame from engine.applySize ──
+  /**
+   * Per-frame opacity writer. Computes backdrop + screen opacity from the
+   * sheet's progress (0..1 within allowed range), gated by sub-pixel dedup
+   * caches so steady-state frames don't trigger style recalc.
+   *
+   * `progressChanged` is the engine's already-computed dedup gate — when
+   * `false`, opacity is by construction a pure function of `progress` so
+   * cached values are still valid; we short-circuit the Math.min/max +
+   * division work entirely. Setters that mutate ranges/mode/enabled
+   * invalidate the cache by writing -1 sentinels so the next call re-runs
+   * the math.
+   */
+  applyOpacity(progress, progressChanged) {
+    if (!progressChanged && this.backdropOpacitySentinel.value !== -1 && this.screenOpacitySentinel.value !== -1) {
+      return;
+    }
+    if (this.backdrop && this.isTopSheet()) {
+      const [s, e] = this.backdropRange;
+      const range = Math.max(e - s, RANGE_DIVISION_EPSILON);
+      const backdropOpacity = Math.min(
+        Math.max((progress - s) / range, 0),
+        1
+      );
+      if (this.backdropOpacitySentinel.shouldWrite(
+        backdropOpacity,
+        OPACITY_WRITE_EPSILON
+      )) {
+        this.backdrop.style.opacity = String(backdropOpacity);
+      }
+      const nextPointer = backdropOpacity > POINTER_EVENTS_OPACITY_THRESHOLD ? "auto" : "none";
+      if (nextPointer !== this.lastBackdropPointer) {
+        this.backdrop.style.pointerEvents = nextPointer;
+        this.lastBackdropPointer = nextPointer;
+      }
+    }
+    if (this.screenComponent && this.scrimMode !== "off") {
+      const [ss, se] = this.screenRange;
+      const screenOpacity = Math.min(
+        1,
+        Math.max(
+          0,
+          (progress - ss) / Math.max(RANGE_DIVISION_EPSILON, se - ss)
+        )
+      );
+      if (this.screenOpacitySentinel.shouldWrite(
+        screenOpacity,
+        OPACITY_WRITE_EPSILON
+      )) {
+        this.screenComponent.style.opacity = String(screenOpacity);
+      }
+      const nextDisplay = screenOpacity > 0 ? "" : "none";
+      if (nextDisplay !== this.lastScreenDisplay) {
+        this.screenComponent.style.display = nextDisplay;
+        this.lastScreenDisplay = nextDisplay;
+      }
+    }
+  }
+  // ── Public setters (engine forwards these 1:1) ─────────────────────
+  /**
+   * Replace the [start, end] progress window in which the backdrop fades 0→1.
+   * @param range - Tuple of two progress values in 0..1 (start <= end).
+   * @param applySize - Engine-supplied recompute hook; runs one applyOpacity pass.
+   * @example
+   *   // Backdrop only starts darkening after the sheet crosses 30% open.
+   *   engine.setBackdropRange([0.3, 1]);
+   */
+  setBackdropRange(range, applySize) {
+    if (this.isDestroyed()) return;
+    this.backdropRange = range;
+    this.invalidateOpacityCache();
+    applySize();
+  }
+  /**
+   * Replace the [start, end] progress window in which the screen scrim fades 0→1.
+   * @param range - Tuple of two progress values in 0..1 (start <= end).
+   * @param applySize - Engine-supplied recompute hook; runs one applyOpacity pass.
+   * @example
+   *   // Scrim is fully opaque only when the sheet is past 50% — softer feel.
+   *   engine.setScreenRange([0, 0.5]);
+   */
+  setScreenRange(range, applySize) {
+    if (this.isDestroyed()) return;
+    this.screenRange = range;
+    this.invalidateOpacityCache();
+    applySize();
+  }
+  /**
+   * Set the scrim background color. Pass `null`/`undefined` to clear the
+   * inline write and let consumer CSS take over.
+   * @param color - Any valid CSS color string, or `null`/`undefined` to clear.
+   * @example
+   *   engine.setScrimColor("rgba(0, 0, 0, 0.6)");
+   *   engine.setScrimColor(null); // hand back to consumer CSS
+   */
+  setScrimColor(color) {
+    if (this.isDestroyed()) return;
+    this.applyScrimStyles({ color: color === void 0 ? null : color });
+  }
+  /**
+   * Set the scrim backdrop-filter blur radius. Pass `null`/`undefined` to clear.
+   * @param blur - CSS length (e.g. `"8px"`) consumed as `blur(<value>)`, or
+   *               `null`/`undefined` to remove the filter.
+   * @example
+   *   engine.setScrimBlur("12px"); // frosted-glass effect
+   *   engine.setScrimBlur(null);    // disable blur
+   */
+  setScrimBlur(blur) {
+    if (this.isDestroyed()) return;
+    this.applyScrimStyles({ blur: blur === void 0 ? null : blur });
+  }
+  /**
+   * Toggle whether the scrim layer captures pointer events.
+   * @param interactive - `true` → `pointer-events: auto`; `false` → `none`.
+   * @example
+   *   engine.setScrimInteractive(true);  // scrim swallows clicks
+   *   engine.setScrimInteractive(false); // clicks pass through to content below
+   */
+  setScrimInteractive(interactive) {
+    if (this.isDestroyed()) return;
+    this.applyScrimStyles({ interactive });
+  }
+  /**
+   * Switch scrim positioning at runtime.
+   * @param mode - `"full"` (consumer CSS), `"above-sheet"` (engine-pinned inset
+   *               so only the area NOT covered by the sheet is dimmed), or
+   *               `"off"` (display:none + opacity:0 — no remount needed).
+   * @param applySize - Engine-supplied recompute hook; runs one applyOpacity pass.
+   * @example
+   *   engine.setScrimMode("above-sheet"); // dim only the area above the sheet
+   *   engine.setScrimMode("off");          // disable scrim layer
+   */
+  setScrimMode(mode, applySize) {
+    if (this.isDestroyed()) return;
+    if (mode === this.scrimMode) return;
+    this.invalidateOpacityCache();
+    const previous = this.scrimMode;
+    this.scrimMode = mode;
+    if (this.screenComponent) {
+      const s = this.screenComponent.style;
+      if (previous === "above-sheet" && mode !== "above-sheet") {
+        s.position = "";
+        s.inset = "";
+        s.pointerEvents = "";
+      }
+      if (mode === "above-sheet") {
+        this.applyAboveSheetInset();
+      } else if (mode === "off") {
+        s.opacity = "0";
+        s.display = "none";
+        this.screenOpacitySentinel.setLastWritten(0);
+        this.lastScreenDisplay = "none";
+      } else {
+        if (this.lastScreenDisplay === "none") {
+          s.display = "";
+          this.lastScreenDisplay = "";
+        }
+      }
+    }
+    applySize();
+  }
+  /**
+   * Enable or disable click-on-scrim → snap to first non-zero allowed snap.
+   * Auto-promotes `pointer-events: auto` when scrim is non-interactive so the
+   * click listener actually fires.
+   * @param enabled - `true` installs the click listener; `false` removes it.
+   * @example
+   *   engine.setScrimTapToClose(true);  // tap outside sheet collapses it
+   *   engine.setScrimTapToClose(false); // require explicit close button
+   */
+  setScrimTapToClose(enabled) {
+    if (this.isDestroyed()) return;
+    if (!this.screenComponent) return;
+    const installed = this.detachScrimTap !== null;
+    if (enabled === installed) return;
+    if (enabled) {
+      const target = this.screenComponent;
+      if (target.style.pointerEvents === "none") {
+        target.style.pointerEvents = "auto";
+      }
+      const onClick = () => {
+        if (this.isDestroyed()) return;
+        const allowed = this.getAllowedIds();
+        const snaps = this.getResolvedSnaps();
+        const fallback = allowed.find((id) => {
+          const snap = findById(id, snaps);
+          return snap !== null && snap.size > 0;
+        });
+        if (fallback) this.snapToFn(fallback);
+      };
+      target.addEventListener("click", onClick);
+      this.detachScrimTap = () => target.removeEventListener("click", onClick);
+      this.scrimTapToCloseEnabled = true;
+    } else {
+      this.detachScrimTap?.();
+      this.detachScrimTap = null;
+      this.scrimTapToCloseEnabled = false;
+    }
+  }
+  /**
+   * Toggle the scrim layer without remounting. Disabling stashes current
+   * `screenRange`/`backdropRange` and degenerates them to `[1, 1]` (opacity
+   * formula → 0 across the whole range); re-enabling restores the saved values.
+   * @param enabled - `false` hides scrim, `true` restores prior ranges.
+   * @param applySize - Engine-supplied recompute hook; runs one applyOpacity pass.
+   * @example
+   *   engine.setScrimEnabled(false); // hide scrim, ranges remembered
+   *   engine.setScrimEnabled(true);  // restore prior ranges (no remount)
+   */
+  setScrimEnabled(enabled, applySize) {
+    if (this.isDestroyed()) return;
+    if (enabled === this.scrimEnabled) return;
+    this.scrimEnabled = enabled;
+    if (!enabled) {
+      this.savedScrimRanges = {
+        screen: this.screenRange,
+        backdrop: this.backdropRange
+      };
+      this.screenRange = [1, 1];
+      this.backdropRange = [1, 1];
+    } else {
+      this.screenRange = this.savedScrimRanges?.screen ?? [0, 1];
+      this.backdropRange = this.savedScrimRanges?.backdrop ?? [0, 1];
+      this.savedScrimRanges = null;
+    }
+    applySize();
+  }
+  /**
+   * Batch-update multiple scrim fields with a single applySize() at the end.
+   * If `preset` is set, it seeds color/blur/interactive/range first; explicit
+   * fields override.
+   * @param opts - Partial scrim config: preset, mode, enabled, tapToClose,
+   *               color, blur, interactive, range.
+   * @param applySize - Engine-supplied recompute hook; runs ONCE per call.
+   * @example
+   *   engine.setScrim({
+   *     preset: "frosted",
+   *     mode: "above-sheet",
+   *     tapToClose: true,
+   *   });
+   */
+  setScrim(opts, applySize) {
+    if (this.isDestroyed()) return;
+    if (opts.preset) {
+      const cfg = SCRIM_PRESETS[opts.preset];
+      this.applyScrimStyles({
+        color: cfg.color,
+        blur: cfg.blur ?? null,
+        interactive: cfg.interactive
+      });
+      this.screenRange = cfg.range;
+    }
+    const noop = () => {
+    };
+    if (opts.mode !== void 0) this.setScrimMode(opts.mode, noop);
+    if (opts.enabled !== void 0) this.setScrimEnabled(opts.enabled, noop);
+    if (opts.tapToClose !== void 0) this.setScrimTapToClose(opts.tapToClose);
+    this.applyScrimStyles({
+      color: opts.color,
+      blur: opts.blur,
+      interactive: opts.interactive
+    });
+    if (opts.range !== void 0) {
+      this.screenRange = opts.range;
+    }
+    this.invalidateOpacityCache();
+    applySize();
+  }
+  /**
+   * Inject a positioned floating element into the scrim layer (e.g. a close
+   * button anchored top-right). Replaces any prior overlay so repeated calls
+   * (reactive effects re-running) don't accumulate wrappers.
+   * @param opts - Children element, optional `inset` (default `"16px"`),
+   *               `position` (9-way grid, default `"top-right"`), and
+   *               `interactive` flag (default `true`).
+   * @returns Teardown function that removes the wrapper from the DOM.
+   * @example
+   *   const teardown = engine.setScrimOverlay({
+   *     children: closeBtn,
+   *     position: "top-right",
+   *     inset: "20px",
+   *   });
+   *   // later: teardown(); // remove the floating button
+   */
+  setScrimOverlay(opts) {
+    if (this.isDestroyed()) return () => {
+    };
+    if (!this.screenComponent) return () => {
+    };
+    this.scrimOverlayTeardown?.();
+    const screen = this.screenComponent;
+    const inset = opts.inset ?? "16px";
+    const position = opts.position ?? "top-right";
+    const interactive = opts.interactive ?? true;
+    const wrapper = screen.ownerDocument.createElement("div");
+    wrapper.className = "bs-scrim-overlay";
+    const ws = wrapper.style;
+    ws.position = "absolute";
+    switch (position) {
+      case "top-left":
+        ws.top = inset;
+        ws.left = inset;
+        break;
+      case "top-center":
+        ws.top = inset;
+        ws.left = "50%";
+        ws.transform = "translateX(-50%)";
+        break;
+      case "top-right":
+        ws.top = inset;
+        ws.right = inset;
+        break;
+      case "center-left":
+        ws.top = "50%";
+        ws.left = inset;
+        ws.transform = "translateY(-50%)";
+        break;
+      case "center":
+        ws.top = "50%";
+        ws.left = "50%";
+        ws.transform = "translate(-50%, -50%)";
+        break;
+      case "center-right":
+        ws.top = "50%";
+        ws.right = inset;
+        ws.transform = "translateY(-50%)";
+        break;
+      case "bottom-left":
+        ws.bottom = inset;
+        ws.left = inset;
+        break;
+      case "bottom-center":
+        ws.bottom = inset;
+        ws.left = "50%";
+        ws.transform = "translateX(-50%)";
+        break;
+      case "bottom-right":
+        ws.bottom = inset;
+        ws.right = inset;
+        break;
+    }
+    if (interactive) {
+      ws.pointerEvents = "auto";
+    }
+    wrapper.appendChild(opts.children);
+    screen.appendChild(wrapper);
+    const teardown = () => {
+      if (wrapper.parentNode) wrapper.parentNode.removeChild(wrapper);
+      if (this.scrimOverlayTeardown === teardown) {
+        this.scrimOverlayTeardown = null;
+      }
+    };
+    this.scrimOverlayTeardown = teardown;
+    return teardown;
+  }
+  /** Tear down toggle-state listeners + remove any injected overlay wrapper. */
+  destroy() {
+    this.detachScrimTap?.();
+    this.detachScrimTap = null;
+    this.scrimOverlayTeardown?.();
+    this.scrimOverlayTeardown = null;
+    if (this.screenComponent) {
+      const s = this.screenComponent.style;
+      s.opacity = "";
+      s.display = "";
+    }
+    if (this.backdrop) {
+      this.backdrop.style.opacity = "";
+      this.backdrop.style.pointerEvents = "";
+    }
+    this.invalidateOpacityCache();
+    this.lastBackdropPointer = "";
+    this.lastScreenDisplay = "";
+  }
+  // ── Private helpers ────────────────────────────────────────────────
+  /** Centralized scrim style writer — atomic 3-property write across all setters. */
+  applyScrimStyles(opts) {
+    if (!this.screenComponent) return;
+    const s = this.screenComponent.style;
+    if (opts.color !== void 0) {
+      s.background = opts.color === null ? "" : opts.color;
+    }
+    if (opts.blur !== void 0) {
+      const w = s;
+      if (opts.blur === null) {
+        s.backdropFilter = "";
+        w.webkitBackdropFilter = "";
+      } else {
+        const filter = `blur(${opts.blur})`;
+        s.backdropFilter = filter;
+        w.webkitBackdropFilter = filter;
+      }
+    }
+    if (opts.interactive !== void 0) {
+      s.pointerEvents = opts.interactive ? "auto" : "none";
+    }
+  }
+  /** Pin the screen overlay to the area NOT occupied by the sheet. */
+  applyAboveSheetInset() {
+    if (!this.screenComponent) return;
+    const insetByMode = {
+      bottom: "0 0 var(--bs-size) 0",
+      top: "var(--bs-size) 0 0 0",
+      left: "0 0 0 var(--bs-size)",
+      right: "0 var(--bs-size) 0 0"
+    };
+    const s = this.screenComponent.style;
+    s.position = "fixed";
+    s.inset = insetByMode[this.mode];
+    s.pointerEvents = "none";
+  }
+};
+
+// src/core/animation/animation.ts
+var easeOutBack = (t) => {
+  const c1 = 1.40158;
+  const c3 = c1 + 1;
+  return 1 + c3 * Math.pow(t - 1, 3) + c1 * Math.pow(t - 1, 2);
+};
+var easeOutCubic = (t) => 1 - Math.pow(1 - t, 3);
+var easeLinear = (t) => t;
+var easeOutQuint = (t) => 1 - Math.pow(1 - t, 5);
+var tween = ({
+  from,
+  to,
+  duration,
+  easing = easeOutCubic,
+  onUpdate
+}) => {
+  let cancelled = false;
+  let rafId = 0;
+  let resolveFn = null;
+  const start = performance.now();
+  const promise = new Promise((resolve) => {
+    resolveFn = resolve;
+    if (duration <= 0) {
+      onUpdate(to);
+      resolve();
+      return;
+    }
+    const step = (now) => {
+      if (cancelled) return;
+      const elapsed = now - start;
+      const t = Math.min(elapsed / duration, 1);
+      const value = from + (to - from) * easing(t);
+      onUpdate(value);
+      if (t < 1) {
+        rafId = requestAnimationFrame(step);
+      } else {
+        resolve();
+      }
+    };
+    rafId = requestAnimationFrame(step);
+  });
+  return {
+    cancel: () => {
+      cancelled = true;
+      cancelAnimationFrame(rafId);
+      resolveFn?.();
+    },
+    promise
+  };
+};
+
+// src/core/animation/spring.ts
+var DEFAULT_SPRING = {
+  stiffness: 220,
+  damping: 26,
+  mass: 1,
+  restDelta: 0.5,
+  restSpeed: 0.5
+};
+var MAX_DT = 1 / 30;
+var runSpring = ({
+  from,
+  to,
+  velocity = 0,
+  config,
+  onUpdate
+}) => {
+  const cfg = { ...DEFAULT_SPRING, ...config };
+  let cancelled = false;
+  let rafId = 0;
+  let resolveFn = null;
+  let x = from;
+  let v = velocity;
+  let lastTime = performance.now();
+  const promise = new Promise((resolve) => {
+    resolveFn = resolve;
+    const step = (now) => {
+      if (cancelled) return;
+      const dt = Math.min((now - lastTime) / 1e3, MAX_DT);
+      lastTime = now;
+      const subDt = Math.min(dt, 1 / 240);
+      let stepsLeft = Math.max(1, Math.ceil(dt / subDt));
+      while (stepsLeft-- > 0) {
+        const force = -cfg.stiffness * (x - to) - cfg.damping * v;
+        const accel = force / cfg.mass;
+        v += accel * subDt;
+        x += v * subDt;
+      }
+      onUpdate(x, v);
+      const isAtRest = Math.abs(to - x) < (cfg.restDelta ?? 0.5) && Math.abs(v) < (cfg.restSpeed ?? 0.5);
+      if (isAtRest) {
+        onUpdate(to, 0);
+        resolve();
+      } else {
+        rafId = requestAnimationFrame(step);
+      }
+    };
+    rafId = requestAnimationFrame(step);
+  });
+  return {
+    cancel: () => {
+      cancelled = true;
+      cancelAnimationFrame(rafId);
+      resolveFn?.();
+    },
+    promise
+  };
+};
+
+// src/core/animation/animation-presets.ts
+var DEFAULT_DURATION = 220;
+function resolveAnimationPreset(animation) {
+  switch (animation) {
+    case "ios-spring":
+      return {
+        kind: "spring",
+        spring: { stiffness: 300, damping: 30, mass: 1 }
+      };
+    case "material-bounce":
+      return {
+        kind: "spring",
+        spring: { stiffness: 200, damping: 22, mass: 1 }
+      };
+    case "linear":
+      return { kind: "tween", duration: DEFAULT_DURATION, easing: easeLinear };
+    case "snappy":
+      return { kind: "tween", duration: 180, easing: easeOutQuint };
+    case "tween":
+      return { kind: "tween" };
+    case "spring":
+    case void 0:
+    default:
+      return { kind: "spring" };
+  }
+}
+
+// src/core/controllers/animation-runner.ts
+var DEFAULT_DURATION2 = 220;
+var VELOCITY_PX_PER_S = 1e3;
+var AnimationRunner = class {
+  constructor(deps, opts) {
+    __publicField(this, "element");
+    __publicField(this, "getRootEl");
+    __publicField(this, "applySizeFn");
+    __publicField(this, "getSize");
+    __publicField(this, "isDragging");
+    __publicField(this, "animationKind");
+    __publicField(this, "springConfig");
+    __publicField(this, "duration");
+    __publicField(this, "easing");
+    __publicField(this, "respectReducedMotion");
+    /** Live-tracked via mq listener so animateTo skips matchMedia per snap. */
+    __publicField(this, "reducedMotion", false);
+    /** Disposes the matchMedia change listener — drained from destroy(). */
+    __publicField(this, "detachReducedMotion", null);
+    /** Computed once — both inputs (option + API presence) stable for life. */
+    __publicField(this, "viewTransitionsAvailable");
+    /** In-flight handles. Public for tests / debugging only — engine drives via cancel(). */
+    __publicField(this, "currentTween", null);
+    __publicField(this, "currentSpring", null);
+    this.element = deps.element;
+    this.getRootEl = deps.getRootEl;
+    this.applySizeFn = deps.applySize;
+    this.getSize = deps.getSize;
+    this.isDragging = deps.isDragging;
+    const preset = resolveAnimationPreset(opts.animation);
+    this.animationKind = preset.kind;
+    this.duration = opts.duration ?? preset.duration ?? DEFAULT_DURATION2;
+    this.easing = opts.easing ?? preset.easing ?? easeOutBack;
+    this.springConfig = { ...preset.spring ?? {}, ...opts.spring ?? {} };
+    this.respectReducedMotion = opts.respectReducedMotion ?? true;
+    const viewTransitionsEnabled = opts.viewTransitions ?? false;
+    this.viewTransitionsAvailable = viewTransitionsEnabled && typeof document !== "undefined" && typeof document.startViewTransition === "function";
+    if (this.respectReducedMotion && typeof window !== "undefined" && typeof window.matchMedia === "function") {
+      const mq = window.matchMedia("(prefers-reduced-motion: reduce)");
+      this.reducedMotion = mq.matches;
+      const onMqChange = (e) => {
+        this.reducedMotion = e.matches;
+      };
+      if (typeof mq.addEventListener === "function") {
+        mq.addEventListener("change", onMqChange);
+        this.detachReducedMotion = () => mq.removeEventListener("change", onMqChange);
+      } else if (typeof mq.addListener === "function") {
+        mq.addListener(onMqChange);
+        this.detachReducedMotion = () => mq.removeListener(onMqChange);
+      }
+    }
+  }
+  /**
+   * Live derived flag — `true` whenever a spring/tween handle is in flight.
+   * Reading the canonical handles (instead of mirroring into a separate
+   * boolean) eliminates the reduced-motion early-return latent bug where
+   * the flag stayed true forever, and removes the cross-controller
+   * setIsAnimating callback.
+   */
+  get isAnimating() {
+    return this.currentTween !== null || this.currentSpring !== null;
+  }
+  /** Cancel any in-flight tween/spring without touching engine state. */
+  cancel() {
+    this.currentTween?.cancel();
+    this.currentSpring?.cancel();
+  }
+  /**
+   * Animate from current size to `target`. Resolves when the animation
+   * completes; resolves early if cancelled mid-flight (caller checks an
+   * abort signal post-await for cycle-invariant correctness).
+   */
+  async animateTo(target, velocityPxPerMs) {
+    if (target === this.getSize()) return;
+    this.currentTween?.cancel();
+    this.currentSpring?.cancel();
+    this.getRootEl()?.setAttribute("data-animating", "true");
+    this.element.style.willChange = "transform";
+    if (this.reducedMotion) {
+      this.applySizeFn(target);
+      this.getRootEl()?.removeAttribute("data-animating");
+      if (!this.isDragging()) this.element.style.willChange = "auto";
+      return;
+    }
+    if (this.animationKind === "spring") {
+      const spring = runSpring({
+        from: this.getSize(),
+        to: target,
+        velocity: velocityPxPerMs * VELOCITY_PX_PER_S,
+        config: this.springConfig,
+        onUpdate: (v) => this.applySizeFn(v)
+      });
+      this.currentSpring = spring;
+      await spring.promise;
+      if (this.currentSpring === spring) this.currentSpring = null;
+    } else {
+      const tw = tween({
+        from: this.getSize(),
+        to: target,
+        duration: this.duration,
+        easing: this.easing,
+        onUpdate: (v) => this.applySizeFn(v)
+      });
+      this.currentTween = tw;
+      await tw.promise;
+      if (this.currentTween === tw) this.currentTween = null;
+    }
+    if (!this.isAnimating) {
+      this.getRootEl()?.removeAttribute("data-animating");
+      if (!this.isDragging()) this.element.style.willChange = "auto";
+    }
+  }
+  /** Tear down the matchMedia listener. Engine calls from destroy(). */
+  destroy() {
+    this.detachReducedMotion?.();
+    this.detachReducedMotion = null;
+    this.currentTween = null;
+    this.currentSpring = null;
+  }
+};
+
+// src/core/lifecycle/focusTrap.ts
+var FOCUSABLE = [
+  "a[href]",
+  "area[href]",
+  "button:not([disabled])",
+  "input:not([disabled]):not([type='hidden'])",
+  "select:not([disabled])",
+  "textarea:not([disabled])",
+  "iframe",
+  "object",
+  "embed",
+  "[contenteditable='true']",
+  "[tabindex]:not([tabindex='-1'])"
+].join(",");
+var isVisible = (el) => {
+  if (typeof el.checkVisibility === "function") {
+    return el.checkVisibility({ checkOpacity: false, checkVisibilityCSS: true });
+  }
+  return el.offsetParent !== null;
+};
+var focusables = (root) => Array.from(root.querySelectorAll(FOCUSABLE)).filter(
+  (el) => !el.hasAttribute("inert") && isVisible(el) && !el.matches("[aria-hidden='true']")
+);
+var installFocusTrap = (container, options = {}) => {
+  if (typeof document === "undefined") return () => {
+  };
+  const previouslyFocused = document.activeElement;
+  const focusInitial = () => {
+    const initial = typeof options.initialFocus === "string" ? container.querySelector(options.initialFocus) : options.initialFocus ?? focusables(container)[0] ?? container;
+    initial?.focus({ preventScroll: true });
+  };
+  focusInitial();
+  const handleKey = (e) => {
+    if (e.key === "Escape" && options.onEscape) {
+      options.onEscape();
+      return;
+    }
+    if (e.key !== "Tab") return;
+    const list = focusables(container);
+    if (list.length === 0) {
+      e.preventDefault();
+      return;
+    }
+    const first = list[0];
+    const last = list[list.length - 1];
+    const active = document.activeElement;
+    if (e.shiftKey && active === first) {
+      e.preventDefault();
+      last.focus();
+    } else if (!e.shiftKey && active === last) {
+      e.preventDefault();
+      first.focus();
+    }
+  };
+  const handleFocusIn = (e) => {
+    const target = e.target;
+    if (target && !container.contains(target)) {
+      const list = focusables(container);
+      list[0]?.focus({ preventScroll: true });
+    }
+  };
+  document.addEventListener("keydown", handleKey, true);
+  document.addEventListener("focusin", handleFocusIn, true);
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    document.removeEventListener("keydown", handleKey, true);
+    document.removeEventListener("focusin", handleFocusIn, true);
+    if (previouslyFocused && document.contains(previouslyFocused)) {
+      previouslyFocused.focus({ preventScroll: true });
+    } else {
+      const fallback = document.querySelector("[data-bs-restore-fallback]");
+      fallback?.focus({ preventScroll: true });
+    }
+  };
+};
+
+// src/core/lifecycle/scrollLock.ts
+var lockCount = 0;
+var savedStyles = null;
+var lockBodyScroll = () => {
+  if (typeof document === "undefined") return () => {
+  };
+  if (lockCount === 0) {
+    const body = document.body;
+    savedStyles = {
+      overflow: body.style.overflow,
+      position: body.style.position,
+      top: body.style.top,
+      width: body.style.width,
+      scrollY: window.scrollY
+    };
+    body.style.overflow = "hidden";
+    body.style.position = "fixed";
+    body.style.top = `-${savedStyles.scrollY}px`;
+    body.style.width = "100%";
+  }
+  lockCount++;
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    lockCount = Math.max(0, lockCount - 1);
+    if (lockCount === 0 && savedStyles) {
+      const body = document.body;
+      body.style.overflow = savedStyles.overflow;
+      body.style.position = savedStyles.position;
+      body.style.top = savedStyles.top;
+      body.style.width = savedStyles.width;
+      window.scrollTo(0, savedStyles.scrollY);
+      savedStyles = null;
+    }
+  };
+};
+
+// src/core/features/inert-siblings.ts
+function createInertSiblings(rootProvider) {
+  const tracked = [];
+  return {
+    apply() {
+      if (typeof document === "undefined") return;
+      const root = rootProvider();
+      const parent = root.parentElement ?? document.body;
+      for (const child of Array.from(parent.children)) {
+        if (child === root) continue;
+        if (child.hasAttribute("inert")) continue;
+        child.setAttribute("inert", "");
+        tracked.push(child);
+      }
+    },
+    remove() {
+      for (const el of tracked) el.removeAttribute("inert");
+      tracked.length = 0;
+    }
+  };
+}
+
+// src/core/controllers/lifecycle-controller.ts
+var LifecycleController = class {
+  constructor(deps, opts) {
+    __publicField(this, "element");
+    __publicField(this, "closeFn");
+    __publicField(this, "focusTrapEnabled");
+    __publicField(this, "initialFocus");
+    __publicField(this, "closeOnEscape");
+    __publicField(this, "bodyScrollLockEnabled");
+    __publicField(this, "inertSiblingsEnabled");
+    __publicField(this, "inertSiblings");
+    __publicField(this, "shouldApplyInertSiblings");
+    __publicField(this, "returnFocus");
+    /** Toggle-state teardowns — fire on close, NOT in destroy-only stack. */
+    __publicField(this, "releaseFocusTrap", null);
+    __publicField(this, "releaseScrollLock", null);
+    /** True between install() and release(). Guards release()/destroy() from
+     *  re-running side effects (notably `returnFocus.focus()`) on already-
+     *  released or never-installed instances. */
+    __publicField(this, "installed", false);
+    __publicField(this, "destroyed", false);
+    this.element = deps.element;
+    this.closeFn = deps.close;
+    this.focusTrapEnabled = opts.focusTrap ?? false;
+    this.initialFocus = opts.initialFocus;
+    this.closeOnEscape = opts.closeOnEscape ?? true;
+    this.bodyScrollLockEnabled = opts.lockBodyScroll ?? true;
+    this.inertSiblingsEnabled = opts.inertSiblings ?? false;
+    this.shouldApplyInertSiblings = opts.shouldApplyInertSiblings ?? (() => true);
+    this.returnFocus = opts.returnFocus;
+    this.inertSiblings = createInertSiblings(() => this.element);
+  }
+  /**
+   * Run the open-time install steps. Idempotent: each step checks its
+   * existing teardown ref so a re-open during a half-cancelled close
+   * doesn't double-install. Sets `installed=true` BEFORE the first side
+   * effect so a partial throw (detached / shadow-DOM target) leaves the
+   * caller's `release()` rollback path armed to undo whatever did succeed.
+   * No-op when destroyed.
+   */
+  install() {
+    if (this.destroyed) return;
+    this.installed = true;
+    if (this.bodyScrollLockEnabled && !this.releaseScrollLock) {
+      this.releaseScrollLock = lockBodyScroll();
+    }
+    if (this.focusTrapEnabled && !this.releaseFocusTrap) {
+      this.releaseFocusTrap = installFocusTrap(this.element, {
+        initialFocus: this.initialFocus,
+        onEscape: this.closeOnEscape ? () => void this.closeFn() : void 0
+      });
+    }
+    if (this.inertSiblingsEnabled && this.shouldApplyInertSiblings()) {
+      this.inertSiblings.apply();
+    }
+  }
+  /**
+   * Update the post-release focus target. Overlay re-binds this when the
+   * consumer changes `returnFocus` after construction; the new value applies
+   * on the next `release()`. No-op when destroyed.
+   */
+  setReturnFocus(target) {
+    if (this.destroyed) return;
+    this.returnFocus = target;
+  }
+  /**
+   * Release all install-time teardowns. Short-circuits when not installed,
+   * so `close() → destroy()` (each routing through here) only restores
+   * focus once. The `installed` guard lets `inertSiblings.remove()` and
+   * the focus-trap/scroll-lock teardown nullings stay simple — they were
+   * already idempotent, but `returnFocus.focus()` was firing on every call.
+   */
+  release() {
+    if (!this.installed) return;
+    this.installed = false;
+    this.releaseFocusTrap?.();
+    this.releaseFocusTrap = null;
+    this.releaseScrollLock?.();
+    this.releaseScrollLock = null;
+    this.inertSiblings.remove();
+    if (this.returnFocus) {
+      const target = typeof this.returnFocus === "function" ? this.returnFocus() : this.returnFocus;
+      target?.focus?.();
+    }
+  }
+  /**
+   * Final teardown — releases any still-installed listeners and seals the
+   * controller. After destroy(), install() is a no-op and setReturnFocus()
+   * is rejected, so post-destroy mutations can't queue up a stale focus
+   * restore.
+   */
+  destroy() {
+    this.release();
+    this.destroyed = true;
+  }
+};
+
+// src/core/gestures.ts
+var isAxisVertical = (mode) => mode === "bottom" || mode === "top";
+var SampleRing = class {
+  // current count, ≤ capacity
+  constructor(capacity) {
+    __publicField(this, "slots");
+    __publicField(this, "capacity");
+    __publicField(this, "head", 0);
+    // next write index
+    __publicField(this, "size", 0);
+    this.capacity = capacity;
+    this.slots = new Array(capacity);
+    for (let i = 0; i < capacity; i++) this.slots[i] = { t: 0, v: 0 };
+  }
+  push(t, v) {
+    const slot = this.slots[this.head];
+    slot.t = t;
+    slot.v = v;
+    this.head = (this.head + 1) % this.capacity;
+    if (this.size < this.capacity) this.size++;
+  }
+  /**
+   * Drop oldest entries whose timestamp is below `cutoff`, but never shrink
+   * below `minKeep`. Mirrors the original
+   *   `while (samples.length > minKeep && samples[0].t < cutoff) samples.shift()`
+   * but without copying — just advances the logical tail.
+   */
+  pruneBefore(cutoff, minKeep) {
+    while (this.size > minKeep) {
+      const oldestIdx = (this.head - this.size + this.capacity) % this.capacity;
+      if (this.slots[oldestIdx].t < cutoff) this.size--;
+      else break;
+    }
+  }
+  get length() {
+    return this.size;
+  }
+  oldest() {
+    if (this.size === 0) return void 0;
+    return this.slots[(this.head - this.size + this.capacity) % this.capacity];
+  }
+  newest() {
+    if (this.size === 0) return void 0;
+    return this.slots[(this.head - 1 + this.capacity) % this.capacity];
+  }
+  reset() {
+    this.head = 0;
+    this.size = 0;
+  }
+};
+var installGestures = (handle, mode, callbacks) => {
+  let activePointerId = null;
+  let activePointerType = "touch";
+  let startCoord = 0;
+  let lastCoord = 0;
+  const VELOCITY_WINDOW_MS = (kind) => kind === "mouse" ? 160 : 120;
+  const MAX_SAMPLES = 32;
+  const samples = new SampleRing(MAX_SAMPLES);
+  const axis = isAxisVertical(mode) ? "Y" : "X";
+  const sign = mode === "bottom" || mode === "right" ? -1 : 1;
+  const coordOf = (e) => axis === "Y" ? e.clientY : e.clientX;
+  const onPointerDown = (e) => {
+    if (activePointerId !== null) return;
+    if (e.button !== void 0 && e.button !== 0) return;
+    activePointerId = e.pointerId;
+    activePointerType = e.pointerType || "touch";
+    startCoord = coordOf(e);
+    lastCoord = startCoord;
+    samples.reset();
+    samples.push(e.timeStamp, startCoord);
+    try {
+      handle.setPointerCapture(e.pointerId);
+    } catch {
+    }
+    callbacks.onStart(startCoord, activePointerType);
+  };
+  const onPointerMove = (e) => {
+    if (e.pointerId !== activePointerId) return;
+    const coord = coordOf(e);
+    const rawDelta = coord - startCoord;
+    const delta = rawDelta * sign;
+    lastCoord = coord;
+    samples.push(e.timeStamp, coord);
+    const cutoff = e.timeStamp - VELOCITY_WINDOW_MS(activePointerType);
+    samples.pruneBefore(cutoff, 2);
+    callbacks.onMove(delta);
+  };
+  const finishGesture = (e) => {
+    if (e.pointerId !== activePointerId) return;
+    const rawDelta = lastCoord - startCoord;
+    const delta = rawDelta * sign;
+    let velocity = 0;
+    if (samples.length >= 3) {
+      const first = samples.oldest();
+      const last = samples.newest();
+      const dt = last.t - first.t;
+      if (dt > 0) velocity = (last.v - first.v) / dt * sign;
+    }
+    const finishedKind = activePointerType;
+    activePointerId = null;
+    samples.reset();
+    try {
+      if (handle.hasPointerCapture(e.pointerId)) {
+        handle.releasePointerCapture(e.pointerId);
+      }
+    } catch {
+    }
+    callbacks.onEnd(delta, velocity, finishedKind);
+  };
+  const onPointerCancel = (e) => {
+    if (e.pointerId !== activePointerId) return;
+    activePointerId = null;
+    samples.reset();
+    callbacks.onCancel?.();
+  };
+  handle.addEventListener("pointerdown", onPointerDown);
+  handle.addEventListener("pointermove", onPointerMove);
+  handle.addEventListener("pointerup", finishGesture);
+  handle.addEventListener("pointercancel", onPointerCancel);
+  handle.style.touchAction = isAxisVertical(mode) ? "pan-x" : "pan-y";
+  return () => {
+    handle.removeEventListener("pointerdown", onPointerDown);
+    handle.removeEventListener("pointermove", onPointerMove);
+    handle.removeEventListener("pointerup", finishGesture);
+    handle.removeEventListener("pointercancel", onPointerCancel);
+    if (activePointerId !== null && handle.hasPointerCapture(activePointerId)) {
+      handle.releasePointerCapture(activePointerId);
+    }
+  };
+};
+
+// src/core/primitives/rubber-band.ts
+var RUBBER_BAND_FACTOR = 0.55;
+function rubberBand(overshoot, maxAxisSize) {
+  const cap = Math.min(maxAxisSize * 0.15, 80);
+  return Math.sign(overshoot) * Math.pow(Math.abs(overshoot), RUBBER_BAND_FACTOR) * Math.min(6, cap / Math.max(Math.abs(overshoot), 1));
+}
+
+// src/core/features/soft-keyboard.ts
+function dismissSoftKeyboardIfFocused(root) {
+  if (typeof document === "undefined") return false;
+  const active = document.activeElement;
+  if (!active) return false;
+  if (!root.contains(active)) return false;
+  const tag = active.tagName;
+  const isEditable = tag === "INPUT" || tag === "TEXTAREA" || active.isContentEditable === true;
+  if (!isEditable) return false;
+  try {
+    active.blur();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/core/controllers/gesture-controller.ts
+var GestureController = class {
+  constructor(deps) {
+    __publicField(this, "deps");
+    __publicField(this, "detach", null);
+    __publicField(this, "isDragging_", false);
+    __publicField(this, "dragStartSize", 0);
+    // Only "touch" gestures are eligible for soft-keyboard dismissal —
+    // mouse/trackpad users don't have a keyboard to dismiss.
+    __publicField(this, "currentPointerKind", "touch");
+    // One blur per drag — flipping focus every move event races the keyboard's
+    // own animations on iOS and makes the page jitter.
+    __publicField(this, "keyboardDismissed", false);
+    // Reused payload object for the "drag" event — mutated each onMove instead
+    // of allocating a fresh `{size, delta}` per frame. At 60-120Hz a long drag
+    // would otherwise churn tens of KB through the GC. Mirrors browser
+    // PointerEvent semantics: consumers must NOT retain the reference across
+    // frames (clone if needed). See SheetEventMap.drag JSDoc.
+    __publicField(this, "dragPayload", { size: 0, delta: 0 });
+    this.deps = deps;
+  }
+  /** True between `dragstart` and `dragend`/`onCancel`. */
+  get isDragging() {
+    return this.isDragging_;
+  }
+  /**
+   * Bind pointer listeners on the handle and return a teardown. Engine pushes
+   * the teardown into its TeardownStack so destroy() drains it once.
+   */
+  install() {
+    if (this.detach) return this.detach;
+    this.detach = installGestures(this.deps.handle, this.deps.mode, {
+      onStart: (_coord, kind) => {
+        this.deps.cancelAnimation();
+        this.isDragging_ = true;
+        this.dragStartSize = this.deps.getDragContext().size;
+        this.currentPointerKind = kind;
+        this.keyboardDismissed = false;
+        this.deps.getRoot()?.setAttribute("data-dragging", "true");
+        this.deps.element.style.willChange = "transform";
+        this.deps.emit("dragstart", { size: this.dragStartSize });
+      },
+      onMove: (delta) => {
+        const ctx = this.deps.getDragContext();
+        const { min, max } = ctx.range;
+        const maxAxis = ctx.maxAxisSize;
+        const rubberOn = ctx.rubberBandEnabled;
+        let next = this.dragStartSize + delta;
+        if (next > max) {
+          next = rubberOn ? max + rubberBand(next - max, maxAxis) : max;
+        } else if (next < min) {
+          next = rubberOn ? min - rubberBand(min - next, maxAxis) : min;
+        }
+        this.deps.applySize(next);
+        if (!this.keyboardDismissed && this.currentPointerKind === "touch" && this.deps.mode === "bottom" && next < this.dragStartSize) {
+          if (dismissSoftKeyboardIfFocused(this.deps.element)) {
+            this.keyboardDismissed = true;
+          }
+        }
+        if (this.deps.listenerCount("drag") > 0) {
+          this.dragPayload.size = next;
+          this.dragPayload.delta = delta;
+          this.deps.emit("drag", this.dragPayload);
+        }
+      },
+      onEnd: (delta, velocity, kind) => {
+        this.isDragging_ = false;
+        this.keyboardDismissed = false;
+        this.deps.getRoot()?.removeAttribute("data-dragging");
+        this.deps.emit("dragend", {
+          size: this.deps.getDragContext().size,
+          velocity
+        });
+        this.deps.settleAfterDrag(delta, velocity, kind);
+      },
+      onCancel: () => {
+        this.isDragging_ = false;
+        this.keyboardDismissed = false;
+        this.deps.getRoot()?.removeAttribute("data-dragging");
+        const restoreTo = this.dragStartSize;
+        void this.deps.animateTo(restoreTo, 0);
+      }
+    });
+    return this.detach;
+  }
+  /**
+   * Force-clear drag visual state. Engine calls from destroy() when destroyed
+   * mid-drag — gesture detach won't synthesize an onCancel, so we have to
+   * roll back the data-attribute + will-change ourselves.
+   */
+  forceClearDragState() {
+    if (!this.isDragging_) return;
+    this.isDragging_ = false;
+    this.keyboardDismissed = false;
+    this.deps.getRoot()?.removeAttribute("data-dragging");
+    this.deps.element.style.willChange = "auto";
+  }
+};
+
+// src/core/primitives/aria-slider-writer.ts
+var AriaSliderWriter = class {
+  constructor(handle, mode) {
+    __publicField(this, "handle", handle);
+    handle.setAttribute(
+      "aria-orientation",
+      mode === "bottom" || mode === "top" ? "vertical" : "horizontal"
+    );
+  }
+  /**
+   * Update slider position. `allowedIds` length determines `aria-valuemax`;
+   * `activeId` indexes into it for `aria-valuenow` + `aria-valuetext`.
+   * Empty list → strip every dynamic attr so AT skips the handle entirely.
+   */
+  setValue(allowedIds, activeId) {
+    if (allowedIds.length === 0) {
+      this.handle.removeAttribute("aria-valuemin");
+      this.handle.removeAttribute("aria-valuemax");
+      this.handle.removeAttribute("aria-valuenow");
+      this.handle.removeAttribute("aria-valuetext");
+      return;
+    }
+    const max = Math.max(allowedIds.length - 1, 0);
+    const idx = Math.max(allowedIds.indexOf(activeId), 0);
+    this.handle.setAttribute("aria-valuemin", "0");
+    this.handle.setAttribute("aria-valuemax", String(max));
+    this.handle.setAttribute("aria-valuenow", String(idx));
+    this.handle.setAttribute("aria-valuetext", activeId);
+  }
+};
+
+// src/core/features/scroll-cache.ts
+function createScrollCache(deps) {
+  const positions = /* @__PURE__ */ new Map();
+  const isSmallSize = (size) => {
+    const max = deps.getMaxAxisSize();
+    if (max <= 0) return false;
+    return size < max / 2;
+  };
+  return {
+    cache(fromId, prevSize, nextSize) {
+      const container = deps.scrollContainer;
+      if (!container) return;
+      if (isSmallSize(prevSize)) return;
+      if (!isSmallSize(nextSize)) return;
+      positions.set(fromId, container.scrollTop);
+    },
+    restore(toId, prevSize, nextSize) {
+      const container = deps.scrollContainer;
+      if (!container) return;
+      if (isSmallSize(nextSize)) return;
+      if (!isSmallSize(prevSize)) return;
+      const cached = positions.get(toId);
+      if (cached === void 0) return;
+      container.scrollTop = cached;
+      positions.delete(toId);
+    },
+    clear() {
+      positions.clear();
+    }
+  };
+}
+
+// src/core/primitives/engine-options.ts
+var DEFAULT_FLICK_VELOCITY = 0.65;
+var DEFAULT_DRAG_THRESHOLD = 18;
+function resolveEngineOptions(opts, extras) {
+  const initialAllowed = opts.allowed ?? opts.snapPoints.map((p) => p.id);
+  let initialId = opts.initial ?? initialAllowed[0] ?? opts.snapPoints[0]?.id ?? "default";
+  if (opts.persistKey) {
+    const restored = readPersistedId(opts.persistKey);
+    if (restored && initialAllowed.includes(restored)) {
+      initialId = restored;
+    }
+  }
+  return {
+    mode: opts.mode ?? "bottom",
+    flickVelocity: opts.flickVelocity ?? DEFAULT_FLICK_VELOCITY,
+    dragThreshold: opts.dragThreshold ?? DEFAULT_DRAG_THRESHOLD,
+    rubberBandEnabled: opts.rubberBand ?? true,
+    closeOnBack: opts.closeOnBack ?? false,
+    initialAllowed,
+    initialId,
+    scrim: {
+      scrimMode: opts.scrimMode,
+      scrimColor: opts.scrimColor,
+      scrimBlur: opts.scrimBlur,
+      // Auto-promote pointer-events when tap-to-close is on so the click
+      // listener actually receives events. Caller can still force `false`
+      // explicitly to opt out — `??` only kicks in for `undefined`.
+      scrimInteractive: opts.scrimInteractive ?? (opts.scrimTapToClose ? true : void 0),
+      scrimTapToClose: opts.scrimTapToClose,
+      scrimPreset: opts.scrimPreset,
+      screenRange: opts.screenRange,
+      backdropRange: opts.backdropRange
+    },
+    animation: {
+      animation: opts.animation,
+      duration: opts.duration,
+      easing: opts.easing,
+      spring: opts.spring,
+      respectReducedMotion: opts.respectReducedMotion,
+      viewTransitions: opts.viewTransitions
+    },
+    lifecycle: {
+      focusTrap: opts.focusTrap,
+      initialFocus: opts.initialFocus,
+      closeOnEscape: opts.closeOnEscape,
+      lockBodyScroll: opts.lockBodyScroll,
+      inertSiblings: opts.inertSiblings,
+      // Folded in from `extras` so the lifecycle bag is fully assembled at
+      // the call site — engine no longer needs a spread+override at
+      // controller construction. When `extras` is omitted, the field stays
+      // undefined and the controller uses its own default predicate.
+      shouldApplyInertSiblings: extras?.shouldApplyInertSiblings
+    }
+  };
+}
+
+// src/core/BottomSheetEngine.ts
+var HAPTIC_DURATION_MS = 8;
+var TeardownStack = class {
+  constructor() {
+    __publicField(this, "fns", []);
+  }
+  add(fn) {
+    if (fn) this.fns.push(fn);
+  }
+  drain() {
+    while (this.fns.length) {
+      try {
+        this.fns.pop()();
+      } catch (err) {
+        queueMicrotask(() => {
+          throw err;
+        });
+      }
+    }
+  }
+};
+var BottomSheetEngine = class {
+  constructor(opts) {
+    __publicField(this, "id", nextInstanceId("bs"));
+    __publicField(this, "element");
+    __publicField(this, "handle");
+    __publicField(this, "scrollContainer");
+    __publicField(this, "backdrop");
+    __publicField(this, "screenComponent");
+    __publicField(this, "mode");
+    __publicField(this, "flickVelocity");
+    __publicField(this, "dragThreshold");
+    __publicField(this, "rubberBandEnabled");
+    __publicField(this, "scrim");
+    __publicField(this, "aria");
+    __publicField(this, "animation");
+    __publicField(this, "lifecycle");
+    __publicField(this, "closeOnBack");
+    __publicField(this, "routedTo");
+    // Engine retains `snapPointsRaw` for the "find a closed-id" query in
+    // close() (raw input, not resolved geometry). Resolver owns geometry.
+    __publicField(this, "snapPointsRaw");
+    __publicField(this, "snaps");
+    __publicField(this, "activeId");
+    __publicField(this, "size", 0);
+    // Constructed in attach(); a plugin's install() could read `state` before
+    // attach completes if the constructor throws partway through. State getter
+    // null-guards via `this.gesture?.isDragging ?? false`.
+    __publicField(this, "gesture");
+    __publicField(this, "rootEl", null);
+    __publicField(this, "destroyed", false);
+    // In-flight ViewTransition handle. A second snapTo while a VT is in flight
+    // would otherwise let Chromium reject the second's promise and flicker —
+    // newCycle() calls skipTransition() to abort cleanly.
+    __publicField(this, "currentViewTransition", null);
+    // Each cycle captures the signal at entry; when a newer cycle aborts the
+    // controller, the captured signal flips to `aborted=true` and post-await
+    // guards short-circuit (prevents stale snap/open/close emits).
+    __publicField(this, "currentAbort", new AbortController());
+    // Sub-pixel `--bs-size` deltas and <1% `--bs-progress` deltas are not
+    // visually distinguishable; gating CSSOM writes drops 30-50% of writes
+    // during the spring's settle tail.
+    __publicField(this, "sizeWriteSentinel", new WriteSentinel());
+    __publicField(this, "progressWriteSentinel", new WriteSentinel());
+    __publicField(this, "isTopSheet", true);
+    // Pooled payload — identity documented in SheetEventMap.progress JSDoc;
+    // consumers must not retain across frames.
+    __publicField(this, "progressPayload", {
+      value: 0,
+      size: 0
+    });
+    // Pooled buffer for `getDragContext()` — onMove calls this 60-120×/s.
+    // Inner `range` object identity is also stable (mutated in place).
+    __publicField(this, "dragContextBuf", {
+      size: 0,
+      maxAxisSize: 0,
+      range: { min: 0, max: 0 },
+      rubberBandEnabled: false
+    });
+    __publicField(this, "bus", createEventBus());
+    __publicField(this, "persistKey");
+    __publicField(this, "linkedSheets", []);
+    __publicField(this, "scrollCache");
+    // Single LIFO stack for ALL destroy-only teardowns. Plugins (added last)
+    // tear down first before the infrastructure they depend on. Toggle-semantic
+    // listeners (focus-trap / scroll-lock / scrim tap-to-close) stay as named
+    // fields on their controllers.
+    __publicField(this, "teardowns", new TeardownStack());
+    // Pre-computed transform template — built once per engine since `mode` is
+    // fixed for its lifetime. Avoids the 4-arm switch at 60-120 Hz.
+    __publicField(this, "transformTemplate");
+    const resolved = resolveEngineOptions(opts, {
+      shouldApplyInertSiblings: () => {
+        if (typeof document === "undefined") return false;
+        const bodyChildren = Array.from(document.body.children);
+        return bodyChildren.some(
+          (c) => c === opts.element || c.contains(opts.element)
+        );
+      }
+    });
+    this.element = opts.element;
+    this.handle = opts.handle ?? opts.element;
+    this.scrollContainer = opts.scrollContainer;
+    this.backdrop = opts.backdrop;
+    this.screenComponent = opts.screenComponent;
+    this.mode = resolved.mode;
+    this.transformTemplate = buildTransformTemplate(this.mode);
+    this.aria = new AriaSliderWriter(this.handle, this.mode);
+    this.flickVelocity = resolved.flickVelocity;
+    this.dragThreshold = resolved.dragThreshold;
+    this.rubberBandEnabled = resolved.rubberBandEnabled;
+    this.scrim = new ScrimController(
+      {
+        mode: this.mode,
+        screenComponent: this.screenComponent,
+        backdrop: this.backdrop,
+        isDestroyed: () => this.destroyed,
+        isTopSheet: () => this.isTopSheet,
+        getAllowedIds: () => this.snaps.getAllowedIds().slice(),
+        getResolvedSnaps: () => this.snaps.getResolvedSnaps().slice(),
+        snapTo: (id) => {
+          void this.snapTo(id);
+        }
+      },
+      resolved.scrim
+    );
+    this.animation = new AnimationRunner(
+      {
+        element: this.element,
+        getRootEl: () => this.rootEl,
+        applySize: (size) => this.applySize(size),
+        getSize: () => this.size,
+        // Optional chain protects synthetic test paths that drive animateTo
+        // before attach() (gesture is constructed there).
+        isDragging: () => this.gesture?.isDragging ?? false
+      },
+      resolved.animation
+    );
+    this.lifecycle = new LifecycleController(
+      {
+        element: this.element,
+        close: () => this.close()
+      },
+      resolved.lifecycle
+    );
+    this.closeOnBack = resolved.closeOnBack;
+    this.routedTo = opts.routedTo;
+    this.snapPointsRaw = opts.snapPoints;
+    this.persistKey = opts.persistKey;
+    if (opts.linkedSheets) {
+      this.linkedSheets = opts.linkedSheets;
+    }
+    this.activeId = resolved.initialId;
+    auditVhUsage(this.snapPointsRaw);
+    this.rootEl = this.element.closest(".bs-root");
+    this.snaps = new SnapResolver(
+      this.snapPointsRaw,
+      resolved.initialAllowed,
+      this.mode,
+      () => this.handle.offsetHeight,
+      (maxAxisSize) => {
+        this.element.style[layoutAxis(this.mode)] = `${maxAxisSize}px`;
+      }
+    );
+    const initial = this.snaps.findById(this.activeId);
+    if (initial) this.size = initial.size;
+    this.applySize(this.size);
+    this.updateAriaSlider();
+    this.scrollCache = createScrollCache({
+      scrollContainer: this.scrollContainer,
+      getMaxAxisSize: () => this.snaps.getMaxAxisSize()
+    });
+    this.attach();
+    this.registerInStack();
+    if (this.snaps.getMaxAxisSize() === 0 && typeof IntersectionObserver !== "undefined" && typeof document !== "undefined") {
+      const io = new IntersectionObserver((entries) => {
+        for (const entry of entries) {
+          if (!entry.isIntersecting) continue;
+          if (this.destroyed) return;
+          this.snaps.recompute();
+          const current = this.snaps.findById(this.activeId);
+          if (current) {
+            this.size = current.size;
+            this.applySize(this.size);
+            this.updateAriaSlider();
+          }
+          io.disconnect();
+          return;
+        }
+      });
+      io.observe(this.element);
+      this.teardowns.add(() => io.disconnect());
+    }
+    if (this.persistKey) {
+      this.teardowns.add(installPersist(this, this.persistKey));
+    }
+    this.teardowns.add(
+      installAutoCollapse({
+        ms: opts.autoCollapseAfter,
+        isDestroyed: () => this.destroyed,
+        isDragging: () => this.gesture?.isDragging ?? false,
+        getAllowedIds: () => this.snaps.getAllowedIds().slice(),
+        getActiveId: () => this.activeId,
+        resolveSnap: (id) => this.snaps.findById(id),
+        snapTo: (id) => {
+          void this.snapTo(id);
+        },
+        on: (event, fn) => this.on(event, fn)
+      })
+    );
+    this.teardowns.add(
+      installRoute({
+        routedTo: this.routedTo,
+        closeOnBack: this.closeOnBack,
+        isTopSheet: () => this.isTopSheet,
+        getSize: () => this.size,
+        isDestroyed: () => this.destroyed,
+        close: () => this.close(),
+        on: (event, fn) => this.on(event, fn),
+        sheetId: this.id
+      })
+    );
+    if (this.size > 0) {
+      this.handleOpen();
+    }
+  }
+  get state() {
+    return {
+      size: this.size,
+      activeId: this.activeId,
+      isDragging: this.gesture?.isDragging ?? false,
+      isAnimating: this.animation.isAnimating,
+      progress: this.computeProgress(this.size)
+    };
+  }
+  on(event, fn) {
+    return this.bus.on(event, fn);
+  }
+  /**
+   * Register a plugin. `install` runs synchronously; if it returns a function,
+   * it's captured for teardown during `destroy()`. No-op if already destroyed
+   * — installing into a torn-down engine would leak listeners.
+   *
+   * Throws from `plugin.install` are caught and rethrown via `queueMicrotask`
+   * so a buggy plugin can't take the engine down with it: the engine stays
+   * usable, sibling plugins still install, and the error surfaces in dev tools
+   * on the next tick instead of being swallowed. Mirrors the per-fn isolation
+   * model used for teardowns.
+   *
+   * Plugins that accept the second `scope` argument get transactional cleanup:
+   * push partial-install cleanups via `scope.add(fn)` and the engine drains
+   * them on throw, OR merges them into destroy-time teardowns on success.
+   */
+  use(plugin) {
+    if (this.destroyed) {
+      console.warn(
+        `[BottomSheet] use("${plugin.name}") called on destroyed engine \u2014 ignored.`
+      );
+      return this;
+    }
+    const scoped = [];
+    const scope = {
+      // typeof check — not just truthiness — so a JS-only plugin pushing a
+      // bogus value is silently rejected instead of queueing a confusing
+      // TypeError on destroy() drain.
+      add: (fn) => {
+        if (typeof fn === "function") scoped.push(fn);
+      }
+    };
+    let teardown;
+    try {
+      teardown = plugin.install(this, scope);
+    } catch (err) {
+      for (let i = scoped.length - 1; i >= 0; i--) {
+        try {
+          scoped[i]();
+        } catch (cleanupErr) {
+          queueMicrotask(() => {
+            throw cleanupErr;
+          });
+        }
+      }
+      queueMicrotask(() => {
+        throw err;
+      });
+      return this;
+    }
+    for (const fn of scoped) this.teardowns.add(fn);
+    if (typeof teardown === "function") {
+      this.teardowns.add(teardown);
+    }
+    return this;
+  }
+  /**
+   * Replace the linked-sheets list at runtime. Use when peer engines aren't
+   * available at construction time (mounted later in the tree). The wiring
+   * to the `open` event is independent of this list — it reads `linkedSheets`
+   * lazily on emit, so this setter is a simple field swap.
+   */
+  setLinkedSheets(sheets) {
+    if (this.destroyed) return;
+    this.linkedSheets = sheets;
+  }
+  /** Read-only view of the current allow-list, for cross-sheet target negotiation. */
+  getAllowedIds() {
+    return this.snaps.getAllowedIds().slice();
+  }
+  /**
+   * Animate to a snap point by id. Resolves when the animation completes.
+   *
+   * Two call shapes:
+   * ```ts
+   * engine.snapTo("full");                           // default velocity
+   * engine.snapTo("full", 0.5);                      // px/ms initial velocity
+   * engine.snapTo("full", { velocity: 0.5, signal }); // abortable
+   * ```
+   *
+   * When `opts.signal` is provided, calling `controller.abort()` cancels the
+   * in-flight tween/spring and the returned promise resolves without firing
+   * `snap`. The captured `AbortSignal` is checked after each await so external
+   * aborts ride the same cycle invariant as internal ones (resize, destroy,
+   * concurrent snapTo).
+   */
+  async snapTo(id, velocityOrOpts = 0, _skipBeforeSnap = false) {
+    if (this.destroyed) return;
+    const opts = typeof velocityOrOpts === "object" ? velocityOrOpts : { velocity: velocityOrOpts };
+    const velocityPxPerMs = opts.velocity ?? 0;
+    const externalSignal = opts.signal;
+    if (externalSignal?.aborted) return;
+    const target = this.snaps.findById(id);
+    if (!target) {
+      console.warn(`[BottomSheet] unknown snap id: ${id}`);
+      return;
+    }
+    if (!this.snaps.getAllowedIds().includes(id)) {
+      console.warn(`[BottomSheet] snap "${id}" is not in allowed list`);
+      return;
+    }
+    if (!_skipBeforeSnap && this.emitBeforeSnap(target, this.activeId)) {
+      return;
+    }
+    const signal = this.newCycle();
+    const onExternalAbort = () => {
+      this.animation.cancel();
+      this.newCycle();
+    };
+    externalSignal?.addEventListener("abort", onExternalAbort, { once: true });
+    const wasClosed = this.size === 0;
+    const previousId = this.activeId;
+    const previousSize = this.size;
+    this.scrollCache.cache(previousId, previousSize, target.size);
+    this.activeId = id;
+    if (this.animation.viewTransitionsAvailable) {
+      this.currentViewTransition?.skipTransition?.();
+      const vt = document.startViewTransition(() => {
+        this.applySize(target.size);
+      });
+      this.currentViewTransition = vt;
+      try {
+        await vt.finished;
+      } catch {
+      }
+      if (this.currentViewTransition === vt) this.currentViewTransition = null;
+    } else {
+      await this.animation.animateTo(target.size, velocityPxPerMs);
+    }
+    externalSignal?.removeEventListener("abort", onExternalAbort);
+    if (signal.aborted) return;
+    this.scrollCache.restore(id, previousSize, target.size);
+    this.updateAriaSlider();
+    this.emit("snap", { id, size: target.size });
+    if (wasClosed && target.size > 0) {
+      this.emit("open", { id });
+      this.handleOpen();
+      notifyLinkedSheets(this.linkedSheets, this);
+    }
+    if (target.size === 0) {
+      this.emit("close", void 0);
+      this.handleClose();
+    }
+  }
+  /**
+   * Drive the sheet to an arbitrary px size, bypassing snap matching.
+   * Useful for preview scrubs, animation chaining, or programmatic gestures.
+   * Animates with the configured spring/tween. Resolves when the animation
+   * completes. Does NOT update `activeId` — call `snapTo(id)` after to commit.
+   *
+   * Unlike `snapTo`, this does not fire `before-snap` (it isn't a snap commit)
+   * nor `snap` (the sheet isn't settling to a known snap). `progress` events
+   * still fire via applySize. Target is clamped to `[0, maxAxisSize]`.
+   */
+  async dragTo(targetSize, velocityOrOpts = 0) {
+    if (this.destroyed) return;
+    const opts = typeof velocityOrOpts === "object" ? velocityOrOpts : { velocity: velocityOrOpts };
+    const velocityPxPerMs = opts.velocity ?? 0;
+    const externalSignal = opts.signal;
+    if (externalSignal?.aborted) return;
+    this.newCycle();
+    const onExternalAbort = () => {
+      this.animation.cancel();
+      this.newCycle();
+    };
+    externalSignal?.addEventListener("abort", onExternalAbort, { once: true });
+    const clamped = Math.max(0, Math.min(targetSize, this.snaps.getMaxAxisSize()));
+    await this.animation.animateTo(clamped, velocityPxPerMs);
+    externalSignal?.removeEventListener("abort", onExternalAbort);
+    if (this.destroyed || externalSignal?.aborted) return;
+  }
+  open(id) {
+    if (this.destroyed) return Promise.resolve();
+    const target = id ?? this.snaps.getAllowedIds().find((a) => a !== "closed") ?? this.activeId;
+    return this.snapTo(target);
+  }
+  close() {
+    if (this.destroyed) return Promise.resolve();
+    const closedId = this.snapPointsRaw.find((p) => p.id === "closed")?.id ?? this.snaps.getAllowedIds()[0];
+    return this.snapTo(closedId ?? this.activeId);
+  }
+  setAllowed(ids, snap) {
+    if (this.destroyed) return;
+    const willSnap = snap !== void 0 && ids.includes(snap) || !ids.includes(this.activeId) && ids.length > 0;
+    if (!willSnap) {
+      this.animation.cancel();
+      this.newCycle();
+    }
+    this.snaps.setAllowedIds(ids);
+    this.updateAriaSlider();
+    if (snap && ids.includes(snap)) {
+      void this.snapTo(
+        snap,
+        0,
+        /* internal */
+        true
+      );
+    } else if (!ids.includes(this.activeId)) {
+      const fallback = ids[0];
+      if (fallback) void this.snapTo(
+        fallback,
+        0,
+        /* internal */
+        true
+      );
+    }
+  }
+  setBackdropRange(range) {
+    this.scrim.setBackdropRange(range, () => this.applySize(this.size));
+  }
+  setScreenRange(range) {
+    this.scrim.setScreenRange(range, () => this.applySize(this.size));
+  }
+  setScrimColor(color) {
+    this.scrim.setScrimColor(color);
+  }
+  setScrimBlur(blur) {
+    this.scrim.setScrimBlur(blur);
+  }
+  setScrimInteractive(interactive) {
+    this.scrim.setScrimInteractive(interactive);
+  }
+  /**
+   * Batch-update multiple scrim fields in one call. Apply order is:
+   *   1. `preset` — fills baseline color/blur/range/interactive.
+   *   2. `mode` — re-positions the scrim (fixed inset / clear / hide).
+   *   3. `enabled` — flips the opacity contribution on/off.
+   *   4. `tapToClose` — installs/tears the click listener.
+   *   5. `color` / `blur` / `interactive` / `range` — explicit overrides.
+   *   6. ONE `applySize` so the per-frame opacity stays consistent.
+   *
+   * Performance: collecting changes here (vs calling individual setters)
+   * avoids repeated `applySize` calls during a multi-field swap. Setters
+   * called here suppress their own internal `applySize` either by passing
+   * through fast-paths (mode/enabled no-op when value unchanged) or by
+   * being visual-only (color/blur/interactive don't influence opacity).
+   */
+  setScrim(opts) {
+    this.scrim.setScrim(opts, () => this.applySize(this.size));
+  }
+  setScrimMode(mode) {
+    this.scrim.setScrimMode(mode, () => this.applySize(this.size));
+  }
+  setScrimTapToClose(enabled) {
+    this.scrim.setScrimTapToClose(enabled);
+  }
+  setScrimEnabled(enabled) {
+    this.scrim.setScrimEnabled(enabled, () => this.applySize(this.size));
+  }
+  setScrimOverlay(opts) {
+    return this.scrim.setScrimOverlay(opts);
+  }
+  /**
+   * Read-only snapshot of scrim state. Use the `setScrim*` setters to mutate.
+   * Stable public API — internals (e.g. cached opacity sentinels) are NOT
+   * exposed so consumers can't accidentally couple to ScrimController shape.
+   */
+  getScrimState() {
+    return { mode: this.scrim.scrimMode, enabled: this.scrim.scrimEnabled };
+  }
+  setSnapPoints(points, allowed) {
+    if (this.destroyed) return;
+    this.animation.cancel();
+    this.newCycle();
+    this.snapPointsRaw = points;
+    auditVhUsage(points);
+    this.snaps.setRaw(points);
+    if (allowed) this.snaps.setAllowedIds(allowed);
+    this.scrollCache.clear();
+    this.scrim.invalidateOpacityCache();
+    const current = this.snaps.findById(this.activeId);
+    if (current) {
+      this.applySize(current.size);
+    }
+    this.updateAriaSlider();
+  }
+  destroy() {
+    this.destroyed = true;
+    this.currentAbort.abort();
+    this.currentViewTransition?.skipTransition?.();
+    this.currentViewTransition = null;
+    this.bus.clear();
+    this.animation.cancel();
+    this.gesture?.forceClearDragState();
+    this.teardowns.drain();
+    this.scrim.destroy();
+    this.animation.destroy();
+    this.lifecycle.destroy();
+    if (this.backdrop) {
+      this.backdrop.style.opacity = "";
+      this.backdrop.style.pointerEvents = "";
+    }
+    if (this.screenComponent) {
+      this.screenComponent.style.opacity = "";
+      this.screenComponent.style.display = "";
+    }
+    this.sizeWriteSentinel.invalidate();
+    this.progressWriteSentinel.invalidate();
+  }
+  emit(event, payload) {
+    this.bus.emit(event, payload);
+  }
+  /**
+   * Abort the current cycle's signal and replace the controller. Returns the
+   * fresh signal so the caller can capture it locally before any await — when
+   * a future newCycle() / destroy aborts our controller, the captured signal
+   * flips to aborted and post-await guards short-circuit.
+   */
+  newCycle() {
+    this.currentAbort.abort();
+    this.currentAbort = new AbortController();
+    return this.currentAbort.signal;
+  }
+  /**
+   * Fire `before-snap` and report whether a listener cancelled it. The
+   * `cancel()` callback exposed to listeners is frozen after the synchronous
+   * emit phase so async callers can't silently miss — they get a console
+   * warning. Returns `true` when cancelled so callers can early-return /
+   * spring-back without re-implementing the cancel/frozen pattern.
+   */
+  emitBeforeSnap(target, previousId) {
+    let cancelled = false;
+    let frozen = false;
+    this.emit("before-snap", {
+      id: target.id,
+      size: target.size,
+      previousId,
+      cancel: () => {
+        if (frozen) {
+          console.warn(
+            "[BottomSheet] before-snap.cancel() called asynchronously \u2014 ignored. cancel() must be invoked synchronously inside the listener."
+          );
+          return;
+        }
+        cancelled = true;
+      }
+    });
+    frozen = true;
+    return cancelled;
+  }
+  recomputeSnaps() {
+    const seen = /* @__PURE__ */ new Set();
+    for (const p of this.snapPointsRaw) {
+      if (seen.has(p.id)) {
+        console.warn(
+          `[BottomSheet] duplicate snap id "${p.id}" \u2014 only the first occurrence is reachable.`
+        );
+      }
+      seen.add(p.id);
+    }
+    this.snaps.setRaw(this.snapPointsRaw);
+    this.scrim.invalidateOpacityCache();
+  }
+  /**
+   * Memoised `allowedRange()` — delegates to SnapResolver which owns the cache.
+   * Engine wrapper kept so existing call sites don't all need updating;
+   * resolver-level memoization survives across method invocations.
+   */
+  getAllowedRange() {
+    return this.snaps.getAllowedRange();
+  }
+  /**
+   * Write ARIA slider value attributes onto the handle so the engine itself
+   * is the source of truth for screen-reader announcements. Called from the
+   * constructor and from every code path that mutates `activeId` /
+   * `allowedIds`. WAI-ARIA 1.2 requires `aria-valuenow` for `role="slider"` —
+   * without it screen readers can't announce drag/snap progress to keyboard
+   * + AT users (WCAG 4.1.2 Name, Role, Value).
+   *
+   * Engine does NOT set `role="slider"` itself — that's the adapter's or
+   * consumer markup's responsibility. We only decorate with dynamic values.
+   *
+   * Empty allowed-list is malformed input (settable via `setAllowed([])`);
+   * short-circuit to remove ARIA value attributes so screen readers see a
+   * no-value slider rather than a degenerate `min=max=now=0` (WAI-ARIA 1.2
+   * requires `valuemax > valuemin` for `role="slider"`).
+   */
+  updateAriaSlider() {
+    this.aria.setValue(this.snaps.getAllowedIds(), this.activeId);
+  }
+  registerInStack() {
+    this.teardowns.add(sheetStack.push({
+      id: this.id,
+      setZIndex: (z) => {
+        this.element.style.zIndex = String(z);
+        if (this.backdrop) this.backdrop.style.zIndex = String(z - 1);
+      },
+      setIsTop: (isTop) => {
+        this.isTopSheet = isTop;
+        if (this.backdrop) {
+          this.backdrop.style.display = isTop ? "" : "none";
+        }
+      }
+    }));
+  }
+  attach() {
+    this.gesture = new GestureController({
+      handle: this.handle,
+      element: this.element,
+      mode: this.mode,
+      getRoot: () => this.rootEl,
+      // Single coalesced reader — narrows the DI surface and removes 3 getter
+      // dispatches per onMove frame at 60-120Hz. Returns a SHARED buffer
+      // (this.dragContextBuf) — see field JSDoc for the retention contract.
+      // Inner `range` object is mutated in place too so callers caching its
+      // identity between frames stay valid.
+      getDragContext: () => {
+        const buf = this.dragContextBuf;
+        const r = this.getAllowedRange();
+        buf.size = this.size;
+        buf.maxAxisSize = this.snaps.getMaxAxisSize();
+        buf.range.min = r.min;
+        buf.range.max = r.max;
+        buf.rubberBandEnabled = this.rubberBandEnabled;
+        return buf;
+      },
+      cancelAnimation: () => this.animation.cancel(),
+      applySize: (size) => this.applySize(size),
+      animateTo: (size, velocity) => this.animation.animateTo(size, velocity),
+      settleAfterDrag: (delta, velocity, kind) => this.settleAfterDrag(delta, velocity, kind),
+      emit: (event, payload) => this.emit(event, payload),
+      listenerCount: (event) => this.bus.listenerCount(event)
+    });
+    this.teardowns.add(this.gesture.install());
+    try {
+      this.attachFeatures();
+    } catch (err) {
+      this.teardowns.drain();
+      try {
+        this.scrim.destroy();
+      } catch (destroyErr) {
+        queueMicrotask(() => {
+          throw destroyErr;
+        });
+      }
+      try {
+        this.animation.destroy();
+      } catch (destroyErr) {
+        queueMicrotask(() => {
+          throw destroyErr;
+        });
+      }
+      try {
+        this.lifecycle.destroy();
+      } catch (destroyErr) {
+        queueMicrotask(() => {
+          throw destroyErr;
+        });
+      }
+      this.destroyed = true;
+      throw err;
+    }
+  }
+  attachFeatures() {
+    if (this.scrollContainer) {
+      this.teardowns.add(installContentSwipe({
+        container: this.scrollContainer,
+        isDragging: () => this.gesture?.isDragging ?? false,
+        isAnimating: () => this.animation.isAnimating,
+        getAllowedIds: () => this.snaps.getAllowedIds(),
+        getActiveId: () => this.activeId,
+        snapTo: (id) => {
+          void this.snapTo(id);
+        }
+      }));
+    }
+    if (typeof window !== "undefined") {
+      this.teardowns.add(installResizeObserver({
+        element: this.element,
+        getMode: () => this.mode,
+        isDestroyed: () => this.destroyed,
+        isDragging: () => this.gesture?.isDragging ?? false,
+        resolveActiveSnap: () => this.snaps.findById(this.activeId),
+        getMaxAxisSize: () => this.snaps.getMaxAxisSize(),
+        getSize: () => this.size,
+        setMaxAxisSize: (size) => {
+          this.snaps.setMaxAxisSize(size);
+        },
+        setSize: (size) => {
+          this.size = size;
+        },
+        recomputeSnaps: () => this.recomputeSnaps(),
+        applySize: (size) => this.applySize(size),
+        cancelInFlight: () => {
+          this.animation.cancel();
+        },
+        newCycle: () => {
+          this.newCycle();
+        }
+      }));
+      if (this.lifecycle.closeOnEscape) {
+        const onKey = (e) => {
+          if (this.destroyed) return;
+          if (e.key === "Escape" && this.isTopSheet && this.size > 0) {
+            void this.close();
+          }
+        };
+        document.addEventListener("keydown", onKey);
+        this.teardowns.add(
+          () => document.removeEventListener("keydown", onKey)
+        );
+      }
+      this.teardowns.add(installVisualViewport({
+        element: this.element,
+        isVerticalAxis: () => this.mode === "bottom" || this.mode === "top",
+        isDestroyed: () => this.destroyed,
+        isDragging: () => this.gesture?.isDragging ?? false,
+        recomputeSnaps: () => this.recomputeSnaps(),
+        resolveActiveSnap: () => this.snaps.findById(this.activeId),
+        getMaxAxisSize: () => this.snaps.getMaxAxisSize(),
+        getSize: () => this.size,
+        setMaxAxisSize: (size) => {
+          this.snaps.setMaxAxisSize(size);
+        },
+        setSize: (size) => {
+          this.size = size;
+        },
+        applySize: (size) => this.applySize(size)
+      }));
+    }
+    this.teardowns.add(installSliderKeyboard({
+      handle: this.handle,
+      mode: this.mode,
+      isDestroyed: () => this.destroyed,
+      getAllowedIds: () => this.snaps.getAllowedIds(),
+      getActiveId: () => this.activeId,
+      snapTo: (id) => {
+        void this.snapTo(id);
+      }
+    }));
+    this.scrim.attach();
+  }
+  settleAfterDrag(delta, velocity, kind = "touch") {
+    const signal = this.newCycle();
+    const target = this.snaps.findDragSettleTarget({
+      delta,
+      velocity,
+      pointerKind: kind,
+      size: this.size,
+      activeId: this.activeId,
+      flickVelocity: this.flickVelocity,
+      dragThreshold: this.dragThreshold
+    });
+    if (!target) return;
+    const previousId = this.activeId;
+    if (this.emitBeforeSnap(target, previousId)) {
+      const restore = this.snaps.findById(previousId);
+      if (restore) {
+        void this.animation.animateTo(restore.size, 0);
+      }
+      return;
+    }
+    const previousSize = this.size;
+    this.scrollCache.cache(previousId, previousSize, target.size);
+    this.activeId = target.id;
+    void this.animation.animateTo(target.size, velocity).then(() => {
+      if (signal.aborted) return;
+      this.scrollCache.restore(target.id, previousSize, target.size);
+      this.updateAriaSlider();
+      this.emit("snap", { id: target.id, size: target.size });
+      this.haptic();
+      if (previousId === "closed" && target.size > 0) {
+        this.emit("open", { id: target.id });
+        this.handleOpen();
+      }
+      if (target.size === 0) {
+        this.emit("close", void 0);
+        this.handleClose();
+      }
+    });
+  }
+  /** Trigger a brief haptic tick (iOS Safari + Android Chrome support). */
+  haptic() {
+    if (typeof navigator !== "undefined" && "vibrate" in navigator) {
+      try {
+        navigator.vibrate(HAPTIC_DURATION_MS);
+      } catch {
+      }
+    }
+  }
+  applySize(size) {
+    this.size = size;
+    const offset = this.snaps.getMaxAxisSize() - size;
+    const style = this.element.style;
+    style.transform = this.transformTemplate(offset);
+    if (this.sizeWriteSentinel.shouldWrite(size, SIZE_WRITE_EPSILON)) {
+      style.setProperty("--bs-size", `${size}px`);
+    }
+    const progress = this.computeProgress(size);
+    const progressChanged = this.progressWriteSentinel.shouldWrite(
+      progress,
+      OPACITY_WRITE_EPSILON
+    );
+    if (progressChanged) {
+      style.setProperty("--bs-progress", String(progress));
+    }
+    this.scrim.applyOpacity(progress, progressChanged);
+    if (progressChanged && this.bus.listenerCount("progress") > 0) {
+      this.progressPayload.value = progress;
+      this.progressPayload.size = size;
+      this.emit("progress", this.progressPayload);
+    }
+  }
+  computeProgress(size) {
+    const { min, max } = this.getAllowedRange();
+    if (max <= min) return 0;
+    return Math.min(Math.max((size - min) / (max - min), 0), 1);
+  }
+  handleOpen() {
+    try {
+      this.lifecycle.install();
+    } catch (err) {
+      if (!this.destroyed) this.newCycle();
+      this.handleClose();
+      this.applySize(0);
+      this.activeId = this.snapPointsRaw.find((p) => p.id === "closed")?.id ?? this.activeId;
+      this.size = 0;
+      queueMicrotask(() => {
+        throw err;
+      });
+    }
+  }
+  handleClose() {
+    this.lifecycle.release();
+  }
+};
+var BottomSheet = qwik.component$((props) => {
+  const sheetRef = qwik.useSignal();
+  const handleRef = qwik.useSignal();
+  const contentRef = qwik.useSignal();
+  const backdropRef = qwik.useSignal();
+  const initialActive = props.initial ?? props.snapPoints[0]?.id ?? "default";
+  const state = qwik.useStore({
+    size: 0,
+    activeId: initialActive,
+    isDragging: false,
+    isAnimating: false,
+    progress: 0
+  });
+  qwik.useVisibleTask$(({ cleanup }) => {
+    if (!sheetRef.value) return;
+    if (!handleRef.value || !contentRef.value) {
+      console.warn(
+        "[BottomSheet/qwik] handle or content ref missing at attach time \u2014 drag and content-swipe disabled. Make sure ref bindings render before useVisibleTask$ fires."
+      );
+    }
+    const engineOpts = {
+      element: sheetRef.value,
+      handle: handleRef.value,
+      scrollContainer: contentRef.value,
+      backdrop: props.backdrop !== false ? backdropRef.value : void 0,
+      mode: props.mode ?? "bottom",
+      // Widen literal-id back to string at the engine boundary — the engine
+      // is string-typed at runtime, the TId narrowing is a TS-only veneer.
+      snapPoints: props.snapPoints,
+      allowed: props.allowed,
+      initial: props.initial,
+      animation: props.animation,
+      spring: props.spring,
+      focusTrap: props.focusTrap,
+      closeOnEscape: props.closeOnEscape,
+      closeOnBack: props.closeOnBack,
+      lockBodyScroll: props.lockBodyScroll,
+      rubberBand: props.rubberBand,
+      backdropRange: props.backdropRange
+    };
+    const engine = new BottomSheetEngine(engineOpts);
+    const sync = () => {
+      const s = engine.state;
+      state.size = s.size;
+      state.activeId = s.activeId;
+      state.isDragging = s.isDragging;
+      state.isAnimating = s.isAnimating;
+      state.progress = s.progress;
+      props.onChange$?.(s);
+    };
+    sync();
+    engine.on("snap", (payload) => {
+      sync();
+      props.onSnap$?.(payload.id);
+    });
+    engine.on("dragstart", sync);
+    engine.on("dragend", sync);
+    cleanup(() => engine.destroy());
+  });
+  const showBackdrop = props.backdrop !== false;
+  const mode = props.mode ?? "bottom";
+  const ariaLabel = props.ariaLabel ?? "Bottom sheet";
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { class: "bs-root", children: [
+    showBackdrop ? /* @__PURE__ */ jsxRuntime.jsx("div", { class: "bs-backdrop", ref: backdropRef }) : null,
+    /* @__PURE__ */ jsxRuntime.jsxs(
+      "section",
+      {
+        class: "bs-sheet",
+        ref: sheetRef,
+        "data-mode": mode,
+        "data-active": state.activeId,
+        role: "dialog",
+        "aria-modal": props.focusTrap ? "true" : void 0,
+        "aria-label": ariaLabel,
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "div",
+            {
+              class: "bs-handle",
+              ref: handleRef,
+              role: "slider",
+              tabIndex: 0,
+              "aria-label": "Resize sheet",
+              children: /* @__PURE__ */ jsxRuntime.jsx(qwik.Slot, { name: "header" })
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx("div", { class: "bs-content", ref: contentRef, children: /* @__PURE__ */ jsxRuntime.jsx(qwik.Slot, {}) }),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { class: "bs-sr-only", role: "status", "aria-live": "polite", children: state.activeId })
+        ]
+      }
+    )
+  ] });
+});
+
+exports.BottomSheet = BottomSheet;
+//# sourceMappingURL=qwik.cjs.map
+//# sourceMappingURL=qwik.cjs.map