@eifi1/ui-kit 0.39.1 → 0.40.1

package/dist/feedback/feedback-vocabulary.js

@@ -12,6 +12,7 @@ import {
   MoreHorizontal,
   OctagonAlert,
   PauseCircle,
+  RotateCcw,
   Wrench
 } from "lucide-react";
 const FEEDBACK_STATUS_META = {
@@ -29,6 +30,16 @@ const FEEDBACK_STATUS_META = {
     activeBg: "bg-brand-soft",
     activeText: "text-brand"
   },
+  // Sent back by its author or an admin and released for work again (0.40, feedback
+  // contract §10.2 decision 4): the Rework button's `RotateCcw`, in the danger tint so the
+  // queue shows reworks apart from new reports. Not IN_PROGRESS's warning tint — that is
+  // where a REWORK row moves next — and WONT_DO, the only other red, sits at the far end
+  // with `Ban`.
+  REWORK: {
+    icon: RotateCcw,
+    activeBg: "bg-danger-soft",
+    activeText: "text-danger"
+  },
   IN_PROGRESS: {
     icon: Wrench,
     activeBg: "bg-warning-soft",
@@ -78,13 +89,17 @@ const FEEDBACK_STATUS_ORDER = Object.keys(FEEDBACK_STATUS_META);
 const OFF_CHAIN = ["NEEDS_LIVE_TEST", "POSTPONED", "WONT_DO"];
 const FORWARD_CHAIN = ["OPEN", "READY", "IN_PROGRESS", "IN_EVALUATION", "DONE"];
 function nextFeedbackStatus(current) {
+  if (current === "REWORK") return "IN_PROGRESS";
   const at = FORWARD_CHAIN.indexOf(current);
   return at !== -1 && at < FORWARD_CHAIN.length - 1 ? FORWARD_CHAIN[at + 1] : null;
 }
 function visibleFeedbackStatuses(current) {
   const set = /* @__PURE__ */ new Set([current]);
   const at = FORWARD_CHAIN.indexOf(current);
-  if (at !== -1) {
+  if (current === "REWORK") {
+    set.add("IN_PROGRESS");
+    for (const off of OFF_CHAIN) set.add(off);
+  } else if (at !== -1) {
     if (at < FORWARD_CHAIN.length - 1) set.add(FORWARD_CHAIN[at + 1]);
     if (at > 0) set.add(FORWARD_CHAIN[at - 1]);
     for (const off of OFF_CHAIN) set.add(off);

package/dist/feedback/feedback-vocabulary.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/feedback/feedback-vocabulary.ts"],"sourcesContent":["import {\n  Ban,\n  Bug,\n  CheckCircle2,\n  ClipboardCheck,\n  CloudUpload,\n  Eye,\n  HelpCircle,\n  Inbox,\n  Lightbulb,\n  MoreHorizontal,\n  OctagonAlert,\n  PauseCircle,\n  Wrench,\n} from \"lucide-react\";\nimport type { LucideIcon } from \"lucide-react\";\n\n/**\n * The feedback **vocabulary**: the eight statuses and five categories, the glyph and tone\n * of each, their orders, and the policy for how a report moves from status to status.\n *\n * Data and plain functions, no components. Until 0.34 this lived at the top of\n * feedback-inbox.tsx, so the feedback menu every app mounts in its top bar imported the\n * inbox — its components and the attachment field they render — for one constant (a\n * category's glyph), and only tree-shaking kept the rest out of every app's entry chunk.\n * From here the top bar's imports reach none of it (MOD-1, refactor audit 2026-10).\n * feedback-inbox.tsx re-exports every name here, so nothing an app imports has moved.\n */\n\n/** The eight states a report can be in.\n *\n *  Shared value for value across the apps on purpose: it is what lets one habit,\n *  and one agent prompt, work on any repo. Five are a chain and three sit off\n *  it — see {@link visibleFeedbackStatuses} for what that buys. `READY` joined in 0.31\n *  (feedback contract §8.2): OPEN is \"filed, not yet triaged\", READY \"released for\n *  implementation\", and nobody works an OPEN row. */\nexport type FeedbackStatus =\n  | \"OPEN\"\n  | \"READY\"\n  | \"IN_PROGRESS\"\n  | \"IN_EVALUATION\"\n  | \"NEEDS_LIVE_TEST\"\n  | \"POSTPONED\"\n  | \"DONE\"\n  | \"WONT_DO\";\n\n/** What a report is about. `CRASH` is filed by an error boundary and never\n *  chosen, which is exactly why it is loud below and absent from every picker. */\nexport type FeedbackCategory = \"CRASH\" | \"BUG\" | \"IDEA\" | \"QUESTION\" | \"OTHER\";\n\n/**\n * A glyph and a tone per status.\n *\n * Colour alone is not a label — two of these sit a hue apart, and a consumer who\n * moves `--brand` can park it beside any of the others — so every status carries\n * its own shape as well. Declaration order is chain order, and\n * {@link FEEDBACK_STATUS_ORDER} is derived from it rather than restated, because\n * a restated list cannot be checked for exhaustiveness: an eighth status would\n * break the build here and leave a literal eight long (as READY did in 0.31).\n */\nexport const FEEDBACK_STATUS_META: Record<\n  FeedbackStatus,\n  { icon: LucideIcon; activeBg: string; activeText: string }\n> = {\n  OPEN: {\n    icon: Inbox,\n    activeBg: \"bg-active\",\n    activeText: \"text-primary\",\n  },\n  // Triaged and released for implementation (feedback contract §8.2, keksdose live\n  // #396): OPEN is \"filed, nobody has looked yet\", READY is \"go\". The brand tint at full\n  // strength, so it reads as the go-ahead beside OPEN's neutral fill and\n  // NEEDS_LIVE_TEST's muted brand.\n  READY: {\n    icon: ClipboardCheck,\n    activeBg: \"bg-brand-soft\",\n    activeText: \"text-brand\",\n  },\n  IN_PROGRESS: {\n    icon: Wrench,\n    activeBg: \"bg-warning-soft\",\n    activeText: \"text-warning\",\n  },\n  // Where solved work is parked, waiting on the person who reported it. Its own\n  // colour, because \"somebody has to check this\" is a state you want to find by\n  // scanning rather than by reading.\n  IN_EVALUATION: {\n    icon: Eye,\n    activeBg: \"bg-info-soft\",\n    activeText: \"text-info\",\n  },\n  // Resolved but only checkable on a deployed build — the SOFT brand tint, so it\n  // reads as \"waiting on something\" rather than as a done or a refusal, and it\n  // follows whatever the consumer's brand is instead of pinning an indigo island\n  // beside it.\n  NEEDS_LIVE_TEST: {\n    icon: CloudUpload,\n    activeBg: \"bg-brand-soft\",\n    activeText: \"text-brand-muted\",\n  },\n  // Parked on purpose. Muted, not `--danger`: it is not a refusal.\n  POSTPONED: {\n    icon: PauseCircle,\n    activeBg: \"bg-active\",\n    activeText: \"text-secondary\",\n  },\n  // The one status with nowhere to move to: the vocabulary has a brand, an info, a\n  // warning and a danger, and nothing that means \"succeeded\". Deliberately NOT\n  // borrowed from a family that means something else — `--status-synced` is a\n  // FIELD's trip to the database rather than an outcome, and tokens.css says so in\n  // as many words. Green beside WONT_DO's red is the classic CVD-unsafe pair, which\n  // is why both carry a glyph and neither leans on colour alone.\n  DONE: {\n    icon: CheckCircle2,\n    activeBg: \"bg-success-soft\",\n    activeText: \"text-success\",\n  },\n  WONT_DO: {\n    icon: Ban,\n    activeBg: \"bg-danger-soft\",\n    activeText: \"text-danger\",\n  },\n};\n\n/** Chain order, then the three off it. The order a picker offers, and the rank a\n *  status column sorts by — so a list sorted by status reads as a queue rather\n *  than as an alphabet. */\nexport const FEEDBACK_STATUS_ORDER = Object.keys(FEEDBACK_STATUS_META) as FeedbackStatus[];\n\n/** States that sit OFF the linear chain: reachable from anywhere, leading\n *  nowhere by themselves. `WONT_DO` has always worked this way; `POSTPONED`\n *  (\"not now\") and `NEEDS_LIVE_TEST` (\"resolved, but only provable on a deployed\n *  build\") are the same shape — a row can be parked or handed to the next deploy\n *  from any point, and comes back to the chain when somebody picks a real state\n *  for it.\n *\n *  Kept out of the forward chain deliberately: putting them in it would mean an\n *  \"advance\" gesture could park an item, and every row would have to pass\n *  through them to reach `DONE`. */\nconst OFF_CHAIN: FeedbackStatus[] = [\"NEEDS_LIVE_TEST\", \"POSTPONED\", \"WONT_DO\"];\n\nconst FORWARD_CHAIN: FeedbackStatus[] = [\"OPEN\", \"READY\", \"IN_PROGRESS\", \"IN_EVALUATION\", \"DONE\"];\n\n/** The next status along the chain, or null at the end (or off it, as `WONT_DO`\n *  is). What a swipe-to-advance gesture commits. */\nexport function nextFeedbackStatus(current: FeedbackStatus): FeedbackStatus | null {\n  const at = FORWARD_CHAIN.indexOf(current);\n  return at !== -1 && at < FORWARD_CHAIN.length - 1 ? FORWARD_CHAIN[at + 1] : null;\n}\n\n/**\n * The steps that make sense from where a row currently stands.\n *\n * For the compact control in a table cell: it is a glanceable triage affordance,\n * and a row of eight icons in a cell is noise. One step forward, one step back\n * (so an item can be sent back for rework), and any of the three off-chain\n * verdicts — which is what makes those usable as verdicts at all.\n *\n * The two parking states are not dead ends: each offers the step that resumes\n * work and the ones that close it, but deliberately **not each other** —\n * \"postponed\" and \"waiting on a deploy\" are different answers to different\n * questions, and a row moving between them directly is a re-triage, which starts\n * by picking the work back up.\n */\nexport function visibleFeedbackStatuses(current: FeedbackStatus): FeedbackStatus[] {\n  const set = new Set<FeedbackStatus>([current]);\n  const at = FORWARD_CHAIN.indexOf(current);\n  if (at !== -1) {\n    if (at < FORWARD_CHAIN.length - 1) set.add(FORWARD_CHAIN[at + 1]);\n    if (at > 0) set.add(FORWARD_CHAIN[at - 1]);\n    for (const off of OFF_CHAIN) set.add(off);\n  } else if (current !== \"WONT_DO\") {\n    set.add(\"IN_PROGRESS\");\n    set.add(\"DONE\");\n    set.add(\"WONT_DO\");\n  }\n  // WONT_DO falls through with nothing added: it stays terminal, reopened by a\n  // note from its author rather than by a status pill.\n  return FEEDBACK_STATUS_ORDER.filter((status) => set.has(status));\n}\n\n/**\n * Every status, in chain order — what an EXPANDED row offers.\n *\n * {@link visibleFeedbackStatuses} narrows the choice to the steps that make\n * sense from where a row is, which is right for a table cell. Once the row is\n * open in front of you, that same narrowing turns every non-adjacent move into a\n * walk: OPEN to DONE meant three round trips, and WONT_DO could not be left at\n * all except through a rework note.\n *\n * Takes a `current` it does not use, so the two policies read as one pair at the\n * call sites and a future rule (\"terminal rows still cannot jump to X\") has a\n * place to live.\n */\nexport function selectableFeedbackStatuses(_current: FeedbackStatus): FeedbackStatus[] {\n  return [...FEEDBACK_STATUS_ORDER];\n}\n\n/**\n * Per-category badge treatment, the counterpart to the status meta above.\n *\n * A category cell that is one grey pill holding the raw enum makes a CRASH —\n * filed automatically, by somebody staring at a broken page right now — read\n * exactly like a QUESTION, and sit unnoticed in the queue. `--danger` plus its own\n * glyph is what makes that impossible; the hand-filed categories stay\n * deliberately quiet so that the loud one means something.\n *\n * Declaration order is triage order, CRASH first.\n */\nexport const FEEDBACK_CATEGORY_META: Record<\n  FeedbackCategory,\n  { icon: LucideIcon; badgeBg: string; badgeText: string }\n> = {\n  CRASH: {\n    icon: OctagonAlert,\n    badgeBg: \"bg-danger-soft\",\n    badgeText: \"text-danger\",\n  },\n  BUG: {\n    icon: Bug,\n    badgeBg: \"bg-warning-soft\",\n    badgeText: \"text-warning\",\n  },\n  IDEA: {\n    icon: Lightbulb,\n    badgeBg: \"bg-surface-2\",\n    badgeText: \"text-secondary\",\n  },\n  QUESTION: {\n    icon: HelpCircle,\n    badgeBg: \"bg-surface-2\",\n    badgeText: \"text-secondary\",\n  },\n  OTHER: {\n    icon: MoreHorizontal,\n    badgeBg: \"bg-surface-2\",\n    badgeText: \"text-secondary\",\n  },\n};\n\n/** Triage order, CRASH first — also a category column's sort key and the option\n *  order in its filter. Sorting by the raw enum is alphabetical, which parks\n *  CRASH between BUG and IDEA. */\nexport const FEEDBACK_CATEGORY_ORDER = Object.keys(FEEDBACK_CATEGORY_META) as FeedbackCategory[];\n\n/** A category's rank for a column sort. Anything this build has never heard of —\n *  an older client against a newer API — sorts LAST rather than to `indexOf`'s\n *  −1, which would rank it above CRASH. */\nexport function feedbackCategoryRank(category: FeedbackCategory): number {\n  const at = FEEDBACK_CATEGORY_ORDER.indexOf(category);\n  return at === -1 ? FEEDBACK_CATEGORY_ORDER.length : at;\n}\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../../src/feedback/feedback-vocabulary.ts"],"sourcesContent":["import {\n  Ban,\n  Bug,\n  CheckCircle2,\n  ClipboardCheck,\n  CloudUpload,\n  Eye,\n  HelpCircle,\n  Inbox,\n  Lightbulb,\n  MoreHorizontal,\n  OctagonAlert,\n  PauseCircle,\n  RotateCcw,\n  Wrench,\n} from \"lucide-react\";\nimport type { LucideIcon } from \"lucide-react\";\n\n/**\n * The feedback **vocabulary**: the nine statuses and five categories, the glyph and tone\n * of each, their orders, and the policy for how a report moves from status to status.\n *\n * Data and plain functions, no components. Until 0.34 this lived at the top of\n * feedback-inbox.tsx, so the feedback menu every app mounts in its top bar imported the\n * inbox — its components and the attachment field they render — for one constant (a\n * category's glyph), and only tree-shaking kept the rest out of every app's entry chunk.\n * From here the top bar's imports reach none of it (MOD-1, refactor audit 2026-10).\n * feedback-inbox.tsx re-exports every name here, so nothing an app imports has moved.\n */\n\n/** The nine states a report can be in.\n *\n *  Shared value for value across the apps on purpose: it is what lets one habit,\n *  and one agent prompt, work on any repo. Five are a chain and three sit off\n *  it — see {@link visibleFeedbackStatuses} for what that buys. `READY` joined in 0.31\n *  (feedback contract §8.2): OPEN is \"filed, not yet triaged\", READY \"released for\n *  implementation\", and nobody works an OPEN row. `REWORK` joined in 0.40 (§10.2\n *  decisions 2, 4): \"sent back, released for work again\" — a READY that came back. */\nexport type FeedbackStatus =\n  | \"OPEN\"\n  | \"READY\"\n  | \"REWORK\"\n  | \"IN_PROGRESS\"\n  | \"IN_EVALUATION\"\n  | \"NEEDS_LIVE_TEST\"\n  | \"POSTPONED\"\n  | \"DONE\"\n  | \"WONT_DO\";\n\n/** What a report is about. `CRASH` is filed by an error boundary and never\n *  chosen, which is exactly why it is loud below and absent from every picker. */\nexport type FeedbackCategory = \"CRASH\" | \"BUG\" | \"IDEA\" | \"QUESTION\" | \"OTHER\";\n\n/**\n * A glyph and a tone per status.\n *\n * Colour alone is not a label — two of these sit a hue apart, and a consumer who\n * moves `--brand` can park it beside any of the others — so every status carries\n * its own shape as well. Declaration order is chain order, and\n * {@link FEEDBACK_STATUS_ORDER} is derived from it rather than restated, because\n * a restated list cannot be checked for exhaustiveness: an eighth status would\n * break the build here and leave a literal eight long (as READY did in 0.31).\n */\nexport const FEEDBACK_STATUS_META: Record<\n  FeedbackStatus,\n  { icon: LucideIcon; activeBg: string; activeText: string }\n> = {\n  OPEN: {\n    icon: Inbox,\n    activeBg: \"bg-active\",\n    activeText: \"text-primary\",\n  },\n  // Triaged and released for implementation (feedback contract §8.2, keksdose live\n  // #396): OPEN is \"filed, nobody has looked yet\", READY is \"go\". The brand tint at full\n  // strength, so it reads as the go-ahead beside OPEN's neutral fill and\n  // NEEDS_LIVE_TEST's muted brand.\n  READY: {\n    icon: ClipboardCheck,\n    activeBg: \"bg-brand-soft\",\n    activeText: \"text-brand\",\n  },\n  // Sent back by its author or an admin and released for work again (0.40, feedback\n  // contract §10.2 decision 4): the Rework button's `RotateCcw`, in the danger tint so the\n  // queue shows reworks apart from new reports. Not IN_PROGRESS's warning tint — that is\n  // where a REWORK row moves next — and WONT_DO, the only other red, sits at the far end\n  // with `Ban`.\n  REWORK: {\n    icon: RotateCcw,\n    activeBg: \"bg-danger-soft\",\n    activeText: \"text-danger\",\n  },\n  IN_PROGRESS: {\n    icon: Wrench,\n    activeBg: \"bg-warning-soft\",\n    activeText: \"text-warning\",\n  },\n  // Where solved work is parked, waiting on the person who reported it. Its own\n  // colour, because \"somebody has to check this\" is a state you want to find by\n  // scanning rather than by reading.\n  IN_EVALUATION: {\n    icon: Eye,\n    activeBg: \"bg-info-soft\",\n    activeText: \"text-info\",\n  },\n  // Resolved but only checkable on a deployed build — the SOFT brand tint, so it\n  // reads as \"waiting on something\" rather than as a done or a refusal, and it\n  // follows whatever the consumer's brand is instead of pinning an indigo island\n  // beside it.\n  NEEDS_LIVE_TEST: {\n    icon: CloudUpload,\n    activeBg: \"bg-brand-soft\",\n    activeText: \"text-brand-muted\",\n  },\n  // Parked on purpose. Muted, not `--danger`: it is not a refusal.\n  POSTPONED: {\n    icon: PauseCircle,\n    activeBg: \"bg-active\",\n    activeText: \"text-secondary\",\n  },\n  // The one status with nowhere to move to: the vocabulary has a brand, an info, a\n  // warning and a danger, and nothing that means \"succeeded\". Deliberately NOT\n  // borrowed from a family that means something else — `--status-synced` is a\n  // FIELD's trip to the database rather than an outcome, and tokens.css says so in\n  // as many words. Green beside WONT_DO's red is the classic CVD-unsafe pair, which\n  // is why both carry a glyph and neither leans on colour alone.\n  DONE: {\n    icon: CheckCircle2,\n    activeBg: \"bg-success-soft\",\n    activeText: \"text-success\",\n  },\n  WONT_DO: {\n    icon: Ban,\n    activeBg: \"bg-danger-soft\",\n    activeText: \"text-danger\",\n  },\n};\n\n/** Chain order, then the three off it. The order a picker offers, and the rank a\n *  status column sorts by — so a list sorted by status reads as a queue rather\n *  than as an alphabet. */\nexport const FEEDBACK_STATUS_ORDER = Object.keys(FEEDBACK_STATUS_META) as FeedbackStatus[];\n\n/** States that sit OFF the linear chain: reachable from anywhere, leading\n *  nowhere by themselves. `WONT_DO` has always worked this way; `POSTPONED`\n *  (\"not now\") and `NEEDS_LIVE_TEST` (\"resolved, but only provable on a deployed\n *  build\") are the same shape — a row can be parked or handed to the next deploy\n *  from any point, and comes back to the chain when somebody picks a real state\n *  for it.\n *\n *  Kept out of the forward chain deliberately: putting them in it would mean an\n *  \"advance\" gesture could park an item, and every row would have to pass\n *  through them to reach `DONE`. */\nconst OFF_CHAIN: FeedbackStatus[] = [\"NEEDS_LIVE_TEST\", \"POSTPONED\", \"WONT_DO\"];\n\nconst FORWARD_CHAIN: FeedbackStatus[] = [\"OPEN\", \"READY\", \"IN_PROGRESS\", \"IN_EVALUATION\", \"DONE\"];\n\n/** The next status along the chain, or null at the end (or off it, as `WONT_DO`\n *  is). What a swipe-to-advance gesture commits. `REWORK` (0.40) is not in the chain —\n *  \"advance\" from READY still goes to IN_PROGRESS — but it leads there too: a reworked\n *  row is READY's twin. */\nexport function nextFeedbackStatus(current: FeedbackStatus): FeedbackStatus | null {\n  if (current === \"REWORK\") return \"IN_PROGRESS\";\n  const at = FORWARD_CHAIN.indexOf(current);\n  return at !== -1 && at < FORWARD_CHAIN.length - 1 ? FORWARD_CHAIN[at + 1] : null;\n}\n\n/**\n * The steps that make sense from where a row currently stands.\n *\n * For the compact control in a table cell: it is a glanceable triage affordance,\n * and a row of nine icons in a cell is noise. One step forward, one step back\n * (so an item can be sent back for rework), and any of the three off-chain\n * verdicts — which is what makes those usable as verdicts at all.\n *\n * The two parking states are not dead ends: each offers the step that resumes\n * work and the ones that close it, but deliberately **not each other** —\n * \"postponed\" and \"waiting on a deploy\" are different answers to different\n * questions, and a row moving between them directly is a re-triage, which starts\n * by picking the work back up.\n */\nexport function visibleFeedbackStatuses(current: FeedbackStatus): FeedbackStatus[] {\n  const set = new Set<FeedbackStatus>([current]);\n  const at = FORWARD_CHAIN.indexOf(current);\n  if (current === \"REWORK\") {\n    // READY's twin (0.40, §10.2 decision 4): the step that picks the work up, and the\n    // verdicts a released row can still get.\n    set.add(\"IN_PROGRESS\");\n    for (const off of OFF_CHAIN) set.add(off);\n  } else if (at !== -1) {\n    if (at < FORWARD_CHAIN.length - 1) set.add(FORWARD_CHAIN[at + 1]);\n    if (at > 0) set.add(FORWARD_CHAIN[at - 1]);\n    for (const off of OFF_CHAIN) set.add(off);\n  } else if (current !== \"WONT_DO\") {\n    set.add(\"IN_PROGRESS\");\n    set.add(\"DONE\");\n    set.add(\"WONT_DO\");\n  }\n  // WONT_DO falls through with nothing added: it stays terminal, reopened by a\n  // note from its author rather than by a status pill.\n  return FEEDBACK_STATUS_ORDER.filter((status) => set.has(status));\n}\n\n/**\n * Every status, in chain order — what an EXPANDED row offers.\n *\n * {@link visibleFeedbackStatuses} narrows the choice to the steps that make\n * sense from where a row is, which is right for a table cell. Once the row is\n * open in front of you, that same narrowing turns every non-adjacent move into a\n * walk: OPEN to DONE meant three round trips, and WONT_DO could not be left at\n * all except through a rework note.\n *\n * Takes a `current` it does not use, so the two policies read as one pair at the\n * call sites and a future rule (\"terminal rows still cannot jump to X\") has a\n * place to live.\n */\nexport function selectableFeedbackStatuses(_current: FeedbackStatus): FeedbackStatus[] {\n  return [...FEEDBACK_STATUS_ORDER];\n}\n\n/**\n * Per-category badge treatment, the counterpart to the status meta above.\n *\n * A category cell that is one grey pill holding the raw enum makes a CRASH —\n * filed automatically, by somebody staring at a broken page right now — read\n * exactly like a QUESTION, and sit unnoticed in the queue. `--danger` plus its own\n * glyph is what makes that impossible; the hand-filed categories stay\n * deliberately quiet so that the loud one means something.\n *\n * Declaration order is triage order, CRASH first.\n */\nexport const FEEDBACK_CATEGORY_META: Record<\n  FeedbackCategory,\n  { icon: LucideIcon; badgeBg: string; badgeText: string }\n> = {\n  CRASH: {\n    icon: OctagonAlert,\n    badgeBg: \"bg-danger-soft\",\n    badgeText: \"text-danger\",\n  },\n  BUG: {\n    icon: Bug,\n    badgeBg: \"bg-warning-soft\",\n    badgeText: \"text-warning\",\n  },\n  IDEA: {\n    icon: Lightbulb,\n    badgeBg: \"bg-surface-2\",\n    badgeText: \"text-secondary\",\n  },\n  QUESTION: {\n    icon: HelpCircle,\n    badgeBg: \"bg-surface-2\",\n    badgeText: \"text-secondary\",\n  },\n  OTHER: {\n    icon: MoreHorizontal,\n    badgeBg: \"bg-surface-2\",\n    badgeText: \"text-secondary\",\n  },\n};\n\n/** Triage order, CRASH first — also a category column's sort key and the option\n *  order in its filter. Sorting by the raw enum is alphabetical, which parks\n *  CRASH between BUG and IDEA. */\nexport const FEEDBACK_CATEGORY_ORDER = Object.keys(FEEDBACK_CATEGORY_META) as FeedbackCategory[];\n\n/** A category's rank for a column sort. Anything this build has never heard of —\n *  an older client against a newer API — sorts LAST rather than to `indexOf`'s\n *  −1, which would rank it above CRASH. */\nexport function feedbackCategoryRank(category: FeedbackCategory): number {\n  const at = FEEDBACK_CATEGORY_ORDER.indexOf(category);\n  return at === -1 ? FEEDBACK_CATEGORY_ORDER.length : at;\n}\n"],"mappings":"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","names":[]}

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

@@ -0,0 +1,30 @@
+import { type PointerEvent as ReactPointerEvent } from "react";
+export interface LongPressResult {
+    handlers: {
+        onPointerDown: (e: ReactPointerEvent) => void;
+        onPointerMove: (e: ReactPointerEvent) => void;
+        onContextMenu: (e: {
+            preventDefault: () => void;
+        }) => void;
+    };
+    /** True exactly once after a long press fired: call it from an `onClickCapture` to
+     *  swallow the click the browser still sends when the finger lifts. */
+    consumeClick: () => boolean;
+}
+/**
+ * A press-and-hold on a touch row that may ALSO be swipeable.
+ *
+ *  - The cancel listeners live on `window`: `useRowSwipe` captures the pointer on an
+ *    ancestor once a drag resolves to the x axis, after which the pressed element's
+ *    own pointer handlers stop firing, and a timer cancelled only there would fire
+ *    mid-swipe.
+ *  - A scroll cancels too (`touch-action: pan-y` hands vertical panning to the
+ *    browser, which sends `pointercancel`; the capture-phase `scroll` is the backstop).
+ *  - `contextmenu` is suppressed while enabled — Android fires it at ~500 ms. Pair it
+ *    with `select-none [-webkit-touch-callout:none]` on the element: iOS's callout
+ *    only yields to that CSS.
+ */
+export declare function useLongPress(onLongPress: () => void, { enabled, delay }?: {
+    enabled?: boolean;
+    delay?: number;
+}): LongPressResult;

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

@@ -0,0 +1,77 @@
+"use client";
+import { useCallback, useEffect, useRef } from "react";
+const LONG_PRESS_MS = 500;
+const SLOP_PX = 8;
+const movedBeyondSlop = (from, x, y) => Math.hypot(x - from.x, y - from.y) > SLOP_PX;
+function useLongPress(onLongPress, { enabled = true, delay = LONG_PRESS_MS } = {}) {
+  const timer = useRef(null);
+  const start = useRef({ x: 0, y: 0 });
+  const fired = useRef(false);
+  const teardown = useRef(null);
+  const cbRef = useRef(onLongPress);
+  useEffect(() => {
+    cbRef.current = onLongPress;
+  });
+  const cancel = useCallback(() => {
+    if (timer.current !== null) {
+      window.clearTimeout(timer.current);
+      timer.current = null;
+    }
+    teardown.current?.();
+    teardown.current = null;
+  }, []);
+  const onPointerDown = useCallback(
+    (e) => {
+      fired.current = false;
+      if (!enabled) return;
+      if (e.pointerType === "mouse" && e.button !== 0) return;
+      cancel();
+      start.current = { x: e.clientX, y: e.clientY };
+      const onEnd = () => cancel();
+      const onMove = (ev) => {
+        if (movedBeyondSlop(start.current, ev.clientX, ev.clientY)) cancel();
+      };
+      window.addEventListener("pointerup", onEnd);
+      window.addEventListener("pointercancel", onEnd);
+      window.addEventListener("pointermove", onMove);
+      window.addEventListener("scroll", onEnd, { capture: true, passive: true });
+      teardown.current = () => {
+        window.removeEventListener("pointerup", onEnd);
+        window.removeEventListener("pointercancel", onEnd);
+        window.removeEventListener("pointermove", onMove);
+        window.removeEventListener("scroll", onEnd, { capture: true });
+      };
+      timer.current = window.setTimeout(() => {
+        cancel();
+        fired.current = true;
+        navigator.vibrate?.(20);
+        cbRef.current();
+      }, delay);
+    },
+    [cancel, delay, enabled]
+  );
+  const onPointerMove = useCallback(
+    (e) => {
+      if (timer.current === null) return;
+      if (movedBeyondSlop(start.current, e.clientX, e.clientY)) cancel();
+    },
+    [cancel]
+  );
+  const onContextMenu = useCallback(
+    (e) => {
+      if (enabled) e.preventDefault();
+    },
+    [enabled]
+  );
+  const consumeClick = useCallback(() => {
+    if (!fired.current) return false;
+    fired.current = false;
+    return true;
+  }, []);
+  useEffect(() => cancel, [cancel]);
+  return { handlers: { onPointerDown, onPointerMove, onContextMenu }, consumeClick };
+}
+export {
+  useLongPress
+};
+//# sourceMappingURL=use-long-press.js.map

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

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

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

@@ -18,9 +18,23 @@ function runUnwind() {
     if (taggedSentinel() === null) buryUnder(job.entries);
     return;
   }
+  const bottom = job.entries[0];
+  carry = { href: job.href, idx: bottom.idx, key: bottom.key };
   pendingProgrammatic += 1;
   window.history.go(-job.entries.length);
 }
+let carry = null;
+function carryOnto(href, mark) {
+  const here = currentHref();
+  if (here === href || routeOf(here) !== routeOf(href)) return;
+  const now = routerMark();
+  if (mark.idx !== void 0 && now.idx !== void 0 && mark.idx !== now.idx) return;
+  if (mark.key !== void 0 && now.key !== void 0 && mark.key !== now.key) return;
+  const state = window.history.state;
+  window.history.replaceState(state, "", href);
+  pendingProgrammatic += 1;
+  window.dispatchEvent(new PopStateEvent("popstate", { state }));
+}
 function currentHref() {
   return typeof window === "undefined" ? "" : window.location.href;
 }
@@ -126,7 +140,20 @@ function noteAddress() {
   const top = pushed[pushed.length - 1];
   if (!top || top.dead || !stack.some((e) => e.id === top.id)) return;
   const tag = taggedSentinel();
-  if (tag === top.id || tag === null && standing === top.id && isStillOn(top)) top.href = currentHref();
+  if (tag === top.id || tag === null && standing === top.id && isStillOn(top)) {
+    top.href = currentHref();
+    top.seen = top.href;
+  }
+}
+function noteSeen() {
+  const top = pushed[pushed.length - 1];
+  if (!top || top.dead || !stack.some((e) => e.id === top.id)) return;
+  const tag = taggedSentinel();
+  if (tag === top.id || tag === null && standing === top.id && isStillOn(top)) top.seen = currentHref();
+}
+function noteSeenNowAndLater() {
+  noteSeen();
+  setTimeout(noteSeen, 0);
 }
 function handlePop() {
   standing = taggedSentinel();
@@ -134,6 +161,9 @@ function handlePop() {
   lastSeen = routerMark();
   if (pendingProgrammatic > 0) {
     pendingProgrammatic -= 1;
+    const job = carry;
+    carry = null;
+    if (job) carryOnto(job.href, job);
     return;
   }
   closeOnPop();
@@ -145,7 +175,9 @@ function closeOnPop() {
   if (currentSentinel() === top.id) return;
   stack.pop();
   consumed.add(top.id);
+  const record = pushed.find((p) => p.id === top.id);
   forgetPushed(top.id);
+  if (record && !record.dead) carryOnto(record.seen, record);
   top.close();
 }
 function ensureListening() {
@@ -153,6 +185,7 @@ function ensureListening() {
   window.addEventListener("popstate", handlePop);
   window.addEventListener("pointerdown", noteAddress, true);
   window.addEventListener("keydown", noteAddress, true);
+  for (const type of ["click", "keyup", "change", "input"]) window.addEventListener(type, noteSeenNowAndLater);
   listening = true;
 }
 function useOverlayHistory(open, onClose) {
@@ -176,14 +209,15 @@ function useOverlayHistory(open, onClose) {
       window.history.replaceState(marked, "");
       for (const owed of inherited.slice(0, -1)) pushed.push({ ...owed, dead: true });
       const was = inherited[inherited.length - 1];
-      pushed.push({ id, href: currentHref(), dead: false, idx: was.idx, key: was.key, route: was.route });
+      pushed.push({ id, href: currentHref(), seen: currentHref(), dead: false, idx: was.idx, key: was.key, route: was.route });
       standing = id;
     } else {
       const under = pushed.findIndex((p) => p.id === currentSentinel());
       pushed.splice(under + 1);
       window.history.pushState(marked, "");
       const page = routerMark();
-      pushed.push({ id, href: currentHref(), dead: false, idx: page.idx, key: page.key, route: routeOf(currentHref()) });
+      const at = currentHref();
+      pushed.push({ id, href: at, seen: at, dead: false, idx: page.idx, key: page.key, route: routeOf(at) });
       standing = id;
     }
     return () => {

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 * ## 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}\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}\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;\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  pendingProgrammatic += 1;\n  window.history.go(-job.entries.length);\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(\n    { ...(prev && typeof prev === \"object\" ? prev : {}), [SENTINEL_KEY]: id },\n    \"\",\n  );\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))) top.href = currentHref();\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    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  stack.pop();\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  forgetPushed(top.id);\n  top.close();\n}\n\nfunction ensureListening() {\n  if (listening || typeof window === \"undefined\") return;\n  window.addEventListener(\"popstate\", handlePop);\n  window.addEventListener(\"pointerdown\", noteAddress, true);\n  window.addEventListener(\"keydown\", noteAddress, true);\n  listening = true;\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 */\nexport function useOverlayHistory(open: boolean, onClose: () => void): 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  useEffect(() => {\n    closeRef.current = onClose;\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() };\n    stack.push(entry);\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({ id, href: currentHref(), dead: false, idx: was.idx, key: was.key, route: was.route });\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      pushed.push({ id, href: currentHref(), dead: false, idx: page.idx, key: page.key, route: routeOf(currentHref()) });\n      standing = id;\n    }\n    return () => {\n      const at = stack.indexOf(entry);\n      if (at >= 0) stack.splice(at, 1);\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;AA0DlC,MAAM,eAAe;AAOrB,MAAM,QAAwB,CAAC;AAqC/B,MAAM,SAAwB,CAAC;AA6B/B,MAAM,SAAS,oBAAI,IAAyB;AAI5C,IAAI,WAAwE;AAK5E,MAAM,WAAW,oBAAI,IAAY;AAKjC,IAAI,sBAAsB;AAC1B,IAAI,YAAY;AAChB,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,yBAAuB;AACvB,SAAO,QAAQ,GAAG,CAAC,IAAI,QAAQ,MAAM;AACvC;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,IACb,EAAE,GAAI,QAAQ,OAAO,SAAS,WAAW,OAAO,CAAC,GAAI,CAAC,YAAY,GAAG,GAAG;AAAA,IACxE;AAAA,EACF;AACF;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,EAAI,KAAI,OAAO,YAAY;AACxG;AAEA,SAAS,YAAY;AAInB,aAAW,eAAe;AAC1B,QAAM,OAAO;AACb,aAAW,WAAW;AACtB,MAAI,sBAAsB,GAAG;AAC3B,2BAAuB;AACvB;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;AAClC,QAAM,IAAI;AAGV,WAAS,IAAI,IAAI,EAAE;AACnB,eAAa,IAAI,EAAE;AACnB,MAAI,MAAM;AACZ;AAEA,SAAS,kBAAkB;AACzB,MAAI,aAAa,OAAO,WAAW,YAAa;AAChD,SAAO,iBAAiB,YAAY,SAAS;AAC7C,SAAO,iBAAiB,eAAe,aAAa,IAAI;AACxD,SAAO,iBAAiB,WAAW,aAAa,IAAI;AACpD,cAAY;AACd;AASO,SAAS,kBAAkB,MAAe,SAA2B;AAG1E,QAAM,WAAW,OAAO,OAAO;AAC/B,YAAU,MAAM;AACd,aAAS,UAAU;AAAA,EACrB,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,EAAE;AAClE,UAAM,KAAK,KAAK;AAChB,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,EAAE,IAAI,MAAM,YAAY,GAAG,MAAM,OAAO,KAAK,IAAI,KAAK,KAAK,IAAI,KAAK,OAAO,IAAI,MAAM,CAAC;AAClG,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,aAAO,KAAK,EAAE,IAAI,MAAM,YAAY,GAAG,MAAM,OAAO,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,OAAO,QAAQ,YAAY,CAAC,EAAE,CAAC;AACjH,iBAAW;AAAA,IACb;AACA,WAAO,MAAM;AACX,YAAM,KAAK,MAAM,QAAQ,KAAK;AAC9B,UAAI,MAAM,EAAG,OAAM,OAAO,IAAI,CAAC;AAG/B,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}\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;\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(\n    { ...(prev && typeof prev === \"object\" ? prev : {}), [SENTINEL_KEY]: id },\n    \"\",\n  );\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  stack.pop();\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\nfunction ensureListening() {\n  if (listening || typeof window === \"undefined\") return;\n  window.addEventListener(\"popstate\", handlePop);\n  window.addEventListener(\"pointerdown\", noteAddress, true);\n  window.addEventListener(\"keydown\", noteAddress, true);\n  for (const type of [\"click\", \"keyup\", \"change\", \"input\"]) window.addEventListener(type, noteSeenNowAndLater);\n  listening = true;\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 */\nexport function useOverlayHistory(open: boolean, onClose: () => void): 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  useEffect(() => {\n    closeRef.current = onClose;\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() };\n    stack.push(entry);\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({ id, href: currentHref(), seen: currentHref(), dead: false, idx: was.idx, key: was.key, route: was.route });\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\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/german.js

@@ -56,6 +56,7 @@ function germanLabels(numberLocale) {
     feedbackStatus: {
       OPEN: "Offen",
       READY: "Bereit zur Umsetzung",
+      REWORK: "Nacharbeit angefordert",
       IN_PROGRESS: "In Bearbeitung",
       IN_EVALUATION: "Zur Pr\xFCfung",
       NEEDS_LIVE_TEST: "Live testen",
@@ -89,12 +90,14 @@ function germanLabels(numberLocale) {
       trigger: "Feedback senden",
       myFeedback: "Mein Feedback",
       viewFeedback: "Feedback ansehen",
-      allFeedback: "Alle R\xFCckmeldungen"
+      allFeedback: "Alle R\xFCckmeldungen",
+      discussion: "Feedback-Diskussion",
+      inbox: "Feedback-Eingang"
     },
     // 0.38.0 — docs/feedback-harmonization.md §9: the public pages and the two feedback
     // notification types. "Rückmeldungen" and "Eine Person" are the contract's (§9.2, §9.5).
     feedbackPublic: {
-      title: "Alle R\xFCckmeldungen",
+      title: "Feedback-Diskussion",
       sort: "Sortieren",
       sortNewest: "Neueste",
       sortVotes: "Meistgew\xFCnscht",
@@ -126,7 +129,7 @@ function germanLabels(numberLocale) {
       attachUrl: "Aktuelle Seiten-URL anh\xE4ngen"
     },
     feedbackPage: {
-      title: "Feedback",
+      title: "Feedback-Eingang",
       myTitle: "Mein Feedback",
       columnId: "#",
       columnDate: "Datum",
@@ -310,6 +313,8 @@ function germanLabels(numberLocale) {
       filter: "Filter",
       close: "Schlie\xDFen",
       selectRow: "Zeile ausw\xE4hlen",
+      selectRows: "Zeilen ausw\xE4hlen",
+      cancelSelection: "Abbrechen",
       rowDetails: "Details",
       autoSize: "Spaltenbreiten anpassen",
       loading: "Wird geladen\u2026",
@@ -496,7 +501,9 @@ function germanLabels(numberLocale) {
     tabs: {
       // "Tab" is what German UIs say; "Registerkarte" reads like a 1990s manual.
       add: "Tab hinzuf\xFCgen",
-      remove: (tab) => `${tab} entfernen`
+      remove: (tab) => `${tab} entfernen`,
+      more: "Weitere Tabs",
+      backToFirst: "Zur\xFCck zum ersten Tab"
     },
     appShell: {
       collapse: "Seitenleiste einklappen",
@@ -511,7 +518,8 @@ function germanLabels(numberLocale) {
       role: (value) => `Rolle: ${value}`
     },
     pickerSheet: {
-      close: "Schlie\xDFen"
+      close: "Schlie\xDFen",
+      done: "Fertig"
     },
     dialogFrame: {
       close: "Schlie\xDFen"