@leavepulse/ui 0.77.3 → 0.78.0

package/dist/composables/usePaintSelect.js

@@ -1,6 +1,7 @@
 import { ref, toValue, onMounted, onBeforeUnmount, readonly } from "vue";
 import { useHotkeys } from "./useHotkeys.js";
 import { scrollParent } from "./scroll.js";
+import { nodeWindow } from "./realm.js";
 const HOLD_MS = 320;
 const SLOP_PX = 8;
 const EDGE_PX = 40;
@@ -23,8 +24,9 @@ function usePaintSelect(options) {
     }
     return out;
   }
+  const hostWindow = () => options.root.value ? nodeWindow(options.root.value) : window;
   function keyAt(x, y) {
-    const item = document.elementFromPoint(x, y)?.closest("[data-paint-key]");
+    const item = options.root.value?.ownerDocument.elementFromPoint(x, y)?.closest("[data-paint-key]");
     if (!item || !options.root.value?.contains(item)) return void 0;
     return resolve(item.dataset.paintKey ?? "");
   }
@@ -45,11 +47,11 @@ function usePaintSelect(options) {
   function tick() {
     frame = 0;
     if (!stroke) return;
-    const box = stroke.scroller?.getBoundingClientRect() ?? { top: 0, bottom: window.innerHeight };
+    const box = stroke.scroller?.getBoundingClientRect() ?? { top: 0, bottom: hostWindow().innerHeight };
     const delta = stroke.y > box.bottom - EDGE_PX ? SCROLL_STEP : stroke.y < box.top + EDGE_PX ? -SCROLL_STEP : 0;
     if (delta) {
       if (stroke.scroller) stroke.scroller.scrollTop += delta;
-      else window.scrollBy(0, delta);
+      else hostWindow().scrollBy(0, delta);
       extend();
     }
     frame = requestAnimationFrame(tick);
@@ -61,7 +63,7 @@ function usePaintSelect(options) {
     const before = new Set(options.selection());
     stroke = { keys, anchor, paint: !before.has(key), before, x, y, scroller: scrollParent(options.root.value) };
     painting.value = true;
-    window.getSelection()?.removeAllRanges();
+    hostWindow().getSelection()?.removeAllRanges();
     if (options.root.value) options.root.value.style.userSelect = "none";
     extend();
     if (!frame) frame = requestAnimationFrame(tick);
@@ -138,22 +140,24 @@ function usePaintSelect(options) {
     ] : [],
     { scope: options.root }
   );
+  let listening = null;
   onMounted(() => {
-    window.addEventListener("pointermove", onMove);
-    window.addEventListener("pointerup", onUp);
-    window.addEventListener("pointercancel", onUp);
-    window.addEventListener("click", onClickCapture, true);
-    window.addEventListener("contextmenu", onContextMenu, true);
+    listening = hostWindow();
+    listening.addEventListener("pointermove", onMove);
+    listening.addEventListener("pointerup", onUp);
+    listening.addEventListener("pointercancel", onUp);
+    listening.addEventListener("click", onClickCapture, true);
+    listening.addEventListener("contextmenu", onContextMenu, true);
     options.root.value?.addEventListener("touchmove", onTouchMove, { passive: false });
   });
   onBeforeUnmount(() => {
     onUp();
     swallowClick = false;
-    window.removeEventListener("pointermove", onMove);
-    window.removeEventListener("pointerup", onUp);
-    window.removeEventListener("pointercancel", onUp);
-    window.removeEventListener("click", onClickCapture, true);
-    window.removeEventListener("contextmenu", onContextMenu, true);
+    listening?.removeEventListener("pointermove", onMove);
+    listening?.removeEventListener("pointerup", onUp);
+    listening?.removeEventListener("pointercancel", onUp);
+    listening?.removeEventListener("click", onClickCapture, true);
+    listening?.removeEventListener("contextmenu", onContextMenu, true);
     options.root.value?.removeEventListener("touchmove", onTouchMove);
   });
   return { onPointerDown, painting: readonly(painting) };

package/dist/composables/usePaletteCommands.d.ts

@@ -1,5 +1,6 @@
 import { type Directive, type MaybeRefOrGetter } from "vue";
 import type { Command } from "../components/LpCommandPalette.vue";
+import type { ContextMenuItemDef } from "../components/LpContextMenu.vue";
 export interface PaletteRegistration {
     commands: () => readonly Command[];
     priority: number;
@@ -30,6 +31,12 @@ export declare function usePaletteCommands(commands: MaybeRefOrGetter<readonly C
     scope?: PaletteScope;
 }): void;
 /** Manual definitions override a discovered command without changing its place. */
+/** A titled menu as one command of the palette, with its items inside. */
+export declare function useMenuPalette(menu: {
+    palette?: PaletteControlOptions;
+    title?: string;
+    items: ContextMenuItemDef[];
+}): void;
 export declare function mergePaletteCommands(discovered: readonly Command[], manual: readonly Command[]): Command[];
 export type PaletteControlOptions = false | {
     id?: string;

package/dist/composables/usePaletteCommands.js

@@ -1,4 +1,5 @@
-import { inject, toValue, onScopeDispose, getCurrentInstance, ref, onMounted, onUpdated, provide, shallowReactive, computed, shallowRef, useId, h } from "vue";
+import { useId, inject, toValue, onScopeDispose, provide, getCurrentInstance, ref, onMounted, onUpdated, computed, h, shallowReactive, shallowRef } from "vue";
+import { menuPaletteCommands } from "../components/commandPalette.js";
 import { useField, provideField } from "./useField.js";
 import { useLabels } from "./useLpConfig.js";
 function uniqueCommands(commands) {
@@ -73,6 +74,15 @@ function usePaletteCommands(commands, options = {}) {
   });
   onScopeDispose(unregister);
 }
+function useMenuPalette(menu) {
+  const scope = usePaletteScope();
+  const generated = useId();
+  usePaletteCommands(() => {
+    if (menu.palette === false || !menu.title || !menu.items.length) return [];
+    const id = `${scope?.id}/${menu.palette?.id ?? generated}`;
+    return [{ id, label: menu.palette?.label ?? menu.title, children: menuPaletteCommands(menu.items, id) }];
+  }, { automatic: true });
+}
 function mergePaletteCommands(discovered, manual) {
   const overrides = new Map(manual.map((command) => [command.id, command]));
   return uniqueCommands([...discovered.map((command) => overrides.get(command.id) ?? command), ...manual]);
@@ -219,6 +229,7 @@ export {
   mergePaletteCommands,
   providePaletteScope,
   suppressPaletteDiscovery,
+  useMenuPalette,
   usePaletteAction,
   usePaletteCommands,
   usePaletteControl,

package/dist/composables/usePersisted.d.ts

@@ -24,5 +24,15 @@ export interface PersistedOptions<T> {
  *
  * A changed key reads the new key's value, so one component instance can
  * follow the thing it shows (a drawer per record).
+ *
+ * Made for small preferences, and this is the contract:
+ * - JSON values only, `initial` included. A Map, Set or Date does not survive
+ *   the round trip, a key holding `undefined` is dropped, and a BigInt or a
+ *   cycle throws here, however `T` reads.
+ * - Every change walks the value and rewrites it whole, synchronously. A large
+ *   document wants its own saving: debounced, with dirty state and versions.
+ * - One owner per key. Two refs on one key do not see each other's writes
+ *   (the `storage` event only reaches other tabs) and the last write wins, so
+ *   share the ref instead.
  */
 export declare function usePersisted<T>(key: MaybeRefOrGetter<string | false | null | undefined>, initial: T, options?: PersistedOptions<T>): Ref<T>;

package/dist/composables/usePersisted.js

@@ -1,4 +1,4 @@
-import { ref, watch, toValue, getCurrentInstance, inject } from "vue";
+import { getCurrentInstance, toValue, inject, ref, watch } from "vue";
 import { LP_CONFIG } from "./useLpConfig.js";
 const browserStorage = {
   get(key) {

package/dist/composables/usePillTransition.d.ts

@@ -1,12 +1,12 @@
 import { type ComputedRef } from "vue";
 export type PillTransition = {
     duration: number;
-} | {
+} | Readonly<{
     type: "spring";
     stiffness: number;
     damping: number;
     mass?: number;
-};
+}>;
 export type PillFeel = "pill" | "float" | "layout";
 export declare function usePillTransition(feel?: PillFeel): ComputedRef<PillTransition>;
 /** The feels a pointer follower uses; "layout" is a motion-v layout move only. */

package/dist/composables/usePillTransition.js

@@ -1,10 +1,10 @@
 import { computed } from "vue";
 import { usePrefersReducedMotion } from "./useReducedMotion.js";
-const SPRING = {
-  pill: { type: "spring", stiffness: 520, damping: 40 },
-  float: { type: "spring", stiffness: 210, damping: 26 },
-  layout: { type: "spring", stiffness: 520, damping: 42, mass: 0.9 }
-};
+const SPRING = Object.freeze({
+  pill: Object.freeze({ type: "spring", stiffness: 520, damping: 40 }),
+  float: Object.freeze({ type: "spring", stiffness: 210, damping: 26 }),
+  layout: Object.freeze({ type: "spring", stiffness: 520, damping: 42, mass: 0.9 })
+});
 function usePillTransition(feel = "pill") {
   const reduceMotion = usePrefersReducedMotion();
   return computed(

package/dist/composables/useResizeObserver.js

@@ -1,3 +1,4 @@
+import { nodeWindow } from "./realm.js";
 import { watch, toValue, onScopeDispose } from "vue";
 function useResizeObserver(target, callback, options = {}) {
   const { immediate = false, ...observe } = options;
@@ -13,7 +14,7 @@ function useResizeObserver(target, callback, options = {}) {
       if (!el) return;
       if (immediate) callback(void 0, el);
       if (typeof ResizeObserver === "undefined") return;
-      observer = new ResizeObserver((entries) => {
+      observer = new (nodeWindow(el)).ResizeObserver((entries) => {
         const entry = entries[entries.length - 1];
         if (entry) callback(entry, el);
       });

package/dist/composables/useReveal.js

@@ -1,3 +1,4 @@
+import { nodeWindow } from "./realm.js";
 import { ref, watch, toValue, onBeforeUnmount } from "vue";
 import { prefersReducedMotion } from "./easing.js";
 function useReveal(options = {}) {
@@ -27,7 +28,7 @@ function useReveal(options = {}) {
         reveal();
         return;
       }
-      observer = new IntersectionObserver(
+      observer = new (nodeWindow(node)).IntersectionObserver(
         (entries) => {
           if (entries.some((entry) => entry.isIntersecting)) reveal();
         },

package/dist/composables/useRovingFocus.d.ts

@@ -13,9 +13,9 @@ export interface UseRovingFocusOptions {
     /**
      * Which axis the arrows follow. `vertical` (default) uses ↑↓, `horizontal`
      * uses ←→, `both` accepts either — for a grid whose wrapping the caller
-     * cannot describe here.
+     * cannot describe here. A ref or getter follows a list that changes axis.
      */
-    orientation?: "vertical" | "horizontal" | "both";
+    orientation?: MaybeRefOrGetter<"vertical" | "horizontal" | "both">;
     /** Wrap around at the ends instead of stopping. Default true. */
     loop?: boolean;
     /** Jump to an item by typing its first letters. Default true. */

package/dist/composables/useRovingFocus.js

@@ -1,5 +1,8 @@
 import { ref, computed, toValue, watch } from "vue";
+import { isTextEntry } from "./textEntry.js";
+import { isHTMLElement } from "./realm.js";
 const NON_TEXT_INPUTS = /* @__PURE__ */ new Set(["checkbox", "radio", "button", "submit", "reset", "range", "color", "file", "image"]);
+const ROW_FIELD = { select: true, inputType: (type) => !NON_TEXT_INPUTS.has(type) };
 const TYPEAHEAD_RESET_MS = 700;
 function useRovingFocus(items, options = {}) {
   const {
@@ -70,15 +73,11 @@ function useRovingFocus(items, options = {}) {
       }
     }
   }
-  function isTextEntry(target) {
-    if (!(target instanceof HTMLElement)) return false;
-    if (target.isContentEditable || target instanceof HTMLTextAreaElement || target instanceof HTMLSelectElement) return true;
-    return target instanceof HTMLInputElement && !NON_TEXT_INPUTS.has(target.type);
-  }
   function onKeydown(event) {
-    if (event.isComposing || isTextEntry(event.target)) return;
-    const vertical = orientation === "vertical" || orientation === "both";
-    const horizontal = orientation === "horizontal" || orientation === "both";
+    if (event.isComposing || isTextEntry(event.target, ROW_FIELD)) return;
+    const axis = toValue(orientation);
+    const vertical = axis === "vertical" || axis === "both";
+    const horizontal = axis === "horizontal" || axis === "both";
     switch (event.key) {
       case "ArrowDown":
         if (!vertical) return;
@@ -126,9 +125,8 @@ function useRovingFocus(items, options = {}) {
     }
   }
   watch(activeId, (id) => {
-    if (!id || typeof document === "undefined") return;
     const container = containerEl.value;
-    if (!container || !container.contains(document.activeElement)) return;
+    if (!id || !container || !container.contains(container.ownerDocument.activeElement)) return;
     const target = container.querySelector(
       `[data-roving-id="${CSS.escape(id)}"]`
     );
@@ -138,7 +136,7 @@ function useRovingFocus(items, options = {}) {
     containerEl.value = el;
   }
   const containerProps = computed(() => ({
-    ref: (el) => setContainer(el instanceof HTMLElement ? el : null),
+    ref: (el) => setContainer(isHTMLElement(el) ? el : null),
     onKeydown
   }));
   function itemProps(id) {

package/dist/composables/useScramble.js

@@ -1,13 +1,19 @@
 import { toValue, shallowRef, computed, watch, onScopeDispose } from "vue";
 import { scrambleFrame, planScramble, settledCells, SCRAMBLE_GLYPHS } from "../components/scramble.js";
 import { prefersReducedMotion } from "./easing.js";
+const SEED_MULTIPLIER = 16807;
+const SEED_MODULUS = 2147483647;
+function seededRandom(seed = 1) {
+  return () => (seed = seed * SEED_MULTIPLIER % SEED_MODULUS) / SEED_MODULUS;
+}
 function useScramble(source, options = {}) {
   const random = options.random ?? Math.random;
+  const firstRoll = options.random ?? seededRandom();
   const tick = options.tick ?? 50;
   const glyphs = () => toValue(options.glyphs) || SCRAMBLE_GLYPHS;
   const initial = toValue(source);
   const cells = shallowRef(
-    options.start === "masked" ? scrambleFrame(planScramble(initial, initial, { duration: 1, keep: options.keep }, random), 0, random, glyphs()) : settledCells(initial)
+    options.start === "masked" ? scrambleFrame(planScramble(initial, initial, { duration: 1, keep: options.keep }, firstRoll), 0, firstRoll, glyphs()) : settledCells(initial)
   );
   const running = shallowRef(false);
   const text = computed(() => cells.value.map((cell) => cell.char).join(""));

package/dist/composables/useShift.js

@@ -1,4 +1,5 @@
 import { ref, watch, toValue, onBeforeUnmount, nextTick } from "vue";
+import { nodeWindow, isElement } from "./realm.js";
 import { prefersReducedMotion } from "./easing.js";
 const TWEEN_MS = 160;
 const RETARGET_AFTER_MS = 40;
@@ -18,7 +19,7 @@ function useShift(options = {}) {
   const scrolled = /* @__PURE__ */ new Set();
   const rememberScroll = (event) => {
     const target = event.target;
-    if (target instanceof Element) scrolled.add(target);
+    if (isElement(target)) scrolled.add(target);
   };
   function readScroll() {
     const tops = /* @__PURE__ */ new Map();
@@ -72,7 +73,7 @@ function useShift(options = {}) {
     tweenStart = performance.now();
     resizing.value = true;
     clearTimeout(settleTimer);
-    const wait = prefersReducedMotion() ? 0 : toValue(options.duration) ?? TWEEN_MS;
+    const wait = prefersReducedMotion(nodeWindow(node)) ? 0 : toValue(options.duration) ?? TWEEN_MS;
     settleTimer = setTimeout(() => {
       inFlight = false;
       resizing.value = false;
@@ -125,12 +126,13 @@ function useShift(options = {}) {
         ro.disconnect();
         for (const child of Array.from(node.children)) ro.observe(child);
       };
-      if (typeof ResizeObserver !== "undefined") {
-        ro = new ResizeObserver(() => retune());
+      const win = nodeWindow(node);
+      if (typeof win.ResizeObserver !== "undefined") {
+        ro = new win.ResizeObserver(() => retune());
         watchChildren();
       }
-      if (typeof MutationObserver !== "undefined") {
-        mo = new MutationObserver(() => {
+      if (typeof win.MutationObserver !== "undefined") {
+        mo = new win.MutationObserver(() => {
           watchChildren();
           retune();
         });

package/dist/composables/useTilt.js

@@ -1,4 +1,5 @@
 import { computed, toValue, ref } from "vue";
+import { isHTMLElement } from "./realm.js";
 import { usePointerFrame } from "./usePointerFrame.js";
 import { usePrefersReducedMotion } from "./useReducedMotion.js";
 import { spotlightPoint } from "./useSpotlight.js";
@@ -21,7 +22,7 @@ function useTilt(source = {}) {
     }
   });
   function onPointerMove(e) {
-    if (e.currentTarget instanceof HTMLElement) target = e.currentTarget;
+    if (isHTMLElement(e.currentTarget)) target = e.currentTarget;
     pointer.move(e);
   }
   function onPointerEnter() {

package/dist/composables/useTween.js

@@ -1,6 +1,9 @@
-import { shallowRef, watch, toValue, onScopeDispose } from "vue";
+import { clamp } from "./clamp.js";
+import { useView } from "./useView.js";
+import { hasInjectionContext, shallowRef, watch, toValue, onScopeDispose } from "vue";
 import { durationToken, prefersReducedMotion, tokenEase } from "./easing.js";
 function useTween(source, mix, options = {}) {
+  const view = hasInjectionContext() ? useView() : null;
   const shown = shallowRef(source());
   let target = shown.value;
   let frame = 0;
@@ -11,18 +14,19 @@ function useTween(source, mix, options = {}) {
   watch(source, (to) => {
     if (options.equal?.(target, to)) return;
     target = to;
-    const ms = toValue(options.duration) ?? durationToken("duration-medium");
-    if (toValue(options.enabled) === false || ms <= 0 || prefersReducedMotion() || typeof requestAnimationFrame === "undefined") {
+    const scope = view?.value?.document;
+    const ms = toValue(options.duration) ?? durationToken("duration-medium", void 0, scope);
+    if (toValue(options.enabled) === false || ms <= 0 || prefersReducedMotion(view?.value?.window) || typeof requestAnimationFrame === "undefined") {
       stop();
       shown.value = to;
       return;
     }
     const from = shown.value;
-    const ease = options.ease ?? tokenEase("ease-emphasized");
+    const ease = options.ease ?? tokenEase("ease-emphasized", scope);
     const started = performance.now();
     stop();
     const step = (now) => {
-      const t = Math.min(1, Math.max(0, (now - started) / ms));
+      const t = clamp((now - started) / ms, 0, 1);
       shown.value = t < 1 ? mix(from, to, ease(t)) : to;
       frame = t < 1 ? requestAnimationFrame(step) : 0;
     };

package/dist/composables/useView.d.ts

@@ -1,4 +1,5 @@
 import { type ComputedRef } from "vue";
+export { isElement, isHTMLElement, isInputElement, isNode, nodeWindow } from "./realm";
 export interface LpView {
     window: Window;
     document: Document;

package/dist/composables/useView.js

@@ -1,4 +1,7 @@
 import { inject, computed, provide } from "vue";
+import { isNode } from "./realm.js";
+import { isElement, isHTMLElement, isInputElement, nodeWindow } from "./realm.js";
+import { isTextEntry } from "./textEntry.js";
 const LP_VIEW = /* @__PURE__ */ Symbol.for("lp-view");
 function provideView(view) {
   provide(LP_VIEW, view);
@@ -21,11 +24,15 @@ function usePortalTarget() {
 }
 const ORIGIN = "lpViewDocument";
 const FORWARDED = ["pointerdown", "pointerup", "click", "focusin", "keydown"];
+function typedHere(event) {
+  const printable = event.key.length === 1 && !event.ctrlKey && !event.metaKey;
+  return printable && isTextEntry(event.target, { select: true });
+}
 function forwardViewEvents(from, to) {
   const forward = (event) => {
     if (event.type === "keydown") {
       const key = event;
-      if (key.defaultPrevented || key.key !== "Escape" && !key.ctrlKey && !key.metaKey) return;
+      if (key.defaultPrevented || typedHere(key)) return;
     }
     const Copy = event.constructor;
     const copy = new Copy(event.type, event);
@@ -47,7 +54,7 @@ function originOf(event) {
   const marked = inner[ORIGIN];
   if (marked) return marked;
   const target = inner.target;
-  if (!target || typeof target.nodeType !== "number") return null;
+  if (!isNode(target)) return null;
   return target.nodeType === 9 ? target : target.ownerDocument;
 }
 function useOutsideGuard() {
@@ -59,6 +66,11 @@ function useOutsideGuard() {
 }
 export {
   forwardViewEvents,
+  isElement,
+  isHTMLElement,
+  isInputElement,
+  isNode,
+  nodeWindow,
   provideView,
   useOutsideGuard,
   usePortalTarget,

package/dist/composables/useZoomPan.js

@@ -1,3 +1,4 @@
+import { clamp } from "./clamp.js";
 import { ref, computed, toValue } from "vue";
 function useZoomPan(options = {}) {
   const min = options.min ?? 1;
@@ -17,9 +18,6 @@ function useZoomPan(options = {}) {
   function setViewport(el) {
     viewport = el;
   }
-  function clamp(value, lo, hi) {
-    return Math.min(hi, Math.max(lo, value));
-  }
   function clampPan() {
     if (!viewport) return;
     const rect = viewport.getBoundingClientRect();
@@ -116,7 +114,7 @@ function useZoomPan(options = {}) {
   const offset = computed(() => ({ x: x.value, y: y.value }));
   function setView(view) {
     if (view.scale !== void 0) {
-      scale.value = Math.min(maxOf(), Math.max(min, view.scale));
+      scale.value = clamp(view.scale, min, maxOf());
     }
     x.value = view.x;
     y.value = view.y;

package/dist/composables/windowing.d.ts

@@ -0,0 +1,40 @@
+import { type ComputedRef } from "vue";
+export interface WindowRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface WindowViewport {
+    width: number;
+    height: number;
+}
+export interface WindowBounds {
+    minWidth: number;
+    minHeight: number;
+}
+export type WindowDock = "left" | "right" | "top" | "bottom" | "full";
+export type WindowEdge = "n" | "s" | "e" | "w" | "ne" | "nw" | "se" | "sw";
+export declare const WINDOW_DOCKS: readonly WindowDock[];
+/** True for a stored rectangle that can still be used. */
+export declare function isWindowRect(value: unknown): value is WindowRect;
+/** Fit a rectangle on screen: no smaller than its bounds where there is room, never larger than the view. */
+export declare function clampRect(rect: WindowRect, viewport: WindowViewport, bounds: WindowBounds): WindowRect;
+/** Pull a moved rectangle onto the view's edges and the edges of other windows, when within `threshold`. */
+export declare function snapRect(rect: WindowRect, viewport: WindowViewport, others: readonly WindowRect[], threshold: number): WindowRect;
+/** Which dock a pointer at this point asks for: the top edge fills the view. */
+export declare function dockAt(x: number, y: number, viewport: WindowViewport, edge: number): WindowDock | null;
+/** The rectangle of a dock. `fraction` is the share of the view a side takes. */
+export declare function dockedRect(dock: WindowDock, viewport: WindowViewport, fraction: number): WindowRect;
+/** Drag one edge or corner; the opposite side stays put, also against the bounds and the view. */
+export declare function resizeRect(start: WindowRect, edge: WindowEdge, dx: number, dy: number, viewport: WindowViewport, bounds: WindowBounds): WindowRect;
+export interface WindowLayer {
+    /** Join the order, or come to its top. Ignored on the server, where nothing would release it. */
+    raise: () => void;
+    release: () => void;
+    /** Where the other open windows are, for snapping to. */
+    others: () => WindowRect[];
+    z: ComputedRef<string>;
+    top: ComputedRef<boolean>;
+}
+export declare function useWindowLayer(rect: () => WindowRect | null): WindowLayer;

package/dist/composables/windowing.js

@@ -0,0 +1,118 @@
+import { clamp } from "./clamp.js";
+import { ref, computed } from "vue";
+const WINDOW_DOCKS = ["left", "right", "top", "bottom", "full"];
+function isWindowRect(value) {
+  const rect = value;
+  return !!rect && [rect.x, rect.y, rect.width, rect.height].every((n) => typeof n === "number" && Number.isFinite(n)) && rect.width > 0 && rect.height > 0;
+}
+const between = (value, min, max) => Math.min(Math.max(value, min), Math.max(min, max));
+function clampRect(rect, viewport, bounds) {
+  const width = clamp(rect.width, bounds.minWidth, viewport.width);
+  const height = clamp(rect.height, bounds.minHeight, viewport.height);
+  return {
+    x: between(rect.x, 0, viewport.width - width),
+    y: between(rect.y, 0, viewport.height - height),
+    width,
+    height
+  };
+}
+function nearest(value, candidates, threshold) {
+  let best = value;
+  let distance = threshold;
+  for (const candidate of candidates) {
+    const gap = Math.abs(candidate - value);
+    if (gap <= distance) {
+      best = candidate;
+      distance = gap;
+    }
+  }
+  return best;
+}
+function snapRect(rect, viewport, others, threshold) {
+  const xs = [0, viewport.width - rect.width];
+  const ys = [0, viewport.height - rect.height];
+  for (const other of others) {
+    xs.push(other.x, other.x + other.width, other.x - rect.width, other.x + other.width - rect.width);
+    ys.push(other.y, other.y + other.height, other.y - rect.height, other.y + other.height - rect.height);
+  }
+  return { ...rect, x: nearest(rect.x, xs, threshold), y: nearest(rect.y, ys, threshold) };
+}
+function dockAt(x, y, viewport, edge) {
+  if (y <= edge) return "full";
+  if (x <= edge) return "left";
+  if (x >= viewport.width - edge) return "right";
+  if (y >= viewport.height - edge) return "bottom";
+  return null;
+}
+function dockedRect(dock, viewport, fraction) {
+  const { width, height } = viewport;
+  const across = Math.round(width * fraction);
+  const down = Math.round(height * fraction);
+  switch (dock) {
+    case "left":
+      return { x: 0, y: 0, width: across, height };
+    case "right":
+      return { x: width - across, y: 0, width: across, height };
+    case "top":
+      return { x: 0, y: 0, width, height: down };
+    case "bottom":
+      return { x: 0, y: height - down, width, height: down };
+    case "full":
+      return { x: 0, y: 0, width, height };
+  }
+}
+function resizeRect(start, edge, dx, dy, viewport, bounds) {
+  let { x, y, width, height } = start;
+  const right = start.x + start.width;
+  const bottom = start.y + start.height;
+  if (edge.includes("e")) width = between(start.width + dx, bounds.minWidth, viewport.width - start.x);
+  if (edge.includes("s")) height = between(start.height + dy, bounds.minHeight, viewport.height - start.y);
+  if (edge.includes("w")) {
+    x = between(start.x + dx, 0, right - bounds.minWidth);
+    width = right - x;
+  }
+  if (edge.includes("n")) {
+    y = between(start.y + dy, 0, bottom - bounds.minHeight);
+    height = bottom - y;
+  }
+  return { x, y, width, height };
+}
+const WINDOW_Z_ROOM = 20;
+const STATE_KEY = /* @__PURE__ */ Symbol.for("@leavepulse/ui:window-stack");
+const g = globalThis;
+const state = g[STATE_KEY] ??= { order: ref([]), nextId: 0, rects: /* @__PURE__ */ new Map() };
+function useWindowLayer(rect) {
+  const id = state.nextId++;
+  const order = state.order;
+  return {
+    raise: () => {
+      if (typeof window === "undefined") return;
+      state.rects.set(id, rect);
+      if (order.value[order.value.length - 1] === id) return;
+      order.value = [...order.value.filter((x) => x !== id), id];
+    },
+    release: () => {
+      state.rects.delete(id);
+      order.value = order.value.filter((x) => x !== id);
+    },
+    others: () => [...state.rects.entries()].flatMap(([other, read]) => {
+      const found = other === id ? null : read();
+      return found ? [found] : [];
+    }),
+    z: computed(() => {
+      const at = clamp(order.value.indexOf(id), 0, WINDOW_Z_ROOM - 1);
+      return `calc(var(--z-dropdown) - ${WINDOW_Z_ROOM - at})`;
+    }),
+    top: computed(() => order.value[order.value.length - 1] === id)
+  };
+}
+export {
+  WINDOW_DOCKS,
+  clampRect,
+  dockAt,
+  dockedRect,
+  isWindowRect,
+  resizeRect,
+  snapRect,
+  useWindowLayer
+};

package/dist/icons-all.js

@@ -1,3 +1,3 @@
 import lucide from "@iconify-json/lucide/icons.json";
-import { a as registerIconCollection } from "./chunks/icons-DMITlfw5.js";
+import { a as registerIconCollection } from "./chunks/icons-CYfcpSDS.js";
 registerIconCollection(lucide);

package/dist/icons.d.ts

@@ -1,6 +1,10 @@
 import { type IconifyJSON } from "@iconify/vue";
 /** Bumped whenever icons are registered, so rendered icons re-resolve. */
 export declare const iconsVersion: import("vue").Ref<number, number>;
+/** Names that could not be loaded, so an LpIcon can show its `fallback`. */
+export declare const failedIcons: import("vue").Reactive<Set<string>>;
+/** Load once, but forget a failure: a lost chunk must not fail every later icon too. */
+export declare function loadOnce<T>(load: () => Promise<T>): () => Promise<T>;
 /** Register a whole iconify collection (any prefix) for offline use. */
 export declare function registerIconCollection(collection: IconifyJSON): void;
 /**