@eifi1/ui-kit 0.51.5 → 0.51.7

package/src/components/tabs.tsx

@@ -2,7 +2,7 @@ import { useLayoutEffect, useMemo, useRef } from "react";
 import { ChevronLeft, ChevronRight, Plus, X } from "lucide-react";
 import type { ComponentPropsWithoutRef, KeyboardEvent, ReactNode, Ref } from "react";
 import { cn } from "../lib/cn";
-import { FOCUS_RING_WIDTH } from "./focus-ring";
+import { FOCUS_RING } from "./focus-ring";
 import { scrollIntoStrip, useStripFade } from "../lib/strip-fade";
 import { horizontalStep } from "../lib/direction";
 import { usePhoneLayout } from "../hooks/use-breakpoint";
@@ -205,9 +205,7 @@ const TABLIST_CLASSES = "flex gap-1 overflow-x-auto overflow-y-hidden border-b b
 // selection. `--bg-active` is the kit's own selected-row fill (the sidebar's), so the
 // admin page's nav and the app's own sidebar mark "you are here" the same way.
 const TABLIST_VERTICAL_CLASSES = "flex flex-col gap-0.5";
-const TAB_VERTICAL_CLASSES =
-  FOCUS_RING_WIDTH +
-  " flex w-full items-center rounded-md px-3 py-2 text-start text-sm font-medium transition-colors focus:outline-none focus-visible:ring-strong";
+const TAB_VERTICAL_CLASSES = `flex w-full items-center rounded-md px-3 py-2 text-start text-sm font-medium transition-colors focus:outline-none ${FOCUS_RING}`;
 const TAB_VERTICAL_ACTIVE_CLASSES = "bg-active text-primary";
 const TAB_VERTICAL_INACTIVE_CLASSES = "text-muted hover:bg-hover hover:text-primary";
 
@@ -215,9 +213,14 @@ const TAB_VERTICAL_INACTIVE_CLASSES = "text-muted hover:bg-hover hover:text-prim
 // links · … · 31 Punkte") made one tab 448px wide in a 390px strip, and a tab wider
 // than the strip cannot be scrolled into view — its end was simply off screen
 // (lenkbank L3). The label and detail truncate inside it instead; see `inner`.
-const TAB_CLASSES =
-  FOCUS_RING_WIDTH +
-  " max-w-full whitespace-nowrap px-3 py-2 text-sm font-medium transition-colors border-b-2 -mb-px focus:outline-none focus-visible:ring-strong";
+//
+// Keyboard focus on a tab, a side-nav row and the add button is the kit's one focus frame
+// (text-size §5), in brand. Until 0.51.7 it rang in `ring-strong`: 2.54:1 on the light
+// page and 2.76:1 on a card, under WCAG 1.4.11's 3:1 (refactor audit 2026-10-30, DSP-8;
+// NavPills made the same move in 0.34, DOC-7). INSET on a tab: the strip scrolls
+// (`overflow-x-auto overflow-y-hidden`), so a ring outside the tab is cut off along its
+// top and bottom, and at a cut end.
+const TAB_CLASSES = `max-w-full whitespace-nowrap px-3 py-2 text-sm font-medium transition-colors border-b-2 -mb-px focus:outline-none ${FOCUS_RING} focus-visible:ring-inset`;
 const TAB_ACTIVE_CLASSES = "border-[var(--text-primary)] text-primary";
 const TAB_INACTIVE_CLASSES = "border-transparent text-muted hover:text-secondary hover:border-strong";
 
@@ -225,9 +228,7 @@ const TAB_INACTIVE_CLASSES = "border-transparent text-muted hover:text-secondary
 // `onRemove`).
 const TAB_REMOVABLE_CLASSES = "pe-8";
 const TAB_EMPTY_CLASSES = "-mx-1.5 rounded border border-dashed border-strong px-1.5";
-const TAB_ADD_CLASSES =
-  FOCUS_RING_WIDTH +
-  " inline-flex items-center gap-1 whitespace-nowrap rounded-md px-3 py-2 text-sm font-medium text-muted transition-colors hover:text-primary focus:outline-none focus-visible:ring-strong disabled:cursor-not-allowed disabled:opacity-50 [&_svg]:size-4";
+const TAB_ADD_CLASSES = `inline-flex items-center gap-1 whitespace-nowrap rounded-md px-3 py-2 text-sm font-medium text-muted transition-colors hover:text-primary focus:outline-none ${FOCUS_RING} disabled:cursor-not-allowed disabled:opacity-50 [&_svg]:size-4`;
 // `relative`: the phone's visually hidden label needs a positioned ancestor (see the
 // sr-only rule in CONTRIBUTING); `max-md:px-2` squares the lone "+".
 const TAB_ADD_PHONE_CLASSES = "relative max-md:px-2";
@@ -262,6 +263,8 @@ export function Tabs<T extends string>({
   const cue = overflowCue && !vertical;
   const cueStart = cue && (fade.overflow === "start" || fade.overflow === "both");
   const cueEnd = cue && (fade.overflow === "end" || fade.overflow === "both");
+  // The cue gutters (see `stripBox`): there only while the strip overflows at all.
+  const gutters = cue && fade.overflow !== undefined;
   // Three quarters of the visible width toward `side`; an RTL strip runs leftward.
   const onCue = (side: "start" | "end") => {
     const strip = stripRef.current;
@@ -333,15 +336,25 @@ export function Tabs<T extends string>({
   // "80 km," under the add button. Only the strip scrolls (`scrollBy` on it, not
   // `scrollIntoView`, which would scroll the page as well), and only as far as needed
   // to clear the fade.
+  //
+  // And again when the cue gutters appear (refactor audit 2026-10-30, DSP-16). They come a
+  // render after the strip is first measured as overflowing — on mount, or with the very
+  // tab that tipped it over — and take 24px off each end, so a tab scrolled clear before
+  // them ended 24px past the visible end, under the fade and the ›.
   useLayoutEffect(() => {
     const strip = stripRef.current;
     const tab = strip?.querySelector<HTMLElement>('[role="tab"][aria-selected="true"]');
     if (strip && tab) scrollIntoStrip(strip, tab);
-  }, [active]);
+  }, [active, gutters]);
   const isRemovable = (tab: TabItem<T>) => onRemove !== undefined && tab.removable !== false;
   // Whether Delete reaches this tab: every removable tab, or only the open one.
   const deletesOnKey = (tab: TabItem<T>) => isRemovable(tab) && (removeOn === "every" || tab.id === active);
   const nameOf = (tab: TabItem<T>) => tab.name ?? (typeof tab.label === "string" ? tab.label : tab.id);
+  // The strip's one tab stop (see `tabIndex` below): the open tab, or the first while
+  // `active` names none. "No sheet open" is a real state — KS's sheet strips pass `""` —
+  // and with the stop on the selection alone every tab was -1, so the keyboard could not
+  // reach the one control that opens a sheet (refactor audit 2026-10-30, DSP-1).
+  const stop = tabs.some((t) => t.id === active) ? active : tabs[0]?.id;
 
   // Where focus goes once a removal the strip asked for has happened. The caller
   // owns `tabs` and may take its time (a confirmation, a request), so this waits
@@ -370,10 +383,14 @@ export function Tabs<T extends string>({
     if (focused && focused !== document.body && !strip.contains(focused) && focused !== removeRef.current) return;
     // The removed tab was open: focus follows the caller's new selection, which is
     // also the strip's tab stop. It was not: its neighbour, as the ARIA pattern has it.
-    const target = !pending.wasActive && tabs.some((t) => t.id === pending.neighbour) ? pending.neighbour : active;
+    // The caller opened nothing in its place (KS drops the sheet and the selection in one
+    // render): the neighbour too, else the stop — not an index of -1 and the page (DSP-1).
+    const present = (id: T | undefined) => tabs.some((t) => t.id === id);
+    const target =
+      pending.wasActive && present(active) ? active : present(pending.neighbour) ? pending.neighbour : stop;
     const index = tabs.findIndex((t) => t.id === target);
     strip.querySelectorAll<HTMLElement>('[role="tab"]')[index]?.focus();
-  }, [tabs, active]);
+  }, [tabs, active, stop]);
 
   // Arrow keys walk the strip in DOM order (ARIA tabs pattern). Home/End jump
   // to the ends. Focus only — activation stays on click/Enter/Space, because a tab
@@ -462,8 +479,8 @@ export function Tabs<T extends string>({
           // strip back on the next visit in a state they never chose. The cost is that
           // Tab out and back returns to the open tab rather than to the last one
           // looked at; the ARIA pattern allows either, and this one needs no second
-          // piece of state shadowing `active`.
-          tabIndex: isActive ? 0 : -1,
+          // piece of state shadowing `active`. With nothing open, the first tab (`stop`).
+          tabIndex: tab.id === stop ? 0 : -1,
           // Only the open tab: see `panelId`.
           "aria-controls": isActive ? panelId : undefined,
           id: isActive && panelId ? `${panelId}-tab` : undefined,
@@ -612,8 +629,7 @@ export function Tabs<T extends string>({
     ) : null;
   // The box the cues sit in, ‹ in the gutter before the strip and › in the one after it
   // (see `gutterAt`). There whether or not the strip overflows right now, so a resize
-  // never re-parents it; the gutters only while it overflows at all.
-  const gutters = cue && fade.overflow !== undefined;
+  // never re-parents it; the gutters only while it overflows at all (`gutters`).
   const stripBox = cue ? (
     <div className={cn("relative flex min-w-0", !onAdd && "flex-1", gutters && "px-[24px]")}>
       {tablist}

package/src/components/treemap.tsx

@@ -111,6 +111,44 @@ export interface TreemapProps extends Omit<ComponentPropsWithoutRef<"div">, "chi
    * so a caller colouring a legend beside the map is guaranteed the same list.
    */
   colors?: readonly string[];
+  /**
+   * How tiles are parted (0.51.6, keksdose dev #642, Marcel: "The borders do not look
+   * nice when changing from tile to tile. Can this be uniform black?" — and then, on the
+   * contrast rule that would go with it: follow the contrast setting).
+   *
+   * - `"auto"` (default): `"uniform"` at Standard contrast, `"contrast"` while More
+   *   contrast is in force (`<html data-contrast="more">`: the reader chose it, or chose
+   *   System on a device that asks for more). Followed live.
+   * - `"uniform"`: one 2px gutter in the page's ground colour (`--bg-page`, near-black
+   *   in the dark theme) round every tile, and nothing else. Tiles always abut, so the
+   *   gutter parts them; each tile is named by its label.
+   * - `"contrast"`: the 0.49 rule. The gutter is the card's colour (`--bg-surface`),
+   *   and a tile whose hue is under 3:1 against the card gets a 1px ink edge inside it
+   *   (WCAG 1.4.11, `useChartEdge`). In the dark theme that ink is light, so some tiles
+   *   carry a white outline and their neighbours none — the unevenness #642 saw, and
+   *   the price of the edge for a reader who asked for it.
+   */
+  edges?: TreemapEdges;
+}
+
+/** {@link TreemapProps.edges}. */
+export type TreemapEdges = "auto" | "uniform" | "contrast";
+
+// `<html data-contrast>`, followed live: what `edges="auto"` keys on. Read here rather
+// than through theme/contrast, whose store would come into the chart entry with it.
+function subscribeContrast(onChange: () => void): () => void {
+  if (typeof MutationObserver === "undefined" || typeof document === "undefined") return () => {};
+  const observer = new MutationObserver(onChange);
+  observer.observe(document.documentElement, { attributes: true, attributeFilter: ["data-contrast"] });
+  return () => observer.disconnect();
+}
+const readMoreContrast = () =>
+  typeof document !== "undefined" && document.documentElement.getAttribute("data-contrast") === "more";
+
+/** The edges a tile draws: `auto` resolved against the contrast in force. */
+function useTileEdges(edges: TreemapEdges): "uniform" | "contrast" {
+  const more = useSyncExternalStore(subscribeContrast, readMoreContrast, () => false);
+  return edges === "auto" ? (more ? "contrast" : "uniform") : edges;
 }
 
 // ── The categorical ramp, as concrete hex ──────────────────────────────────
@@ -218,6 +256,8 @@ export interface TreemapCellProps {
    *  the label stands in the tile's top RIGHT corner and is shaped right-to-left, so a
    *  clipped name ends in its ellipsis on the reading end. Default `ltr`. */
   dir?: Direction;
+  /** See {@link TreemapProps.edges}. Default `auto`. */
+  edges?: TreemapEdges;
 }
 
 /**
@@ -245,11 +285,13 @@ export function TreemapCell({
   redactNames,
   nodeNote,
   dir = "ltr",
+  edges: edgesProp = "auto",
 }: TreemapCellProps) {
   // Before the early return: a hook has to run on every render of the cell.
   const tokenHex = useChartTokenHex();
   const { scale } = useTextSize();
   const edgeFor = useChartEdge();
+  const edges = useTileEdges(edgesProp);
   // Depth 0 is recharts' synthetic root, which spans the whole chart.
   if (!depth) return null;
   // Whole pixels: a rect on a half pixel renders its edge across two half-lit
@@ -261,9 +303,10 @@ export function TreemapCell({
   const tileFill = fill ?? "var(--chart-1)";
   const measured = measurableFill(tileFill, tokenHex);
   const ink = labelColor ?? (measured ? textOn(measured) : "currentColor");
-  // A tile in a hue under 3:1 against the card gets a 1px ink edge inside the gutter
-  // (WCAG 1.4.11, anyplot's rule); a hue that clears it stays bare.
-  const edge = measured ? edgeFor(measured) : undefined;
+  // `contrast`: a tile in a hue under 3:1 against the card gets a 1px ink edge inside
+  // the gutter (WCAG 1.4.11, anyplot's rule); a hue that clears it stays bare.
+  // `uniform`: no per-tile edge; every tile is parted by the same gutter.
+  const edge = edges === "contrast" && measured ? edgeFor(measured) : undefined;
   // The halo only on an OPAQUE fill we could measure. A translucent fill (a
   // `color-mix(… transparent)`) composited twice — once as the tile, once as the halo
   // over it — draws a darker ring round every glyph, which read as doubled text on the
@@ -309,9 +352,19 @@ export function TreemapCell({
       // for as long as the tile has keyboard focus.
       className={activate ? "outline-none [&:focus-visible>rect]:stroke-[var(--brand)]" : undefined}
     >
-      {/* The 2px gutter is the card showing through, not a white grid — on a dark
-          surface white lines glare harder than the tiles. */}
-      <rect x={px} y={py} width={pw} height={ph} fill={tileFill} stroke="var(--bg-surface)" strokeWidth={2} rx={3} />
+      {/* The 2px gutter: the page's ground (`uniform`, the same dark line round every
+          tile in the dark theme) or the card showing through (`contrast`). Never a white
+          grid: on a dark surface white lines glare harder than the tiles. */}
+      <rect
+        x={px}
+        y={py}
+        width={pw}
+        height={ph}
+        fill={tileFill}
+        stroke={edges === "contrast" ? "var(--bg-surface)" : "var(--bg-page)"}
+        strokeWidth={2}
+        rx={3}
+      />
       {edge && pw > 3 && ph > 3 && (
         <rect
           data-edge=""
@@ -418,6 +471,7 @@ export function Treemap({
   nodeNote,
   maxTiles,
   colors,
+  edges = "auto",
   style,
   ...rest
 }: TreemapProps) {
@@ -471,7 +525,15 @@ export function Treemap({
         dataKey="size"
         fill="var(--chart-1)"
         isAnimationActive={false}
-        content={<TreemapCell onNodeClick={onNodeClick} redactNames={redactNames} nodeNote={nodeNote} dir={dir} />}
+        content={
+          <TreemapCell
+            onNodeClick={onNodeClick}
+            redactNames={redactNames}
+            nodeNote={nodeNote}
+            dir={dir}
+            edges={edges}
+          />
+        }
       >
         <ChartTooltip content={<Content hideLabel valueFormatter={format} />} />
       </RechartsTreemap>

package/src/hooks/use-dismiss.ts

@@ -42,8 +42,9 @@ import { isComposing } from "../lib/ime";
  * draft, InlineEditField cancelling its edit, the date picker's month grid going back to
  * the days. Those call {@link claimEscape}, and no layer is handed the key. The only
  * other claim is the layer owner's OWN handler — a dialog's `onKeyDown` prop calling
- * `preventDefault()` on Escape (a busy reauth dialog holding itself open, Kurvenschmiede's
- * gear wizard asking first), through {@link runOwnKeyDown}. A `preventDefault()`
+ * `preventDefault()` on Escape (Kurvenschmiede's gear wizard asking first), through
+ * {@link runOwnKeyDown}. A dialog holding itself open while its request runs passes
+ * Modal's `busy` instead (0.51.7, DUP-3), which holds the backdrop and Back as well. A `preventDefault()`
  * anywhere else claims nothing: a search box keeping Chromium from clearing itself
  * must not hold a dialog open (FullBleedDialog's 0.8.0 fix, which Modal never had).
  *

package/src/hooks/use-overlay-history.ts

@@ -71,6 +71,8 @@ const SENTINEL_KEY = "__hbUiOverlayHistory";
 interface OverlayEntry {
   id: string;
   close: () => void;
+  /** The overlay refuses to close right now — see the `held` option. */
+  held: () => boolean;
 }
 
 const stack: OverlayEntry[] = [];
@@ -510,6 +512,11 @@ function closeOnPop() {
   // is no longer ours: either the layer below (a different overlay's marker) or
   // the plain page entry (none at all).
   if (currentSentinel() === top.id) return;
+  // Checked before anything below moves: a held overlay keeps its place and its record.
+  if (top.held()) {
+    putBack(top.id);
+    return;
+  }
   stack.pop();
   // The browser consumed this entry, so the overlay's own cleanup has nothing left
   // to unwind and nothing to record as owed.
@@ -521,6 +528,29 @@ function closeOnPop() {
   top.close();
 }
 
+/**
+ * A Back press the top overlay refuses (a busy `Modal`, DUP-3). A popstate cannot be
+ * refused — the browser has already left our entry — so the entry is put back: what the
+ * page wrote into the address while the overlay was up is carried down first (#412), as
+ * for a close, and the same marker is pushed again over it, as the mount pushed it. Left
+ * on the page entry, the overlay would stay up with no entry of its own, and the Back
+ * after its request would leave the page under it.
+ *
+ * A push and not `history.go(1)` back onto the old entry: a traversal lands a task later
+ * and fires nothing at all if a listener has pushed meanwhile, and a programmatic pop
+ * counted for it would then swallow the user's next real Back.
+ */
+function putBack(id: string): void {
+  const record = pushed.find((p) => p.id === id);
+  if (record && !record.dead) carryOnto(record.seen, record);
+  const prev: unknown = window.history.state;
+  window.history.pushState({ ...(prev && typeof prev === "object" ? prev : {}), [SENTINEL_KEY]: id }, "");
+  standing = id;
+  // The address the entry shows now is the one the user last acted on: the cleanup's
+  // owner's-close check (#584) must not read the carried address as a rewrite.
+  if (record) record.href = record.seen = currentHref();
+}
+
 function ensureListening() {
   if (listening || typeof window === "undefined") return;
   window.addEventListener("popstate", handlePop);
@@ -536,20 +566,26 @@ function ensureListening() {
  * @param open      whether the overlay is currently showing. Components that mount
  *                  only while open (the common case) pass `true`.
  * @param onClose   the overlay's own close handler — the same one Escape calls.
+ * @param options.held  the overlay refuses to close right now (a `Modal` whose request
+ *                  is in flight, DUP-3): Back does not call `onClose`, and the entry the
+ *                  press took is put back, so the overlay still has one for the next
+ *                  Back. Read when Back is pressed. Default false.
  */
-export function useOverlayHistory(open: boolean, onClose: () => void): void {
+export function useOverlayHistory(open: boolean, onClose: () => void, { held = false }: { held?: boolean } = {}): void {
   // The listener fires outside React's render, so it reads the latest handler
   // through a ref rather than through the closure the effect captured.
   const closeRef = useRef(onClose);
+  const heldRef = useRef(held);
   useEffect(() => {
     closeRef.current = onClose;
+    heldRef.current = held;
   });
 
   useEffect(() => {
     if (!open || typeof window === "undefined") return;
     ensureListening();
     const id = `overlay-${(nextId += 1)}`;
-    const entry: OverlayEntry = { id, close: () => closeRef.current() };
+    const entry: OverlayEntry = { id, close: () => closeRef.current(), held: () => heldRef.current };
     stack.push(entry);
     const prev = window.history.state;
     const marked = { ...(prev && typeof prev === "object" ? prev : {}), [SENTINEL_KEY]: id };

package/src/lib/calc.ts

@@ -244,9 +244,20 @@ export function commitExpression(raw: string): string {
  * keystroke-by-keystroke but stray characters can't be entered. A lone leading
  * `-` is kept — in a plain field it is simply a negative amount; in a field whose
  * caller owns the sign it is read off again by {@link splitLeadingSign}. The text
- * is resolved to a plain number on blur/Enter via {@link commitExpression}. */
+ * is resolved to a plain number on blur/Enter via {@link commitExpression}.
+ *
+ * The typographic minus and the two dashes become "-" first, as in
+ * {@link evaluateExpression}: U+2212 is what the kit's own `formatMoney` and
+ * `formatNumber` print for every negative since 0.49, and stripping it with the
+ * stray characters turned a pasted "−1.234,50 €" into a positive amount (refactor
+ * audit 2026-10-30, INP-3). */
 export function sanitizeLive(raw: string): string {
-  return dropExtraDots(raw.replace(/,/g, ".").replace(/[^0-9.+\-*/×÷()]/g, ""));
+  return dropExtraDots(
+    raw
+      .replace(/[−–—]/g, "-")
+      .replace(/,/g, ".")
+      .replace(/[^0-9.+\-*/×÷()]/g, ""),
+  );
 }
 
 /**

package/src/lib/clipboard-minus.ts

@@ -5,8 +5,8 @@
  * as a number: a figure copied out of a kit table and pasted into Excel landed as text.
  * So while a selection inside the page is copied, every U+2212 standing directly before a
  * number — optionally after a currency code or symbol and spaces: "−CHF 1,250.50",
- * "−€2,000", "−12%" — becomes the ASCII "-" in the clipboard, in `text/plain` AND in
- * `text/html` (Excel pastes the HTML flavour, as cells). The page keeps "−".
+ * "−€2,000", "−US$12", "−12%" — becomes the ASCII "-" in the clipboard, in `text/plain` AND
+ * in `text/html` (Excel pastes the HTML flavour, as cells). The page keeps "−".
  *
  * A copy with no such minus is left to the browser untouched, and so is any copy out of an
  * input, a textarea or an editable element: what the person typed is theirs.
@@ -15,8 +15,18 @@
  * the one part every app mounts, the signed-out pages included.
  */
 
-/** U+2212, then (optionally) a currency code or symbol, then spaces, then a digit. */
-const MINUS_BEFORE_NUMBER = /\u2212(?=(?:[A-Z]{3}|\p{Sc})?[\s\u00a0\u202f]*\d)/gu;
+/**
+ * U+2212, then up to five letters, currency symbols or dots, then spaces, then a digit.
+ *
+ * Five of them, not "a code or one symbol": English and Chinese write a currency with
+ * letters before the symbol — "−US$", "−CA$", "−A$", "−NZ$", "−HK$", "−R$", "−MX$",
+ * "−JP¥", "−CN¥" — and `narrowSymbol` with letters alone ("−kr", "−zł", "−Kč"). Those kept
+ * U+2212 in the clipboard, and Excel pasted them as text: 35 of 351 locale × currency
+ * pairs at the default display, every one English or Chinese, and 136 of 1428 with
+ * `narrowSymbol` (refactor audit 2026-10-30, DSP-11). A minus with no digit after it
+ * ("x−y", "a − b") is still left alone.
+ */
+const MINUS_BEFORE_NUMBER = /\u2212(?=[\p{L}\p{Sc}.]{0,5}[\s\u00a0\u202f]*\d)/gu;
 
 /**
  * `text` with each U+2212 that stands before a number (in the sense above) as the ASCII

package/src/lib/decimal-marks.ts

@@ -37,7 +37,13 @@ export function decimalMark(locale: string | undefined): "," | "." {
  * field's settle then made that 1.23, final. This decides per operand, from the
  * typist's own text, before that fold:
  *
- * - both marks present: the one that is not the locale's is grouping, and goes;
+ * - both marks present: the LAST one is the decimal mark, whichever the locale's is, and
+ *   the other is grouping and goes. The order says the convention the figure was written
+ *   in — "1.234,56" German, "1,234.56" English — and a figure pasted from another app or
+ *   locale keeps it. Taking the non-locale mark as grouping wherever it stood read
+ *   "1.234,56" in a "." locale (en, de-CH) as 1.23456, which a money field then settled
+ *   to 1.23 (refactor audit 2026-10-30, INP-3). Typed in the locale's own convention, its
+ *   mark comes last and nothing changes;
  * - in a "," locale, only "." present: grouping when it cannot be a decimal as a
  *   German reader writes it — twice ("1.234.567"), or in thousands shape ("1.234",
  *   "12.500") — otherwise a decimal ("1.5", typed by a dot-decimal habit). A first
@@ -53,10 +59,13 @@ export function decimalMark(locale: string | undefined): "," | "." {
 export function normalizeTypedMarks(raw: string, mark: "," | "."): string {
   const other = mark === "," ? "." : ",";
   return raw.replace(/[0-9.,]+/g, (operand) => {
-    const hasMark = operand.includes(mark);
     const count = operand.split(other).length - 1;
     if (count === 0) return operand;
-    const grouping = hasMark ? true : count > 1 || (mark === "," && /^[1-9]\d{0,2}(\.\d{3})+$/.test(operand));
+    if (operand.includes(mark)) {
+      const grouping = operand.lastIndexOf(mark) > operand.lastIndexOf(other) ? other : mark;
+      return operand.split(grouping).join("");
+    }
+    const grouping = count > 1 || (mark === "," && /^[1-9]\d{0,2}(\.\d{3})+$/.test(operand));
     return grouping ? operand.split(other).join("") : operand;
   });
 }

package/src/lib/format.ts

@@ -335,8 +335,8 @@ export function formatDate(
 }
 
 export interface FormatRelativeTimeOptions extends BaseOptions {
-  /** The zone of the date printed past `absoluteAfterDays` (0.46). Left out: the
-   *  device's. */
+  /** The zone of the date printed past `absoluteAfterDays` (0.46), and (0.51.7) the zone
+   *  whose calendar days "yesterday" and "2 days ago" count. Left out: the device's. */
   timeZone?: string;
   /** The moment it is measured from. Default: now. */
   now?: DateInput;
@@ -370,6 +370,20 @@ const RELATIVE_STEPS: Array<[number, Intl.RelativeTimeFormatUnit, number]> = [
   [Infinity, "year", 365.25 * DAY],
 ];
 
+/**
+ * `d`'s calendar day in `timeZone` (left out: the device's), as a whole number of days:
+ * that day's UTC midnight over a day's length. Two of them subtract to whole calendar
+ * days — a 23- or 25-hour DST day still counts one.
+ */
+function dayNumber(d: Date, timeZone: string | undefined): number {
+  if (!timeZone) return Date.UTC(d.getFullYear(), d.getMonth(), d.getDate()) / DAY;
+  // `en-US`: Gregorian, Latin digits — the parts are read back as numbers.
+  const fields: Intl.DateTimeFormatOptions = { timeZone, year: "numeric", month: "numeric", day: "numeric" };
+  const parts = dateFormatter("en-US", fields).formatToParts(d);
+  const part = (type: Intl.DateTimeFormatPartTypes) => Number(parts.find((p) => p.type === type)?.value);
+  return Date.UTC(part("year"), part("month") - 1, part("day")) / DAY;
+}
+
 const relativeFormatters = new Map<string, Intl.RelativeTimeFormat>();
 function relativeFormatter(
   locale: string | undefined,
@@ -389,7 +403,9 @@ function relativeFormatter(
  * How long ago (or until) `value` is, in `locale`'s words, through
  * `Intl.RelativeTimeFormat`: "3 hours ago", "vor 3 Stunden", "il y a 3 heures",
  * "in 2 days", and under 45 seconds "now". The unit is picked by size — seconds,
- * minutes, hours, days, weeks, months, years — and the count is rounded.
+ * minutes, hours, days, weeks, months, years — and the count is rounded; days are
+ * CALENDAR days (0.51.7), in `timeZone` when given: "yesterday" is the day before today,
+ * however few hours ago that was.
  */
 export function formatRelativeTime(value: DateInput, options: FormatRelativeTimeOptions = {}): string {
   const d = toDate(value);
@@ -402,6 +418,17 @@ export function formatRelativeTime(value: DateInput, options: FormatRelativeTime
   }
   const rtf = relativeFormatter(options.locale, options.numeric ?? "auto", options.style ?? "long");
   const [, unit, size] = RELATIVE_STEPS.find(([limit]) => abs < limit)!;
+  if (unit === "day") {
+    // By the calendar, not in 24-hour units (refactor audit 2026-10-30, DSP-7): rounded
+    // elapsed time made 00:10 seen at 23:50 "yesterday" and 01:00 yesterday seen at 23:30
+    // "2 days ago", beside an exact date (DateMark's second line, the feedback thread's
+    // tooltip) that said otherwise. Counted in `timeZone`, the zone that date is printed
+    // in; a bare "YYYY-MM-DD" is the day it names wherever it is read, as in formatDate.
+    // Still the same day (22 hours and more since just after midnight): in hours.
+    const bareDay = typeof value === "string" && BARE_ISO_DAY.test(value);
+    const days = dayNumber(d, bareDay ? undefined : options.timeZone) - dayNumber(now, options.timeZone);
+    return days === 0 ? rtf.format(Math.round(diff / HOUR), "hour") : rtf.format(days, "day");
+  }
   // Under 45 seconds is "now" rather than "12 seconds ago": a feed that ticks through
   // the seconds is noise, and nothing reads a timestamp to the second.
   const count = unit === "second" ? 0 : Math.round(diff / size);

package/src/lib/text-match.ts

@@ -32,6 +32,18 @@ export function foldForSearch(text: string, locale?: string): string {
     .replace(/ß/g, "ss");
 }
 
+/**
+ * Whether two names are one name as a picker's search reads them: folded
+ * ({@link foldForSearch}) and trimmed — "cafe" is Café, " MIGROS " is Migros. For "does
+ * the typed text name a record that exists" (a create row, InlineEntityCombobox's blur
+ * commit), which compared with plain `toLowerCase` while the list beside it folded, so
+ * "cafe" listed Café as a hit and offered "Create “cafe”" too — a duplicate payee or shop
+ * chain one Enter away (refactor audit 2026-10-30, DUP-5). Internal: not in the barrel.
+ */
+export function sameName(a: string, b: string, locale?: string): boolean {
+  return foldForSearch(a.trim(), locale) === foldForSearch(b.trim(), locale);
+}
+
 /**
  * A picker's query as its words, each folded (0.51.4, keksdose's /prices shop picker):
  * "Migros  Zürich" → `["migros", "zurich"]`. An empty or blank query has no words.

package/src/tour/tour.tsx

@@ -140,7 +140,9 @@ export interface TourStep {
   /** Runs before the step is shown — e.g. navigate to a route, open a panel.
    *  May be async; the step waits for it, then locates the target. Receives the
    *  {@link TourStepContext} (0.50); a step entered by "Guide me" sees `via: "at"` and
-   *  should leave an open form alone. */
+   *  should leave an open form alone. One that throws or rejects is logged to the
+   *  console, and the step is located and shown anyway. Enter and the arrows wait for
+   *  it; Escape does not. */
   beforeStep?: (ctx: TourStepContext) => void | Promise<void>;
 }
 
@@ -481,7 +483,10 @@ export function TourProvider({
       const last = Math.max(0, s.length - 1);
       floorRef.current = opts?.at === undefined ? 0 : resolveAt(s, opts.at);
       const via: TourStepContext["via"] = opts?.at === undefined ? "start" : "at";
-      const wanted = Math.min(Math.max(floorRef.current, opts?.startIndex ?? floorRef.current), last);
+      // Floored, as `at` is (FLW-9): `steps[1.5]` is undefined, and `forward` threw on
+      // its `when` — an edited `?tourStep=2.5` was enough.
+      const asked = opts?.startIndex === undefined ? floorRef.current : Math.floor(opts.startIndex);
+      const wanted = Math.min(Math.max(floorRef.current, asked), last);
       let to = forward(s, wanted, via);
       if (to < 0) to = backward(s, wanted, via);
       // Not one step of the run is shown: there is nothing to tour.
@@ -561,7 +566,7 @@ export function TourProvider({
     (i: number) => {
       const s = stepsRef.current;
       if (!s || s.length === 0) return;
-      const wanted = Math.min(Math.max(floorRef.current, i), s.length - 1);
+      const wanted = Math.min(Math.max(floorRef.current, Math.floor(i)), s.length - 1);
       let to = forward(s, wanted, "goto");
       if (to < 0) to = backward(s, wanted, "goto");
       if (to >= 0) arrive(s, to, "goto");
@@ -990,7 +995,15 @@ function TourOverlay({
       setLocated({ index, step, rect: el ? spotRectOf(el, step) : null, dir: dirOf(el), layer, fullScreen });
     };
     void (async () => {
-      await step.beforeStep?.(stepContext(gates, via));
+      try {
+        await step.beforeStep?.(stepContext(gates, via));
+      } catch (error) {
+        // The step is shown anyway (FLW-5): left unlocated, the tour stayed `active`
+        // with no card, no scrim and no Escape layer, and everything keyed on "a tour
+        // runs" (the `?tour=` mirror, the apps' PWA-update hold) stayed on with it. The
+        // target may well be there regardless; if not, the finder gives up and centres.
+        console.error(error);
+      }
       if (cancelled) return;
       if (!step.target) {
         settle(null);
@@ -1318,6 +1331,10 @@ function TourOverlay({
         if (!ready) onSkip();
         return;
       }
+      // Nothing on screen to move on from: a step whose `beforeStep` is still running
+      // (a route loading) is not passed over by an Enter or a → pressed on the bare
+      // page (FLW-5). Escape, above, still leaves.
+      if (!ready) return;
       if (e.key === "Enter") {
         if (step.awaitClick || step.awaitInput || ownsKey(e.target, "Enter")) return;
         e.preventDefault();

package/src/tour/use-tour-url-sync.ts

@@ -94,10 +94,11 @@ const NavigationContext: Context<NavigationProbe> = (() => {
   }
 })();
 
-/** The step a link asks for, 0-based: `tourStep` is 1-based (keksdose), an alias 0-based. */
+/** The step a link asks for, 0-based: `tourStep` is 1-based (keksdose), an alias 0-based.
+ *  Floored, as the aliases always were (FLW-9): `?tourStep=2.5` was index 1.5. */
 function stepOf(params: URLSearchParams, aliases: readonly string[]): number {
   const step = Number(params.get("tourStep"));
-  if (params.has("tourStep")) return Number.isFinite(step) && step > 0 ? step - 1 : 0;
+  if (params.has("tourStep")) return Number.isFinite(step) && step >= 1 ? Math.floor(step) - 1 : 0;
   for (const alias of aliases) {
     const value = Number(params.get(alias));
     if (params.has(alias)) return Number.isFinite(value) && value > 0 ? Math.floor(value) : 0;
@@ -166,7 +167,10 @@ export function useTourUrlSync({ launch, ready = true, stepAliases = [] }: UseTo
     launchingRef.current = true;
     void Promise.resolve()
       .then(() => launchRef.current(pending.id, { startIndex: pending.startIndex }, startRef.current, live.engine))
-      .catch(() => undefined)
+      // Said, as `TourProvider`'s own `launch` path says it (FLW-9): swallowed, a launch
+      // that failed was a tour that silently did not start — in kastlan after its
+      // launcher had already turned practice mode on.
+      .catch((error: unknown) => console.error(error))
       .finally(() => {
         launchingRef.current = false;
         setSettled((n) => n + 1);