@eifi1/ui-kit 0.53.0 → 0.55.0

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\";\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"]}
+{"version":3,"sources":["../../src/hooks/use-focus-trap.ts"],"sourcesContent":["import { useEffect, useLayoutEffect, useRef, useState } from \"react\";\nimport { returnFocus, tabStops, tabStopsAround } 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 — the kit's one rule for it, lib/focus-left's\n *     `returnFocus` (0.52 code review 2026-10-31, held to 0.55; see the cleanup). Until\n *     then this said so and did not: a gone opener left the focus on `<body>`.\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  /**\n   * Give the focus back as the trap is released — the kit's one rule, lib/focus-left's\n   * `returnFocus` (0.52 code review 2026-10-31, held to 0.55): only a focus that was lost\n   * or is still inside the container is moved; to the {@link opener}, else to what had\n   * the focus as the trap engaged, else to the tab stops that stood around that, nearest\n   * first; never to `<body>`. Default `true`.\n   */\n  restoreFocus?: boolean;\n  /**\n   * The control this overlay was opened from, when it knows it — its trigger. The focus\n   * goes back there first, and to what had it as the trap engaged only when the trigger\n   * cannot take it. Read as the trap is released. A Popover names its trigger: on Safari\n   * (and Firefox on macOS) a click does not focus the button it lands on, so \"what had the\n   * focus\" was the page, and the focus fell to `<body>` on close (0.55).\n   */\n  opener?: () => Element | null;\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\", opener: namedOpener }: 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, opener: namedOpener });\n  useLayoutEffect(() => {\n    optsRef.current = { active, restoreFocus, initialFocus, opener: namedOpener };\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    // Where the focus goes if the opener has left by the release (the row that owned it\n    // was filtered away, deleted from the dialog it opened): the stops that stood around\n    // it, nearest first — after it, then before — as AlertBanner's × reads them. Read\n    // NOW, while the opener still has a place in the page to measure from; held by this\n    // closure only, so it goes with the trap. Three a side: one that takes the focus is\n    // all that is wanted.\n    const around: HTMLElement[] = [];\n    if (optsRef.current.restoreFocus && opener instanceof Element && opener.isConnected && opener !== document.body) {\n      const { after, before } = tabStopsAround(opener, 3);\n      for (const stop of [...after, ...before]) if (!container.contains(stop)) around.push(stop);\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      // The kit's one rule (lib/focus-left `returnFocus`; 0.52 code review 2026-10-31,\n      // held to 0.55), in this, the releasing commit. Only a focus that fell with the\n      // panel, or is still in one on its way out, is moved: an app's own `focus()` in\n      // `onClose` is kept, where this used to put the opener over it. Then the named\n      // trigger, what had the focus as the trap engaged, and the stops that stood around\n      // that — where a gone opener used to leave the focus on <body> (\"a wrong guess is\n      // worse than no move\"; the header promised the nearest thing that still exists).\n      // `isConnected` and the focus are checked for each, as restoring to a removed or a\n      // disabled node is the drop to <body> this guards against.\n      const named = optsRef.current.opener?.();\n      returnFocus({\n        opener: named ?? opener,\n        fallback: [named ? opener : null, ...around],\n        closing: container.isConnected ? container : null,\n      });\n    };\n  }, [active, containerRef, opener]);\n}\n"],"mappings":"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","names":["tabStops"]}

package/dist/hooks/use-has-camera.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Does this device have a camera to take a photo WITH? keksdose's `useHasCamera`
+ * (shared/hooks/use-has-camera.ts:28, live #292 round three: *"If there is no device to
+ * take a photo can the take photo button be hidden? … If they do not have a web cam?"*),
+ * for every app — kastlan's handover photo buttons offer the camera on a desktop that has
+ * none (kastlan reuse audit 2026-11-02, proposal 8).
+ *
+ * `navigator.mediaDevices.enumerateDevices()` is the only honest answer there is. It
+ * reports the PRESENCE of a video input without a permission: the spec hides a device's
+ * label and id until the camera is granted, not the device, so counting `videoinput`
+ * entries asks the user nothing and opens no prompt. A webcam plugged in later fires
+ * `devicechange`, which asks again.
+ *
+ * **It fails OPEN, as keksdose's does.** Every answer that is not a positive "no" keeps
+ * the camera: no `mediaDevices` at all (an insecure context — `http://` on a LAN address
+ * is how the apps are developed), an `enumerateDevices` that rejects (a permissions
+ * policy), and — the one place this goes further than keksdose — a list with nothing in
+ * it whatever its kind: a device with no camera still has a speaker or a microphone to
+ * list, so an empty list is a browser declining to say (older WebKit, a hardened
+ * privacy mode), not a device without one. Hiding the control that opens the camera
+ * because the browser would not say takes the feature away from the phone it is for;
+ * showing it on a desktop that cannot use it costs one tap.
+ *
+ * **Cached**, unlike keksdose's: one answer for the page, shared by every button that
+ * asks. The first to mount asks the browser and listens for `devicechange`; the rest
+ * read the answer, and a button mounted later starts from it — so a desktop with no
+ * webcam does not show "Take photo" for a frame on every page that has the button.
+ * When the last one unmounts the listener goes, and the next first mount asks again (a
+ * camera may have come or gone in between). Before an answer, on the server and in
+ * jsdom (which has no `mediaDevices`), it is `true`.
+ *
+ * What it does not answer is whether a file input's `capture` will be HONOURED — a
+ * desktop Chrome with a webcam reports a video input and then ignores `capture`. That is
+ * why {@link CameraButton} opens the camera with `getUserMedia`, not with `capture`.
+ */
+export declare function useHasCamera(): boolean;

package/dist/hooks/use-has-camera.js

@@ -0,0 +1,53 @@
+"use client";
+import { useSyncExternalStore } from "react";
+function useHasCamera() {
+  return useSyncExternalStore(subscribe, snapshot, serverSnapshot);
+}
+let known;
+const listeners = /* @__PURE__ */ new Set();
+let watched = null;
+function settle(next) {
+  if (next === known) return;
+  known = next;
+  for (const listener of listeners) listener();
+}
+function ask() {
+  const media = watched;
+  if (!media) return;
+  media.enumerateDevices().then(
+    (devices) => {
+      settle(devices.length === 0 ? void 0 : devices.some((d) => d.kind === "videoinput"));
+    },
+    // A refusal is not an absence — see "fails open" above.
+    () => settle(void 0)
+  );
+}
+function subscribe(listener) {
+  listeners.add(listener);
+  if (listeners.size === 1) {
+    const media = typeof navigator === "undefined" ? void 0 : navigator.mediaDevices;
+    if (media && typeof media.enumerateDevices === "function") {
+      watched = media;
+      media.addEventListener?.("devicechange", ask);
+      ask();
+    } else {
+      settle(void 0);
+    }
+  }
+  return () => {
+    listeners.delete(listener);
+    if (listeners.size > 0 || !watched) return;
+    watched.removeEventListener?.("devicechange", ask);
+    watched = null;
+  };
+}
+function snapshot() {
+  return known ?? true;
+}
+function serverSnapshot() {
+  return true;
+}
+export {
+  useHasCamera
+};
+//# sourceMappingURL=use-has-camera.js.map

package/dist/hooks/use-has-camera.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/use-has-camera.ts"],"sourcesContent":["import { useSyncExternalStore } from \"react\";\n\n/**\n * Does this device have a camera to take a photo WITH? keksdose's `useHasCamera`\n * (shared/hooks/use-has-camera.ts:28, live #292 round three: *\"If there is no device to\n * take a photo can the take photo button be hidden? … If they do not have a web cam?\"*),\n * for every app — kastlan's handover photo buttons offer the camera on a desktop that has\n * none (kastlan reuse audit 2026-11-02, proposal 8).\n *\n * `navigator.mediaDevices.enumerateDevices()` is the only honest answer there is. It\n * reports the PRESENCE of a video input without a permission: the spec hides a device's\n * label and id until the camera is granted, not the device, so counting `videoinput`\n * entries asks the user nothing and opens no prompt. A webcam plugged in later fires\n * `devicechange`, which asks again.\n *\n * **It fails OPEN, as keksdose's does.** Every answer that is not a positive \"no\" keeps\n * the camera: no `mediaDevices` at all (an insecure context — `http://` on a LAN address\n * is how the apps are developed), an `enumerateDevices` that rejects (a permissions\n * policy), and — the one place this goes further than keksdose — a list with nothing in\n * it whatever its kind: a device with no camera still has a speaker or a microphone to\n * list, so an empty list is a browser declining to say (older WebKit, a hardened\n * privacy mode), not a device without one. Hiding the control that opens the camera\n * because the browser would not say takes the feature away from the phone it is for;\n * showing it on a desktop that cannot use it costs one tap.\n *\n * **Cached**, unlike keksdose's: one answer for the page, shared by every button that\n * asks. The first to mount asks the browser and listens for `devicechange`; the rest\n * read the answer, and a button mounted later starts from it — so a desktop with no\n * webcam does not show \"Take photo\" for a frame on every page that has the button.\n * When the last one unmounts the listener goes, and the next first mount asks again (a\n * camera may have come or gone in between). Before an answer, on the server and in\n * jsdom (which has no `mediaDevices`), it is `true`.\n *\n * What it does not answer is whether a file input's `capture` will be HONOURED — a\n * desktop Chrome with a webcam reports a video input and then ignores `capture`. That is\n * why {@link CameraButton} opens the camera with `getUserMedia`, not with `capture`.\n */\nexport function useHasCamera(): boolean {\n  return useSyncExternalStore(subscribe, snapshot, serverSnapshot);\n}\n\n/** The last answer: `undefined` until there is one, or when the browser would not say. */\nlet known: boolean | undefined;\nconst listeners = new Set<() => void>();\n/** The `MediaDevices` the `devicechange` listener is on, while anyone listens. */\nlet watched: MediaDevices | null = null;\n\nfunction settle(next: boolean | undefined) {\n  if (next === known) return;\n  known = next;\n  for (const listener of listeners) listener();\n}\n\nfunction ask() {\n  const media = watched;\n  if (!media) return;\n  media.enumerateDevices().then(\n    (devices) => {\n      // An answer that arrives after the last listener left still counts: it is about\n      // the device, and the next mount starts from it.\n      settle(devices.length === 0 ? undefined : devices.some((d) => d.kind === \"videoinput\"));\n    },\n    // A refusal is not an absence — see \"fails open\" above.\n    () => settle(undefined),\n  );\n}\n\nfunction subscribe(listener: () => void): () => void {\n  listeners.add(listener);\n  if (listeners.size === 1) {\n    const media = typeof navigator === \"undefined\" ? undefined : navigator.mediaDevices;\n    if (media && typeof media.enumerateDevices === \"function\") {\n      watched = media;\n      media.addEventListener?.(\"devicechange\", ask);\n      ask();\n    } else {\n      // Nothing to ask: an unknown, whatever an earlier page (or test) found.\n      settle(undefined);\n    }\n  }\n  return () => {\n    listeners.delete(listener);\n    if (listeners.size > 0 || !watched) return;\n    watched.removeEventListener?.(\"devicechange\", ask);\n    watched = null;\n  };\n}\n\nfunction snapshot(): boolean {\n  return known ?? true;\n}\n\nfunction serverSnapshot(): boolean {\n  return true;\n}\n"],"mappings":";AAAA,SAAS,4BAA4B;AAqC9B,SAAS,eAAwB;AACtC,SAAO,qBAAqB,WAAW,UAAU,cAAc;AACjE;AAGA,IAAI;AACJ,MAAM,YAAY,oBAAI,IAAgB;AAEtC,IAAI,UAA+B;AAEnC,SAAS,OAAO,MAA2B;AACzC,MAAI,SAAS,MAAO;AACpB,UAAQ;AACR,aAAW,YAAY,UAAW,UAAS;AAC7C;AAEA,SAAS,MAAM;AACb,QAAM,QAAQ;AACd,MAAI,CAAC,MAAO;AACZ,QAAM,iBAAiB,EAAE;AAAA,IACvB,CAAC,YAAY;AAGX,aAAO,QAAQ,WAAW,IAAI,SAAY,QAAQ,KAAK,CAAC,MAAM,EAAE,SAAS,YAAY,CAAC;AAAA,IACxF;AAAA;AAAA,IAEA,MAAM,OAAO,MAAS;AAAA,EACxB;AACF;AAEA,SAAS,UAAU,UAAkC;AACnD,YAAU,IAAI,QAAQ;AACtB,MAAI,UAAU,SAAS,GAAG;AACxB,UAAM,QAAQ,OAAO,cAAc,cAAc,SAAY,UAAU;AACvE,QAAI,SAAS,OAAO,MAAM,qBAAqB,YAAY;AACzD,gBAAU;AACV,YAAM,mBAAmB,gBAAgB,GAAG;AAC5C,UAAI;AAAA,IACN,OAAO;AAEL,aAAO,MAAS;AAAA,IAClB;AAAA,EACF;AACA,SAAO,MAAM;AACX,cAAU,OAAO,QAAQ;AACzB,QAAI,UAAU,OAAO,KAAK,CAAC,QAAS;AACpC,YAAQ,sBAAsB,gBAAgB,GAAG;AACjD,cAAU;AAAA,EACZ;AACF;AAEA,SAAS,WAAoB;AAC3B,SAAO,SAAS;AAClB;AAEA,SAAS,iBAA0B;AACjC,SAAO;AACT;","names":[]}

package/dist/hooks/use-hotkey.js

@@ -1,5 +1,6 @@
 "use client";
 import { useEffect, useRef } from "react";
+import { isEditableContent } from "../lib/editable-content.js";
 function isApplePlatform() {
   if (typeof navigator === "undefined") return false;
   const nav = navigator;
@@ -59,7 +60,7 @@ function matchesHotkey(e, combo) {
 }
 function isTypingTarget(target) {
   if (!(target instanceof HTMLElement)) return false;
-  if (target.isContentEditable) return true;
+  if (isEditableContent(target)) return true;
   if (target instanceof HTMLTextAreaElement || target instanceof HTMLSelectElement) return true;
   if (target instanceof HTMLInputElement) {
     return !["button", "checkbox", "radio", "submit", "reset", "range", "color", "file", "image"].includes(target.type);

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/** 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":[]}
+{"version":3,"sources":["../../src/hooks/use-hotkey.ts"],"sourcesContent":["import { useEffect, useRef } from \"react\";\nimport { isEditableContent } from \"../lib/editable-content\";\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? Editable content by the kit's one\n *  rule (lib/editable-content; written here in 0.54, moved there for the tour, the bulk\n *  bar and the clipboard in its follow-up). */\nfunction isTypingTarget(target: EventTarget | null): boolean {\n  if (!(target instanceof HTMLElement)) return false;\n  if (isEditableContent(target)) 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-overlay-history.d.ts

@@ -8,7 +8,12 @@
  *                  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.
+ * @param options.onRefused  called once for each Back `held` refused, after its entry is
+ *                  put back — how a held `Modal` hears the press it dropped and passes
+ *                  it on as `onDismissRefused("back")` (0.54 follow-up, keksdose
+ *                  recovery-code-pane).
  */
-export declare function useOverlayHistory(open: boolean, onClose: () => void, { held }?: {
+export declare function useOverlayHistory(open: boolean, onClose: () => void, { held, onRefused }?: {
     held?: boolean;
+    onRefused?: () => void;
 }): void;

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

@@ -173,6 +173,7 @@ function closeOnPop() {
   if (currentSentinel() === top.id) return;
   if (top.held()) {
     putBack(top.id);
+    top.refused();
     return;
   }
   stack.pop();
@@ -211,18 +212,25 @@ function syncGestureListeners() {
     for (const type of SEEN_EVENTS) window.removeEventListener(type, noteSeenNowAndLater);
   }
 }
-function useOverlayHistory(open, onClose, { held = false } = {}) {
+function useOverlayHistory(open, onClose, { held = false, onRefused } = {}) {
   const closeRef = useRef(onClose);
   const heldRef = useRef(held);
+  const refusedRef = useRef(onRefused);
   useEffect(() => {
     closeRef.current = onClose;
     heldRef.current = held;
+    refusedRef.current = onRefused;
   });
   useEffect(() => {
     if (!open || typeof window === "undefined") return;
     ensureListening();
     const id = `overlay-${nextId += 1}`;
-    const entry = { id, close: () => closeRef.current(), held: () => heldRef.current };
+    const entry = {
+      id,
+      close: () => closeRef.current(),
+      held: () => heldRef.current,
+      refused: () => refusedRef.current?.()
+    };
     stack.push(entry);
     syncGestureListeners();
     const prev = window.history.state;

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

@@ -1 +1 @@
-{"version":3,"sources":["../../src/hooks/use-overlay-history.ts"],"sourcesContent":["import { useEffect, useRef } from \"react\";\n\n/**\n * Back closes the overlay, not the page (Keksdose feedback #172).\n *\n * On a phone the Back gesture is the universal \"dismiss this\" — so a dialog or a\n * full-screen search surface that ignores it doesn't merely fail to close: the\n * navigation lands somewhere else entirely, and on a route with nothing beneath it\n * that means leaving the app with the overlay still notionally open.\n *\n * The mechanism is one throwaway, SAME-URL history entry pushed while the overlay is\n * up. Back then pops a same-document entry — no route change, no re-render of the\n * page under it — and this hook turns that pop into `onClose()`. Same trick the\n * transactions page already uses for its unsaved-edit trap\n * (`use-soft-leave-guard.ts`); the two coexist because they use different marker\n * keys AND because `handlePop` only claims a pop that actually consumed OUR entry\n * — a foreign sentinel stacked on top of ours pops back ONTO us, and an overlay\n * that closed on that would vanish mid-edit (feedback #424/#426).\n *\n * Not a URL parameter, deliberately. Encoding \"a dialog is open\" in the address bar\n * makes it shareable and restorable, which is wrong for the overlays this covers —\n * nobody wants to send someone a link that opens a confirm dialog — and it would\n * fight the page-owned `?row=` / `f.*` params that ARE meaningful state.\n *\n * ## Ordering\n *\n * The stack is module-level because correctness here is about order ACROSS\n * instances: every mounted overlay hears the same `popstate`, but only the one whose\n * entry was actually popped may close. Overlays nest and unwind last-in-first-out —\n * a dialog opened from a search surface closes before the surface — so the top of\n * this stack is by construction the entry the browser just popped.\n *\n * ## Not undoing a real navigation\n *\n * The cleanup pops our entry when the overlay closes some other way (a button,\n * Escape, a backdrop click) so history doesn't silently accumulate dead entries. It\n * first checks that our marker is still the CURRENT entry: if the user followed a\n * link while the overlay was open, the router has pushed on top of us, and a blind\n * `history.back()` there would undo their navigation.\n *\n * ## Not undoing the owner's own close\n *\n * Nor when the address under the entry changed in the same breath as the close\n * (keksdose dev #584). A page that opens its editor by PUSHING `?row=x` and closes it\n * by REPLACING the clean URL over the top entry rewrites OUR entry — the overlay sits\n * above `?row=x` — and that rewrite is what unmounts the overlay. Going back from there\n * lands on `?row=x` and the router opens the editor that was just closed. See\n * {@link noteAddress}: an address the overlay LIVED THROUGH (a filter the table wrote\n * while its sheet was up) is still unwound, because the user has acted since.\n *\n * ## Not undoing the owner's replaces either\n *\n * An address the overlay lived through is unwound as an ENTRY, never as an address\n * (keksdose live #412). A report that writes each tick of its payee sheet into the query\n * with `setSearchParams(…, { replace: true })` rewrites the overlay's own entry, and the\n * page entry beneath still carries the address from before the sheet opened — so the\n * traversal that took our entry away also took every tick with it. See {@link carryOnto}:\n * whichever way the entry goes (the unwind after a press, or a Back press), the address it\n * last showed is carried onto the entry it lands on, and the router is told.\n *\n * ## The traversal is deferred\n *\n * And it is *scheduled* rather than issued, because `history.go()` lands a task\n * later while everything this module knows is written synchronously. See\n * {@link Unwind}: an overlay opening inside that window adopts the entry instead\n * of stacking a second one on it, which is what makes the hook survive React\n * StrictMode's mount → clean up → mount (steering-design feedback #49).\n */\nconst SENTINEL_KEY = \"__hbUiOverlayHistory\";\n\ninterface OverlayEntry {\n  id: string;\n  close: () => void;\n  /** The overlay refuses to close right now — see the `held` option. */\n  held: () => boolean;\n}\n\nconst stack: OverlayEntry[] = [];\n\n/**\n * The sentinels we have PUSHED and not yet unwound, oldest first.\n *\n * The stack above tracks live overlays; this tracks live history entries, and the\n * two come apart in exactly one case — which is the bug this list exists for.\n * Nested overlays that close in the same commit unwind parent-first, so the dialog's\n * cleanup runs while the sheet's entry is still on top of its own. It cannot call\n * `history.back()` there (that would consume the SHEET's entry, and the sheet is\n * about to consume it itself), so its entry was simply abandoned: a husk with no\n * live owner sitting between the user and the page.\n *\n * The user paid for it on the next Back press. It popped the husk, `handlePop` found\n * an empty stack and returned, and nothing visible happened — Back had to be pressed\n * twice to leave the page.\n *\n * So an abandoned entry is recorded as `dead` instead, and whichever overlay DOES\n * get to unwind pays the debt with a single `history.go(-n)`. `href` is what keeps\n * that safe: only dead entries pushed at the address we are still sitting at are\n * unwound, so a router navigation that landed between two sentinels is never\n * reversed on the user's behalf.\n */\ninterface PushedEntry {\n  id: string;\n  /** The full address of the entry (query and hash included) as of the last time the\n   *  user acted while it was current — see {@link noteAddress}. */\n  href: string;\n  /** Its overlay is gone but the entry is not — someone above owes this pop. */\n  dead: boolean;\n  /** The router's `idx` on this entry when the marker went on — see {@link locate}. */\n  idx: number | undefined;\n  /** The router's `key` copied from the page entry beneath ours. */\n  key: string | undefined;\n  /** {@link routeOf} the address the marker was placed at. */\n  route: string;\n  /** The entry's address as last OBSERVED, after the user's last gesture had run its\n   *  handlers — what a Back press must carry down (see {@link carryOnto}). `href` is\n   *  the snapshot BEFORE the gesture, which the owner's-close check needs instead. */\n  seen: string;\n}\nconst pushed: PushedEntry[] = [];\n\n/**\n * Entries of ours that a ROUTER NAVIGATION made from inside the overlay has left\n * behind — ours, still in the history, but no longer on top and no longer anyone's.\n *\n * Nothing can take an entry out from under a newer one, so they cannot be unwound;\n * what can be done is to not let the user land on one. A traversal that comes to\n * rest on a buried entry is carried straight on over the whole run of them, in the\n * direction it was going (see `skipBuried`): Back from the new page lands on the page\n * the overlay was opened from, Forward from there lands on the new page, and no press\n * is spent on an entry with nothing on screen for it.\n *\n * `below` / `above` count the buried entries of the same run on either side. The\n * router's `idx` tells the direction apart — except after a REPLACE navigation, when\n * the page above the run shares the run's `idx`; the two keys decide there.\n */\ninterface BuriedEntry {\n  idx: number;\n  /** The `idx` of the router entry that buried the run: higher after a push, the\n   *  same after a replace. */\n  aboveIdx: number;\n  /** The key of the page entry directly beneath the run. */\n  belowKey: string | undefined;\n  /** The key of the router entry that buried the run, when it did. */\n  aboveKey: string | undefined;\n  below: number;\n  above: number;\n}\nconst buried = new Map<string, BuriedEntry>();\n\n/** The router `{idx, key}` of the entry the last traversal (or burial) left us on —\n *  what `skipBuried` compares against to know which way the user was going. */\nlet lastSeen: { idx: number | undefined; key: string | undefined } | null = null;\n\n/** Entries a real Back press already consumed. Their overlay's cleanup still has to\n *  run, and it must not mistake \"my entry is not current\" for \"my entry is buried\"\n *  — it has no entry left at all. */\nconst consumed = new Set<string>();\n\n/** Pops WE caused (a cleanup unwinding its own entries) — their `popstate` is\n *  bookkeeping, not a user gesture, and must not close a second overlay. A\n *  `history.go(-n)` traversal fires exactly ONE popstate however far it travels. */\nlet pendingProgrammatic = 0;\nlet listening = false;\n/** Whether the gesture listeners ({@link noteAddress}, {@link noteSeen}) are on — see\n *  {@link syncGestureListeners}. */\nlet noting = false;\nlet nextId = 0;\n\n/**\n * The unwind a cleanup has asked for and not yet issued.\n *\n * **`history.go()` is asynchronous and everything above is written\n * synchronously**, which is the seam the whole of this block exists to close.\n * The traversal lands a task later, so an overlay that opens in the *same* tick\n * as one that closed used to push its sentinel on top of the entry that was\n * about to be popped — and the pop then took the NEW entry. The overlay left on\n * screen had no entry of its own (so Back no longer closed it) and the old one\n * stayed behind as a husk between the user and their page.\n *\n * That is not an exotic race. **React StrictMode remounts every effect** — mount,\n * clean up, mount again, all in one commit — so in development *every* dialog\n * anyone opened left a husk behind, the position drifted one entry further from\n * the page on each open, and the Back press that was meant to leave the page was\n * spent on something invisible instead (steering-design feedback #49).\n *\n * So the traversal is deferred by a task, and an overlay mounting inside that\n * window **adopts** the entry instead of pushing a second one (see the effect).\n * Adoption is `replaceState` on an entry that is already there: no traversal, no\n * window in which the count can be wrong, and the StrictMode remount costs\n * exactly nothing.\n */\ninterface Unwind {\n  timer: ReturnType<typeof setTimeout>;\n  /** The sentinel on the entry to leave — the top of `entries`. */\n  id: string;\n  href: string;\n  /** That entry plus the abandoned ones directly beneath it, oldest first. */\n  entries: PushedEntry[];\n}\nlet unwind: Unwind | null = null;\n\n/** Issue the deferred traversal, if the ground has not moved under it.\n *\n *  A real Back press or a router navigation during the deferred task leaves us\n *  somewhere that is not the entry we meant to leave, and going back from there\n *  would take something that is not ours. The entries are then simply forgotten\n *  rather than handed back as `dead`: a forgotten entry costs one dead Back\n *  press, while an over-counted one costs the user a navigation they did make. */\nfunction runUnwind(): void {\n  const job = unwind;\n  unwind = null;\n  if (!job) return;\n  if (currentSentinel() !== job.id || currentHref() !== job.href) {\n    // A router navigation landed between the cleanup and this task: the entries\n    // are under it (or were replaced by it) rather than simply forgotten.\n    if (taggedSentinel() === null) buryUnder(job.entries);\n    return;\n  }\n  const bottom = job.entries[0];\n  carry = { href: job.href, idx: bottom.idx, key: bottom.key };\n  pendingProgrammatic += 1;\n  window.history.go(-job.entries.length);\n}\n\n/** The address an unwind in flight must carry onto the entry it lands on. */\nlet carry: { href: string; idx: number | undefined; key: string | undefined } | null = null;\n\n/**\n * Put `href` — the address the overlay's entry last showed — onto the entry a traversal\n * has just landed on, and tell the router (keksdose live #412).\n *\n * Only the query and the hash can differ: an address naming another page is a\n * navigation, never carried. And only onto the page entry the overlay was opened over,\n * which our push copied the router's `{idx, key}` from — a traversal that came to rest\n * anywhere else is not ours to rewrite.\n *\n * The router heard the traversal land on the OLD address in this same event, so a\n * `replaceState` alone would leave it showing the old query under the new one. A\n * synthetic `popstate` makes it read the address again; both reads happen in one event\n * dispatch, so React commits only the second. Ours absorbs it as programmatic.\n */\nfunction carryOnto(href: string, mark: { idx: number | undefined; key: string | undefined }): void {\n  const here = currentHref();\n  if (here === href || routeOf(here) !== routeOf(href)) return;\n  const now = routerMark();\n  if (mark.idx !== undefined && now.idx !== undefined && mark.idx !== now.idx) return;\n  if (mark.key !== undefined && now.key !== undefined && mark.key !== now.key) return;\n  const state: unknown = window.history.state;\n  window.history.replaceState(state, \"\", href);\n  pendingProgrammatic += 1;\n  window.dispatchEvent(new PopStateEvent(\"popstate\", { state }));\n}\n\nfunction currentHref(): string {\n  return typeof window === \"undefined\" ? \"\" : window.location.href;\n}\n\n/** The router's own `{idx, key}` on the current entry, where a router has put them. */\nfunction routerMark(): { idx: number | undefined; key: string | undefined } {\n  const state = typeof window !== \"undefined\" ? (window.history.state as unknown) : null;\n  if (!state || typeof state !== \"object\") return { idx: undefined, key: undefined };\n  const { idx, key } = state as Record<string, unknown>;\n  return { idx: typeof idx === \"number\" ? idx : undefined, key: typeof key === \"string\" ? key : undefined };\n}\n\n/**\n * The part of an address that names the PAGE — the query string left out.\n *\n * A `setSearchParams(…, { replace: true })` rewrites the query on the entry the\n * overlay is standing on; that is a wipe to repair, not a move. Anything else changing\n * is a navigation. Under a hash router the page lives in the hash (`#/table?f.q=x`), so\n * a hash that starts with `#/` counts up to its own `?`; an ordinary `#fragment` does\n * not name a page and is left out.\n */\nfunction routeOf(href: string): string {\n  try {\n    const url = new URL(href);\n    const hashRoute = url.hash.startsWith(\"#/\") ? url.hash.split(\"?\")[0] : \"\";\n    return url.origin + url.pathname + hashRoute;\n  } catch {\n    return href;\n  }\n}\n\n/**\n * Is the untagged entry we are standing on still `p`'s — merely wiped by the router —\n * or an entry the router NAVIGATED to from inside the overlay?\n *\n * The router's `idx` is the one per-entry fact that separates the two, because it is\n * the one the router itself keeps straight: a replace leaves it as it was, a push adds\n * one. Our own push copies the page's state, so our entry carries the page's `idx` and\n * a router push on top of it carries one more. The key would not do — every replace\n * mints a new one, so the wipe this repair exists for would already fail it. Neither\n * would the address alone: a push to the address we are already at is still a push.\n *\n * `idx` does not see one move, the router REPLACING our entry with a different page\n * (same `idx`), so the page named by the address must also be unchanged. Where there is\n * no `idx` to compare (no router, or one that keeps none) the address is all there is.\n */\nfunction isStillOn(p: PushedEntry): boolean {\n  if (routeOf(currentHref()) !== p.route) return false;\n  const { idx } = routerMark();\n  return idx === undefined || p.idx === undefined || idx === p.idx;\n}\n\n/**\n * The router has navigated while our entries were on top: record which of `records`\n * (ours, oldest first, ending with the top one) it buried and which it replaced, and\n * drop them from `pushed` — none of them can be unwound any more. Returns whether it\n * recognised a navigation at all; when it cannot tell (no router `idx` to go by), it\n * leaves everything as it was and the caller falls back to marking the entry dead.\n */\nfunction buryUnder(records: PushedEntry[]): boolean {\n  const top = records[records.length - 1];\n  const here = routerMark();\n  if (!top || top.idx === undefined || here.idx === undefined) return false;\n  let run: PushedEntry[];\n  if (here.idx > top.idx) {\n    run = [];\n    for (let i = records.length - 1; i >= 0 && records[i].idx === top.idx; i -= 1) run.unshift(records[i]);\n  } else if (here.idx === top.idx && !isStillOn(top)) {\n    // Replaced: the top entry IS the new page now, and gone as ours. Those beneath it\n    // are buried under it.\n    run = [];\n    for (let i = records.length - 2; i >= 0 && records[i].idx === top.idx; i -= 1) run.unshift(records[i]);\n  } else {\n    return false;\n  }\n  run.forEach((r, i) => {\n    buried.set(r.id, {\n      idx: top.idx as number,\n      aboveIdx: here.idx as number,\n      belowKey: run[0].key,\n      aboveKey: here.key,\n      below: i,\n      above: run.length - 1 - i,\n    });\n  });\n  for (const r of records) forgetPushed(r.id);\n  lastSeen = here;\n  return true;\n}\n\n/**\n * A traversal came to rest on one of our buried entries: carry it on over the run, the\n * way it was going. Back from above (a higher `idx`, or the very entry that buried us)\n * continues down to the page beneath; Forward from that page continues up. A landing\n * from anywhere this cannot place is left alone — one idle press is the price of not\n * guessing, and a wrong guess would move the user somewhere they did not ask to go.\n */\nfunction skipBuried(from: typeof lastSeen): void {\n  const tag = taggedSentinel();\n  const rec = tag !== null ? buried.get(tag) : undefined;\n  if (!rec || !from || stack.some((e) => e.id === tag)) return;\n  let steps = 0;\n  if ((from.idx !== undefined && from.idx > rec.idx) || (from.key !== undefined && from.key === rec.aboveKey)) {\n    steps = -(rec.below + 1);\n  } else if (\n    from.idx !== undefined &&\n    // Below the run, or level with it when nothing above it is (a push buried it),\n    // or level with it and provably the page beneath (a replace buried it). The\n    // router's first entry has no key at all, so an absent key is a key here.\n    (from.idx < rec.idx || (from.idx === rec.idx && (rec.aboveIdx > rec.idx || from.key === rec.belowKey)))\n  ) {\n    steps = rec.above + 1;\n  }\n  if (steps === 0) return;\n  pendingProgrammatic += 1;\n  window.history.go(steps);\n}\n\nfunction forgetPushed(id: string): void {\n  const at = pushed.findIndex((p) => p.id === id);\n  if (at >= 0) pushed.splice(at, 1);\n}\n\n/**\n * The sentinel this module believes is on the entry we are standing on.\n *\n * `history.state` is where the tag physically sits, because it is the only\n * per-entry storage a browser has — but it is not this module's storage, so\n * since the 2026-09-22 audit it is no longer read as the last word.\n * The ROUTER owns that object and writes it WHOLE: every\n * `setSearchParams(…, { replace: true })` stamps `{usr, key, idx}` over\n * whatever was there. A `DataTable` with `urlSync` does exactly that, on mount\n * and on every filter change — so an overlay opened from such a table had its\n * tag wiped off the entry it was standing on, and then:\n *\n *  * its cleanup read \"not my entry\" and abandoned a live entry as a husk;\n *  * the push path below could not find itself in `pushed`, so it discarded\n *    every record it had (`splice(0)`) and nothing was ever unwound again;\n *  * the StrictMode adoption never matched, so in development every dialog\n *    pushed a second entry and the deferred `go(-1)` ate the live one — which\n *    is Back no longer closing the overlay at all.\n *\n * So `standing` answers when the tag is gone: a MISSING tag on an entry we have\n * not left is a wipe to repair rather than a verdict. The tag is still read\n * FIRST wherever it is there, because it is the one thing that can see a FOREIGN\n * same-URL entry stacked above ours (feedback #424/#426, below) — module-level\n * bookkeeping cannot, since nobody tells us about someone else's `pushState`.\n */\nlet standing: string | null = null;\n\n/** The tag actually on the current entry, with no repair and no belief. */\nfunction taggedSentinel(): string | null {\n  const state = typeof window !== \"undefined\" ? window.history.state : null;\n  if (!state || typeof state !== \"object\") return null;\n  const id = (state as Record<string, unknown>)[SENTINEL_KEY];\n  return typeof id === \"string\" ? id : null;\n}\n\n/** Put our tag back on the current entry, keeping whatever the router has since\n *  written there — we are a passenger in that object, not its owner. */\nfunction retag(id: string): void {\n  const prev = window.history.state;\n  window.history.replaceState({ ...(prev && typeof prev === \"object\" ? prev : {}), [SENTINEL_KEY]: id }, \"\");\n}\n\nfunction currentSentinel(): string | null {\n  const tag = taggedSentinel();\n  if (tag !== null) {\n    standing = tag;\n    return tag;\n  }\n  if (standing === null || typeof window === \"undefined\") return null;\n  // Only ever re-stamp an entry we still hold a record for. Without that guard a\n  // belief left over from an overlay that is long gone — a tab that has since\n  // navigated, a test file that ran another case — would be stamped onto a\n  // stranger's entry, and the next cleanup would traverse off it.\n  //\n  // And only an entry that is still the one the marker was placed on. A row that\n  // NAVIGATES (a palette result, a dialog's link) has the router push the new page\n  // before the overlay's cleanup runs; that entry carries no tag either, and\n  // re-stamping it made the cleanup \"unwind\" the navigation itself — the page\n  // changed and changed straight back. See `isStillOn` for how the two are told apart.\n  const record = pushed.find((p) => p.id === standing);\n  if (!record || !isStillOn(record)) {\n    standing = null;\n    return null;\n  }\n  retag(standing);\n  return standing;\n}\n\n/**\n * The user is about to act: what the current entry's address is NOW is what the\n * overlay standing on it has lived through.\n *\n * The cleanup needs to tell two same-page query rewrites apart, and the address alone\n * cannot. A `DataTable` with `urlSync` replaces `f.*` over the entry while its filter\n * sheet is up, and the sheet is closed LATER, by a press of its own — that entry is\n * still the sheet's and must be unwound (the audit's drift fix, below). A page whose\n * `?row=` drives the overlay replaces the clean URL over the entry and the overlay\n * unmounts BECAUSE of it (keksdose dev #584) — that entry is the owner's now, and\n * unwinding lands on `?row=` beneath and reopens what was just closed. What separates\n * them is whether the user acted in between: the rewrite that closes an overlay is\n * made by the very press that closes it, so it postdates this snapshot.\n *\n * Capture phase, so the snapshot is taken before any handler of the press runs.\n */\nfunction noteAddress(): void {\n  const top = pushed[pushed.length - 1];\n  if (!top || top.dead || !stack.some((e) => e.id === top.id)) return;\n  const tag = taggedSentinel();\n  // Read without `currentSentinel`'s repair: an observation must not write history.\n  if (tag === top.id || (tag === null && standing === top.id && isStillOn(top))) {\n    top.href = currentHref();\n    top.seen = top.href;\n  }\n}\n\n/** After the user's gesture has run its handlers: the address its entry now shows —\n *  what a Back press must carry down (keksdose live #412). Again a little later, for a\n *  handler that writes the address a task after the event. */\nfunction noteSeen(): void {\n  const top = pushed[pushed.length - 1];\n  if (!top || top.dead || !stack.some((e) => e.id === top.id)) return;\n  const tag = taggedSentinel();\n  if (tag === top.id || (tag === null && standing === top.id && isStillOn(top))) top.seen = currentHref();\n}\n\nfunction noteSeenNowAndLater(): void {\n  noteSeen();\n  setTimeout(noteSeen, 0);\n}\n\nfunction handlePop() {\n  // A pop MOVES us, so the belief is stale by definition: re-read it from the\n  // entry we have landed on before anything below consults it, or the repair in\n  // `currentSentinel` would stamp the entry we just left onto the one we are on.\n  standing = taggedSentinel();\n  const from = lastSeen;\n  lastSeen = routerMark();\n  if (pendingProgrammatic > 0) {\n    pendingProgrammatic -= 1;\n    const job = carry;\n    carry = null;\n    if (job) carryOnto(job.href, job);\n    return;\n  }\n  closeOnPop();\n  skipBuried(from);\n}\n\nfunction closeOnPop() {\n  // Nothing open → an ordinary navigation, which is none of our business.\n  const top = stack[stack.length - 1];\n  if (!top) return;\n  // We landed back ON the top overlay's own entry, so that entry was NOT what the\n  // pop consumed — something stacked ABOVE it was (Keksdose feedback #424/#426).\n  // The app layers a second same-URL sentinel of its own on top of ours for the\n  // unsaved-edit trap (`use-soft-leave-guard.ts`), and it pops that sentinel every\n  // time the form goes back to clean — twice-toggling one field was enough to\n  // close the whole dialog. A pop is only ours when the entry we came to rest on\n  // is no longer ours: either the layer below (a different overlay's marker) or\n  // the plain page entry (none at all).\n  if (currentSentinel() === top.id) return;\n  // Checked before anything below moves: a held overlay keeps its place and its record.\n  if (top.held()) {\n    putBack(top.id);\n    return;\n  }\n  stack.pop();\n  syncGestureListeners();\n  // The browser consumed this entry, so the overlay's own cleanup has nothing left\n  // to unwind and nothing to record as owed.\n  consumed.add(top.id);\n  const record = pushed.find((p) => p.id === top.id);\n  forgetPushed(top.id);\n  // What the page wrote into the address while we were up stays (#412).\n  if (record && !record.dead) carryOnto(record.seen, record);\n  top.close();\n}\n\n/**\n * A Back press the top overlay refuses (a busy `Modal`, DUP-3). A popstate cannot be\n * refused — the browser has already left our entry — so the entry is put back: what the\n * page wrote into the address while the overlay was up is carried down first (#412), as\n * for a close, and the same marker is pushed again over it, as the mount pushed it. Left\n * on the page entry, the overlay would stay up with no entry of its own, and the Back\n * after its request would leave the page under it.\n *\n * A push and not `history.go(1)` back onto the old entry: a traversal lands a task later\n * and fires nothing at all if a listener has pushed meanwhile, and a programmatic pop\n * counted for it would then swallow the user's next real Back.\n */\nfunction putBack(id: string): void {\n  const record = pushed.find((p) => p.id === id);\n  if (record && !record.dead) carryOnto(record.seen, record);\n  const prev: unknown = window.history.state;\n  window.history.pushState({ ...(prev && typeof prev === \"object\" ? prev : {}), [SENTINEL_KEY]: id }, \"\");\n  standing = id;\n  // The address the entry shows now is the one the user last acted on: the cleanup's\n  // owner's-close check (#584) must not read the carried address as a rewrite.\n  if (record) record.href = record.seen = currentHref();\n}\n\n/** `popstate` stays from the first overlay on: a traversal of ours (an unwind, a buried\n *  run to skip) lands after the overlay that caused it has gone. */\nfunction ensureListening() {\n  if (listening || typeof window === \"undefined\") return;\n  window.addEventListener(\"popstate\", handlePop);\n  listening = true;\n}\n\nconst SEEN_EVENTS = [\"click\", \"keyup\", \"change\", \"input\"] as const;\n\n/**\n * The gesture listeners, on while an overlay is open and off when the last one closes.\n * Both notes return at once with no overlay up, but the four bubbling ones scheduled a\n * timer for their second look even then — for every click and every keystroke in every\n * field, for the life of the page after its first dialog (refactor audit 2026-10-30,\n * INP-14). Called after each change to `stack`.\n */\nfunction syncGestureListeners(): void {\n  const want = stack.length > 0;\n  if (want === noting || typeof window === \"undefined\") return;\n  noting = want;\n  if (want) {\n    window.addEventListener(\"pointerdown\", noteAddress, true);\n    window.addEventListener(\"keydown\", noteAddress, true);\n    for (const type of SEEN_EVENTS) window.addEventListener(type, noteSeenNowAndLater);\n  } else {\n    window.removeEventListener(\"pointerdown\", noteAddress, true);\n    window.removeEventListener(\"keydown\", noteAddress, true);\n    for (const type of SEEN_EVENTS) window.removeEventListener(type, noteSeenNowAndLater);\n  }\n}\n\n/**\n * Make the platform Back gesture dismiss an overlay.\n *\n * @param open      whether the overlay is currently showing. Components that mount\n *                  only while open (the common case) pass `true`.\n * @param onClose   the overlay's own close handler — the same one Escape calls.\n * @param options.held  the overlay refuses to close right now (a `Modal` whose request\n *                  is in flight, DUP-3): Back does not call `onClose`, and the entry the\n *                  press took is put back, so the overlay still has one for the next\n *                  Back. Read when Back is pressed. Default false.\n */\nexport function useOverlayHistory(open: boolean, onClose: () => void, { held = false }: { held?: boolean } = {}): void {\n  // The listener fires outside React's render, so it reads the latest handler\n  // through a ref rather than through the closure the effect captured.\n  const closeRef = useRef(onClose);\n  const heldRef = useRef(held);\n  useEffect(() => {\n    closeRef.current = onClose;\n    heldRef.current = held;\n  });\n\n  useEffect(() => {\n    if (!open || typeof window === \"undefined\") return;\n    ensureListening();\n    const id = `overlay-${(nextId += 1)}`;\n    const entry: OverlayEntry = { id, close: () => closeRef.current(), held: () => heldRef.current };\n    stack.push(entry);\n    syncGestureListeners();\n    const prev = window.history.state;\n    const marked = { ...(prev && typeof prev === \"object\" ? prev : {}), [SENTINEL_KEY]: id };\n    // An entry that is on its way out and that we are still standing on is ours\n    // to take over: same URL, same slot, only the marker changes. Pushing a\n    // second one on top of it is what used to leave a husk on every StrictMode\n    // remount — see {@link Unwind}.\n    const adopting = unwind && unwind.id === currentSentinel() && unwind.href === currentHref();\n    if (adopting && unwind) {\n      clearTimeout(unwind.timer);\n      const inherited = unwind.entries;\n      unwind = null;\n      // Preserve react-router's own `{usr,key,idx}` — we only swap the marker,\n      // and the entry we are swapping it on is the one the router is already on.\n      window.history.replaceState(marked, \"\");\n      // The abandoned ones beneath come back owed; ours takes the top slot.\n      for (const owed of inherited.slice(0, -1)) pushed.push({ ...owed, dead: true });\n      const was = inherited[inherited.length - 1];\n      pushed.push({\n        id,\n        href: currentHref(),\n        seen: currentHref(),\n        dead: false,\n        idx: was.idx,\n        key: was.key,\n        route: was.route,\n      });\n      standing = id;\n    } else {\n      // A push DESTROYS every entry ahead of the one we are on, so anything we\n      // still had recorded above our own position is gone. Kept, those would be\n      // counted into a later `history.go(-n)` and the overshoot would come out\n      // of a navigation the user actually made. Where we cannot tell which of\n      // ours are beneath us — we are standing on a plain page entry, or on a\n      // husk nobody tracks — none of them can be proven to be, so none survive.\n      const under = pushed.findIndex((p) => p.id === currentSentinel());\n      pushed.splice(under + 1);\n      // Preserve react-router's own `{usr,key,idx}` — we only tack a marker on, and\n      // the URL is unchanged, so the router treats popping this as a no-op re-render.\n      window.history.pushState(marked, \"\");\n      const page = routerMark();\n      const at = currentHref();\n      pushed.push({ id, href: at, seen: at, dead: false, idx: page.idx, key: page.key, route: routeOf(at) });\n      standing = id;\n    }\n    return () => {\n      const at = stack.indexOf(entry);\n      if (at >= 0) stack.splice(at, 1);\n      syncGestureListeners();\n\n      // A Back press already took this entry; there is nothing to unwind or to owe.\n      if (consumed.delete(id)) return;\n\n      const mine = pushed.findIndex((p) => p.id === id);\n      // Still our entry — same page, same router `idx` — but its address is not the one\n      // the user last acted on: the owner rewrote it as part of closing us (see\n      // {@link noteAddress}). The entry is the owner's page now, and the one beneath is\n      // the address it replaced — going back would restore exactly what was closed.\n      // Nothing to unwind; forget the record rather than re-stamp a page we left.\n      if (mine >= 0 && currentHref() !== pushed[mine].href) {\n        const tag = taggedSentinel();\n        if (tag === id || (tag === null && standing === id && isStillOn(pushed[mine]))) {\n          pushed.splice(mine, 1);\n          if (standing === id) standing = null;\n          return;\n        }\n      }\n      // Only unwind an entry that is still THE current one. If a router push landed\n      // on top of it, going back would undo the user's navigation instead — and if\n      // a SIBLING overlay's sentinel landed on top, that overlay is about to unwind\n      // and is the one that can take ours with it.\n      if (currentSentinel() !== id) {\n        // A router navigation from inside the overlay: nothing to unwind — the\n        // entries it left beneath the new page are skipped over instead.\n        if (mine >= 0 && taggedSentinel() === null && buryUnder(pushed.slice(0, pushed.length))) return;\n        if (mine >= 0) pushed[mine].dead = true;\n        return;\n      }\n\n      // Ours plus every abandoned entry lying directly beneath it at this address.\n      // One traversal, so one popstate, so one programmatic pop to absorb.\n      const here = currentHref();\n      let steps = 1;\n      while (steps <= mine && pushed[mine - steps].dead && pushed[mine - steps].href === here) {\n        steps += 1;\n      }\n      const leaving = pushed.splice(mine - (steps - 1), steps);\n      // Scheduled, not issued: an overlay opening in this same tick takes the\n      // entry over instead, which is what makes the hook survive a StrictMode\n      // remount. An unwind already waiting is dropped rather than merged — it\n      // was the entry ABOVE ours and something has since moved off it, so its\n      // count can no longer be proven, and an over-counted traversal costs a\n      // navigation the user made while an under-counted one costs one dead Back.\n      if (unwind) clearTimeout(unwind.timer);\n      unwind = { timer: setTimeout(runUnwind, 0), id, href: here, entries: leaving };\n    };\n  }, [open]);\n}\n"],"mappings":";AAAA,SAAS,WAAW,cAAc;AAoElC,MAAM,eAAe;AASrB,MAAM,QAAwB,CAAC;AAyC/B,MAAM,SAAwB,CAAC;AA6B/B,MAAM,SAAS,oBAAI,IAAyB;AAI5C,IAAI,WAAwE;AAK5E,MAAM,WAAW,oBAAI,IAAY;AAKjC,IAAI,sBAAsB;AAC1B,IAAI,YAAY;AAGhB,IAAI,SAAS;AACb,IAAI,SAAS;AAiCb,IAAI,SAAwB;AAS5B,SAAS,YAAkB;AACzB,QAAM,MAAM;AACZ,WAAS;AACT,MAAI,CAAC,IAAK;AACV,MAAI,gBAAgB,MAAM,IAAI,MAAM,YAAY,MAAM,IAAI,MAAM;AAG9D,QAAI,eAAe,MAAM,KAAM,WAAU,IAAI,OAAO;AACpD;AAAA,EACF;AACA,QAAM,SAAS,IAAI,QAAQ,CAAC;AAC5B,UAAQ,EAAE,MAAM,IAAI,MAAM,KAAK,OAAO,KAAK,KAAK,OAAO,IAAI;AAC3D,yBAAuB;AACvB,SAAO,QAAQ,GAAG,CAAC,IAAI,QAAQ,MAAM;AACvC;AAGA,IAAI,QAAmF;AAgBvF,SAAS,UAAU,MAAc,MAAkE;AACjG,QAAM,OAAO,YAAY;AACzB,MAAI,SAAS,QAAQ,QAAQ,IAAI,MAAM,QAAQ,IAAI,EAAG;AACtD,QAAM,MAAM,WAAW;AACvB,MAAI,KAAK,QAAQ,UAAa,IAAI,QAAQ,UAAa,KAAK,QAAQ,IAAI,IAAK;AAC7E,MAAI,KAAK,QAAQ,UAAa,IAAI,QAAQ,UAAa,KAAK,QAAQ,IAAI,IAAK;AAC7E,QAAM,QAAiB,OAAO,QAAQ;AACtC,SAAO,QAAQ,aAAa,OAAO,IAAI,IAAI;AAC3C,yBAAuB;AACvB,SAAO,cAAc,IAAI,cAAc,YAAY,EAAE,MAAM,CAAC,CAAC;AAC/D;AAEA,SAAS,cAAsB;AAC7B,SAAO,OAAO,WAAW,cAAc,KAAK,OAAO,SAAS;AAC9D;AAGA,SAAS,aAAmE;AAC1E,QAAM,QAAQ,OAAO,WAAW,cAAe,OAAO,QAAQ,QAAoB;AAClF,MAAI,CAAC,SAAS,OAAO,UAAU,SAAU,QAAO,EAAE,KAAK,QAAW,KAAK,OAAU;AACjF,QAAM,EAAE,KAAK,IAAI,IAAI;AACrB,SAAO,EAAE,KAAK,OAAO,QAAQ,WAAW,MAAM,QAAW,KAAK,OAAO,QAAQ,WAAW,MAAM,OAAU;AAC1G;AAWA,SAAS,QAAQ,MAAsB;AACrC,MAAI;AACF,UAAM,MAAM,IAAI,IAAI,IAAI;AACxB,UAAM,YAAY,IAAI,KAAK,WAAW,IAAI,IAAI,IAAI,KAAK,MAAM,GAAG,EAAE,CAAC,IAAI;AACvE,WAAO,IAAI,SAAS,IAAI,WAAW;AAAA,EACrC,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAiBA,SAAS,UAAU,GAAyB;AAC1C,MAAI,QAAQ,YAAY,CAAC,MAAM,EAAE,MAAO,QAAO;AAC/C,QAAM,EAAE,IAAI,IAAI,WAAW;AAC3B,SAAO,QAAQ,UAAa,EAAE,QAAQ,UAAa,QAAQ,EAAE;AAC/D;AASA,SAAS,UAAU,SAAiC;AAClD,QAAM,MAAM,QAAQ,QAAQ,SAAS,CAAC;AACtC,QAAM,OAAO,WAAW;AACxB,MAAI,CAAC,OAAO,IAAI,QAAQ,UAAa,KAAK,QAAQ,OAAW,QAAO;AACpE,MAAI;AACJ,MAAI,KAAK,MAAM,IAAI,KAAK;AACtB,UAAM,CAAC;AACP,aAAS,IAAI,QAAQ,SAAS,GAAG,KAAK,KAAK,QAAQ,CAAC,EAAE,QAAQ,IAAI,KAAK,KAAK,EAAG,KAAI,QAAQ,QAAQ,CAAC,CAAC;AAAA,EACvG,WAAW,KAAK,QAAQ,IAAI,OAAO,CAAC,UAAU,GAAG,GAAG;AAGlD,UAAM,CAAC;AACP,aAAS,IAAI,QAAQ,SAAS,GAAG,KAAK,KAAK,QAAQ,CAAC,EAAE,QAAQ,IAAI,KAAK,KAAK,EAAG,KAAI,QAAQ,QAAQ,CAAC,CAAC;AAAA,EACvG,OAAO;AACL,WAAO;AAAA,EACT;AACA,MAAI,QAAQ,CAAC,GAAG,MAAM;AACpB,WAAO,IAAI,EAAE,IAAI;AAAA,MACf,KAAK,IAAI;AAAA,MACT,UAAU,KAAK;AAAA,MACf,UAAU,IAAI,CAAC,EAAE;AAAA,MACjB,UAAU,KAAK;AAAA,MACf,OAAO;AAAA,MACP,OAAO,IAAI,SAAS,IAAI;AAAA,IAC1B,CAAC;AAAA,EACH,CAAC;AACD,aAAW,KAAK,QAAS,cAAa,EAAE,EAAE;AAC1C,aAAW;AACX,SAAO;AACT;AASA,SAAS,WAAW,MAA6B;AAC/C,QAAM,MAAM,eAAe;AAC3B,QAAM,MAAM,QAAQ,OAAO,OAAO,IAAI,GAAG,IAAI;AAC7C,MAAI,CAAC,OAAO,CAAC,QAAQ,MAAM,KAAK,CAAC,MAAM,EAAE,OAAO,GAAG,EAAG;AACtD,MAAI,QAAQ;AACZ,MAAK,KAAK,QAAQ,UAAa,KAAK,MAAM,IAAI,OAAS,KAAK,QAAQ,UAAa,KAAK,QAAQ,IAAI,UAAW;AAC3G,YAAQ,EAAE,IAAI,QAAQ;AAAA,EACxB,WACE,KAAK,QAAQ;AAAA;AAAA;AAAA,GAIZ,KAAK,MAAM,IAAI,OAAQ,KAAK,QAAQ,IAAI,QAAQ,IAAI,WAAW,IAAI,OAAO,KAAK,QAAQ,IAAI,YAC5F;AACA,YAAQ,IAAI,QAAQ;AAAA,EACtB;AACA,MAAI,UAAU,EAAG;AACjB,yBAAuB;AACvB,SAAO,QAAQ,GAAG,KAAK;AACzB;AAEA,SAAS,aAAa,IAAkB;AACtC,QAAM,KAAK,OAAO,UAAU,CAAC,MAAM,EAAE,OAAO,EAAE;AAC9C,MAAI,MAAM,EAAG,QAAO,OAAO,IAAI,CAAC;AAClC;AA2BA,IAAI,WAA0B;AAG9B,SAAS,iBAAgC;AACvC,QAAM,QAAQ,OAAO,WAAW,cAAc,OAAO,QAAQ,QAAQ;AACrE,MAAI,CAAC,SAAS,OAAO,UAAU,SAAU,QAAO;AAChD,QAAM,KAAM,MAAkC,YAAY;AAC1D,SAAO,OAAO,OAAO,WAAW,KAAK;AACvC;AAIA,SAAS,MAAM,IAAkB;AAC/B,QAAM,OAAO,OAAO,QAAQ;AAC5B,SAAO,QAAQ,aAAa,EAAE,GAAI,QAAQ,OAAO,SAAS,WAAW,OAAO,CAAC,GAAI,CAAC,YAAY,GAAG,GAAG,GAAG,EAAE;AAC3G;AAEA,SAAS,kBAAiC;AACxC,QAAM,MAAM,eAAe;AAC3B,MAAI,QAAQ,MAAM;AAChB,eAAW;AACX,WAAO;AAAA,EACT;AACA,MAAI,aAAa,QAAQ,OAAO,WAAW,YAAa,QAAO;AAW/D,QAAM,SAAS,OAAO,KAAK,CAAC,MAAM,EAAE,OAAO,QAAQ;AACnD,MAAI,CAAC,UAAU,CAAC,UAAU,MAAM,GAAG;AACjC,eAAW;AACX,WAAO;AAAA,EACT;AACA,QAAM,QAAQ;AACd,SAAO;AACT;AAkBA,SAAS,cAAoB;AAC3B,QAAM,MAAM,OAAO,OAAO,SAAS,CAAC;AACpC,MAAI,CAAC,OAAO,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,MAAM,EAAE,OAAO,IAAI,EAAE,EAAG;AAC7D,QAAM,MAAM,eAAe;AAE3B,MAAI,QAAQ,IAAI,MAAO,QAAQ,QAAQ,aAAa,IAAI,MAAM,UAAU,GAAG,GAAI;AAC7E,QAAI,OAAO,YAAY;AACvB,QAAI,OAAO,IAAI;AAAA,EACjB;AACF;AAKA,SAAS,WAAiB;AACxB,QAAM,MAAM,OAAO,OAAO,SAAS,CAAC;AACpC,MAAI,CAAC,OAAO,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,MAAM,EAAE,OAAO,IAAI,EAAE,EAAG;AAC7D,QAAM,MAAM,eAAe;AAC3B,MAAI,QAAQ,IAAI,MAAO,QAAQ,QAAQ,aAAa,IAAI,MAAM,UAAU,GAAG,EAAI,KAAI,OAAO,YAAY;AACxG;AAEA,SAAS,sBAA4B;AACnC,WAAS;AACT,aAAW,UAAU,CAAC;AACxB;AAEA,SAAS,YAAY;AAInB,aAAW,eAAe;AAC1B,QAAM,OAAO;AACb,aAAW,WAAW;AACtB,MAAI,sBAAsB,GAAG;AAC3B,2BAAuB;AACvB,UAAM,MAAM;AACZ,YAAQ;AACR,QAAI,IAAK,WAAU,IAAI,MAAM,GAAG;AAChC;AAAA,EACF;AACA,aAAW;AACX,aAAW,IAAI;AACjB;AAEA,SAAS,aAAa;AAEpB,QAAM,MAAM,MAAM,MAAM,SAAS,CAAC;AAClC,MAAI,CAAC,IAAK;AASV,MAAI,gBAAgB,MAAM,IAAI,GAAI;AAElC,MAAI,IAAI,KAAK,GAAG;AACd,YAAQ,IAAI,EAAE;AACd;AAAA,EACF;AACA,QAAM,IAAI;AACV,uBAAqB;AAGrB,WAAS,IAAI,IAAI,EAAE;AACnB,QAAM,SAAS,OAAO,KAAK,CAAC,MAAM,EAAE,OAAO,IAAI,EAAE;AACjD,eAAa,IAAI,EAAE;AAEnB,MAAI,UAAU,CAAC,OAAO,KAAM,WAAU,OAAO,MAAM,MAAM;AACzD,MAAI,MAAM;AACZ;AAcA,SAAS,QAAQ,IAAkB;AACjC,QAAM,SAAS,OAAO,KAAK,CAAC,MAAM,EAAE,OAAO,EAAE;AAC7C,MAAI,UAAU,CAAC,OAAO,KAAM,WAAU,OAAO,MAAM,MAAM;AACzD,QAAM,OAAgB,OAAO,QAAQ;AACrC,SAAO,QAAQ,UAAU,EAAE,GAAI,QAAQ,OAAO,SAAS,WAAW,OAAO,CAAC,GAAI,CAAC,YAAY,GAAG,GAAG,GAAG,EAAE;AACtG,aAAW;AAGX,MAAI,OAAQ,QAAO,OAAO,OAAO,OAAO,YAAY;AACtD;AAIA,SAAS,kBAAkB;AACzB,MAAI,aAAa,OAAO,WAAW,YAAa;AAChD,SAAO,iBAAiB,YAAY,SAAS;AAC7C,cAAY;AACd;AAEA,MAAM,cAAc,CAAC,SAAS,SAAS,UAAU,OAAO;AASxD,SAAS,uBAA6B;AACpC,QAAM,OAAO,MAAM,SAAS;AAC5B,MAAI,SAAS,UAAU,OAAO,WAAW,YAAa;AACtD,WAAS;AACT,MAAI,MAAM;AACR,WAAO,iBAAiB,eAAe,aAAa,IAAI;AACxD,WAAO,iBAAiB,WAAW,aAAa,IAAI;AACpD,eAAW,QAAQ,YAAa,QAAO,iBAAiB,MAAM,mBAAmB;AAAA,EACnF,OAAO;AACL,WAAO,oBAAoB,eAAe,aAAa,IAAI;AAC3D,WAAO,oBAAoB,WAAW,aAAa,IAAI;AACvD,eAAW,QAAQ,YAAa,QAAO,oBAAoB,MAAM,mBAAmB;AAAA,EACtF;AACF;AAaO,SAAS,kBAAkB,MAAe,SAAqB,EAAE,OAAO,MAAM,IAAwB,CAAC,GAAS;AAGrH,QAAM,WAAW,OAAO,OAAO;AAC/B,QAAM,UAAU,OAAO,IAAI;AAC3B,YAAU,MAAM;AACd,aAAS,UAAU;AACnB,YAAQ,UAAU;AAAA,EACpB,CAAC;AAED,YAAU,MAAM;AACd,QAAI,CAAC,QAAQ,OAAO,WAAW,YAAa;AAC5C,oBAAgB;AAChB,UAAM,KAAK,WAAY,UAAU,CAAE;AACnC,UAAM,QAAsB,EAAE,IAAI,OAAO,MAAM,SAAS,QAAQ,GAAG,MAAM,MAAM,QAAQ,QAAQ;AAC/F,UAAM,KAAK,KAAK;AAChB,yBAAqB;AACrB,UAAM,OAAO,OAAO,QAAQ;AAC5B,UAAM,SAAS,EAAE,GAAI,QAAQ,OAAO,SAAS,WAAW,OAAO,CAAC,GAAI,CAAC,YAAY,GAAG,GAAG;AAKvF,UAAM,WAAW,UAAU,OAAO,OAAO,gBAAgB,KAAK,OAAO,SAAS,YAAY;AAC1F,QAAI,YAAY,QAAQ;AACtB,mBAAa,OAAO,KAAK;AACzB,YAAM,YAAY,OAAO;AACzB,eAAS;AAGT,aAAO,QAAQ,aAAa,QAAQ,EAAE;AAEtC,iBAAW,QAAQ,UAAU,MAAM,GAAG,EAAE,EAAG,QAAO,KAAK,EAAE,GAAG,MAAM,MAAM,KAAK,CAAC;AAC9E,YAAM,MAAM,UAAU,UAAU,SAAS,CAAC;AAC1C,aAAO,KAAK;AAAA,QACV;AAAA,QACA,MAAM,YAAY;AAAA,QAClB,MAAM,YAAY;AAAA,QAClB,MAAM;AAAA,QACN,KAAK,IAAI;AAAA,QACT,KAAK,IAAI;AAAA,QACT,OAAO,IAAI;AAAA,MACb,CAAC;AACD,iBAAW;AAAA,IACb,OAAO;AAOL,YAAM,QAAQ,OAAO,UAAU,CAAC,MAAM,EAAE,OAAO,gBAAgB,CAAC;AAChE,aAAO,OAAO,QAAQ,CAAC;AAGvB,aAAO,QAAQ,UAAU,QAAQ,EAAE;AACnC,YAAM,OAAO,WAAW;AACxB,YAAM,KAAK,YAAY;AACvB,aAAO,KAAK,EAAE,IAAI,MAAM,IAAI,MAAM,IAAI,MAAM,OAAO,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,OAAO,QAAQ,EAAE,EAAE,CAAC;AACrG,iBAAW;AAAA,IACb;AACA,WAAO,MAAM;AACX,YAAM,KAAK,MAAM,QAAQ,KAAK;AAC9B,UAAI,MAAM,EAAG,OAAM,OAAO,IAAI,CAAC;AAC/B,2BAAqB;AAGrB,UAAI,SAAS,OAAO,EAAE,EAAG;AAEzB,YAAM,OAAO,OAAO,UAAU,CAAC,MAAM,EAAE,OAAO,EAAE;AAMhD,UAAI,QAAQ,KAAK,YAAY,MAAM,OAAO,IAAI,EAAE,MAAM;AACpD,cAAM,MAAM,eAAe;AAC3B,YAAI,QAAQ,MAAO,QAAQ,QAAQ,aAAa,MAAM,UAAU,OAAO,IAAI,CAAC,GAAI;AAC9E,iBAAO,OAAO,MAAM,CAAC;AACrB,cAAI,aAAa,GAAI,YAAW;AAChC;AAAA,QACF;AAAA,MACF;AAKA,UAAI,gBAAgB,MAAM,IAAI;AAG5B,YAAI,QAAQ,KAAK,eAAe,MAAM,QAAQ,UAAU,OAAO,MAAM,GAAG,OAAO,MAAM,CAAC,EAAG;AACzF,YAAI,QAAQ,EAAG,QAAO,IAAI,EAAE,OAAO;AACnC;AAAA,MACF;AAIA,YAAM,OAAO,YAAY;AACzB,UAAI,QAAQ;AACZ,aAAO,SAAS,QAAQ,OAAO,OAAO,KAAK,EAAE,QAAQ,OAAO,OAAO,KAAK,EAAE,SAAS,MAAM;AACvF,iBAAS;AAAA,MACX;AACA,YAAM,UAAU,OAAO,OAAO,QAAQ,QAAQ,IAAI,KAAK;AAOvD,UAAI,OAAQ,cAAa,OAAO,KAAK;AACrC,eAAS,EAAE,OAAO,WAAW,WAAW,CAAC,GAAG,IAAI,MAAM,MAAM,SAAS,QAAQ;AAAA,IAC/E;AAAA,EACF,GAAG,CAAC,IAAI,CAAC;AACX;","names":[]}
+{"version":3,"sources":["../../src/hooks/use-overlay-history.ts"],"sourcesContent":["import { useEffect, useRef } from \"react\";\n\n/**\n * Back closes the overlay, not the page (Keksdose feedback #172).\n *\n * On a phone the Back gesture is the universal \"dismiss this\" — so a dialog or a\n * full-screen search surface that ignores it doesn't merely fail to close: the\n * navigation lands somewhere else entirely, and on a route with nothing beneath it\n * that means leaving the app with the overlay still notionally open.\n *\n * The mechanism is one throwaway, SAME-URL history entry pushed while the overlay is\n * up. Back then pops a same-document entry — no route change, no re-render of the\n * page under it — and this hook turns that pop into `onClose()`. Same trick the\n * transactions page already uses for its unsaved-edit trap\n * (`use-soft-leave-guard.ts`); the two coexist because they use different marker\n * keys AND because `handlePop` only claims a pop that actually consumed OUR entry\n * — a foreign sentinel stacked on top of ours pops back ONTO us, and an overlay\n * that closed on that would vanish mid-edit (feedback #424/#426).\n *\n * Not a URL parameter, deliberately. Encoding \"a dialog is open\" in the address bar\n * makes it shareable and restorable, which is wrong for the overlays this covers —\n * nobody wants to send someone a link that opens a confirm dialog — and it would\n * fight the page-owned `?row=` / `f.*` params that ARE meaningful state.\n *\n * ## Ordering\n *\n * The stack is module-level because correctness here is about order ACROSS\n * instances: every mounted overlay hears the same `popstate`, but only the one whose\n * entry was actually popped may close. Overlays nest and unwind last-in-first-out —\n * a dialog opened from a search surface closes before the surface — so the top of\n * this stack is by construction the entry the browser just popped.\n *\n * ## Not undoing a real navigation\n *\n * The cleanup pops our entry when the overlay closes some other way (a button,\n * Escape, a backdrop click) so history doesn't silently accumulate dead entries. It\n * first checks that our marker is still the CURRENT entry: if the user followed a\n * link while the overlay was open, the router has pushed on top of us, and a blind\n * `history.back()` there would undo their navigation.\n *\n * ## Not undoing the owner's own close\n *\n * Nor when the address under the entry changed in the same breath as the close\n * (keksdose dev #584). A page that opens its editor by PUSHING `?row=x` and closes it\n * by REPLACING the clean URL over the top entry rewrites OUR entry — the overlay sits\n * above `?row=x` — and that rewrite is what unmounts the overlay. Going back from there\n * lands on `?row=x` and the router opens the editor that was just closed. See\n * {@link noteAddress}: an address the overlay LIVED THROUGH (a filter the table wrote\n * while its sheet was up) is still unwound, because the user has acted since.\n *\n * ## Not undoing the owner's replaces either\n *\n * An address the overlay lived through is unwound as an ENTRY, never as an address\n * (keksdose live #412). A report that writes each tick of its payee sheet into the query\n * with `setSearchParams(…, { replace: true })` rewrites the overlay's own entry, and the\n * page entry beneath still carries the address from before the sheet opened — so the\n * traversal that took our entry away also took every tick with it. See {@link carryOnto}:\n * whichever way the entry goes (the unwind after a press, or a Back press), the address it\n * last showed is carried onto the entry it lands on, and the router is told.\n *\n * ## The traversal is deferred\n *\n * And it is *scheduled* rather than issued, because `history.go()` lands a task\n * later while everything this module knows is written synchronously. See\n * {@link Unwind}: an overlay opening inside that window adopts the entry instead\n * of stacking a second one on it, which is what makes the hook survive React\n * StrictMode's mount → clean up → mount (steering-design feedback #49).\n */\nconst SENTINEL_KEY = \"__hbUiOverlayHistory\";\n\ninterface OverlayEntry {\n  id: string;\n  close: () => void;\n  /** The overlay refuses to close right now — see the `held` option. */\n  held: () => boolean;\n  /** A Back press `held` refused — see the `onRefused` option. */\n  refused: () => void;\n}\n\nconst stack: OverlayEntry[] = [];\n\n/**\n * The sentinels we have PUSHED and not yet unwound, oldest first.\n *\n * The stack above tracks live overlays; this tracks live history entries, and the\n * two come apart in exactly one case — which is the bug this list exists for.\n * Nested overlays that close in the same commit unwind parent-first, so the dialog's\n * cleanup runs while the sheet's entry is still on top of its own. It cannot call\n * `history.back()` there (that would consume the SHEET's entry, and the sheet is\n * about to consume it itself), so its entry was simply abandoned: a husk with no\n * live owner sitting between the user and the page.\n *\n * The user paid for it on the next Back press. It popped the husk, `handlePop` found\n * an empty stack and returned, and nothing visible happened — Back had to be pressed\n * twice to leave the page.\n *\n * So an abandoned entry is recorded as `dead` instead, and whichever overlay DOES\n * get to unwind pays the debt with a single `history.go(-n)`. `href` is what keeps\n * that safe: only dead entries pushed at the address we are still sitting at are\n * unwound, so a router navigation that landed between two sentinels is never\n * reversed on the user's behalf.\n */\ninterface PushedEntry {\n  id: string;\n  /** The full address of the entry (query and hash included) as of the last time the\n   *  user acted while it was current — see {@link noteAddress}. */\n  href: string;\n  /** Its overlay is gone but the entry is not — someone above owes this pop. */\n  dead: boolean;\n  /** The router's `idx` on this entry when the marker went on — see {@link locate}. */\n  idx: number | undefined;\n  /** The router's `key` copied from the page entry beneath ours. */\n  key: string | undefined;\n  /** {@link routeOf} the address the marker was placed at. */\n  route: string;\n  /** The entry's address as last OBSERVED, after the user's last gesture had run its\n   *  handlers — what a Back press must carry down (see {@link carryOnto}). `href` is\n   *  the snapshot BEFORE the gesture, which the owner's-close check needs instead. */\n  seen: string;\n}\nconst pushed: PushedEntry[] = [];\n\n/**\n * Entries of ours that a ROUTER NAVIGATION made from inside the overlay has left\n * behind — ours, still in the history, but no longer on top and no longer anyone's.\n *\n * Nothing can take an entry out from under a newer one, so they cannot be unwound;\n * what can be done is to not let the user land on one. A traversal that comes to\n * rest on a buried entry is carried straight on over the whole run of them, in the\n * direction it was going (see `skipBuried`): Back from the new page lands on the page\n * the overlay was opened from, Forward from there lands on the new page, and no press\n * is spent on an entry with nothing on screen for it.\n *\n * `below` / `above` count the buried entries of the same run on either side. The\n * router's `idx` tells the direction apart — except after a REPLACE navigation, when\n * the page above the run shares the run's `idx`; the two keys decide there.\n */\ninterface BuriedEntry {\n  idx: number;\n  /** The `idx` of the router entry that buried the run: higher after a push, the\n   *  same after a replace. */\n  aboveIdx: number;\n  /** The key of the page entry directly beneath the run. */\n  belowKey: string | undefined;\n  /** The key of the router entry that buried the run, when it did. */\n  aboveKey: string | undefined;\n  below: number;\n  above: number;\n}\nconst buried = new Map<string, BuriedEntry>();\n\n/** The router `{idx, key}` of the entry the last traversal (or burial) left us on —\n *  what `skipBuried` compares against to know which way the user was going. */\nlet lastSeen: { idx: number | undefined; key: string | undefined } | null = null;\n\n/** Entries a real Back press already consumed. Their overlay's cleanup still has to\n *  run, and it must not mistake \"my entry is not current\" for \"my entry is buried\"\n *  — it has no entry left at all. */\nconst consumed = new Set<string>();\n\n/** Pops WE caused (a cleanup unwinding its own entries) — their `popstate` is\n *  bookkeeping, not a user gesture, and must not close a second overlay. A\n *  `history.go(-n)` traversal fires exactly ONE popstate however far it travels. */\nlet pendingProgrammatic = 0;\nlet listening = false;\n/** Whether the gesture listeners ({@link noteAddress}, {@link noteSeen}) are on — see\n *  {@link syncGestureListeners}. */\nlet noting = false;\nlet nextId = 0;\n\n/**\n * The unwind a cleanup has asked for and not yet issued.\n *\n * **`history.go()` is asynchronous and everything above is written\n * synchronously**, which is the seam the whole of this block exists to close.\n * The traversal lands a task later, so an overlay that opens in the *same* tick\n * as one that closed used to push its sentinel on top of the entry that was\n * about to be popped — and the pop then took the NEW entry. The overlay left on\n * screen had no entry of its own (so Back no longer closed it) and the old one\n * stayed behind as a husk between the user and their page.\n *\n * That is not an exotic race. **React StrictMode remounts every effect** — mount,\n * clean up, mount again, all in one commit — so in development *every* dialog\n * anyone opened left a husk behind, the position drifted one entry further from\n * the page on each open, and the Back press that was meant to leave the page was\n * spent on something invisible instead (steering-design feedback #49).\n *\n * So the traversal is deferred by a task, and an overlay mounting inside that\n * window **adopts** the entry instead of pushing a second one (see the effect).\n * Adoption is `replaceState` on an entry that is already there: no traversal, no\n * window in which the count can be wrong, and the StrictMode remount costs\n * exactly nothing.\n */\ninterface Unwind {\n  timer: ReturnType<typeof setTimeout>;\n  /** The sentinel on the entry to leave — the top of `entries`. */\n  id: string;\n  href: string;\n  /** That entry plus the abandoned ones directly beneath it, oldest first. */\n  entries: PushedEntry[];\n}\nlet unwind: Unwind | null = null;\n\n/** Issue the deferred traversal, if the ground has not moved under it.\n *\n *  A real Back press or a router navigation during the deferred task leaves us\n *  somewhere that is not the entry we meant to leave, and going back from there\n *  would take something that is not ours. The entries are then simply forgotten\n *  rather than handed back as `dead`: a forgotten entry costs one dead Back\n *  press, while an over-counted one costs the user a navigation they did make. */\nfunction runUnwind(): void {\n  const job = unwind;\n  unwind = null;\n  if (!job) return;\n  if (currentSentinel() !== job.id || currentHref() !== job.href) {\n    // A router navigation landed between the cleanup and this task: the entries\n    // are under it (or were replaced by it) rather than simply forgotten.\n    if (taggedSentinel() === null) buryUnder(job.entries);\n    return;\n  }\n  const bottom = job.entries[0];\n  carry = { href: job.href, idx: bottom.idx, key: bottom.key };\n  pendingProgrammatic += 1;\n  window.history.go(-job.entries.length);\n}\n\n/** The address an unwind in flight must carry onto the entry it lands on. */\nlet carry: { href: string; idx: number | undefined; key: string | undefined } | null = null;\n\n/**\n * Put `href` — the address the overlay's entry last showed — onto the entry a traversal\n * has just landed on, and tell the router (keksdose live #412).\n *\n * Only the query and the hash can differ: an address naming another page is a\n * navigation, never carried. And only onto the page entry the overlay was opened over,\n * which our push copied the router's `{idx, key}` from — a traversal that came to rest\n * anywhere else is not ours to rewrite.\n *\n * The router heard the traversal land on the OLD address in this same event, so a\n * `replaceState` alone would leave it showing the old query under the new one. A\n * synthetic `popstate` makes it read the address again; both reads happen in one event\n * dispatch, so React commits only the second. Ours absorbs it as programmatic.\n */\nfunction carryOnto(href: string, mark: { idx: number | undefined; key: string | undefined }): void {\n  const here = currentHref();\n  if (here === href || routeOf(here) !== routeOf(href)) return;\n  const now = routerMark();\n  if (mark.idx !== undefined && now.idx !== undefined && mark.idx !== now.idx) return;\n  if (mark.key !== undefined && now.key !== undefined && mark.key !== now.key) return;\n  const state: unknown = window.history.state;\n  window.history.replaceState(state, \"\", href);\n  pendingProgrammatic += 1;\n  window.dispatchEvent(new PopStateEvent(\"popstate\", { state }));\n}\n\nfunction currentHref(): string {\n  return typeof window === \"undefined\" ? \"\" : window.location.href;\n}\n\n/** The router's own `{idx, key}` on the current entry, where a router has put them. */\nfunction routerMark(): { idx: number | undefined; key: string | undefined } {\n  const state = typeof window !== \"undefined\" ? (window.history.state as unknown) : null;\n  if (!state || typeof state !== \"object\") return { idx: undefined, key: undefined };\n  const { idx, key } = state as Record<string, unknown>;\n  return { idx: typeof idx === \"number\" ? idx : undefined, key: typeof key === \"string\" ? key : undefined };\n}\n\n/**\n * The part of an address that names the PAGE — the query string left out.\n *\n * A `setSearchParams(…, { replace: true })` rewrites the query on the entry the\n * overlay is standing on; that is a wipe to repair, not a move. Anything else changing\n * is a navigation. Under a hash router the page lives in the hash (`#/table?f.q=x`), so\n * a hash that starts with `#/` counts up to its own `?`; an ordinary `#fragment` does\n * not name a page and is left out.\n */\nfunction routeOf(href: string): string {\n  try {\n    const url = new URL(href);\n    const hashRoute = url.hash.startsWith(\"#/\") ? url.hash.split(\"?\")[0] : \"\";\n    return url.origin + url.pathname + hashRoute;\n  } catch {\n    return href;\n  }\n}\n\n/**\n * Is the untagged entry we are standing on still `p`'s — merely wiped by the router —\n * or an entry the router NAVIGATED to from inside the overlay?\n *\n * The router's `idx` is the one per-entry fact that separates the two, because it is\n * the one the router itself keeps straight: a replace leaves it as it was, a push adds\n * one. Our own push copies the page's state, so our entry carries the page's `idx` and\n * a router push on top of it carries one more. The key would not do — every replace\n * mints a new one, so the wipe this repair exists for would already fail it. Neither\n * would the address alone: a push to the address we are already at is still a push.\n *\n * `idx` does not see one move, the router REPLACING our entry with a different page\n * (same `idx`), so the page named by the address must also be unchanged. Where there is\n * no `idx` to compare (no router, or one that keeps none) the address is all there is.\n */\nfunction isStillOn(p: PushedEntry): boolean {\n  if (routeOf(currentHref()) !== p.route) return false;\n  const { idx } = routerMark();\n  return idx === undefined || p.idx === undefined || idx === p.idx;\n}\n\n/**\n * The router has navigated while our entries were on top: record which of `records`\n * (ours, oldest first, ending with the top one) it buried and which it replaced, and\n * drop them from `pushed` — none of them can be unwound any more. Returns whether it\n * recognised a navigation at all; when it cannot tell (no router `idx` to go by), it\n * leaves everything as it was and the caller falls back to marking the entry dead.\n */\nfunction buryUnder(records: PushedEntry[]): boolean {\n  const top = records[records.length - 1];\n  const here = routerMark();\n  if (!top || top.idx === undefined || here.idx === undefined) return false;\n  let run: PushedEntry[];\n  if (here.idx > top.idx) {\n    run = [];\n    for (let i = records.length - 1; i >= 0 && records[i].idx === top.idx; i -= 1) run.unshift(records[i]);\n  } else if (here.idx === top.idx && !isStillOn(top)) {\n    // Replaced: the top entry IS the new page now, and gone as ours. Those beneath it\n    // are buried under it.\n    run = [];\n    for (let i = records.length - 2; i >= 0 && records[i].idx === top.idx; i -= 1) run.unshift(records[i]);\n  } else {\n    return false;\n  }\n  run.forEach((r, i) => {\n    buried.set(r.id, {\n      idx: top.idx as number,\n      aboveIdx: here.idx as number,\n      belowKey: run[0].key,\n      aboveKey: here.key,\n      below: i,\n      above: run.length - 1 - i,\n    });\n  });\n  for (const r of records) forgetPushed(r.id);\n  lastSeen = here;\n  return true;\n}\n\n/**\n * A traversal came to rest on one of our buried entries: carry it on over the run, the\n * way it was going. Back from above (a higher `idx`, or the very entry that buried us)\n * continues down to the page beneath; Forward from that page continues up. A landing\n * from anywhere this cannot place is left alone — one idle press is the price of not\n * guessing, and a wrong guess would move the user somewhere they did not ask to go.\n */\nfunction skipBuried(from: typeof lastSeen): void {\n  const tag = taggedSentinel();\n  const rec = tag !== null ? buried.get(tag) : undefined;\n  if (!rec || !from || stack.some((e) => e.id === tag)) return;\n  let steps = 0;\n  if ((from.idx !== undefined && from.idx > rec.idx) || (from.key !== undefined && from.key === rec.aboveKey)) {\n    steps = -(rec.below + 1);\n  } else if (\n    from.idx !== undefined &&\n    // Below the run, or level with it when nothing above it is (a push buried it),\n    // or level with it and provably the page beneath (a replace buried it). The\n    // router's first entry has no key at all, so an absent key is a key here.\n    (from.idx < rec.idx || (from.idx === rec.idx && (rec.aboveIdx > rec.idx || from.key === rec.belowKey)))\n  ) {\n    steps = rec.above + 1;\n  }\n  if (steps === 0) return;\n  pendingProgrammatic += 1;\n  window.history.go(steps);\n}\n\nfunction forgetPushed(id: string): void {\n  const at = pushed.findIndex((p) => p.id === id);\n  if (at >= 0) pushed.splice(at, 1);\n}\n\n/**\n * The sentinel this module believes is on the entry we are standing on.\n *\n * `history.state` is where the tag physically sits, because it is the only\n * per-entry storage a browser has — but it is not this module's storage, so\n * since the 2026-09-22 audit it is no longer read as the last word.\n * The ROUTER owns that object and writes it WHOLE: every\n * `setSearchParams(…, { replace: true })` stamps `{usr, key, idx}` over\n * whatever was there. A `DataTable` with `urlSync` does exactly that, on mount\n * and on every filter change — so an overlay opened from such a table had its\n * tag wiped off the entry it was standing on, and then:\n *\n *  * its cleanup read \"not my entry\" and abandoned a live entry as a husk;\n *  * the push path below could not find itself in `pushed`, so it discarded\n *    every record it had (`splice(0)`) and nothing was ever unwound again;\n *  * the StrictMode adoption never matched, so in development every dialog\n *    pushed a second entry and the deferred `go(-1)` ate the live one — which\n *    is Back no longer closing the overlay at all.\n *\n * So `standing` answers when the tag is gone: a MISSING tag on an entry we have\n * not left is a wipe to repair rather than a verdict. The tag is still read\n * FIRST wherever it is there, because it is the one thing that can see a FOREIGN\n * same-URL entry stacked above ours (feedback #424/#426, below) — module-level\n * bookkeeping cannot, since nobody tells us about someone else's `pushState`.\n */\nlet standing: string | null = null;\n\n/** The tag actually on the current entry, with no repair and no belief. */\nfunction taggedSentinel(): string | null {\n  const state = typeof window !== \"undefined\" ? window.history.state : null;\n  if (!state || typeof state !== \"object\") return null;\n  const id = (state as Record<string, unknown>)[SENTINEL_KEY];\n  return typeof id === \"string\" ? id : null;\n}\n\n/** Put our tag back on the current entry, keeping whatever the router has since\n *  written there — we are a passenger in that object, not its owner. */\nfunction retag(id: string): void {\n  const prev = window.history.state;\n  window.history.replaceState({ ...(prev && typeof prev === \"object\" ? prev : {}), [SENTINEL_KEY]: id }, \"\");\n}\n\nfunction currentSentinel(): string | null {\n  const tag = taggedSentinel();\n  if (tag !== null) {\n    standing = tag;\n    return tag;\n  }\n  if (standing === null || typeof window === \"undefined\") return null;\n  // Only ever re-stamp an entry we still hold a record for. Without that guard a\n  // belief left over from an overlay that is long gone — a tab that has since\n  // navigated, a test file that ran another case — would be stamped onto a\n  // stranger's entry, and the next cleanup would traverse off it.\n  //\n  // And only an entry that is still the one the marker was placed on. A row that\n  // NAVIGATES (a palette result, a dialog's link) has the router push the new page\n  // before the overlay's cleanup runs; that entry carries no tag either, and\n  // re-stamping it made the cleanup \"unwind\" the navigation itself — the page\n  // changed and changed straight back. See `isStillOn` for how the two are told apart.\n  const record = pushed.find((p) => p.id === standing);\n  if (!record || !isStillOn(record)) {\n    standing = null;\n    return null;\n  }\n  retag(standing);\n  return standing;\n}\n\n/**\n * The user is about to act: what the current entry's address is NOW is what the\n * overlay standing on it has lived through.\n *\n * The cleanup needs to tell two same-page query rewrites apart, and the address alone\n * cannot. A `DataTable` with `urlSync` replaces `f.*` over the entry while its filter\n * sheet is up, and the sheet is closed LATER, by a press of its own — that entry is\n * still the sheet's and must be unwound (the audit's drift fix, below). A page whose\n * `?row=` drives the overlay replaces the clean URL over the entry and the overlay\n * unmounts BECAUSE of it (keksdose dev #584) — that entry is the owner's now, and\n * unwinding lands on `?row=` beneath and reopens what was just closed. What separates\n * them is whether the user acted in between: the rewrite that closes an overlay is\n * made by the very press that closes it, so it postdates this snapshot.\n *\n * Capture phase, so the snapshot is taken before any handler of the press runs.\n */\nfunction noteAddress(): void {\n  const top = pushed[pushed.length - 1];\n  if (!top || top.dead || !stack.some((e) => e.id === top.id)) return;\n  const tag = taggedSentinel();\n  // Read without `currentSentinel`'s repair: an observation must not write history.\n  if (tag === top.id || (tag === null && standing === top.id && isStillOn(top))) {\n    top.href = currentHref();\n    top.seen = top.href;\n  }\n}\n\n/** After the user's gesture has run its handlers: the address its entry now shows —\n *  what a Back press must carry down (keksdose live #412). Again a little later, for a\n *  handler that writes the address a task after the event. */\nfunction noteSeen(): void {\n  const top = pushed[pushed.length - 1];\n  if (!top || top.dead || !stack.some((e) => e.id === top.id)) return;\n  const tag = taggedSentinel();\n  if (tag === top.id || (tag === null && standing === top.id && isStillOn(top))) top.seen = currentHref();\n}\n\nfunction noteSeenNowAndLater(): void {\n  noteSeen();\n  setTimeout(noteSeen, 0);\n}\n\nfunction handlePop() {\n  // A pop MOVES us, so the belief is stale by definition: re-read it from the\n  // entry we have landed on before anything below consults it, or the repair in\n  // `currentSentinel` would stamp the entry we just left onto the one we are on.\n  standing = taggedSentinel();\n  const from = lastSeen;\n  lastSeen = routerMark();\n  if (pendingProgrammatic > 0) {\n    pendingProgrammatic -= 1;\n    const job = carry;\n    carry = null;\n    if (job) carryOnto(job.href, job);\n    return;\n  }\n  closeOnPop();\n  skipBuried(from);\n}\n\nfunction closeOnPop() {\n  // Nothing open → an ordinary navigation, which is none of our business.\n  const top = stack[stack.length - 1];\n  if (!top) return;\n  // We landed back ON the top overlay's own entry, so that entry was NOT what the\n  // pop consumed — something stacked ABOVE it was (Keksdose feedback #424/#426).\n  // The app layers a second same-URL sentinel of its own on top of ours for the\n  // unsaved-edit trap (`use-soft-leave-guard.ts`), and it pops that sentinel every\n  // time the form goes back to clean — twice-toggling one field was enough to\n  // close the whole dialog. A pop is only ours when the entry we came to rest on\n  // is no longer ours: either the layer below (a different overlay's marker) or\n  // the plain page entry (none at all).\n  if (currentSentinel() === top.id) return;\n  // Checked before anything below moves: a held overlay keeps its place and its record.\n  if (top.held()) {\n    putBack(top.id);\n    // Told after the entry is back, so what the overlay does about it (a `Modal`'s\n    // `onDismissRefused`) runs on its own entry, not on the page under it.\n    top.refused();\n    return;\n  }\n  stack.pop();\n  syncGestureListeners();\n  // The browser consumed this entry, so the overlay's own cleanup has nothing left\n  // to unwind and nothing to record as owed.\n  consumed.add(top.id);\n  const record = pushed.find((p) => p.id === top.id);\n  forgetPushed(top.id);\n  // What the page wrote into the address while we were up stays (#412).\n  if (record && !record.dead) carryOnto(record.seen, record);\n  top.close();\n}\n\n/**\n * A Back press the top overlay refuses (a busy `Modal`, DUP-3). A popstate cannot be\n * refused — the browser has already left our entry — so the entry is put back: what the\n * page wrote into the address while the overlay was up is carried down first (#412), as\n * for a close, and the same marker is pushed again over it, as the mount pushed it. Left\n * on the page entry, the overlay would stay up with no entry of its own, and the Back\n * after its request would leave the page under it.\n *\n * A push and not `history.go(1)` back onto the old entry: a traversal lands a task later\n * and fires nothing at all if a listener has pushed meanwhile, and a programmatic pop\n * counted for it would then swallow the user's next real Back.\n */\nfunction putBack(id: string): void {\n  const record = pushed.find((p) => p.id === id);\n  if (record && !record.dead) carryOnto(record.seen, record);\n  const prev: unknown = window.history.state;\n  window.history.pushState({ ...(prev && typeof prev === \"object\" ? prev : {}), [SENTINEL_KEY]: id }, \"\");\n  standing = id;\n  // The address the entry shows now is the one the user last acted on: the cleanup's\n  // owner's-close check (#584) must not read the carried address as a rewrite.\n  if (record) record.href = record.seen = currentHref();\n}\n\n/** `popstate` stays from the first overlay on: a traversal of ours (an unwind, a buried\n *  run to skip) lands after the overlay that caused it has gone. */\nfunction ensureListening() {\n  if (listening || typeof window === \"undefined\") return;\n  window.addEventListener(\"popstate\", handlePop);\n  listening = true;\n}\n\nconst SEEN_EVENTS = [\"click\", \"keyup\", \"change\", \"input\"] as const;\n\n/**\n * The gesture listeners, on while an overlay is open and off when the last one closes.\n * Both notes return at once with no overlay up, but the four bubbling ones scheduled a\n * timer for their second look even then — for every click and every keystroke in every\n * field, for the life of the page after its first dialog (refactor audit 2026-10-30,\n * INP-14). Called after each change to `stack`.\n */\nfunction syncGestureListeners(): void {\n  const want = stack.length > 0;\n  if (want === noting || typeof window === \"undefined\") return;\n  noting = want;\n  if (want) {\n    window.addEventListener(\"pointerdown\", noteAddress, true);\n    window.addEventListener(\"keydown\", noteAddress, true);\n    for (const type of SEEN_EVENTS) window.addEventListener(type, noteSeenNowAndLater);\n  } else {\n    window.removeEventListener(\"pointerdown\", noteAddress, true);\n    window.removeEventListener(\"keydown\", noteAddress, true);\n    for (const type of SEEN_EVENTS) window.removeEventListener(type, noteSeenNowAndLater);\n  }\n}\n\n/**\n * Make the platform Back gesture dismiss an overlay.\n *\n * @param open      whether the overlay is currently showing. Components that mount\n *                  only while open (the common case) pass `true`.\n * @param onClose   the overlay's own close handler — the same one Escape calls.\n * @param options.held  the overlay refuses to close right now (a `Modal` whose request\n *                  is in flight, DUP-3): Back does not call `onClose`, and the entry the\n *                  press took is put back, so the overlay still has one for the next\n *                  Back. Read when Back is pressed. Default false.\n * @param options.onRefused  called once for each Back `held` refused, after its entry is\n *                  put back — how a held `Modal` hears the press it dropped and passes\n *                  it on as `onDismissRefused(\"back\")` (0.54 follow-up, keksdose\n *                  recovery-code-pane).\n */\nexport function useOverlayHistory(\n  open: boolean,\n  onClose: () => void,\n  { held = false, onRefused }: { held?: boolean; onRefused?: () => void } = {},\n): void {\n  // The listener fires outside React's render, so it reads the latest handler\n  // through a ref rather than through the closure the effect captured.\n  const closeRef = useRef(onClose);\n  const heldRef = useRef(held);\n  const refusedRef = useRef(onRefused);\n  useEffect(() => {\n    closeRef.current = onClose;\n    heldRef.current = held;\n    refusedRef.current = onRefused;\n  });\n\n  useEffect(() => {\n    if (!open || typeof window === \"undefined\") return;\n    ensureListening();\n    const id = `overlay-${(nextId += 1)}`;\n    const entry: OverlayEntry = {\n      id,\n      close: () => closeRef.current(),\n      held: () => heldRef.current,\n      refused: () => refusedRef.current?.(),\n    };\n    stack.push(entry);\n    syncGestureListeners();\n    const prev = window.history.state;\n    const marked = { ...(prev && typeof prev === \"object\" ? prev : {}), [SENTINEL_KEY]: id };\n    // An entry that is on its way out and that we are still standing on is ours\n    // to take over: same URL, same slot, only the marker changes. Pushing a\n    // second one on top of it is what used to leave a husk on every StrictMode\n    // remount — see {@link Unwind}.\n    const adopting = unwind && unwind.id === currentSentinel() && unwind.href === currentHref();\n    if (adopting && unwind) {\n      clearTimeout(unwind.timer);\n      const inherited = unwind.entries;\n      unwind = null;\n      // Preserve react-router's own `{usr,key,idx}` — we only swap the marker,\n      // and the entry we are swapping it on is the one the router is already on.\n      window.history.replaceState(marked, \"\");\n      // The abandoned ones beneath come back owed; ours takes the top slot.\n      for (const owed of inherited.slice(0, -1)) pushed.push({ ...owed, dead: true });\n      const was = inherited[inherited.length - 1];\n      pushed.push({\n        id,\n        href: currentHref(),\n        seen: currentHref(),\n        dead: false,\n        idx: was.idx,\n        key: was.key,\n        route: was.route,\n      });\n      standing = id;\n    } else {\n      // A push DESTROYS every entry ahead of the one we are on, so anything we\n      // still had recorded above our own position is gone. Kept, those would be\n      // counted into a later `history.go(-n)` and the overshoot would come out\n      // of a navigation the user actually made. Where we cannot tell which of\n      // ours are beneath us — we are standing on a plain page entry, or on a\n      // husk nobody tracks — none of them can be proven to be, so none survive.\n      const under = pushed.findIndex((p) => p.id === currentSentinel());\n      pushed.splice(under + 1);\n      // Preserve react-router's own `{usr,key,idx}` — we only tack a marker on, and\n      // the URL is unchanged, so the router treats popping this as a no-op re-render.\n      window.history.pushState(marked, \"\");\n      const page = routerMark();\n      const at = currentHref();\n      pushed.push({ id, href: at, seen: at, dead: false, idx: page.idx, key: page.key, route: routeOf(at) });\n      standing = id;\n    }\n    return () => {\n      const at = stack.indexOf(entry);\n      if (at >= 0) stack.splice(at, 1);\n      syncGestureListeners();\n\n      // A Back press already took this entry; there is nothing to unwind or to owe.\n      if (consumed.delete(id)) return;\n\n      const mine = pushed.findIndex((p) => p.id === id);\n      // Still our entry — same page, same router `idx` — but its address is not the one\n      // the user last acted on: the owner rewrote it as part of closing us (see\n      // {@link noteAddress}). The entry is the owner's page now, and the one beneath is\n      // the address it replaced — going back would restore exactly what was closed.\n      // Nothing to unwind; forget the record rather than re-stamp a page we left.\n      if (mine >= 0 && currentHref() !== pushed[mine].href) {\n        const tag = taggedSentinel();\n        if (tag === id || (tag === null && standing === id && isStillOn(pushed[mine]))) {\n          pushed.splice(mine, 1);\n          if (standing === id) standing = null;\n          return;\n        }\n      }\n      // Only unwind an entry that is still THE current one. If a router push landed\n      // on top of it, going back would undo the user's navigation instead — and if\n      // a SIBLING overlay's sentinel landed on top, that overlay is about to unwind\n      // and is the one that can take ours with it.\n      if (currentSentinel() !== id) {\n        // A router navigation from inside the overlay: nothing to unwind — the\n        // entries it left beneath the new page are skipped over instead.\n        if (mine >= 0 && taggedSentinel() === null && buryUnder(pushed.slice(0, pushed.length))) return;\n        if (mine >= 0) pushed[mine].dead = true;\n        return;\n      }\n\n      // Ours plus every abandoned entry lying directly beneath it at this address.\n      // One traversal, so one popstate, so one programmatic pop to absorb.\n      const here = currentHref();\n      let steps = 1;\n      while (steps <= mine && pushed[mine - steps].dead && pushed[mine - steps].href === here) {\n        steps += 1;\n      }\n      const leaving = pushed.splice(mine - (steps - 1), steps);\n      // Scheduled, not issued: an overlay opening in this same tick takes the\n      // entry over instead, which is what makes the hook survive a StrictMode\n      // remount. An unwind already waiting is dropped rather than merged — it\n      // was the entry ABOVE ours and something has since moved off it, so its\n      // count can no longer be proven, and an over-counted traversal costs a\n      // navigation the user made while an under-counted one costs one dead Back.\n      if (unwind) clearTimeout(unwind.timer);\n      unwind = { timer: setTimeout(runUnwind, 0), id, href: here, entries: leaving };\n    };\n  }, [open]);\n}\n"],"mappings":"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","names":[]}

package/dist/i18n/defaults.js

@@ -26,6 +26,7 @@ import { DEFAULT_SWATCH_PICKER_LABELS } from "../components/swatch-picker-labels
 import { DEFAULT_ICON_PICKER_LABELS } from "../components/icon-picker-labels.js";
 import { DEFAULT_DIALOG_FRAME_LABELS } from "../components/dialog-frame-labels.js";
 import { DEFAULT_FILE_PICKER_LABELS } from "../hooks/use-file-picker-labels.js";
+import { DEFAULT_CAMERA_LABELS } from "../components/camera-labels.js";
 import { DEFAULT_MEASURED_GRID_LABELS } from "../components/measured-grid-labels.js";
 import { DEFAULT_CONFIRM_DIALOG_LABELS } from "../components/confirm-dialog-labels.js";
 import { DEFAULT_FLOATING_PANEL_LABELS } from "../components/floating-panel-labels.js";
@@ -101,6 +102,10 @@ import { DEFAULT_SIGN_OUT_PENDING_DIALOG_LABELS } from "../offline/sign-out-pend
 import { DEFAULT_PWA_UPDATE_PROMPT_LABELS } from "../offline/pwa-update-prompt-labels.js";
 import { DEFAULT_SHARED_COMPUTER_LABELS } from "../offline/shared-computer-labels.js";
 import { DEFAULT_TOP_BAR_PARTS_LABELS } from "../shell/top-bar-parts-labels.js";
+import { DEFAULT_HELD_CHANGES_BANNER_LABELS } from "../shell/held-changes-banner-labels.js";
+import { DEFAULT_FIELD_SUGGESTION_LABELS } from "../components/field-suggestion-labels.js";
+import { DEFAULT_CONSENT_AGAIN_LABELS } from "../components/consent-again-notice-labels.js";
+import { DEFAULT_RELEASE_NOTES_LABELS } from "../components/release-notes-labels.js";
 import { DEFAULT_SHARE_CARD_LABELS } from "../components/share-card-labels.js";
 import { DEFAULT_REAUTH_DIALOG_LABELS } from "../components/reauth-dialog-labels.js";
 import { DEFAULT_SERVER_WAKE_LABELS } from "../components/server-wake-labels.js";
@@ -163,6 +168,7 @@ const DEFAULT_UI_KIT_LABELS = {
   iconPicker: DEFAULT_ICON_PICKER_LABELS,
   dialogFrame: DEFAULT_DIALOG_FRAME_LABELS,
   filePicker: DEFAULT_FILE_PICKER_LABELS,
+  camera: DEFAULT_CAMERA_LABELS,
   measuredGrid: DEFAULT_MEASURED_GRID_LABELS,
   feedbackAttachment: DEFAULT_FEEDBACK_ATTACHMENT_LABELS,
   feedbackDialog: DEFAULT_FEEDBACK_DIALOG_LABELS,
@@ -245,7 +251,11 @@ const DEFAULT_UI_KIT_LABELS = {
   mailTestCard: DEFAULT_MAIL_TEST_CARD_LABELS,
   signOutPending: DEFAULT_SIGN_OUT_PENDING_DIALOG_LABELS,
   pwaUpdate: DEFAULT_PWA_UPDATE_PROMPT_LABELS,
-  sharedComputer: DEFAULT_SHARED_COMPUTER_LABELS
+  sharedComputer: DEFAULT_SHARED_COMPUTER_LABELS,
+  heldChanges: DEFAULT_HELD_CHANGES_BANNER_LABELS,
+  fieldSuggestion: DEFAULT_FIELD_SUGGESTION_LABELS,
+  consentAgain: DEFAULT_CONSENT_AGAIN_LABELS,
+  releaseNotes: DEFAULT_RELEASE_NOTES_LABELS
 };
 export {
   DEFAULT_UI_KIT_LABELS