@eifi1/ui-kit 0.51.7 → 0.53.0

package/dist/hooks/use-focus-trap.js

@@ -1,7 +1,7 @@
 "use client";
 import { useEffect, useLayoutEffect, useRef, useState } from "react";
-const FOCUSABLE = 'a[href],button:not([disabled]),textarea:not([disabled]),input:not([disabled]),select:not([disabled]),[tabindex]:not([tabindex="-1"])';
-const isTabStop = (el) => el.tabIndex >= 0 && !el.closest("[hidden],[inert]");
+import { tabStops } from "../lib/focus-left.js";
+import { firstTabStop, tabStops as tabStops2 } from "../lib/focus-left.js";
 const TRAP_ATTR = "data-focus-trap";
 function focusedElement() {
   return typeof document === "undefined" ? null : document.activeElement;
@@ -24,11 +24,11 @@ function useFocusTrap(containerRef, { active = true, restoreFocus = true, initia
       const owner = node.closest(`[${TRAP_ATTR}]`);
       return owner !== null && owner !== container;
     };
-    const tabbables = () => Array.from(container.querySelectorAll(FOCUSABLE)).filter(
+    const tabbables = () => tabStops(container, { includeSelf: false }).filter(
       // A tabbable inside a NESTED open overlay belongs to that overlay's trap, not
       // to this one — otherwise the outer list spans both panels and Tab from the
       // inner panel's last control wraps to the OUTER panel's first.
-      (el) => isTabStop(el) && !inNestedTrap(el)
+      (el) => !inNestedTrap(el)
     );
     const { initialFocus: how } = optsRef.current;
     const focused = document.activeElement;
@@ -69,6 +69,8 @@ function useFocusTrap(containerRef, { active = true, restoreFocus = true, initia
   }, [active, containerRef, opener]);
 }
 export {
+  firstTabStop,
+  tabStops2 as tabStops,
   useFocusTrap
 };
 //# sourceMappingURL=use-focus-trap.js.map

package/dist/hooks/use-focus-trap.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/hooks/use-focus-trap.ts"],"sourcesContent":["import { useEffect, useLayoutEffect, useRef, useState } from \"react\";\n\n/**\n * Keep keyboard focus inside an open overlay, and give it back when it closes.\n *\n * Extracted from `Modal`, which was the ONLY component in this package that did any of\n * this. Every other overlay — the full-bleed dialog a phone's row editor opens, the\n * picker sheet, the numpad, the tour card — declared `role=\"dialog\" aria-modal=\"true\"`\n * and then left focus on the page behind it. That is the worst of the two possible\n * bugs: assistive technology hides the page because of `aria-modal`, while the user's\n * focus is still down there in the part that is now hidden, so Tab walks through\n * controls the screen reader refuses to describe.\n *\n * What this does beyond Modal's original copy:\n *\n *   - **Recomputes the tabbable list on every Tab**, not once when the overlay opens.\n *     These panels have conditionally-rendered contents — a search box that appears\n *     once options load, a \"clear\" button that exists only while a filter is set — and\n *     a list captured at open time traps focus against elements that have since gone.\n *   - **Guards the restore target.** The element focused before opening may have left\n *     the DOM by the time the overlay closes (the row that owned the button was\n *     filtered away). Calling `.focus()` on a detached node silently drops focus to\n *     `<body>`, which for a keyboard user means losing their place in the page\n *     entirely. When the target is gone, focus falls back to the nearest thing that\n *     still exists rather than to nothing.\n *   - **Leaves an app's own autofocus alone** (0.33.1). React honours a child's\n *     `autoFocus` while it commits, and this hook's effect runs AFTER that commit, so\n *     focusing the container there took focus straight back off the field the app had\n *     asked for. See `initialFocus`.\n *   - **Nests.** An overlay can open another — a picker inside a dialog. Only the\n *     innermost trap handles a keystroke, and closing it hands control back to the one\n *     underneath. Innermost is decided by DOM containment rather than by mount order;\n *     see the note on `TRAP_ATTR` for why the obvious stack is wrong.\n *     `use-overlay-history.ts` reasons about the same nesting problem for the back\n *     button; this is the focus half of it.\n */\n\n/**\n * Candidate tab stops, in DOM order — narrowed by {@link isTabStop} to the ones a Tab\n * really reaches.\n *\n * The selector is the one `Modal` used. On its own it was not enough (round 0.34\n * BUG-4): only the bare `[tabindex]` clause excluded `-1`, so a `button`, an `input` or\n * a link taken out of the tab order still counted. A panel that ends in a roving grid —\n * the calendar's days, the month grid, the picker sheet's rows, every one of them `-1`\n * but the active cell — then had a \"last\" stop no Tab ever reaches: Tab from the real\n * last stop was not wrapped and walked out of the open panel, and Shift+Tab from the\n * first landed on a cell that is not a stop at all.\n */\nconst FOCUSABLE =\n  'a[href],button:not([disabled]),textarea:not([disabled]),input:not([disabled]),select:not([disabled]),[tabindex]:not([tabindex=\"-1\"])';\n\n/**\n * A stop the browser's own Tab would land on: in the tab order (`tabIndex` ≥ 0) and not\n * inside something `hidden` or `inert`. Removes only elements a native Tab never\n * reaches, so no correct order changes. `visibility: hidden` and closed `<details>` are\n * still not walked — they need layout, which this list has never read.\n */\nconst isTabStop = (el: HTMLElement): boolean => el.tabIndex >= 0 && !el.closest(\"[hidden],[inert]\");\n\n/**\n * Marks a container whose trap is currently active.\n *\n * \"Which trap is innermost?\" is answered by DOM CONTAINMENT, not by mount order. The\n * obvious implementation — a module-level stack pushed in the effect — is wrong, and\n * wrong in a way that passes a casual reading: React runs CHILD effects before PARENT\n * effects, so a nested overlay pushes first and the outer one ends up on top of the\n * stack, claiming to be innermost. The outer trap then handles the keystroke and wraps\n * focus to its own first element, jumping the user out of the picker they had open.\n *\n * An attribute on the live DOM cannot disagree with the DOM.\n */\nconst TRAP_ATTR = \"data-focus-trap\";\n\nexport interface FocusTrapOptions {\n  /** Trap only while this is true. Mount-time `true` is the common case. */\n  active?: boolean;\n  /** Return focus to whatever had it before the trap engaged. Default `true`. */\n  restoreFocus?: boolean;\n  /**\n   * What to focus when the trap engages. Default is the container itself, which is\n   * what `Modal` does and why: focusing the first FIELD pops the software keyboard on\n   * a phone the moment a dialog opens, before the user has asked to type.\n   * The container needs `tabIndex={-1}` for this to work.\n   *\n   * `\"container\"` and `\"first\"` both step aside when focus is ALREADY inside the\n   * container, on something other than the container itself. That is a child the app\n   * focused on purpose — an `autoFocus`, which React honours before this hook's effect\n   * runs — and the keyboard it brings up is the one the user was promised. Moving focus\n   * off it lost keksdose's create card its amount field the instant it got it, and on a\n   * phone the numpad sheet with it, which shows only while the field is focused (live\n   * #402). A function is the caller's explicit choice and is always followed.\n   */\n  initialFocus?: \"container\" | \"first\" | (() => HTMLElement | null);\n}\n\n/** Whatever has focus right now; nothing on the server, where there is no document. */\nfunction focusedElement(): Element | null {\n  return typeof document === \"undefined\" ? null : document.activeElement;\n}\n\nexport function useFocusTrap(\n  containerRef: React.RefObject<HTMLElement | null>,\n  { active = true, restoreFocus = true, initialFocus = \"container\" }: FocusTrapOptions = {},\n): void {\n  // Latest-ref so a caller passing an inline `initialFocus` thunk — which every caller\n  // will — does not tear the trap down and re-engage it on each render, stealing focus\n  // back to the top of the panel mid-interaction. Written in a LAYOUT effect so that\n  // the trap's cleanup, which runs after the layout effects of the same commit, reads\n  // this render's `active` rather than the last one's — see the cleanup for why.\n  const optsRef = useRef({ active, restoreFocus, initialFocus });\n  useLayoutEffect(() => {\n    optsRef.current = { active, restoreFocus, initialFocus };\n  });\n\n  // Where focus was BEFORE the trap engaged: the element it is given back to on close.\n  //\n  // Read DURING the render that turns the trap on, and that timing is the point. React\n  // honours a child's `autoFocus` while it commits that render, before any effect runs,\n  // so the effect below asking `document.activeElement` would get the child, inside the\n  // overlay. Restoring to that on close aimed focus at the dialog that was closing —\n  // already out of the DOM, so focus fell to <body> rather than going back to the\n  // button that opened it.\n  //\n  // State adjusted during render (the pattern `Modal` uses for `open`) rather than a\n  // ref written there: set once per opening and cleared on release, so a re-render\n  // while open cannot replace it with something inside, and StrictMode's second render\n  // and second effect both see the same element. `undefined` means \"not captured\";\n  // `null` is a capture that found nothing.\n  const [opener, setOpener] = useState<Element | null | undefined>(undefined);\n  if (active && opener === undefined) setOpener(focusedElement());\n  else if (!active && opener !== undefined) setOpener(undefined);\n\n  useEffect(() => {\n    if (!active) return;\n    const container = containerRef.current;\n    if (!container) return;\n\n    container.setAttribute(TRAP_ATTR, \"\");\n\n    /** Is `node` inside a trap nested within this one? */\n    const inNestedTrap = (node: Element | null) => {\n      if (!node) return false;\n      const owner = node.closest(`[${TRAP_ATTR}]`);\n      return owner !== null && owner !== container;\n    };\n\n    const tabbables = () =>\n      Array.from(container.querySelectorAll<HTMLElement>(FOCUSABLE)).filter(\n        // A tabbable inside a NESTED open overlay belongs to that overlay's trap, not\n        // to this one — otherwise the outer list spans both panels and Tab from the\n        // inner panel's last control wraps to the OUTER panel's first.\n        (el) => isTabStop(el) && !inNestedTrap(el),\n      );\n\n    const { initialFocus: how } = optsRef.current;\n    const focused = document.activeElement;\n    // A child that already has focus was given it on purpose — see `initialFocus`.\n    const childHasFocus = focused !== container && container.contains(focused);\n    if (typeof how === \"function\") {\n      (how() ?? container).focus();\n    } else if (!childHasFocus) {\n      (how === \"first\" ? (tabbables()[0] ?? container) : container).focus();\n    }\n\n    const onKeyDown = (e: KeyboardEvent) => {\n      if (e.key !== \"Tab\") return;\n      // Only the innermost trap acts. The event bubbles through every ancestor\n      // container, so without this an outer dialog and an inner picker both handle one\n      // Tab and fight over where focus lands.\n      if (inNestedTrap(document.activeElement)) return;\n\n      // Recomputed per keystroke — see the note at the top of this file.\n      const items = tabbables();\n      if (items.length === 0) {\n        e.preventDefault();\n        container.focus();\n        return;\n      }\n      const first = items[0];\n      const last = items[items.length - 1];\n      const activeEl = document.activeElement;\n      if (e.shiftKey && (activeEl === first || activeEl === container)) {\n        e.preventDefault();\n        last.focus();\n      } else if (!e.shiftKey && activeEl === last) {\n        e.preventDefault();\n        first.focus();\n      }\n    };\n\n    // On the container, not the document: a portalled child panel (an open dropdown\n    // rendered to <body>) is outside this subtree and manages its own focus, which is\n    // the behaviour Modal's comment describes and consumers already depend on.\n    container.addEventListener(\"keydown\", onKeyDown);\n\n    return () => {\n      container.removeEventListener(\"keydown\", onKeyDown);\n      container.removeAttribute(TRAP_ATTR);\n\n      // Only when the trap is really being released: the container has left the page,\n      // or `active` has turned false. StrictMode runs this cleanup once more right after\n      // mounting, with the overlay still up, and then the effect again — and React does\n      // not re-apply `autoFocus` for that second run. Restoring here would pull focus\n      // out of the autofocused field for good: live #402 again, in development.\n      if (container.isConnected && optsRef.current.active) return;\n      if (!optsRef.current.restoreFocus) return;\n      // `isConnected` is the whole point: restoring to a node that has been removed\n      // sends focus to <body> and the user loses their place entirely. When the\n      // original is gone, leave focus where the browser put it rather than moving it\n      // somewhere arbitrary — a wrong guess is worse than no move.\n      if (opener?.isConnected) (opener as HTMLElement).focus?.();\n    };\n  }, [active, containerRef, opener]);\n}\n"],"mappings":";AAAA,SAAS,WAAW,iBAAiB,QAAQ,gBAAgB;AAiD7D,MAAM,YACJ;AAQF,MAAM,YAAY,CAAC,OAA6B,GAAG,YAAY,KAAK,CAAC,GAAG,QAAQ,kBAAkB;AAclG,MAAM,YAAY;AAyBlB,SAAS,iBAAiC;AACxC,SAAO,OAAO,aAAa,cAAc,OAAO,SAAS;AAC3D;AAEO,SAAS,aACd,cACA,EAAE,SAAS,MAAM,eAAe,MAAM,eAAe,YAAY,IAAsB,CAAC,GAClF;AAMN,QAAM,UAAU,OAAO,EAAE,QAAQ,cAAc,aAAa,CAAC;AAC7D,kBAAgB,MAAM;AACpB,YAAQ,UAAU,EAAE,QAAQ,cAAc,aAAa;AAAA,EACzD,CAAC;AAgBD,QAAM,CAAC,QAAQ,SAAS,IAAI,SAAqC,MAAS;AAC1E,MAAI,UAAU,WAAW,OAAW,WAAU,eAAe,CAAC;AAAA,WACrD,CAAC,UAAU,WAAW,OAAW,WAAU,MAAS;AAE7D,YAAU,MAAM;AACd,QAAI,CAAC,OAAQ;AACb,UAAM,YAAY,aAAa;AAC/B,QAAI,CAAC,UAAW;AAEhB,cAAU,aAAa,WAAW,EAAE;AAGpC,UAAM,eAAe,CAAC,SAAyB;AAC7C,UAAI,CAAC,KAAM,QAAO;AAClB,YAAM,QAAQ,KAAK,QAAQ,IAAI,SAAS,GAAG;AAC3C,aAAO,UAAU,QAAQ,UAAU;AAAA,IACrC;AAEA,UAAM,YAAY,MAChB,MAAM,KAAK,UAAU,iBAA8B,SAAS,CAAC,EAAE;AAAA;AAAA;AAAA;AAAA,MAI7D,CAAC,OAAO,UAAU,EAAE,KAAK,CAAC,aAAa,EAAE;AAAA,IAC3C;AAEF,UAAM,EAAE,cAAc,IAAI,IAAI,QAAQ;AACtC,UAAM,UAAU,SAAS;AAEzB,UAAM,gBAAgB,YAAY,aAAa,UAAU,SAAS,OAAO;AACzE,QAAI,OAAO,QAAQ,YAAY;AAC7B,OAAC,IAAI,KAAK,WAAW,MAAM;AAAA,IAC7B,WAAW,CAAC,eAAe;AACzB,OAAC,QAAQ,UAAW,UAAU,EAAE,CAAC,KAAK,YAAa,WAAW,MAAM;AAAA,IACtE;AAEA,UAAM,YAAY,CAAC,MAAqB;AACtC,UAAI,EAAE,QAAQ,MAAO;AAIrB,UAAI,aAAa,SAAS,aAAa,EAAG;AAG1C,YAAM,QAAQ,UAAU;AACxB,UAAI,MAAM,WAAW,GAAG;AACtB,UAAE,eAAe;AACjB,kBAAU,MAAM;AAChB;AAAA,MACF;AACA,YAAM,QAAQ,MAAM,CAAC;AACrB,YAAM,OAAO,MAAM,MAAM,SAAS,CAAC;AACnC,YAAM,WAAW,SAAS;AAC1B,UAAI,EAAE,aAAa,aAAa,SAAS,aAAa,YAAY;AAChE,UAAE,eAAe;AACjB,aAAK,MAAM;AAAA,MACb,WAAW,CAAC,EAAE,YAAY,aAAa,MAAM;AAC3C,UAAE,eAAe;AACjB,cAAM,MAAM;AAAA,MACd;AAAA,IACF;AAKA,cAAU,iBAAiB,WAAW,SAAS;AAE/C,WAAO,MAAM;AACX,gBAAU,oBAAoB,WAAW,SAAS;AAClD,gBAAU,gBAAgB,SAAS;AAOnC,UAAI,UAAU,eAAe,QAAQ,QAAQ,OAAQ;AACrD,UAAI,CAAC,QAAQ,QAAQ,aAAc;AAKnC,UAAI,QAAQ,YAAa,CAAC,OAAuB,QAAQ;AAAA,IAC3D;AAAA,EACF,GAAG,CAAC,QAAQ,cAAc,MAAM,CAAC;AACnC;","names":[]}
+{"version":3,"sources":["../../src/hooks/use-focus-trap.ts"],"sourcesContent":["import { useEffect, useLayoutEffect, useRef, useState } from \"react\";\nimport { tabStops } from \"../lib/focus-left\";\n\n/**\n * Keep keyboard focus inside an open overlay, and give it back when it closes.\n *\n * Extracted from `Modal`, which was the ONLY component in this package that did any of\n * this. Every other overlay — the full-bleed dialog a phone's row editor opens, the\n * picker sheet, the numpad, the tour card — declared `role=\"dialog\" aria-modal=\"true\"`\n * and then left focus on the page behind it. That is the worst of the two possible\n * bugs: assistive technology hides the page because of `aria-modal`, while the user's\n * focus is still down there in the part that is now hidden, so Tab walks through\n * controls the screen reader refuses to describe.\n *\n * What this does beyond Modal's original copy:\n *\n *   - **Recomputes the tabbable list on every Tab**, not once when the overlay opens.\n *     These panels have conditionally-rendered contents — a search box that appears\n *     once options load, a \"clear\" button that exists only while a filter is set — and\n *     a list captured at open time traps focus against elements that have since gone.\n *   - **Guards the restore target.** The element focused before opening may have left\n *     the DOM by the time the overlay closes (the row that owned the button was\n *     filtered away). Calling `.focus()` on a detached node silently drops focus to\n *     `<body>`, which for a keyboard user means losing their place in the page\n *     entirely. When the target is gone, focus falls back to the nearest thing that\n *     still exists rather than to nothing.\n *   - **Leaves an app's own autofocus alone** (0.33.1). React honours a child's\n *     `autoFocus` while it commits, and this hook's effect runs AFTER that commit, so\n *     focusing the container there took focus straight back off the field the app had\n *     asked for. See `initialFocus`.\n *   - **Nests.** An overlay can open another — a picker inside a dialog. Only the\n *     innermost trap handles a keystroke, and closing it hands control back to the one\n *     underneath. Innermost is decided by DOM containment rather than by mount order;\n *     see the note on `TRAP_ATTR` for why the obvious stack is wrong.\n *     `use-overlay-history.ts` reasons about the same nesting problem for the back\n *     button; this is the focus half of it.\n */\n\n// The trap's reading of \"a Tab lands here\" is lib/focus-left's `tabStops` — the kit's one\n// copy of the rule since the 0.52 code review (round 0.34 BUG-4's history is there).\n// Re-exported where refactor audit 2026-10-30, DUP-9 put them, for a part that walks Tab\n// over something that is not a trap (the tour's field + card ring).\nexport { firstTabStop, tabStops } from \"../lib/focus-left\";\n\n/**\n * Marks a container whose trap is currently active.\n *\n * \"Which trap is innermost?\" is answered by DOM CONTAINMENT, not by mount order. The\n * obvious implementation — a module-level stack pushed in the effect — is wrong, and\n * wrong in a way that passes a casual reading: React runs CHILD effects before PARENT\n * effects, so a nested overlay pushes first and the outer one ends up on top of the\n * stack, claiming to be innermost. The outer trap then handles the keystroke and wraps\n * focus to its own first element, jumping the user out of the picker they had open.\n *\n * An attribute on the live DOM cannot disagree with the DOM.\n */\nconst TRAP_ATTR = \"data-focus-trap\";\n\nexport interface FocusTrapOptions {\n  /** Trap only while this is true. Mount-time `true` is the common case. */\n  active?: boolean;\n  /** Return focus to whatever had it before the trap engaged. Default `true`. */\n  restoreFocus?: boolean;\n  /**\n   * What to focus when the trap engages. Default is the container itself, which is\n   * what `Modal` does and why: focusing the first FIELD pops the software keyboard on\n   * a phone the moment a dialog opens, before the user has asked to type.\n   * The container needs `tabIndex={-1}` for this to work.\n   *\n   * `\"container\"` and `\"first\"` both step aside when focus is ALREADY inside the\n   * container, on something other than the container itself. That is a child the app\n   * focused on purpose — an `autoFocus`, which React honours before this hook's effect\n   * runs — and the keyboard it brings up is the one the user was promised. Moving focus\n   * off it lost keksdose's create card its amount field the instant it got it, and on a\n   * phone the numpad sheet with it, which shows only while the field is focused (live\n   * #402). A function is the caller's explicit choice and is always followed.\n   */\n  initialFocus?: \"container\" | \"first\" | (() => HTMLElement | null);\n}\n\n/** Whatever has focus right now; nothing on the server, where there is no document. */\nfunction focusedElement(): Element | null {\n  return typeof document === \"undefined\" ? null : document.activeElement;\n}\n\nexport function useFocusTrap(\n  containerRef: React.RefObject<HTMLElement | null>,\n  { active = true, restoreFocus = true, initialFocus = \"container\" }: FocusTrapOptions = {},\n): void {\n  // Latest-ref so a caller passing an inline `initialFocus` thunk — which every caller\n  // will — does not tear the trap down and re-engage it on each render, stealing focus\n  // back to the top of the panel mid-interaction. Written in a LAYOUT effect so that\n  // the trap's cleanup, which runs after the layout effects of the same commit, reads\n  // this render's `active` rather than the last one's — see the cleanup for why.\n  const optsRef = useRef({ active, restoreFocus, initialFocus });\n  useLayoutEffect(() => {\n    optsRef.current = { active, restoreFocus, initialFocus };\n  });\n\n  // Where focus was BEFORE the trap engaged: the element it is given back to on close.\n  //\n  // Read DURING the render that turns the trap on, and that timing is the point. React\n  // honours a child's `autoFocus` while it commits that render, before any effect runs,\n  // so the effect below asking `document.activeElement` would get the child, inside the\n  // overlay. Restoring to that on close aimed focus at the dialog that was closing —\n  // already out of the DOM, so focus fell to <body> rather than going back to the\n  // button that opened it.\n  //\n  // State adjusted during render (the pattern `Modal` uses for `open`) rather than a\n  // ref written there: set once per opening and cleared on release, so a re-render\n  // while open cannot replace it with something inside, and StrictMode's second render\n  // and second effect both see the same element. `undefined` means \"not captured\";\n  // `null` is a capture that found nothing.\n  const [opener, setOpener] = useState<Element | null | undefined>(undefined);\n  if (active && opener === undefined) setOpener(focusedElement());\n  else if (!active && opener !== undefined) setOpener(undefined);\n\n  useEffect(() => {\n    if (!active) return;\n    const container = containerRef.current;\n    if (!container) return;\n\n    container.setAttribute(TRAP_ATTR, \"\");\n\n    /** Is `node` inside a trap nested within this one? */\n    const inNestedTrap = (node: Element | null) => {\n      if (!node) return false;\n      const owner = node.closest(`[${TRAP_ATTR}]`);\n      return owner !== null && owner !== container;\n    };\n\n    const tabbables = () =>\n      tabStops(container, { includeSelf: false }).filter(\n        // A tabbable inside a NESTED open overlay belongs to that overlay's trap, not\n        // to this one — otherwise the outer list spans both panels and Tab from the\n        // inner panel's last control wraps to the OUTER panel's first.\n        (el) => !inNestedTrap(el),\n      );\n\n    const { initialFocus: how } = optsRef.current;\n    const focused = document.activeElement;\n    // A child that already has focus was given it on purpose — see `initialFocus`.\n    const childHasFocus = focused !== container && container.contains(focused);\n    if (typeof how === \"function\") {\n      (how() ?? container).focus();\n    } else if (!childHasFocus) {\n      (how === \"first\" ? (tabbables()[0] ?? container) : container).focus();\n    }\n\n    const onKeyDown = (e: KeyboardEvent) => {\n      if (e.key !== \"Tab\") return;\n      // Only the innermost trap acts. The event bubbles through every ancestor\n      // container, so without this an outer dialog and an inner picker both handle one\n      // Tab and fight over where focus lands.\n      if (inNestedTrap(document.activeElement)) return;\n\n      // Recomputed per keystroke — see the note at the top of this file.\n      const items = tabbables();\n      if (items.length === 0) {\n        e.preventDefault();\n        container.focus();\n        return;\n      }\n      const first = items[0];\n      const last = items[items.length - 1];\n      const activeEl = document.activeElement;\n      if (e.shiftKey && (activeEl === first || activeEl === container)) {\n        e.preventDefault();\n        last.focus();\n      } else if (!e.shiftKey && activeEl === last) {\n        e.preventDefault();\n        first.focus();\n      }\n    };\n\n    // On the container, not the document: a portalled child panel (an open dropdown\n    // rendered to <body>) is outside this subtree and manages its own focus, which is\n    // the behaviour Modal's comment describes and consumers already depend on.\n    container.addEventListener(\"keydown\", onKeyDown);\n\n    return () => {\n      container.removeEventListener(\"keydown\", onKeyDown);\n      container.removeAttribute(TRAP_ATTR);\n\n      // Only when the trap is really being released: the container has left the page,\n      // or `active` has turned false. StrictMode runs this cleanup once more right after\n      // mounting, with the overlay still up, and then the effect again — and React does\n      // not re-apply `autoFocus` for that second run. Restoring here would pull focus\n      // out of the autofocused field for good: live #402 again, in development.\n      if (container.isConnected && optsRef.current.active) return;\n      if (!optsRef.current.restoreFocus) return;\n      // `isConnected` is the whole point: restoring to a node that has been removed\n      // sends focus to <body> and the user loses their place entirely. When the\n      // original is gone, leave focus where the browser put it rather than moving it\n      // somewhere arbitrary — a wrong guess is worse than no move.\n      if (opener?.isConnected) (opener as HTMLElement).focus?.();\n    };\n  }, [active, containerRef, opener]);\n}\n"],"mappings":";AAAA,SAAS,WAAW,iBAAiB,QAAQ,gBAAgB;AAC7D,SAAS,gBAAgB;AAyCzB,SAAS,cAAc,YAAAA,iBAAgB;AAcvC,MAAM,YAAY;AAyBlB,SAAS,iBAAiC;AACxC,SAAO,OAAO,aAAa,cAAc,OAAO,SAAS;AAC3D;AAEO,SAAS,aACd,cACA,EAAE,SAAS,MAAM,eAAe,MAAM,eAAe,YAAY,IAAsB,CAAC,GAClF;AAMN,QAAM,UAAU,OAAO,EAAE,QAAQ,cAAc,aAAa,CAAC;AAC7D,kBAAgB,MAAM;AACpB,YAAQ,UAAU,EAAE,QAAQ,cAAc,aAAa;AAAA,EACzD,CAAC;AAgBD,QAAM,CAAC,QAAQ,SAAS,IAAI,SAAqC,MAAS;AAC1E,MAAI,UAAU,WAAW,OAAW,WAAU,eAAe,CAAC;AAAA,WACrD,CAAC,UAAU,WAAW,OAAW,WAAU,MAAS;AAE7D,YAAU,MAAM;AACd,QAAI,CAAC,OAAQ;AACb,UAAM,YAAY,aAAa;AAC/B,QAAI,CAAC,UAAW;AAEhB,cAAU,aAAa,WAAW,EAAE;AAGpC,UAAM,eAAe,CAAC,SAAyB;AAC7C,UAAI,CAAC,KAAM,QAAO;AAClB,YAAM,QAAQ,KAAK,QAAQ,IAAI,SAAS,GAAG;AAC3C,aAAO,UAAU,QAAQ,UAAU;AAAA,IACrC;AAEA,UAAM,YAAY,MAChB,SAAS,WAAW,EAAE,aAAa,MAAM,CAAC,EAAE;AAAA;AAAA;AAAA;AAAA,MAI1C,CAAC,OAAO,CAAC,aAAa,EAAE;AAAA,IAC1B;AAEF,UAAM,EAAE,cAAc,IAAI,IAAI,QAAQ;AACtC,UAAM,UAAU,SAAS;AAEzB,UAAM,gBAAgB,YAAY,aAAa,UAAU,SAAS,OAAO;AACzE,QAAI,OAAO,QAAQ,YAAY;AAC7B,OAAC,IAAI,KAAK,WAAW,MAAM;AAAA,IAC7B,WAAW,CAAC,eAAe;AACzB,OAAC,QAAQ,UAAW,UAAU,EAAE,CAAC,KAAK,YAAa,WAAW,MAAM;AAAA,IACtE;AAEA,UAAM,YAAY,CAAC,MAAqB;AACtC,UAAI,EAAE,QAAQ,MAAO;AAIrB,UAAI,aAAa,SAAS,aAAa,EAAG;AAG1C,YAAM,QAAQ,UAAU;AACxB,UAAI,MAAM,WAAW,GAAG;AACtB,UAAE,eAAe;AACjB,kBAAU,MAAM;AAChB;AAAA,MACF;AACA,YAAM,QAAQ,MAAM,CAAC;AACrB,YAAM,OAAO,MAAM,MAAM,SAAS,CAAC;AACnC,YAAM,WAAW,SAAS;AAC1B,UAAI,EAAE,aAAa,aAAa,SAAS,aAAa,YAAY;AAChE,UAAE,eAAe;AACjB,aAAK,MAAM;AAAA,MACb,WAAW,CAAC,EAAE,YAAY,aAAa,MAAM;AAC3C,UAAE,eAAe;AACjB,cAAM,MAAM;AAAA,MACd;AAAA,IACF;AAKA,cAAU,iBAAiB,WAAW,SAAS;AAE/C,WAAO,MAAM;AACX,gBAAU,oBAAoB,WAAW,SAAS;AAClD,gBAAU,gBAAgB,SAAS;AAOnC,UAAI,UAAU,eAAe,QAAQ,QAAQ,OAAQ;AACrD,UAAI,CAAC,QAAQ,QAAQ,aAAc;AAKnC,UAAI,QAAQ,YAAa,CAAC,OAAuB,QAAQ;AAAA,IAC3D;AAAA,EACF,GAAG,CAAC,QAAQ,cAAc,MAAM,CAAC;AACnC;","names":["tabStops"]}

package/dist/hooks/use-hotkey.d.ts

@@ -49,9 +49,12 @@ export declare function matchesHotkey(e: KeyboardEvent, combo: ParsedHotkey): bo
  * - Modifiers match EXACTLY: `"Ctrl+K"` does not fire on Ctrl+Shift+K.
  * - Typing in a field is left alone unless `allowInInputs`, except for a combo with
  *   Ctrl / Meta / Alt, which no one types as text.
- * - A key held down fires once, not on every repeat.
+ * - A key held down fires once, not on every repeat — and its repeats are cancelled as
+ *   the first press was, or the browser acts on them.
  * - The newest `handler` is always called; changing it does not re-attach the listener.
  *
- * `useCommandKey` (the ⌘K palette hook) is unchanged; this is its general form.
+ * `useCommandKey` (the ⌘K palette hook) is this with `"Mod+K"` and `allowInInputs`
+ * since 0.52, and FormActions' Ctrl/Cmd+Enter is {@link matchesHotkey} (refactor audit
+ * 2026-10-30, DUP-12): one reading of a chord.
  */
 export declare function useHotkey(combo: Hotkey | ReadonlyArray<Hotkey>, handler: (event: KeyboardEvent) => void, options?: UseHotkeyOptions): void;

package/dist/hooks/use-hotkey.js

@@ -46,14 +46,15 @@ const KEY_ALIASES = {
   left: "arrowleft",
   right: "arrowright"
 };
+const NON_LATIN_LETTER = /^(?!\p{Script=Latin})\p{L}$/u;
 function matchesHotkey(e, combo) {
   if (e.ctrlKey !== combo.ctrl || e.metaKey !== combo.meta || e.altKey !== combo.alt) return false;
   const want = KEY_ALIASES[combo.key.toLowerCase()] ?? combo.key.toLowerCase();
   const key = (e.key ?? "").toLowerCase();
   const code = (e.code ?? "").toLowerCase();
-  const keyMatches = key === want || code === want;
-  if (!keyMatches) return false;
-  const symbol = want.length === 1 && !/[a-z0-9]/.test(want);
+  const physical = /^[a-z]$/.test(want) && NON_LATIN_LETTER.test(e.key ?? "") && code === `key${want}`;
+  if (key !== want && code !== want && !physical) return false;
+  const symbol = want.length === 1 && !/[a-z0-9 ]/.test(want);
   return symbol && !combo.shift ? true : e.shiftKey === combo.shift;
 }
 function isTypingTarget(target) {
@@ -82,7 +83,6 @@ function useHotkey(combo, handler, options = {}) {
     const parsed = key.split("\0").map((c) => parseHotkey(c, apple));
     const listener = (raw) => {
       const e = raw;
-      if (e.repeat) return;
       const hit = parsed.find((p) => matchesHotkey(e, p));
       if (!hit) return;
       if (allowInInputs !== true && isTypingTarget(e.target)) {
@@ -90,6 +90,7 @@ function useHotkey(combo, handler, options = {}) {
         if (allowInInputs === "never" || !chorded) return;
       }
       if (preventDefault) e.preventDefault();
+      if (e.repeat) return;
       handlerRef.current(e);
     };
     node.addEventListener(event, listener);

package/dist/hooks/use-hotkey.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/hooks/use-hotkey.ts"],"sourcesContent":["import { useEffect, useRef } from \"react\";\n\n/**\n * A key combination: modifiers and one key, joined by \"+\", case-insensitive —\n * `\"Ctrl+Shift+F\"`, `\"Mod+K\"`, `\"Alt+ArrowUp\"`, `\"Escape\"`, `\"?\"`.\n *\n * Modifiers: `Ctrl` (`Control`), `Meta` (`Cmd`, `Command`), `Shift`, `Alt` (`Option`),\n * and `Mod` — Cmd on Apple platforms, Ctrl everywhere else, the one to use for an\n * app shortcut. The key is `KeyboardEvent.key` (\"f\", \"Enter\", \"ArrowUp\", \"/\"), or a\n * `KeyboardEvent.code` (\"KeyF\", \"Digit1\") when the physical key is what matters.\n * Several combos: pass an array.\n */\nexport type Hotkey = string;\n\nexport interface UseHotkeyOptions {\n  /** Off while `false` (default `true`). */\n  enabled?: boolean;\n  /** Call `preventDefault()` on a match (default `true`): Ctrl+Shift+F must not also\n   *  open the browser's own dialog. */\n  preventDefault?: boolean;\n  /** Where to listen. Default `document`. A ref, an element, or `window`. */\n  target?: EventTarget | null | { current: EventTarget | null };\n  /**\n   * Fire while the focus is in a text field, select or contenteditable too. Default\n   * `false`: a shortcut must not steal the letters someone is typing. A combo with Ctrl,\n   * Meta or Alt is not typing — those still fire unless this is `\"never\"`.\n   */\n  allowInInputs?: boolean | \"never\";\n  /** `keydown` (default) or `keyup`. */\n  event?: \"keydown\" | \"keyup\";\n}\n\nexport interface ParsedHotkey {\n  ctrl: boolean;\n  meta: boolean;\n  shift: boolean;\n  alt: boolean;\n  key: string;\n}\n\n/** Whether this is an Apple platform, where `Mod` means Cmd. */\nexport function isApplePlatform(): boolean {\n  if (typeof navigator === \"undefined\") return false;\n  const nav = navigator as Navigator & { userAgentData?: { platform?: string } };\n  return /mac|iphone|ipad|ipod/i.test(nav.userAgentData?.platform || nav.platform || nav.userAgent);\n}\n\n/** Parse one combo. `apple` decides what `Mod` is. Throws on an empty key. */\nexport function parseHotkey(combo: Hotkey, apple = isApplePlatform()): ParsedHotkey {\n  const parts = combo\n    .split(\"+\")\n    .map((p) => p.trim())\n    // \"Ctrl++\" is Ctrl and \"+\": an empty part after a \"+\" is the plus key itself.\n    .map((p, i, all) => (p === \"\" && i === all.length - 1 ? \"+\" : p))\n    .filter((p) => p !== \"\");\n  const out: ParsedHotkey = { ctrl: false, meta: false, shift: false, alt: false, key: \"\" };\n  for (const part of parts) {\n    switch (part.toLowerCase()) {\n      case \"ctrl\":\n      case \"control\":\n        out.ctrl = true;\n        break;\n      case \"meta\":\n      case \"cmd\":\n      case \"command\":\n        out.meta = true;\n        break;\n      case \"mod\":\n        if (apple) out.meta = true;\n        else out.ctrl = true;\n        break;\n      case \"shift\":\n        out.shift = true;\n        break;\n      case \"alt\":\n      case \"option\":\n        out.alt = true;\n        break;\n      default:\n        out.key = part;\n    }\n  }\n  if (!out.key) throw new Error(`useHotkey: \"${combo}\" names no key`);\n  return out;\n}\n\nconst KEY_ALIASES: Record<string, string> = {\n  esc: \"escape\",\n  space: \" \",\n  del: \"delete\",\n  up: \"arrowup\",\n  down: \"arrowdown\",\n  left: \"arrowleft\",\n  right: \"arrowright\",\n};\n\n/** Whether `e` is `combo` — every modifier as named (no more, no fewer), and the key. */\nexport function matchesHotkey(e: KeyboardEvent, combo: ParsedHotkey): boolean {\n  if (e.ctrlKey !== combo.ctrl || e.metaKey !== combo.meta || e.altKey !== combo.alt) return false;\n  const want = KEY_ALIASES[combo.key.toLowerCase()] ?? combo.key.toLowerCase();\n  const key = (e.key ?? \"\").toLowerCase();\n  const code = (e.code ?? \"\").toLowerCase();\n  const keyMatches = key === want || code === want;\n  if (!keyMatches) return false;\n  // Shift must match exactly for a letter or a named key; for a symbol it is how the\n  // symbol is typed (\"?\" is Shift+/ on a US layout, a plain key on others), so an\n  // unnamed Shift is not held against it.\n  const symbol = want.length === 1 && !/[a-z0-9]/.test(want);\n  return symbol && !combo.shift ? true : e.shiftKey === combo.shift;\n}\n\n/** Is the focus somewhere that takes typed characters? */\nfunction isTypingTarget(target: EventTarget | null): boolean {\n  if (!(target instanceof HTMLElement)) return false;\n  if (target.isContentEditable) return true;\n  if (target instanceof HTMLTextAreaElement || target instanceof HTMLSelectElement) return true;\n  if (target instanceof HTMLInputElement) {\n    return ![\"button\", \"checkbox\", \"radio\", \"submit\", \"reset\", \"range\", \"color\", \"file\", \"image\"].includes(target.type);\n  }\n  return false;\n}\n\n/**\n * Call `handler` when `combo` is pressed — kastlan's feedback button (Ctrl+Shift+F,\n * feedback-button:60) wired it by hand, and so will every next shortcut.\n *\n * - `Mod` is Cmd on a Mac and Ctrl elsewhere, read once per mount.\n * - Modifiers match EXACTLY: `\"Ctrl+K\"` does not fire on Ctrl+Shift+K.\n * - Typing in a field is left alone unless `allowInInputs`, except for a combo with\n *   Ctrl / Meta / Alt, which no one types as text.\n * - A key held down fires once, not on every repeat.\n * - The newest `handler` is always called; changing it does not re-attach the listener.\n *\n * `useCommandKey` (the ⌘K palette hook) is unchanged; this is its general form.\n */\nexport function useHotkey(\n  combo: Hotkey | ReadonlyArray<Hotkey>,\n  handler: (event: KeyboardEvent) => void,\n  options: UseHotkeyOptions = {},\n): void {\n  const { enabled = true, preventDefault = true, target, allowInInputs = false, event = \"keydown\" } = options;\n  const handlerRef = useRef(handler);\n  useEffect(() => {\n    handlerRef.current = handler;\n  });\n  const key = typeof combo === \"string\" ? combo : combo.join(\"\\u0000\");\n  const targetEl = target && \"current\" in target ? undefined : target;\n  const targetRef = target && \"current\" in target ? target : undefined;\n\n  useEffect(() => {\n    if (!enabled) return;\n    const node: EventTarget | null =\n      targetRef?.current ?? targetEl ?? (typeof document === \"undefined\" ? null : document);\n    if (!node) return;\n    const apple = isApplePlatform();\n    const parsed = key.split(\"\\u0000\").map((c) => parseHotkey(c, apple));\n    const listener = (raw: Event) => {\n      const e = raw as KeyboardEvent;\n      if (e.repeat) return;\n      const hit = parsed.find((p) => matchesHotkey(e, p));\n      if (!hit) return;\n      if (allowInInputs !== true && isTypingTarget(e.target)) {\n        const chorded = hit.ctrl || hit.meta || hit.alt;\n        if (allowInInputs === \"never\" || !chorded) return;\n      }\n      if (preventDefault) e.preventDefault();\n      handlerRef.current(e);\n    };\n    node.addEventListener(event, listener);\n    return () => node.removeEventListener(event, listener);\n  }, [key, enabled, preventDefault, allowInInputs, event, targetEl, targetRef]);\n}\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../../src/hooks/use-hotkey.ts"],"sourcesContent":["import { useEffect, useRef } from \"react\";\n\n/**\n * A key combination: modifiers and one key, joined by \"+\", case-insensitive —\n * `\"Ctrl+Shift+F\"`, `\"Mod+K\"`, `\"Alt+ArrowUp\"`, `\"Escape\"`, `\"?\"`.\n *\n * Modifiers: `Ctrl` (`Control`), `Meta` (`Cmd`, `Command`), `Shift`, `Alt` (`Option`),\n * and `Mod` — Cmd on Apple platforms, Ctrl everywhere else, the one to use for an\n * app shortcut. The key is `KeyboardEvent.key` (\"f\", \"Enter\", \"ArrowUp\", \"/\"), or a\n * `KeyboardEvent.code` (\"KeyF\", \"Digit1\") when the physical key is what matters.\n * Several combos: pass an array.\n */\nexport type Hotkey = string;\n\nexport interface UseHotkeyOptions {\n  /** Off while `false` (default `true`). */\n  enabled?: boolean;\n  /** Call `preventDefault()` on a match (default `true`): Ctrl+Shift+F must not also\n   *  open the browser's own dialog. */\n  preventDefault?: boolean;\n  /** Where to listen. Default `document`. A ref, an element, or `window`. */\n  target?: EventTarget | null | { current: EventTarget | null };\n  /**\n   * Fire while the focus is in a text field, select or contenteditable too. Default\n   * `false`: a shortcut must not steal the letters someone is typing. A combo with Ctrl,\n   * Meta or Alt is not typing — those still fire unless this is `\"never\"`.\n   */\n  allowInInputs?: boolean | \"never\";\n  /** `keydown` (default) or `keyup`. */\n  event?: \"keydown\" | \"keyup\";\n}\n\nexport interface ParsedHotkey {\n  ctrl: boolean;\n  meta: boolean;\n  shift: boolean;\n  alt: boolean;\n  key: string;\n}\n\n/** Whether this is an Apple platform, where `Mod` means Cmd. */\nexport function isApplePlatform(): boolean {\n  if (typeof navigator === \"undefined\") return false;\n  const nav = navigator as Navigator & { userAgentData?: { platform?: string } };\n  return /mac|iphone|ipad|ipod/i.test(nav.userAgentData?.platform || nav.platform || nav.userAgent);\n}\n\n/** Parse one combo. `apple` decides what `Mod` is. Throws on an empty key. */\nexport function parseHotkey(combo: Hotkey, apple = isApplePlatform()): ParsedHotkey {\n  const parts = combo\n    .split(\"+\")\n    .map((p) => p.trim())\n    // \"Ctrl++\" is Ctrl and \"+\": an empty part after a \"+\" is the plus key itself.\n    .map((p, i, all) => (p === \"\" && i === all.length - 1 ? \"+\" : p))\n    .filter((p) => p !== \"\");\n  const out: ParsedHotkey = { ctrl: false, meta: false, shift: false, alt: false, key: \"\" };\n  for (const part of parts) {\n    switch (part.toLowerCase()) {\n      case \"ctrl\":\n      case \"control\":\n        out.ctrl = true;\n        break;\n      case \"meta\":\n      case \"cmd\":\n      case \"command\":\n        out.meta = true;\n        break;\n      case \"mod\":\n        if (apple) out.meta = true;\n        else out.ctrl = true;\n        break;\n      case \"shift\":\n        out.shift = true;\n        break;\n      case \"alt\":\n      case \"option\":\n        out.alt = true;\n        break;\n      default:\n        out.key = part;\n    }\n  }\n  if (!out.key) throw new Error(`useHotkey: \"${combo}\" names no key`);\n  return out;\n}\n\nconst KEY_ALIASES: Record<string, string> = {\n  esc: \"escape\",\n  space: \" \",\n  del: \"delete\",\n  up: \"arrowup\",\n  down: \"arrowdown\",\n  left: \"arrowleft\",\n  right: \"arrowright\",\n};\n\n/** One letter of a script other than Latin: what a Russian, Greek or Hebrew layout's letter keys type. */\nconst NON_LATIN_LETTER = /^(?!\\p{Script=Latin})\\p{L}$/u;\n\n/** Whether `e` is `combo` — every modifier as named (no more, no fewer), and the key. */\nexport function matchesHotkey(e: KeyboardEvent, combo: ParsedHotkey): boolean {\n  if (e.ctrlKey !== combo.ctrl || e.metaKey !== combo.meta || e.altKey !== combo.alt) return false;\n  const want = KEY_ALIASES[combo.key.toLowerCase()] ?? combo.key.toLowerCase();\n  const key = (e.key ?? \"\").toLowerCase();\n  const code = (e.code ?? \"\").toLowerCase();\n  // On a non-Latin layout `key` is the local letter — Ctrl+K types \"л\" on a Russian one —\n  // so a letter chord never fired there, ⌘K included (0.52 code review, use-hotkey.ts; the\n  // hand-written ⌘K listener before 0.52 compared `key` alone and missed it too). The\n  // physical key stands in for the letter there, and only there: a Latin layout's letter\n  // is wherever it types (Dvorak's K is on QWERTY's V).\n  const physical = /^[a-z]$/.test(want) && NON_LATIN_LETTER.test(e.key ?? \"\") && code === `key${want}`;\n  if (key !== want && code !== want && !physical) return false;\n  // Shift must match exactly for a letter or a named key; for a symbol it is how the\n  // symbol is typed (\"?\" is Shift+/ on a US layout, a plain key on others), so an\n  // unnamed Shift is not held against it. Space is a named key, not a symbol, though its\n  // alias is one character: \"Space\" fired on Shift+Space, the browser's page-up, and\n  // cancelled it (0.52 code review, use-hotkey.ts).\n  const symbol = want.length === 1 && !/[a-z0-9 ]/.test(want);\n  return symbol && !combo.shift ? true : e.shiftKey === combo.shift;\n}\n\n/** Is the focus somewhere that takes typed characters? */\nfunction isTypingTarget(target: EventTarget | null): boolean {\n  if (!(target instanceof HTMLElement)) return false;\n  if (target.isContentEditable) return true;\n  if (target instanceof HTMLTextAreaElement || target instanceof HTMLSelectElement) return true;\n  if (target instanceof HTMLInputElement) {\n    return ![\"button\", \"checkbox\", \"radio\", \"submit\", \"reset\", \"range\", \"color\", \"file\", \"image\"].includes(target.type);\n  }\n  return false;\n}\n\n/**\n * Call `handler` when `combo` is pressed — kastlan's feedback button (Ctrl+Shift+F,\n * feedback-button:60) wired it by hand, and so will every next shortcut.\n *\n * - `Mod` is Cmd on a Mac and Ctrl elsewhere, read once per mount.\n * - Modifiers match EXACTLY: `\"Ctrl+K\"` does not fire on Ctrl+Shift+K.\n * - Typing in a field is left alone unless `allowInInputs`, except for a combo with\n *   Ctrl / Meta / Alt, which no one types as text.\n * - A key held down fires once, not on every repeat — and its repeats are cancelled as\n *   the first press was, or the browser acts on them.\n * - The newest `handler` is always called; changing it does not re-attach the listener.\n *\n * `useCommandKey` (the ⌘K palette hook) is this with `\"Mod+K\"` and `allowInInputs`\n * since 0.52, and FormActions' Ctrl/Cmd+Enter is {@link matchesHotkey} (refactor audit\n * 2026-10-30, DUP-12): one reading of a chord.\n */\nexport function useHotkey(\n  combo: Hotkey | ReadonlyArray<Hotkey>,\n  handler: (event: KeyboardEvent) => void,\n  options: UseHotkeyOptions = {},\n): void {\n  const { enabled = true, preventDefault = true, target, allowInInputs = false, event = \"keydown\" } = options;\n  const handlerRef = useRef(handler);\n  useEffect(() => {\n    handlerRef.current = handler;\n  });\n  const key = typeof combo === \"string\" ? combo : combo.join(\"\\u0000\");\n  const targetEl = target && \"current\" in target ? undefined : target;\n  const targetRef = target && \"current\" in target ? target : undefined;\n\n  useEffect(() => {\n    if (!enabled) return;\n    const node: EventTarget | null =\n      targetRef?.current ?? targetEl ?? (typeof document === \"undefined\" ? null : document);\n    if (!node) return;\n    const apple = isApplePlatform();\n    const parsed = key.split(\"\\u0000\").map((c) => parseHotkey(c, apple));\n    const listener = (raw: Event) => {\n      const e = raw as KeyboardEvent;\n      const hit = parsed.find((p) => matchesHotkey(e, p));\n      if (!hit) return;\n      if (allowInInputs !== true && isTypingTarget(e.target)) {\n        const chorded = hit.ctrl || hit.meta || hit.alt;\n        if (allowInInputs === \"never\" || !chorded) return;\n      }\n      if (preventDefault) e.preventDefault();\n      // A held key's repeats are cancelled like its first press, and call nothing. They\n      // returned before the `preventDefault` once, so a held Ctrl+K's repeats reached the\n      // browser's own Ctrl+K and took the focus out of the palette ⌘K had just opened\n      // (0.52 code review, use-hotkey.ts; the hand-written ⌘K listener cancelled them).\n      if (e.repeat) return;\n      handlerRef.current(e);\n    };\n    node.addEventListener(event, listener);\n    return () => node.removeEventListener(event, listener);\n  }, [key, enabled, preventDefault, allowInInputs, event, targetEl, targetRef]);\n}\n"],"mappings":"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","names":[]}

package/dist/hooks/use-long-press.d.ts

@@ -1,4 +1,10 @@
 import { type PointerEvent as ReactPointerEvent } from "react";
+export interface LongPressOptions {
+    /** Default `true`. Off, a press does nothing and the context menu is the browser's. */
+    enabled?: boolean;
+    /** How long a press is held, in ms. Default 500. */
+    delay?: number;
+}
 export interface LongPressResult {
     handlers: {
         onPointerDown: (e: ReactPointerEvent) => void;
@@ -24,7 +30,4 @@ export interface LongPressResult {
  *    with `select-none [-webkit-touch-callout:none]` on the element: iOS's callout
  *    only yields to that CSS.
  */
-export declare function useLongPress(onLongPress: () => void, { enabled, delay }?: {
-    enabled?: boolean;
-    delay?: number;
-}): LongPressResult;
+export declare function useLongPress(onLongPress: () => void, { enabled, delay }?: LongPressOptions): LongPressResult;

package/dist/hooks/use-long-press.js

@@ -68,6 +68,9 @@ function useLongPress(onLongPress, { enabled = true, delay = LONG_PRESS_MS } = {
     fired.current = false;
     return true;
   }, []);
+  useEffect(() => {
+    if (!enabled) cancel();
+  }, [enabled, cancel]);
   useEffect(() => cancel, [cancel]);
   return { handlers: { onPointerDown, onPointerMove, onContextMenu }, consumeClick };
 }

package/dist/hooks/use-long-press.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/hooks/use-long-press.ts"],"sourcesContent":["import { useCallback, useEffect, useRef, type PointerEvent as ReactPointerEvent } from \"react\";\n\n// The press-and-hold that puts DataTable's phone cards into selection mode (0.40,\n// keksdose live #421). Taken over from keksdose's register list\n// (frontend/src/shared/hooks/use-long-press.ts, its feedback #153) so the kit's cards\n// and kk's register answer the same gesture the same way: 500 ms, an 8 px dead zone,\n// cancelled by a scroll, the trailing click swallowed.\n\nconst LONG_PRESS_MS = 500;\n/** The same 8 px dead zone `useRowSwipe` locks its axis at: the press is dead by the\n *  time the swipe hook takes pointer capture on its (ancestor) layer. */\nconst SLOP_PX = 8;\n\nconst movedBeyondSlop = (from: { x: number; y: number }, x: number, y: number) =>\n  Math.hypot(x - from.x, y - from.y) > SLOP_PX;\n\nexport interface LongPressResult {\n  handlers: {\n    onPointerDown: (e: ReactPointerEvent) => void;\n    onPointerMove: (e: ReactPointerEvent) => void;\n    onContextMenu: (e: { preventDefault: () => void }) => void;\n  };\n  /** True exactly once after a long press fired: call it from an `onClickCapture` to\n   *  swallow the click the browser still sends when the finger lifts. */\n  consumeClick: () => boolean;\n}\n\n/**\n * A press-and-hold on a touch row that may ALSO be swipeable.\n *\n *  - The cancel listeners live on `window`: `useRowSwipe` captures the pointer on an\n *    ancestor once a drag resolves to the x axis, after which the pressed element's\n *    own pointer handlers stop firing, and a timer cancelled only there would fire\n *    mid-swipe.\n *  - A scroll cancels too (`touch-action: pan-y` hands vertical panning to the\n *    browser, which sends `pointercancel`; the capture-phase `scroll` is the backstop).\n *  - `contextmenu` is suppressed while enabled — Android fires it at ~500 ms. Pair it\n *    with `select-none [-webkit-touch-callout:none]` on the element: iOS's callout\n *    only yields to that CSS.\n */\nexport function useLongPress(\n  onLongPress: () => void,\n  { enabled = true, delay = LONG_PRESS_MS }: { enabled?: boolean; delay?: number } = {},\n): LongPressResult {\n  const timer = useRef<number | null>(null);\n  const start = useRef({ x: 0, y: 0 });\n  const fired = useRef(false);\n  const teardown = useRef<(() => void) | null>(null);\n  const cbRef = useRef(onLongPress);\n  useEffect(() => {\n    cbRef.current = onLongPress;\n  });\n\n  const cancel = useCallback(() => {\n    if (timer.current !== null) {\n      window.clearTimeout(timer.current);\n      timer.current = null;\n    }\n    teardown.current?.();\n    teardown.current = null;\n  }, []);\n\n  const onPointerDown = useCallback(\n    (e: ReactPointerEvent) => {\n      // Cleared above every early return: a press whose trailing click never arrives\n      // (the finger lifted over another row) would otherwise leave the latch armed,\n      // and it would eat the next real tap once the card has switched modes.\n      fired.current = false;\n      if (!enabled) return;\n      if (e.pointerType === \"mouse\" && e.button !== 0) return;\n      cancel();\n      start.current = { x: e.clientX, y: e.clientY };\n\n      const onEnd = () => cancel();\n      const onMove = (ev: PointerEvent) => {\n        if (movedBeyondSlop(start.current, ev.clientX, ev.clientY)) cancel();\n      };\n      window.addEventListener(\"pointerup\", onEnd);\n      window.addEventListener(\"pointercancel\", onEnd);\n      window.addEventListener(\"pointermove\", onMove);\n      window.addEventListener(\"scroll\", onEnd, { capture: true, passive: true });\n      teardown.current = () => {\n        window.removeEventListener(\"pointerup\", onEnd);\n        window.removeEventListener(\"pointercancel\", onEnd);\n        window.removeEventListener(\"pointermove\", onMove);\n        window.removeEventListener(\"scroll\", onEnd, { capture: true });\n      };\n\n      timer.current = window.setTimeout(() => {\n        cancel();\n        fired.current = true;\n        // The swipe stages' haptic vocabulary; absent on iOS Safari.\n        navigator.vibrate?.(20);\n        cbRef.current();\n      }, delay);\n    },\n    [cancel, delay, enabled],\n  );\n\n  // Also on the element: it still cancels if an ancestor stops the native event\n  // before it reaches `window`.\n  const onPointerMove = useCallback(\n    (e: ReactPointerEvent) => {\n      if (timer.current === null) return;\n      if (movedBeyondSlop(start.current, e.clientX, e.clientY)) cancel();\n    },\n    [cancel],\n  );\n\n  const onContextMenu = useCallback(\n    (e: { preventDefault: () => void }) => {\n      if (enabled) e.preventDefault();\n    },\n    [enabled],\n  );\n\n  const consumeClick = useCallback(() => {\n    if (!fired.current) return false;\n    fired.current = false;\n    return true;\n  }, []);\n\n  useEffect(() => cancel, [cancel]);\n\n  return { handlers: { onPointerDown, onPointerMove, onContextMenu }, consumeClick };\n}\n"],"mappings":";AAAA,SAAS,aAAa,WAAW,cAAsD;AAQvF,MAAM,gBAAgB;AAGtB,MAAM,UAAU;AAEhB,MAAM,kBAAkB,CAAC,MAAgC,GAAW,MAClE,KAAK,MAAM,IAAI,KAAK,GAAG,IAAI,KAAK,CAAC,IAAI;AA0BhC,SAAS,aACd,aACA,EAAE,UAAU,MAAM,QAAQ,cAAc,IAA2C,CAAC,GACnE;AACjB,QAAM,QAAQ,OAAsB,IAAI;AACxC,QAAM,QAAQ,OAAO,EAAE,GAAG,GAAG,GAAG,EAAE,CAAC;AACnC,QAAM,QAAQ,OAAO,KAAK;AAC1B,QAAM,WAAW,OAA4B,IAAI;AACjD,QAAM,QAAQ,OAAO,WAAW;AAChC,YAAU,MAAM;AACd,UAAM,UAAU;AAAA,EAClB,CAAC;AAED,QAAM,SAAS,YAAY,MAAM;AAC/B,QAAI,MAAM,YAAY,MAAM;AAC1B,aAAO,aAAa,MAAM,OAAO;AACjC,YAAM,UAAU;AAAA,IAClB;AACA,aAAS,UAAU;AACnB,aAAS,UAAU;AAAA,EACrB,GAAG,CAAC,CAAC;AAEL,QAAM,gBAAgB;AAAA,IACpB,CAAC,MAAyB;AAIxB,YAAM,UAAU;AAChB,UAAI,CAAC,QAAS;AACd,UAAI,EAAE,gBAAgB,WAAW,EAAE,WAAW,EAAG;AACjD,aAAO;AACP,YAAM,UAAU,EAAE,GAAG,EAAE,SAAS,GAAG,EAAE,QAAQ;AAE7C,YAAM,QAAQ,MAAM,OAAO;AAC3B,YAAM,SAAS,CAAC,OAAqB;AACnC,YAAI,gBAAgB,MAAM,SAAS,GAAG,SAAS,GAAG,OAAO,EAAG,QAAO;AAAA,MACrE;AACA,aAAO,iBAAiB,aAAa,KAAK;AAC1C,aAAO,iBAAiB,iBAAiB,KAAK;AAC9C,aAAO,iBAAiB,eAAe,MAAM;AAC7C,aAAO,iBAAiB,UAAU,OAAO,EAAE,SAAS,MAAM,SAAS,KAAK,CAAC;AACzE,eAAS,UAAU,MAAM;AACvB,eAAO,oBAAoB,aAAa,KAAK;AAC7C,eAAO,oBAAoB,iBAAiB,KAAK;AACjD,eAAO,oBAAoB,eAAe,MAAM;AAChD,eAAO,oBAAoB,UAAU,OAAO,EAAE,SAAS,KAAK,CAAC;AAAA,MAC/D;AAEA,YAAM,UAAU,OAAO,WAAW,MAAM;AACtC,eAAO;AACP,cAAM,UAAU;AAEhB,kBAAU,UAAU,EAAE;AACtB,cAAM,QAAQ;AAAA,MAChB,GAAG,KAAK;AAAA,IACV;AAAA,IACA,CAAC,QAAQ,OAAO,OAAO;AAAA,EACzB;AAIA,QAAM,gBAAgB;AAAA,IACpB,CAAC,MAAyB;AACxB,UAAI,MAAM,YAAY,KAAM;AAC5B,UAAI,gBAAgB,MAAM,SAAS,EAAE,SAAS,EAAE,OAAO,EAAG,QAAO;AAAA,IACnE;AAAA,IACA,CAAC,MAAM;AAAA,EACT;AAEA,QAAM,gBAAgB;AAAA,IACpB,CAAC,MAAsC;AACrC,UAAI,QAAS,GAAE,eAAe;AAAA,IAChC;AAAA,IACA,CAAC,OAAO;AAAA,EACV;AAEA,QAAM,eAAe,YAAY,MAAM;AACrC,QAAI,CAAC,MAAM,QAAS,QAAO;AAC3B,UAAM,UAAU;AAChB,WAAO;AAAA,EACT,GAAG,CAAC,CAAC;AAEL,YAAU,MAAM,QAAQ,CAAC,MAAM,CAAC;AAEhC,SAAO,EAAE,UAAU,EAAE,eAAe,eAAe,cAAc,GAAG,aAAa;AACnF;","names":[]}
+{"version":3,"sources":["../../src/hooks/use-long-press.ts"],"sourcesContent":["import { useCallback, useEffect, useRef, type PointerEvent as ReactPointerEvent } from \"react\";\n\n// The press-and-hold that puts DataTable's phone cards into selection mode (0.40,\n// keksdose live #421). Taken over from keksdose's register list\n// (frontend/src/shared/hooks/use-long-press.ts, its feedback #153) so the kit's cards\n// and kk's register answer the same gesture the same way: 500 ms, an 8 px dead zone,\n// cancelled by a scroll, the trailing click swallowed. Public since 0.52 (DUP-8, refactor\n// audit 2026-10-30): private, it left keksdose keeping the original beside the copy.\n\nconst LONG_PRESS_MS = 500;\n/** The same 8 px dead zone `useRowSwipe` locks its axis at: the press is dead by the\n *  time the swipe hook takes pointer capture on its (ancestor) layer. */\nconst SLOP_PX = 8;\n\nconst movedBeyondSlop = (from: { x: number; y: number }, x: number, y: number) =>\n  Math.hypot(x - from.x, y - from.y) > SLOP_PX;\n\nexport interface LongPressOptions {\n  /** Default `true`. Off, a press does nothing and the context menu is the browser's. */\n  enabled?: boolean;\n  /** How long a press is held, in ms. Default 500. */\n  delay?: number;\n}\n\nexport interface LongPressResult {\n  handlers: {\n    onPointerDown: (e: ReactPointerEvent) => void;\n    onPointerMove: (e: ReactPointerEvent) => void;\n    onContextMenu: (e: { preventDefault: () => void }) => void;\n  };\n  /** True exactly once after a long press fired: call it from an `onClickCapture` to\n   *  swallow the click the browser still sends when the finger lifts. */\n  consumeClick: () => boolean;\n}\n\n/**\n * A press-and-hold on a touch row that may ALSO be swipeable.\n *\n *  - The cancel listeners live on `window`: `useRowSwipe` captures the pointer on an\n *    ancestor once a drag resolves to the x axis, after which the pressed element's\n *    own pointer handlers stop firing, and a timer cancelled only there would fire\n *    mid-swipe.\n *  - A scroll cancels too (`touch-action: pan-y` hands vertical panning to the\n *    browser, which sends `pointercancel`; the capture-phase `scroll` is the backstop).\n *  - `contextmenu` is suppressed while enabled — Android fires it at ~500 ms. Pair it\n *    with `select-none [-webkit-touch-callout:none]` on the element: iOS's callout\n *    only yields to that CSS.\n */\nexport function useLongPress(\n  onLongPress: () => void,\n  { enabled = true, delay = LONG_PRESS_MS }: LongPressOptions = {},\n): LongPressResult {\n  const timer = useRef<number | null>(null);\n  const start = useRef({ x: 0, y: 0 });\n  const fired = useRef(false);\n  const teardown = useRef<(() => void) | null>(null);\n  const cbRef = useRef(onLongPress);\n  useEffect(() => {\n    cbRef.current = onLongPress;\n  });\n\n  const cancel = useCallback(() => {\n    if (timer.current !== null) {\n      window.clearTimeout(timer.current);\n      timer.current = null;\n    }\n    teardown.current?.();\n    teardown.current = null;\n  }, []);\n\n  const onPointerDown = useCallback(\n    (e: ReactPointerEvent) => {\n      // Cleared above every early return: a press whose trailing click never arrives\n      // (the finger lifted over another row) would otherwise leave the latch armed,\n      // and it would eat the next real tap once the card has switched modes.\n      fired.current = false;\n      if (!enabled) return;\n      if (e.pointerType === \"mouse\" && e.button !== 0) return;\n      cancel();\n      start.current = { x: e.clientX, y: e.clientY };\n\n      const onEnd = () => cancel();\n      const onMove = (ev: PointerEvent) => {\n        if (movedBeyondSlop(start.current, ev.clientX, ev.clientY)) cancel();\n      };\n      window.addEventListener(\"pointerup\", onEnd);\n      window.addEventListener(\"pointercancel\", onEnd);\n      window.addEventListener(\"pointermove\", onMove);\n      window.addEventListener(\"scroll\", onEnd, { capture: true, passive: true });\n      teardown.current = () => {\n        window.removeEventListener(\"pointerup\", onEnd);\n        window.removeEventListener(\"pointercancel\", onEnd);\n        window.removeEventListener(\"pointermove\", onMove);\n        window.removeEventListener(\"scroll\", onEnd, { capture: true });\n      };\n\n      timer.current = window.setTimeout(() => {\n        cancel();\n        fired.current = true;\n        // The swipe stages' haptic vocabulary; absent on iOS Safari.\n        navigator.vibrate?.(20);\n        cbRef.current();\n      }, delay);\n    },\n    [cancel, delay, enabled],\n  );\n\n  // Also on the element: it still cancels if an ancestor stops the native event\n  // before it reaches `window`.\n  const onPointerMove = useCallback(\n    (e: ReactPointerEvent) => {\n      if (timer.current === null) return;\n      if (movedBeyondSlop(start.current, e.clientX, e.clientY)) cancel();\n    },\n    [cancel],\n  );\n\n  const onContextMenu = useCallback(\n    (e: { preventDefault: () => void }) => {\n      if (enabled) e.preventDefault();\n    },\n    [enabled],\n  );\n\n  const consumeClick = useCallback(() => {\n    if (!fired.current) return false;\n    fired.current = false;\n    return true;\n  }, []);\n\n  // Turned off mid-press: the armed timer still fired, entering selection mode against the\n  // caller's wish and arming `consumeClick` for the next click (0.52 code review).\n  useEffect(() => {\n    if (!enabled) cancel();\n  }, [enabled, cancel]);\n\n  useEffect(() => cancel, [cancel]);\n\n  return { handlers: { onPointerDown, onPointerMove, onContextMenu }, consumeClick };\n}\n"],"mappings":";AAAA,SAAS,aAAa,WAAW,cAAsD;AASvF,MAAM,gBAAgB;AAGtB,MAAM,UAAU;AAEhB,MAAM,kBAAkB,CAAC,MAAgC,GAAW,MAClE,KAAK,MAAM,IAAI,KAAK,GAAG,IAAI,KAAK,CAAC,IAAI;AAiChC,SAAS,aACd,aACA,EAAE,UAAU,MAAM,QAAQ,cAAc,IAAsB,CAAC,GAC9C;AACjB,QAAM,QAAQ,OAAsB,IAAI;AACxC,QAAM,QAAQ,OAAO,EAAE,GAAG,GAAG,GAAG,EAAE,CAAC;AACnC,QAAM,QAAQ,OAAO,KAAK;AAC1B,QAAM,WAAW,OAA4B,IAAI;AACjD,QAAM,QAAQ,OAAO,WAAW;AAChC,YAAU,MAAM;AACd,UAAM,UAAU;AAAA,EAClB,CAAC;AAED,QAAM,SAAS,YAAY,MAAM;AAC/B,QAAI,MAAM,YAAY,MAAM;AAC1B,aAAO,aAAa,MAAM,OAAO;AACjC,YAAM,UAAU;AAAA,IAClB;AACA,aAAS,UAAU;AACnB,aAAS,UAAU;AAAA,EACrB,GAAG,CAAC,CAAC;AAEL,QAAM,gBAAgB;AAAA,IACpB,CAAC,MAAyB;AAIxB,YAAM,UAAU;AAChB,UAAI,CAAC,QAAS;AACd,UAAI,EAAE,gBAAgB,WAAW,EAAE,WAAW,EAAG;AACjD,aAAO;AACP,YAAM,UAAU,EAAE,GAAG,EAAE,SAAS,GAAG,EAAE,QAAQ;AAE7C,YAAM,QAAQ,MAAM,OAAO;AAC3B,YAAM,SAAS,CAAC,OAAqB;AACnC,YAAI,gBAAgB,MAAM,SAAS,GAAG,SAAS,GAAG,OAAO,EAAG,QAAO;AAAA,MACrE;AACA,aAAO,iBAAiB,aAAa,KAAK;AAC1C,aAAO,iBAAiB,iBAAiB,KAAK;AAC9C,aAAO,iBAAiB,eAAe,MAAM;AAC7C,aAAO,iBAAiB,UAAU,OAAO,EAAE,SAAS,MAAM,SAAS,KAAK,CAAC;AACzE,eAAS,UAAU,MAAM;AACvB,eAAO,oBAAoB,aAAa,KAAK;AAC7C,eAAO,oBAAoB,iBAAiB,KAAK;AACjD,eAAO,oBAAoB,eAAe,MAAM;AAChD,eAAO,oBAAoB,UAAU,OAAO,EAAE,SAAS,KAAK,CAAC;AAAA,MAC/D;AAEA,YAAM,UAAU,OAAO,WAAW,MAAM;AACtC,eAAO;AACP,cAAM,UAAU;AAEhB,kBAAU,UAAU,EAAE;AACtB,cAAM,QAAQ;AAAA,MAChB,GAAG,KAAK;AAAA,IACV;AAAA,IACA,CAAC,QAAQ,OAAO,OAAO;AAAA,EACzB;AAIA,QAAM,gBAAgB;AAAA,IACpB,CAAC,MAAyB;AACxB,UAAI,MAAM,YAAY,KAAM;AAC5B,UAAI,gBAAgB,MAAM,SAAS,EAAE,SAAS,EAAE,OAAO,EAAG,QAAO;AAAA,IACnE;AAAA,IACA,CAAC,MAAM;AAAA,EACT;AAEA,QAAM,gBAAgB;AAAA,IACpB,CAAC,MAAsC;AACrC,UAAI,QAAS,GAAE,eAAe;AAAA,IAChC;AAAA,IACA,CAAC,OAAO;AAAA,EACV;AAEA,QAAM,eAAe,YAAY,MAAM;AACrC,QAAI,CAAC,MAAM,QAAS,QAAO;AAC3B,UAAM,UAAU;AAChB,WAAO;AAAA,EACT,GAAG,CAAC,CAAC;AAIL,YAAU,MAAM;AACd,QAAI,CAAC,QAAS,QAAO;AAAA,EACvB,GAAG,CAAC,SAAS,MAAM,CAAC;AAEpB,YAAU,MAAM,QAAQ,CAAC,MAAM,CAAC;AAEhC,SAAO,EAAE,UAAU,EAAE,eAAe,eAAe,cAAc,GAAG,aAAa;AACnF;","names":[]}

package/dist/hooks/use-media-query.js

@@ -1,13 +1,21 @@
 "use client";
-import { useEffect, useState } from "react";
+import { useEffect, useEffectEvent, useState } from "react";
 function useMediaQuery(query, fallback) {
   const get = () => typeof window !== "undefined" && typeof window.matchMedia === "function" ? window.matchMedia(query).matches : fallback;
-  const [matches, setMatches] = useState(get);
+  const [state, setState] = useState(() => ({ query, matches: get() }));
+  let matches = state.matches;
+  if (state.query !== query) {
+    matches = get();
+    setState({ query, matches });
+  }
+  const answered = useEffectEvent(() => matches);
   useEffect(() => {
     if (typeof window === "undefined" || typeof window.matchMedia !== "function") return;
     const mql = window.matchMedia(query);
-    const update = () => setMatches(mql.matches);
-    update();
+    const update = () => setState(
+      (prev) => prev.query === query && prev.matches === mql.matches ? prev : { query, matches: mql.matches }
+    );
+    if (mql.matches !== answered()) update();
     mql.addEventListener("change", update);
     return () => mql.removeEventListener("change", update);
   }, [query]);

package/dist/hooks/use-media-query.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/hooks/use-media-query.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\n\n/**\n * Subscribe to a CSS media query, returning whether it currently matches and\n * re-rendering when it changes. `fallback` is the value used during SSR / when\n * `window.matchMedia` is unavailable.\n */\nexport function useMediaQuery(query: string, fallback: boolean): boolean {\n  const get = () =>\n    typeof window !== \"undefined\" && typeof window.matchMedia === \"function\"\n      ? window.matchMedia(query).matches\n      : fallback;\n  const [matches, setMatches] = useState<boolean>(get);\n  useEffect(() => {\n    if (typeof window === \"undefined\" || typeof window.matchMedia !== \"function\") return;\n    const mql = window.matchMedia(query);\n    const update = () => setMatches(mql.matches);\n    update();\n    mql.addEventListener(\"change\", update);\n    return () => mql.removeEventListener(\"change\", update);\n  }, [query]);\n  return matches;\n}\n"],"mappings":";AAAA,SAAS,WAAW,gBAAgB;AAO7B,SAAS,cAAc,OAAe,UAA4B;AACvE,QAAM,MAAM,MACV,OAAO,WAAW,eAAe,OAAO,OAAO,eAAe,aAC1D,OAAO,WAAW,KAAK,EAAE,UACzB;AACN,QAAM,CAAC,SAAS,UAAU,IAAI,SAAkB,GAAG;AACnD,YAAU,MAAM;AACd,QAAI,OAAO,WAAW,eAAe,OAAO,OAAO,eAAe,WAAY;AAC9E,UAAM,MAAM,OAAO,WAAW,KAAK;AACnC,UAAM,SAAS,MAAM,WAAW,IAAI,OAAO;AAC3C,WAAO;AACP,QAAI,iBAAiB,UAAU,MAAM;AACrC,WAAO,MAAM,IAAI,oBAAoB,UAAU,MAAM;AAAA,EACvD,GAAG,CAAC,KAAK,CAAC;AACV,SAAO;AACT;","names":[]}
+{"version":3,"sources":["../../src/hooks/use-media-query.ts"],"sourcesContent":["import { useEffect, useEffectEvent, useState } from \"react\";\n\n/**\n * Subscribe to a CSS media query, returning whether it currently matches and\n * re-rendering when it changes. `fallback` is the value used during SSR / when\n * `window.matchMedia` is unavailable.\n */\nexport function useMediaQuery(query: string, fallback: boolean): boolean {\n  const get = () =>\n    typeof window !== \"undefined\" && typeof window.matchMedia === \"function\"\n      ? window.matchMedia(query).matches\n      : fallback;\n  // The answer is kept with the query it answers, and a new query is asked during the\n  // render that brings it. Read at mount only, the first commit after a new query still\n  // answered the OLD one, until the effect corrected it: `useBreakpoint` asks a new query\n  // when the text size changes, and at Large in a 700 px window the tour card was drawn\n  // un-docked for a frame before it docked (0.52 code review, use-breakpoint.ts).\n  const [state, setState] = useState(() => ({ query, matches: get() }));\n  let matches = state.matches;\n  if (state.query !== query) {\n    matches = get();\n    setState({ query, matches });\n  }\n  const answered = useEffectEvent(() => matches);\n  useEffect(() => {\n    if (typeof window === \"undefined\" || typeof window.matchMedia !== \"function\") return;\n    const mql = window.matchMedia(query);\n    const update = () =>\n      setState((prev) =>\n        prev.query === query && prev.matches === mql.matches ? prev : { query, matches: mql.matches },\n      );\n    // A change between the render and this subscription. Only then: an update that\n    // changes nothing still costs a render (and a commit) right after a new query.\n    if (mql.matches !== answered()) update();\n    mql.addEventListener(\"change\", update);\n    return () => mql.removeEventListener(\"change\", update);\n  }, [query]);\n  return matches;\n}\n"],"mappings":";AAAA,SAAS,WAAW,gBAAgB,gBAAgB;AAO7C,SAAS,cAAc,OAAe,UAA4B;AACvE,QAAM,MAAM,MACV,OAAO,WAAW,eAAe,OAAO,OAAO,eAAe,aAC1D,OAAO,WAAW,KAAK,EAAE,UACzB;AAMN,QAAM,CAAC,OAAO,QAAQ,IAAI,SAAS,OAAO,EAAE,OAAO,SAAS,IAAI,EAAE,EAAE;AACpE,MAAI,UAAU,MAAM;AACpB,MAAI,MAAM,UAAU,OAAO;AACzB,cAAU,IAAI;AACd,aAAS,EAAE,OAAO,QAAQ,CAAC;AAAA,EAC7B;AACA,QAAM,WAAW,eAAe,MAAM,OAAO;AAC7C,YAAU,MAAM;AACd,QAAI,OAAO,WAAW,eAAe,OAAO,OAAO,eAAe,WAAY;AAC9E,UAAM,MAAM,OAAO,WAAW,KAAK;AACnC,UAAM,SAAS,MACb;AAAA,MAAS,CAAC,SACR,KAAK,UAAU,SAAS,KAAK,YAAY,IAAI,UAAU,OAAO,EAAE,OAAO,SAAS,IAAI,QAAQ;AAAA,IAC9F;AAGF,QAAI,IAAI,YAAY,SAAS,EAAG,QAAO;AACvC,QAAI,iBAAiB,UAAU,MAAM;AACrC,WAAO,MAAM,IAAI,oBAAoB,UAAU,MAAM;AAAA,EACvD,GAAG,CAAC,KAAK,CAAC;AACV,SAAO;AACT;","names":[]}

package/dist/hooks/use-mounted.d.ts

@@ -0,0 +1,22 @@
+/**
+ * A mounted guard and a callback-to-promise bridge, for a card that awaits an app's
+ * callback and must not set state after the page moved on.
+ *
+ * Written for the account settings parts (0.34) and then imported by seven notifications
+ * modules out of `account/account-parts.ts`: a generic helper living in a feature folder
+ * that the folder beside it reached into sideways (refactor audit 2026-10-30, MOD-6).
+ * `account-parts.ts` re-exports both, so nothing that imported them there moved, and
+ * `admin/admin-parts.ts` re-exports `settle` in place of its own copy (0.52 code review).
+ *
+ * @internal Not part of the barrel.
+ */
+/** Whether the component is still mounted — a late answer after the app navigated away
+ *  (the deletion signs out) must not set state. */
+export declare function useMounted(): {
+    readonly current: boolean;
+};
+/** Call `call` and hand back a promise, a throw included — a callback may return
+ *  nothing (done at once), a promise, or throw before it returns one. Typed by what it
+ *  answers, so the admin parts' copy, which kept the type, could go (0.52 code review,
+ *  admin/admin-parts.ts). */
+export declare function settle<R>(call: () => R): Promise<Awaited<R>>;

package/dist/hooks/use-mounted.js

@@ -0,0 +1,24 @@
+"use client";
+import { useEffect, useRef } from "react";
+function useMounted() {
+  const mounted = useRef(true);
+  useEffect(() => {
+    mounted.current = true;
+    return () => {
+      mounted.current = false;
+    };
+  }, []);
+  return mounted;
+}
+function settle(call) {
+  try {
+    return Promise.resolve(call());
+  } catch (error) {
+    return Promise.reject(error);
+  }
+}
+export {
+  settle,
+  useMounted
+};
+//# sourceMappingURL=use-mounted.js.map

package/dist/hooks/use-mounted.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/use-mounted.ts"],"sourcesContent":["import { useEffect, useRef } from \"react\";\n\n/**\n * A mounted guard and a callback-to-promise bridge, for a card that awaits an app's\n * callback and must not set state after the page moved on.\n *\n * Written for the account settings parts (0.34) and then imported by seven notifications\n * modules out of `account/account-parts.ts`: a generic helper living in a feature folder\n * that the folder beside it reached into sideways (refactor audit 2026-10-30, MOD-6).\n * `account-parts.ts` re-exports both, so nothing that imported them there moved, and\n * `admin/admin-parts.ts` re-exports `settle` in place of its own copy (0.52 code review).\n *\n * @internal Not part of the barrel.\n */\n\n/** Whether the component is still mounted — a late answer after the app navigated away\n *  (the deletion signs out) must not set state. */\nexport function useMounted(): { readonly current: boolean } {\n  const mounted = useRef(true);\n  useEffect(() => {\n    mounted.current = true;\n    return () => {\n      mounted.current = false;\n    };\n  }, []);\n  return mounted;\n}\n\n/** Call `call` and hand back a promise, a throw included — a callback may return\n *  nothing (done at once), a promise, or throw before it returns one. Typed by what it\n *  answers, so the admin parts' copy, which kept the type, could go (0.52 code review,\n *  admin/admin-parts.ts). */\nexport function settle<R>(call: () => R): Promise<Awaited<R>> {\n  try {\n    return Promise.resolve(call());\n  } catch (error) {\n    return Promise.reject(error);\n  }\n}\n"],"mappings":";AAAA,SAAS,WAAW,cAAc;AAiB3B,SAAS,aAA4C;AAC1D,QAAM,UAAU,OAAO,IAAI;AAC3B,YAAU,MAAM;AACd,YAAQ,UAAU;AAClB,WAAO,MAAM;AACX,cAAQ,UAAU;AAAA,IACpB;AAAA,EACF,GAAG,CAAC,CAAC;AACL,SAAO;AACT;AAMO,SAAS,OAAU,MAAoC;AAC5D,MAAI;AACF,WAAO,QAAQ,QAAQ,KAAK,CAAC;AAAA,EAC/B,SAAS,OAAO;AACd,WAAO,QAAQ,OAAO,KAAK;AAAA,EAC7B;AACF;","names":[]}

package/dist/hooks/use-overlay-history.js

@@ -8,6 +8,7 @@ let lastSeen = null;
 const consumed = /* @__PURE__ */ new Set();
 let pendingProgrammatic = 0;
 let listening = false;
+let noting = false;
 let nextId = 0;
 let unwind = null;
 function runUnwind() {
@@ -175,6 +176,7 @@ function closeOnPop() {
     return;
   }
   stack.pop();
+  syncGestureListeners();
   consumed.add(top.id);
   const record = pushed.find((p) => p.id === top.id);
   forgetPushed(top.id);
@@ -192,11 +194,23 @@ function putBack(id) {
 function ensureListening() {
   if (listening || typeof window === "undefined") return;
   window.addEventListener("popstate", handlePop);
-  window.addEventListener("pointerdown", noteAddress, true);
-  window.addEventListener("keydown", noteAddress, true);
-  for (const type of ["click", "keyup", "change", "input"]) window.addEventListener(type, noteSeenNowAndLater);
   listening = true;
 }
+const SEEN_EVENTS = ["click", "keyup", "change", "input"];
+function syncGestureListeners() {
+  const want = stack.length > 0;
+  if (want === noting || typeof window === "undefined") return;
+  noting = want;
+  if (want) {
+    window.addEventListener("pointerdown", noteAddress, true);
+    window.addEventListener("keydown", noteAddress, true);
+    for (const type of SEEN_EVENTS) window.addEventListener(type, noteSeenNowAndLater);
+  } else {
+    window.removeEventListener("pointerdown", noteAddress, true);
+    window.removeEventListener("keydown", noteAddress, true);
+    for (const type of SEEN_EVENTS) window.removeEventListener(type, noteSeenNowAndLater);
+  }
+}
 function useOverlayHistory(open, onClose, { held = false } = {}) {
   const closeRef = useRef(onClose);
   const heldRef = useRef(held);
@@ -210,6 +224,7 @@ function useOverlayHistory(open, onClose, { held = false } = {}) {
     const id = `overlay-${nextId += 1}`;
     const entry = { id, close: () => closeRef.current(), held: () => heldRef.current };
     stack.push(entry);
+    syncGestureListeners();
     const prev = window.history.state;
     const marked = { ...prev && typeof prev === "object" ? prev : {}, [SENTINEL_KEY]: id };
     const adopting = unwind && unwind.id === currentSentinel() && unwind.href === currentHref();
@@ -242,6 +257,7 @@ function useOverlayHistory(open, onClose, { held = false } = {}) {
     return () => {
       const at = stack.indexOf(entry);
       if (at >= 0) stack.splice(at, 1);
+      syncGestureListeners();
       if (consumed.delete(id)) return;
       const mine = pushed.findIndex((p) => p.id === id);
       if (mine >= 0 && currentHref() !== pushed[mine].href) {