@eifi1/ui-kit 0.51.6 → 0.52.0

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

@@ -1 +1 @@
-{"version":3,"sources":["../../src/hooks/use-dismiss.ts"],"sourcesContent":["import { useCallback, useEffect, useRef, useSyncExternalStore } from \"react\";\nimport type { KeyboardEvent as ReactKeyboardEvent, RefObject } from \"react\";\nimport { isComposing } from \"../lib/ime\";\n\n/*\n * # One Escape stack (round 0.34 Wave 2, DUP-1)\n *\n * Escape closes the TOPMOST thing on screen, and only that: a list open in a dialog\n * closes and the dialog stays; the next press closes the dialog.\n *\n * \"Who owns Escape\" used to be decided five ways. The anchored pickers listened on the\n * document; Modal, FullBleedDialog, PickerSheet and Popover closed in their own panel's\n * `onKeyDown` and stopped the key; CommandPalette closed without stopping it. A dialog's\n * handler sits earlier on the key's path than any document listener, so Escape in an\n * open list inside a Modal closed the MODAL and threw the form away (BUG-1, sev 4,\n * kastlan's lease dialog), and HoverMenu, the numpad and a tooltip could not be\n * dismissed inside a dialog at all. And Modal and FullBleedDialog disagreed on when a\n * child had \"claimed\" the key: a ChipInput clearing its draft kept a Modal open and\n * closed a FullBleedDialog.\n *\n * Now every overlay and picker pushes a layer while it is open ({@link useDismissLayer}),\n * last in, first out, the way `use-overlay-history` stacks the Back gesture. One\n * capture-phase listener on the document notes which layer is on top as each Escape\n * goes down — before any handler on the page runs, so a layer that closes on the way\n * cannot pass the key on to the one beneath it. That layer, and only that one, is\n * handed the key:\n *\n * - at the first layer element the key passes on its way back up ({@link takeEscape},\n *   which Modal's panel, a picker's search box and the rest call from their\n *   `onKeyDown`). The key is stopped there, so nothing around the layers — a\n *   FloatingPanel, an app's own panel — closes with it;\n * - or, when focus is in none of them (a hover menu, a tooltip, the numpad over its\n *   field, a press on the page), at the document once the key has been everywhere else.\n *\n * Layers stack in the order they OPEN, which is the order their effects run. Two that\n * open in the same commit stack child first — the one case that order gets wrong, and\n * one no overlay in the kit does: each opens on a press, after whatever it sits in.\n *\n * ## Claiming the key: one rule\n *\n * An Escape that means \"undo this step\" is not a dismissal: ChipInput clearing its\n * draft, InlineEditField cancelling its edit, the date picker's month grid going back to\n * the days. Those call {@link claimEscape}, and no layer is handed the key. The only\n * other claim is the layer owner's OWN handler — a dialog's `onKeyDown` prop calling\n * `preventDefault()` on Escape (a busy reauth dialog holding itself open, Kurvenschmiede's\n * gear wizard asking first), through {@link runOwnKeyDown}. A `preventDefault()`\n * anywhere else claims nothing: a search box keeping Chromium from clearing itself\n * must not hold a dialog open (FullBleedDialog's 0.8.0 fix, which Modal never had).\n *\n * The owner's handler hears Escape only while its own layer is on top (0.35, KS). It\n * runs before the stack is asked, so with a tooltip, a hover menu or a list open over\n * the dialog and focus on the panel, the gear wizard asked \"Discard this gear?\" and the\n * tooltip stayed. Now the layer above takes that press, and the next one is the\n * owner's. Every other key reaches the handler as before.\n *\n * A handler that STOPS the key before it reaches a layer element has taken it too —\n * that is the DOM, and it is what the kit's cell editors and confirm buttons do.\n */\n\n/** A layer's handler, read through a ref so the stack holds one stable entry per open. */\ninterface Layer {\n  escape: (e: KeyboardEvent) => void;\n  /** Whether it covers the page — a dialog, a sheet, a popover, a list — rather than\n   *  annotating it (a tooltip). Counted by {@link useOverlayOpen}. */\n  overlay: boolean;\n}\n\n/** What {@link useDismissLayer} hands back: its layer while open, for\n *  {@link runOwnKeyDown} to tell whether that layer is the one on top. */\nexport type DismissLayer = RefObject<Layer | null>;\n\n/** Open layers, oldest first. Module-level, because the order is ACROSS instances. */\nconst layers: Layer[] = [];\n\n/** Escapes a claimant has taken — see {@link claimEscape}. Weak: an event is garbage\n *  once its dispatch is over. */\nconst claimed = new WeakSet<Event>();\n\n/** The Escape on its way through the page: the layer that was topmost as it went down,\n *  and whether that layer has been handed it yet. */\nlet inFlight: { event: KeyboardEvent; layer: Layer; done: boolean } | null = null;\n\nfunction nativeOf(e: KeyboardEvent | ReactKeyboardEvent): KeyboardEvent {\n  return \"nativeEvent\" in e ? e.nativeEvent : e;\n}\n\nfunction onCapture(e: KeyboardEvent): void {\n  if (e.key !== \"Escape\") return;\n  // An Escape inside an IME composition cancels the composition and nothing else.\n  const top = isComposing(e) ? undefined : layers[layers.length - 1];\n  inFlight = top ? { event: e, layer: top, done: false } : null;\n}\n\n/** The fallback: no layer element was on the key's path, or none took it. */\nfunction onBubble(e: KeyboardEvent): void {\n  handOver(e, false);\n}\n\nfunction handOver(e: KeyboardEvent | ReactKeyboardEvent, stop: boolean): boolean {\n  const native = nativeOf(e);\n  const flight = inFlight;\n  if (native.key !== \"Escape\" || !flight || flight.event !== native || flight.done) return false;\n  if (claimed.has(native)) return false;\n  flight.done = true;\n  // Consumed: a type=\"search\" box does not clear itself as well, and a handler further\n  // out that checks `defaultPrevented` (FloatingPanel, an app's own panel) leaves it.\n  e.preventDefault();\n  if (stop) e.stopPropagation();\n  // A layer that closed on the way, by a handler of its own, has had its Escape.\n  if (layers.includes(flight.layer)) flight.layer.escape(native);\n  return true;\n}\n\nfunction push(layer: Layer): void {\n  if (layers.length === 0) {\n    document.addEventListener(\"keydown\", onCapture, true);\n    document.addEventListener(\"keydown\", onBubble);\n  }\n  layers.push(layer);\n  if (layer.overlay) notifyOverlays();\n}\n\nfunction pop(layer: Layer): void {\n  const at = layers.indexOf(layer);\n  if (at >= 0) layers.splice(at, 1);\n  if (at >= 0 && layer.overlay) notifyOverlays();\n  if (layers.length > 0) return;\n  document.removeEventListener(\"keydown\", onCapture, true);\n  document.removeEventListener(\"keydown\", onBubble);\n  inFlight = null;\n}\n\n/**\n * An Escape layer on the stack while `open`: the topmost layer is handed the next\n * Escape and calls `onEscape`, every layer under it waits its turn. A list opened inside\n * a dialog is above the dialog; a popover opened from a list, above the list.\n *\n * Where focus can be INSIDE the layer, its element's `onKeyDown` calls\n * {@link takeEscape} too, so the key stops there — see the module note. `onEscape` is\n * read live, so it need not be memoised; the layer is pushed and popped only when\n * `open` flips. The layer it returns is for the owner's {@link runOwnKeyDown}.\n */\nexport function useDismissLayer(\n  open: boolean,\n  onEscape: (e: KeyboardEvent) => void,\n  { overlay = true }: { overlay?: boolean } = {},\n): DismissLayer {\n  const handlerRef = useRef(onEscape);\n  const layerRef = useRef<Layer | null>(null);\n  // Written in an effect, not during render, so it satisfies react-hooks/refs: a\n  // render that React starts and then discards — a transition, a Suspense retry —\n  // would otherwise leave this holding a handler from a tree that never committed,\n  // and the stack would go on to call it. Keydown events fire after the commit, so\n  // the ref is always current by the time one arrives.\n  useEffect(() => {\n    handlerRef.current = onEscape;\n  });\n  useEffect(() => {\n    if (!open || typeof document === \"undefined\") return;\n    const layer: Layer = { escape: (e) => handlerRef.current(e), overlay };\n    layerRef.current = layer;\n    push(layer);\n    return () => {\n      pop(layer);\n      layerRef.current = null;\n    };\n  }, [open, overlay]);\n  return layerRef;\n}\n\n/*\n * Whether an overlay is open (0.49 KIT-11): every layer on the stack but a tooltip's is a\n * dialog, a sheet, a popover, a hover menu or a list covering part of the page, so the\n * stack is also the one place that knows. The floating launchers (`hideWhenOverlay`) step\n * aside while one is open instead of floating over it or beside it.\n */\nconst overlayListeners = new Set<() => void>();\n\nfunction notifyOverlays(): void {\n  for (const listener of overlayListeners) listener();\n}\n\nfunction subscribeOverlays(listener: () => void): () => void {\n  overlayListeners.add(listener);\n  return () => {\n    overlayListeners.delete(listener);\n  };\n}\n\nfunction anyOverlayOpen(): boolean {\n  return layers.some((layer) => layer.overlay);\n}\n\n/** True while a kit dialog, sheet, popover, hover menu or list is open (any layer of the\n *  Escape stack but a tooltip's). Internal. */\nexport function useOverlayOpen(enabled = true): boolean {\n  const open = useSyncExternalStore(subscribeOverlays, anyOverlayOpen, () => false);\n  return enabled && open;\n}\n\n/**\n * For a layer's own element, in its `onKeyDown`: hands an Escape on its way up to the\n * topmost layer — this one, unless something opened over it without taking focus (a\n * tooltip, the numpad) — and stops it here. True when it did; false for any other key,\n * a claimed Escape, or one already handed over.\n */\nexport function takeEscape(e: KeyboardEvent | ReactKeyboardEvent): boolean {\n  return handOver(e, true);\n}\n\n/**\n * For an Escape that means \"undo this step\", not \"close\": the key is the caller's, and\n * no layer is handed it. `preventDefault()`s it as well, so a handler further out that\n * checks `defaultPrevented` leaves it alone, as before.\n */\nexport function claimEscape(e: KeyboardEvent | ReactKeyboardEvent): void {\n  claimed.add(nativeOf(e));\n  e.preventDefault();\n}\n\n/**\n * Runs a layer owner's own key handler — a dialog's `onKeyDown` prop — and turns a\n * `preventDefault()` it makes on Escape into a claim: the one way, beside\n * {@link claimEscape}, to keep a layer open.\n *\n * Given the owner's `layer` (what {@link useDismissLayer} returned), an Escape that went\n * down while another layer was above that one skips the handler: the press is the\n * layer's on top, and the owner hears the next (0.35, KS). Without it, or while the\n * owner's layer is not open, the handler sees every key, as before.\n */\nexport function runOwnKeyDown<E extends ReactKeyboardEvent>(\n  e: E,\n  handler: ((e: E) => void) | undefined,\n  layer?: DismissLayer,\n): void {\n  if (!handler) return;\n  if (layer && aboveOwner(e, layer.current)) return;\n  const before = e.defaultPrevented;\n  handler(e);\n  if (e.key === \"Escape\" && !before && e.defaultPrevented) claimed.add(nativeOf(e));\n}\n\n/** Whether this Escape went down with a layer above `owner` — the topmost one then was\n *  another, and `owner` is on the stack. An Escape the stack did not note (one inside an\n *  IME composition) is nobody else's. */\nfunction aboveOwner(e: ReactKeyboardEvent, owner: Layer | null): boolean {\n  const flight = inFlight;\n  if (e.key !== \"Escape\" || !owner || !flight || flight.event !== nativeOf(e)) return false;\n  return flight.layer !== owner && layers.includes(owner);\n}\n\n/**\n * Calls `handler` on an Escape while `enabled` — as an Escape layer. Since 0.34 this is\n * {@link useDismissLayer} with its arguments the other way round: it hears the key only\n * while nothing opened above it, and inside a dialog it no longer loses the key to the\n * dialog (Wave 2, DUP-1). `handler` is read live, so it need not be memoised.\n */\nexport function useEscapeKey(handler: () => void, enabled = true): void {\n  useDismissLayer(enabled, handler);\n}\n\n/** Called with each native press an owner's React tree saw — see {@link useOutsideClick}. */\ntype PressMark = (press: Event) => void;\n\n/** The outside-click hooks watching each ref, for {@link pressInside}. */\nconst watchers = new WeakMap<RefObject<HTMLElement | null>, Set<PressMark>>();\n\n/** What an `onPointerDownCapture` hands over: a React event, its press inside. */\ntype ReactPress = { nativeEvent: Event };\n\n/**\n * An `onPointerDownCapture` for a panel whose `ref` an outside-click hook watches but\n * whose element the hook's owner does not render — {@link DropdownPanel} and\n * `ComboboxPanel` take `panelRef` from `useDropdown` / `useComboboxCore`. Every press\n * that reaches the panel through the React tree, a portalled list opened inside it\n * included, is marked inside for each hook watching `ref`. See {@link useOutsideClick}.\n */\nexport function pressInside(ref: RefObject<HTMLElement | null> | undefined): ((e: ReactPress) => void) | undefined {\n  if (!ref) return undefined;\n  return (e) => {\n    watchers.get(ref)?.forEach((mark) => mark(e.nativeEvent));\n  };\n}\n\n/**\n * Calls `handler` on a press that lands outside every supplied element, while\n * `enabled` — the outside-click-to-close half of the same dismissal story. Pass one\n * ref or several (trigger + panel); a press inside any of them is ignored. Refs and\n * `handler` are read live, so an inline `[triggerRef, panelRef]` array is fine and\n * won't churn the listener.\n *\n * ## A panel opened from inside is inside (0.48, keksdose dev#623)\n *\n * A CurrencySelect in a Popover: the currency list is portalled to `<body>`, so in the\n * DOM it is outside the popover's panel, and the first press on a currency closed the\n * POPOVER at pointerdown — the list went with it and the choice never landed. The same\n * for a combobox, a menu, a date picker's popover, a dropdown, at any depth.\n *\n * In the React tree the portal is still where it was opened from, and React passes a\n * press up that tree, through portals. So the hook hands back an\n * `onPointerDownCapture`: put it on the element the press should count as inside of —\n * the kit's Popover panel, HoverMenu, DropdownPanel and ComboboxPanel do — and every\n * press that travels through that element in React, portalled panels opened inside it\n * included, is not outside. React's listeners sit on the root and on each portal's\n * container, so they hear the press before this document listener does. No owner chain\n * to keep: depth is free, and an app's own portal inside a kit panel is covered too. A\n * panel the hook's owner does not render takes {@link pressInside} with the watched ref.\n *\n * **`pointerdown`, not `mousedown`** — one event covering mouse, touch and pen.\n * This listened for `mousedown` alone, which on a touch platform is a SYNTHESISED\n * event: the browser emits it for most taps, which is why nothing obviously broke,\n * but the synthesis is not guaranteed. A tap that begins a scroll, or one that lands\n * on an element which preventDefaults the touch sequence, may never produce one — and\n * on a phone-first PWA whose pickers, menus and flyouts all dismiss through this hook,\n * inheriting that is worse than choosing it.\n *\n * The one behaviour this changes deliberately: a touch-drag that starts outside an\n * open panel now dismisses it at touch-down, where before it did not dismiss at all\n * (a drag synthesises no mousedown). That matches every other platform surface, and\n * the anchored panels re-measure on scroll precisely because the page moves under\n * them.\n */\nexport function useOutsideClick(\n  refs: RefObject<HTMLElement | null> | RefObject<HTMLElement | null>[],\n  handler: () => void,\n  enabled = true,\n): (e: ReactPress) => void {\n  const refsRef = useRef(refs);\n  const handlerRef = useRef(handler);\n  // The last press this owner's React tree saw: the one the document listener is about\n  // to hear, when it went through a panel the owner marked.\n  const insideRef = useRef<Event | null>(null);\n  // In an effect rather than during render — see the note in useDismissLayer.\n  useEffect(() => {\n    refsRef.current = refs;\n    handlerRef.current = handler;\n  });\n  const markInside = useCallback((e: ReactPress) => {\n    insideRef.current = e.nativeEvent;\n  }, []);\n  useEffect(() => {\n    if (!enabled) return;\n    const mark: PressMark = (press) => {\n      insideRef.current = press;\n    };\n    const watched = Array.isArray(refsRef.current) ? refsRef.current : [refsRef.current];\n    for (const r of watched) {\n      const set = watchers.get(r) ?? new Set<PressMark>();\n      set.add(mark);\n      watchers.set(r, set);\n    }\n    const onPointerDown = (e: Event) => {\n      const inside = insideRef.current === e;\n      insideRef.current = null;\n      if (inside) return;\n      const target = e.target as Node;\n      const list = Array.isArray(refsRef.current) ? refsRef.current : [refsRef.current];\n      for (const r of list) {\n        if (r.current?.contains(target)) return;\n      }\n      handlerRef.current();\n    };\n    document.addEventListener(\"pointerdown\", onPointerDown);\n    return () => {\n      document.removeEventListener(\"pointerdown\", onPointerDown);\n      for (const r of watched) watchers.get(r)?.delete(mark);\n    };\n  }, [enabled]);\n  return markInside;\n}\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../../src/hooks/use-dismiss.ts"],"sourcesContent":["import { useCallback, useEffect, useRef, useSyncExternalStore } from \"react\";\nimport type { KeyboardEvent as ReactKeyboardEvent, RefObject } from \"react\";\nimport { isComposing } from \"../lib/ime\";\n\n/*\n * # One Escape stack (round 0.34 Wave 2, DUP-1)\n *\n * Escape closes the TOPMOST thing on screen, and only that: a list open in a dialog\n * closes and the dialog stays; the next press closes the dialog.\n *\n * \"Who owns Escape\" used to be decided five ways. The anchored pickers listened on the\n * document; Modal, FullBleedDialog, PickerSheet and Popover closed in their own panel's\n * `onKeyDown` and stopped the key; CommandPalette closed without stopping it. A dialog's\n * handler sits earlier on the key's path than any document listener, so Escape in an\n * open list inside a Modal closed the MODAL and threw the form away (BUG-1, sev 4,\n * kastlan's lease dialog), and HoverMenu, the numpad and a tooltip could not be\n * dismissed inside a dialog at all. And Modal and FullBleedDialog disagreed on when a\n * child had \"claimed\" the key: a ChipInput clearing its draft kept a Modal open and\n * closed a FullBleedDialog.\n *\n * Now every overlay and picker pushes a layer while it is open ({@link useDismissLayer}),\n * last in, first out, the way `use-overlay-history` stacks the Back gesture. One\n * capture-phase listener on the document notes which layer is on top as each Escape\n * goes down — before any handler on the page runs, so a layer that closes on the way\n * cannot pass the key on to the one beneath it. That layer, and only that one, is\n * handed the key:\n *\n * - at the first layer element the key passes on its way back up ({@link takeEscape},\n *   which Modal's panel, a picker's search box and the rest call from their\n *   `onKeyDown`). The key is stopped there, so nothing around the layers — a\n *   FloatingPanel, an app's own panel — closes with it;\n * - or, when focus is in none of them (a hover menu, a tooltip, the numpad over its\n *   field, a press on the page), at the document once the key has been everywhere else.\n *\n * Layers stack in the order they OPEN, which is the order their effects run. Two that\n * open in the same commit stack child first — the one case that order gets wrong, and\n * one no overlay in the kit does: each opens on a press, after whatever it sits in.\n *\n * ## Claiming the key: one rule\n *\n * An Escape that means \"undo this step\" is not a dismissal: ChipInput clearing its\n * draft, InlineEditField cancelling its edit, the date picker's month grid going back to\n * the days. Those call {@link claimEscape}, and no layer is handed the key. The only\n * other claim is the layer owner's OWN handler — a dialog's `onKeyDown` prop calling\n * `preventDefault()` on Escape (Kurvenschmiede's gear wizard asking first), through\n * {@link runOwnKeyDown}. A dialog holding itself open while its request runs passes\n * Modal's `busy` instead (0.51.7, DUP-3), which holds the backdrop and Back as well. A `preventDefault()`\n * anywhere else claims nothing: a search box keeping Chromium from clearing itself\n * must not hold a dialog open (FullBleedDialog's 0.8.0 fix, which Modal never had).\n *\n * The owner's handler hears Escape only while its own layer is on top (0.35, KS). It\n * runs before the stack is asked, so with a tooltip, a hover menu or a list open over\n * the dialog and focus on the panel, the gear wizard asked \"Discard this gear?\" and the\n * tooltip stayed. Now the layer above takes that press, and the next one is the\n * owner's. Every other key reaches the handler as before.\n *\n * A handler that STOPS the key before it reaches a layer element has taken it too —\n * that is the DOM, and it is what the kit's cell editors and confirm buttons do.\n */\n\n/** A layer's handler, read through a ref so the stack holds one stable entry per open. */\ninterface Layer {\n  escape: (e: KeyboardEvent) => void;\n  /** Whether it covers the page — a dialog, a sheet, a popover, a list — rather than\n   *  annotating it (a tooltip). Counted by {@link useOverlayOpen}. */\n  overlay: boolean;\n}\n\n/** What {@link useDismissLayer} hands back: its layer while open, for\n *  {@link runOwnKeyDown} to tell whether that layer is the one on top. */\nexport type DismissLayer = RefObject<Layer | null>;\n\n/** Open layers, oldest first. Module-level, because the order is ACROSS instances. */\nconst layers: Layer[] = [];\n\n/** Escapes a claimant has taken — see {@link claimEscape}. Weak: an event is garbage\n *  once its dispatch is over. */\nconst claimed = new WeakSet<Event>();\n\n/** The Escape on its way through the page: the layer that was topmost as it went down,\n *  and whether that layer has been handed it yet. */\nlet inFlight: { event: KeyboardEvent; layer: Layer; done: boolean } | null = null;\n\nfunction nativeOf(e: KeyboardEvent | ReactKeyboardEvent): KeyboardEvent {\n  return \"nativeEvent\" in e ? e.nativeEvent : e;\n}\n\nfunction onCapture(e: KeyboardEvent): void {\n  if (e.key !== \"Escape\") return;\n  // An Escape inside an IME composition cancels the composition and nothing else.\n  const top = isComposing(e) ? undefined : layers[layers.length - 1];\n  inFlight = top ? { event: e, layer: top, done: false } : null;\n}\n\n/** The fallback: no layer element was on the key's path, or none took it. */\nfunction onBubble(e: KeyboardEvent): void {\n  handOver(e, false);\n}\n\nfunction handOver(e: KeyboardEvent | ReactKeyboardEvent, stop: boolean): boolean {\n  const native = nativeOf(e);\n  const flight = inFlight;\n  if (native.key !== \"Escape\" || !flight || flight.event !== native || flight.done) return false;\n  if (claimed.has(native)) return false;\n  flight.done = true;\n  // Consumed: a type=\"search\" box does not clear itself as well, and a handler further\n  // out that checks `defaultPrevented` (FloatingPanel, an app's own panel) leaves it.\n  e.preventDefault();\n  if (stop) e.stopPropagation();\n  // A layer that closed on the way, by a handler of its own, has had its Escape.\n  if (layers.includes(flight.layer)) flight.layer.escape(native);\n  return true;\n}\n\nfunction push(layer: Layer): void {\n  if (layers.length === 0) {\n    document.addEventListener(\"keydown\", onCapture, true);\n    document.addEventListener(\"keydown\", onBubble);\n  }\n  layers.push(layer);\n  if (layer.overlay) notifyOverlays();\n}\n\nfunction pop(layer: Layer): void {\n  const at = layers.indexOf(layer);\n  if (at >= 0) layers.splice(at, 1);\n  if (at >= 0 && layer.overlay) notifyOverlays();\n  if (layers.length > 0) return;\n  document.removeEventListener(\"keydown\", onCapture, true);\n  document.removeEventListener(\"keydown\", onBubble);\n  inFlight = null;\n}\n\n/**\n * An Escape layer on the stack while `open`: the topmost layer is handed the next\n * Escape and calls `onEscape`, every layer under it waits its turn. A list opened inside\n * a dialog is above the dialog; a popover opened from a list, above the list.\n *\n * Where focus can be INSIDE the layer, its element's `onKeyDown` calls\n * {@link takeEscape} too, so the key stops there — see the module note. `onEscape` is\n * read live, so it need not be memoised; the layer is pushed and popped only when\n * `open` flips. The layer it returns is for the owner's {@link runOwnKeyDown}.\n */\nexport function useDismissLayer(\n  open: boolean,\n  onEscape: (e: KeyboardEvent) => void,\n  { overlay = true }: { overlay?: boolean } = {},\n): DismissLayer {\n  const handlerRef = useRef(onEscape);\n  const layerRef = useRef<Layer | null>(null);\n  // Written in an effect, not during render, so it satisfies react-hooks/refs: a\n  // render that React starts and then discards — a transition, a Suspense retry —\n  // would otherwise leave this holding a handler from a tree that never committed,\n  // and the stack would go on to call it. Keydown events fire after the commit, so\n  // the ref is always current by the time one arrives.\n  useEffect(() => {\n    handlerRef.current = onEscape;\n  });\n  useEffect(() => {\n    if (!open || typeof document === \"undefined\") return;\n    const layer: Layer = { escape: (e) => handlerRef.current(e), overlay };\n    layerRef.current = layer;\n    push(layer);\n    return () => {\n      pop(layer);\n      layerRef.current = null;\n    };\n  }, [open, overlay]);\n  return layerRef;\n}\n\n/*\n * Whether an overlay is open (0.49 KIT-11): every layer on the stack but a tooltip's is a\n * dialog, a sheet, a popover, a hover menu or a list covering part of the page, so the\n * stack is also the one place that knows. The floating launchers (`hideWhenOverlay`) step\n * aside while one is open instead of floating over it or beside it.\n */\nconst overlayListeners = new Set<() => void>();\n\nfunction notifyOverlays(): void {\n  for (const listener of overlayListeners) listener();\n}\n\nfunction subscribeOverlays(listener: () => void): () => void {\n  overlayListeners.add(listener);\n  return () => {\n    overlayListeners.delete(listener);\n  };\n}\n\nfunction anyOverlayOpen(): boolean {\n  return layers.some((layer) => layer.overlay);\n}\n\n/** True while a kit dialog, sheet, popover, hover menu or list is open (any layer of the\n *  Escape stack but a tooltip's). Internal. */\nexport function useOverlayOpen(enabled = true): boolean {\n  const open = useSyncExternalStore(subscribeOverlays, anyOverlayOpen, () => false);\n  return enabled && open;\n}\n\n/**\n * For a layer's own element, in its `onKeyDown`: hands an Escape on its way up to the\n * topmost layer — this one, unless something opened over it without taking focus (a\n * tooltip, the numpad) — and stops it here. True when it did; false for any other key,\n * a claimed Escape, or one already handed over.\n */\nexport function takeEscape(e: KeyboardEvent | ReactKeyboardEvent): boolean {\n  return handOver(e, true);\n}\n\n/**\n * For an Escape that means \"undo this step\", not \"close\": the key is the caller's, and\n * no layer is handed it. `preventDefault()`s it as well, so a handler further out that\n * checks `defaultPrevented` leaves it alone, as before.\n */\nexport function claimEscape(e: KeyboardEvent | ReactKeyboardEvent): void {\n  claimed.add(nativeOf(e));\n  e.preventDefault();\n}\n\n/**\n * Runs a layer owner's own key handler — a dialog's `onKeyDown` prop — and turns a\n * `preventDefault()` it makes on Escape into a claim: the one way, beside\n * {@link claimEscape}, to keep a layer open.\n *\n * Given the owner's `layer` (what {@link useDismissLayer} returned), an Escape that went\n * down while another layer was above that one skips the handler: the press is the\n * layer's on top, and the owner hears the next (0.35, KS). Without it, or while the\n * owner's layer is not open, the handler sees every key, as before.\n */\nexport function runOwnKeyDown<E extends ReactKeyboardEvent>(\n  e: E,\n  handler: ((e: E) => void) | undefined,\n  layer?: DismissLayer,\n): void {\n  if (!handler) return;\n  if (layer && aboveOwner(e, layer.current)) return;\n  const before = e.defaultPrevented;\n  handler(e);\n  if (e.key === \"Escape\" && !before && e.defaultPrevented) claimed.add(nativeOf(e));\n}\n\n/** Whether this Escape went down with a layer above `owner` — the topmost one then was\n *  another, and `owner` is on the stack. An Escape the stack did not note (one inside an\n *  IME composition) is nobody else's. */\nfunction aboveOwner(e: ReactKeyboardEvent, owner: Layer | null): boolean {\n  const flight = inFlight;\n  if (e.key !== \"Escape\" || !owner || !flight || flight.event !== nativeOf(e)) return false;\n  return flight.layer !== owner && layers.includes(owner);\n}\n\n/**\n * Calls `handler` on an Escape while `enabled` — as an Escape layer. Since 0.34 this is\n * {@link useDismissLayer} with its arguments the other way round: it hears the key only\n * while nothing opened above it, and inside a dialog it no longer loses the key to the\n * dialog (Wave 2, DUP-1). `handler` is read live, so it need not be memoised.\n */\nexport function useEscapeKey(handler: () => void, enabled = true): void {\n  useDismissLayer(enabled, handler);\n}\n\n/** Called with each native press an owner's React tree saw — see {@link useOutsideClick}. */\ntype PressMark = (press: Event) => void;\n\n/** The outside-click hooks watching each ref, for {@link pressInside}. */\nconst watchers = new WeakMap<RefObject<HTMLElement | null>, Set<PressMark>>();\n\n/** What an `onPointerDownCapture` hands over: a React event, its press inside. */\ntype ReactPress = { nativeEvent: Event };\n\n/**\n * An `onPointerDownCapture` for a panel whose `ref` an outside-click hook watches but\n * whose element the hook's owner does not render — {@link DropdownPanel} and\n * `ComboboxPanel` take `panelRef` from `useDropdown` / `useComboboxCore`. Every press\n * that reaches the panel through the React tree, a portalled list opened inside it\n * included, is marked inside for each hook watching `ref`. See {@link useOutsideClick}.\n */\nexport function pressInside(ref: RefObject<HTMLElement | null> | undefined): ((e: ReactPress) => void) | undefined {\n  if (!ref) return undefined;\n  return (e) => {\n    watchers.get(ref)?.forEach((mark) => mark(e.nativeEvent));\n  };\n}\n\n/**\n * Calls `handler` on a press that lands outside every supplied element, while\n * `enabled` — the outside-click-to-close half of the same dismissal story. Pass one\n * ref or several (trigger + panel); a press inside any of them is ignored. Refs and\n * `handler` are read live, so an inline `[triggerRef, panelRef]` array is fine and\n * won't churn the listener.\n *\n * ## A panel opened from inside is inside (0.48, keksdose dev#623)\n *\n * A CurrencySelect in a Popover: the currency list is portalled to `<body>`, so in the\n * DOM it is outside the popover's panel, and the first press on a currency closed the\n * POPOVER at pointerdown — the list went with it and the choice never landed. The same\n * for a combobox, a menu, a date picker's popover, a dropdown, at any depth.\n *\n * In the React tree the portal is still where it was opened from, and React passes a\n * press up that tree, through portals. So the hook hands back an\n * `onPointerDownCapture`: put it on the element the press should count as inside of —\n * the kit's Popover panel, HoverMenu, DropdownPanel and ComboboxPanel do — and every\n * press that travels through that element in React, portalled panels opened inside it\n * included, is not outside. React's listeners sit on the root and on each portal's\n * container, so they hear the press before this document listener does. No owner chain\n * to keep: depth is free, and an app's own portal inside a kit panel is covered too. A\n * panel the hook's owner does not render takes {@link pressInside} with the watched ref.\n *\n * **`pointerdown`, not `mousedown`** — one event covering mouse, touch and pen.\n * This listened for `mousedown` alone, which on a touch platform is a SYNTHESISED\n * event: the browser emits it for most taps, which is why nothing obviously broke,\n * but the synthesis is not guaranteed. A tap that begins a scroll, or one that lands\n * on an element which preventDefaults the touch sequence, may never produce one — and\n * on a phone-first PWA whose pickers, menus and flyouts all dismiss through this hook,\n * inheriting that is worse than choosing it.\n *\n * The one behaviour this changes deliberately: a touch-drag that starts outside an\n * open panel now dismisses it at touch-down, where before it did not dismiss at all\n * (a drag synthesises no mousedown). That matches every other platform surface, and\n * the anchored panels re-measure on scroll precisely because the page moves under\n * them.\n */\nexport function useOutsideClick(\n  refs: RefObject<HTMLElement | null> | RefObject<HTMLElement | null>[],\n  handler: () => void,\n  enabled = true,\n): (e: ReactPress) => void {\n  const refsRef = useRef(refs);\n  const handlerRef = useRef(handler);\n  // The last press this owner's React tree saw: the one the document listener is about\n  // to hear, when it went through a panel the owner marked.\n  const insideRef = useRef<Event | null>(null);\n  // In an effect rather than during render — see the note in useDismissLayer.\n  useEffect(() => {\n    refsRef.current = refs;\n    handlerRef.current = handler;\n  });\n  const markInside = useCallback((e: ReactPress) => {\n    insideRef.current = e.nativeEvent;\n  }, []);\n  useEffect(() => {\n    if (!enabled) return;\n    const mark: PressMark = (press) => {\n      insideRef.current = press;\n    };\n    const watched = Array.isArray(refsRef.current) ? refsRef.current : [refsRef.current];\n    for (const r of watched) {\n      const set = watchers.get(r) ?? new Set<PressMark>();\n      set.add(mark);\n      watchers.set(r, set);\n    }\n    const onPointerDown = (e: Event) => {\n      const inside = insideRef.current === e;\n      insideRef.current = null;\n      if (inside) return;\n      const target = e.target as Node;\n      const list = Array.isArray(refsRef.current) ? refsRef.current : [refsRef.current];\n      for (const r of list) {\n        if (r.current?.contains(target)) return;\n      }\n      handlerRef.current();\n    };\n    document.addEventListener(\"pointerdown\", onPointerDown);\n    return () => {\n      document.removeEventListener(\"pointerdown\", onPointerDown);\n      for (const r of watched) watchers.get(r)?.delete(mark);\n    };\n  }, [enabled]);\n  return markInside;\n}\n"],"mappings":"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","names":[]}

package/dist/hooks/use-focus-trap.d.ts

@@ -1,3 +1,38 @@
+/**
+ * Keep keyboard focus inside an open overlay, and give it back when it closes.
+ *
+ * Extracted from `Modal`, which was the ONLY component in this package that did any of
+ * this. Every other overlay — the full-bleed dialog a phone's row editor opens, the
+ * picker sheet, the numpad, the tour card — declared `role="dialog" aria-modal="true"`
+ * and then left focus on the page behind it. That is the worst of the two possible
+ * bugs: assistive technology hides the page because of `aria-modal`, while the user's
+ * focus is still down there in the part that is now hidden, so Tab walks through
+ * controls the screen reader refuses to describe.
+ *
+ * What this does beyond Modal's original copy:
+ *
+ *   - **Recomputes the tabbable list on every Tab**, not once when the overlay opens.
+ *     These panels have conditionally-rendered contents — a search box that appears
+ *     once options load, a "clear" button that exists only while a filter is set — and
+ *     a list captured at open time traps focus against elements that have since gone.
+ *   - **Guards the restore target.** The element focused before opening may have left
+ *     the DOM by the time the overlay closes (the row that owned the button was
+ *     filtered away). Calling `.focus()` on a detached node silently drops focus to
+ *     `<body>`, which for a keyboard user means losing their place in the page
+ *     entirely. When the target is gone, focus falls back to the nearest thing that
+ *     still exists rather than to nothing.
+ *   - **Leaves an app's own autofocus alone** (0.33.1). React honours a child's
+ *     `autoFocus` while it commits, and this hook's effect runs AFTER that commit, so
+ *     focusing the container there took focus straight back off the field the app had
+ *     asked for. See `initialFocus`.
+ *   - **Nests.** An overlay can open another — a picker inside a dialog. Only the
+ *     innermost trap handles a keystroke, and closing it hands control back to the one
+ *     underneath. Innermost is decided by DOM containment rather than by mount order;
+ *     see the note on `TRAP_ATTR` for why the obvious stack is wrong.
+ *     `use-overlay-history.ts` reasons about the same nesting problem for the back
+ *     button; this is the focus half of it.
+ */
+export { firstTabStop, tabStops } from "../lib/focus-left.js";
 export interface FocusTrapOptions {
     /** Trap only while this is true. Mount-time `true` is the common case. */
     active?: boolean;

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.d.ts

@@ -4,5 +4,11 @@
  * @param open      whether the overlay is currently showing. Components that mount
  *                  only while open (the common case) pass `true`.
  * @param onClose   the overlay's own close handler — the same one Escape calls.
+ * @param options.held  the overlay refuses to close right now (a `Modal` whose request
+ *                  is in flight, DUP-3): Back does not call `onClose`, and the entry the
+ *                  press took is put back, so the overlay still has one for the next
+ *                  Back. Read when Back is pressed. Default false.
  */
-export declare function useOverlayHistory(open: boolean, onClose: () => void): void;
+export declare function useOverlayHistory(open: boolean, onClose: () => void, { held }?: {
+    held?: boolean;
+}): void;

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() {
@@ -170,32 +171,60 @@ function closeOnPop() {
   const top = stack[stack.length - 1];
   if (!top) return;
   if (currentSentinel() === top.id) return;
+  if (top.held()) {
+    putBack(top.id);
+    return;
+  }
   stack.pop();
+  syncGestureListeners();
   consumed.add(top.id);
   const record = pushed.find((p) => p.id === top.id);
   forgetPushed(top.id);
   if (record && !record.dead) carryOnto(record.seen, record);
   top.close();
 }
+function putBack(id) {
+  const record = pushed.find((p) => p.id === id);
+  if (record && !record.dead) carryOnto(record.seen, record);
+  const prev = window.history.state;
+  window.history.pushState({ ...prev && typeof prev === "object" ? prev : {}, [SENTINEL_KEY]: id }, "");
+  standing = id;
+  if (record) record.href = record.seen = currentHref();
+}
 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;
 }
-function useOverlayHistory(open, onClose) {
+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);
   useEffect(() => {
     closeRef.current = onClose;
+    heldRef.current = held;
   });
   useEffect(() => {
     if (!open || typeof window === "undefined") return;
     ensureListening();
     const id = `overlay-${nextId += 1}`;
-    const entry = { id, close: () => closeRef.current() };
+    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();
@@ -228,6 +257,7 @@ function useOverlayHistory(open, onClose) {
     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) {