@eifi1/ui-kit 0.51.6 → 0.52.0

package/src/lib/day-format.ts

@@ -0,0 +1,96 @@
+import { useCallback } from "react";
+import { useKitDateFormatter, useKitLocale, useKitTimeZone } from "../i18n/kit-labels";
+import { toLocalIso } from "./dates";
+import { clockTime } from "./date-format";
+import { EMPTY_FORMATTED_VALUE, formatDate, toDate, type DateInput, type FormatDateStyle } from "./format";
+import { dateFormatter } from "./intl-cache";
+import { isBareIsoDay } from "./iso-day";
+
+/**
+ * How a kit component prints a day — ONE ladder (refactor audit 2026-10-30, DUP-2):
+ *
+ *  1. the component's own prop (`formatDate`, `renderDate`), when the app gave one and it
+ *     answers;
+ *  2. else the `<UiKitProvider formatDate>` (keksdose K12: the app's date-format
+ *     preference), asked for the calendar day with `source: "dateMark"`;
+ *  3. else the kit's `formatDate` in the provider's locale AND `timeZone` (0.46).
+ *
+ * 0.46's rule — "a label that identifies a day follows the preference" — held only where
+ * a component wrote that ladder itself: four copies (admin's `useDayText`, AccountStateChip,
+ * DateMark, the feedback table), while about twelve components took their own prop or
+ * nothing and went straight to `lib/format`. keksdose set the provider's `formatDate` and
+ * still passed it into six components by hand; and the 10 that imported the raw
+ * `formatDate` ignored the provider's `timeZone`.
+ *
+ * @internal Not part of the barrel: the components' props are the public way in.
+ */
+
+/** What a {@link DayFormatter} call may ask for. */
+export interface DayTextOptions {
+  /**
+   * Name the day of the week — what the provider's formatter is told (its `weekday`).
+   * keksdose's rule: a date in a COLUMN carries it, a date in a SENTENCE does not
+   * (dev#546). Default `false`. The kit's own rendering follows `style`, not this.
+   */
+  weekday?: boolean;
+  /** Add the clock time, in the language (date-format rule 3): a timestamp. Default false. */
+  time?: boolean;
+  /** The kit's own rendering (step 3). Default `"medium"`, `"dateTime"` with `time`. */
+  style?: FormatDateStyle | Intl.DateTimeFormatOptions;
+  /** `false`: skip the provider (step 2) — a component's explicit style wins over it,
+   *  as `DateMark`'s `dateStyle` does. Default `true`. */
+  preference?: boolean;
+  /** Printed for no value. Default "—". */
+  empty?: string;
+}
+
+/** A component's day printer: a value in, its text out. */
+export type DayFormatter<V extends DateInput = DateInput> = (value: V, options?: DayTextOptions) => string;
+
+/** The calendar day `date` falls on in `timeZone`, as "YYYY-MM-DD" — so the day the
+ *  provider is asked for is the day the kit's own rendering would print. */
+function isoDayIn(date: Date, timeZone: string | undefined): string {
+  if (!timeZone) return toLocalIso(date);
+  try {
+    // `en-CA` writes YYYY-MM-DD with Latin digits.
+    const parts = dateFormatter("en-CA", { timeZone, year: "numeric", month: "2-digit", day: "2-digit" }).formatToParts(
+      date,
+    );
+    const part = (type: Intl.DateTimeFormatPartTypes) => parts.find((p) => p.type === type)?.value ?? "";
+    return `${part("year")}-${part("month")}-${part("day")}`;
+  } catch {
+    return toLocalIso(date);
+  }
+}
+
+/**
+ * The component's day printer, bound to its `prop`, the provider's `formatDate`, locale
+ * and `timeZone`. `prop` is called with the value as the component passed it, and wins
+ * whenever it answers non-empty. A value that does not parse is printed as it came
+ * (a bug upstream is better seen than hidden behind a dash).
+ */
+export function useDayFormatter<V extends DateInput = DateInput>(
+  prop?: ((value: V) => string) | null,
+  localeProp?: string,
+): DayFormatter<V> {
+  const locale = useKitLocale(localeProp);
+  const timeZone = useKitTimeZone();
+  const fromProvider = useKitDateFormatter();
+  return useCallback<DayFormatter<V>>(
+    (value, options = {}) => {
+      const own = prop?.(value);
+      if (own) return own;
+      if (value === null || value === undefined || value === "") return options.empty ?? EMPTY_FORMATTED_VALUE;
+      const date = toDate(value);
+      if (!date) return String(value);
+      const bareDay = isBareIsoDay(value);
+      if (fromProvider && options.preference !== false) {
+        const iso = bareDay ? value : isoDayIn(date, timeZone);
+        const day = fromProvider(iso, { unit: "day", source: "dateMark", locale, weekday: options.weekday ?? false });
+        if (day) return options.time && !bareDay ? `${day}, ${clockTime(date, locale, timeZone)}` : day;
+      }
+      return formatDate(value, options.style ?? (options.time ? "dateTime" : "medium"), { locale, timeZone });
+    },
+    [prop, fromProvider, locale, timeZone],
+  );
+}

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/describe-failure.ts

@@ -0,0 +1,18 @@
+import type { ReactNode } from "react";
+import { hasContent } from "./presence";
+
+/**
+ * The failure ladder, once: the app's words for a failure when it has any, else the
+ * kit's `fallback`.
+ *
+ * "Any" is {@link hasContent}, so an app's `describeError` answering `""` (nothing to say
+ * about this one) gets the kit's sentence. Written as `own ?? fallback` in the auth forms,
+ * where `""` printed an empty alert, and both ways within one file in the reviewer scope
+ * editor; it lived in the notification cards' parts only (refactor audit 2026-10-30,
+ * DUP-14).
+ *
+ * @internal Package-private — not re-exported from the barrel.
+ */
+export function describeFailure(own: ReactNode | undefined, fallback: ReactNode): ReactNode {
+  return hasContent(own) ? own : fallback;
+}

package/src/lib/direction.ts

@@ -33,3 +33,42 @@ export function horizontalStep(key: string, el: Element | null | undefined): 1 |
   const forward = (key === "ArrowRight") !== isRtl(el);
   return forward ? 1 : -1;
 }
+
+/**
+ * Where a key moves the focus in a list with ONE tab stop (a roving tabindex): the index
+ * to focus from `at` among `count` items, or `undefined` for a key that moves nothing.
+ * ←/→ along `dir` — → is next in `ltr` and previous in `rtl` — ↓/↑ as next and previous,
+ * Home and End to the ends. With `wrap`, past the last is the first and before the first
+ * the last (a ring: PieChart's slices); without, the ends hold (a plane: Treemap's tiles).
+ *
+ * The charts each mapped the keys themselves, and differently at the ends (0.52 code
+ * review of treemap.tsx, finding 9); the end rule is now a word at the call.
+ *
+ * `dir` and not an element to read it off (0.52 code review, deep, charts, findings 1 and
+ * 14): a list in the page's flow takes the page's (`dirOf(el)`), but a plot is laid out
+ * left to right in any page (see `ChartContainer`) and passes `"ltr"` — read off the
+ * element, Treemap's → walked an RTL page's tiles backwards, against the picture.
+ */
+export function rovingTarget(
+  key: string,
+  dir: Direction,
+  at: number,
+  count: number,
+  wrap: boolean,
+): number | undefined {
+  const physical = key === "ArrowRight" ? 1 : key === "ArrowLeft" ? -1 : 0;
+  const step = dir === "rtl" ? -physical : physical;
+  const to = step
+    ? at + step
+    : key === "ArrowDown"
+      ? at + 1
+      : key === "ArrowUp"
+        ? at - 1
+        : key === "Home"
+          ? 0
+          : key === "End"
+            ? count - 1
+            : undefined;
+  if (to === undefined || count <= 0) return undefined;
+  return wrap ? ((to % count) + count) % count : Math.max(0, Math.min(count - 1, to));
+}

package/src/lib/focus-left.ts

@@ -0,0 +1,156 @@
+// "The focused node left" (refactor audit 2026-10-30, Wave 1: DSP-4, DSP-15). When the
+// element holding the keyboard's focus is removed — a table row deleted, filtered out or
+// approved; a bulk bar gone with its Clear; a banner its × took away — the browser puts
+// focus on <body> and says nothing: no blur in Chromium, none in jsdom. A keyboard or
+// screen-reader user then starts again from the top of the page. The overlays give focus
+// back to their opener (use-focus-trap); these helpers are for the controls that leave
+// the page while the focus is IN them, and decide where it goes instead.
+
+/**
+ * Candidate tab stops, in DOM order — narrowed by {@link isTabStop} to the ones a Tab
+ * really reaches. The kit's one copy of the rule (0.52 code review, lib/focus-left.ts):
+ * this file and use-focus-trap each had it, with an exported `firstTabStop` apiece that
+ * disagreed about the element itself, and a combobox panel's toolbar had a third
+ * selector. The trap, the focus a removed node drops (below), the tour's field ring and
+ * the toolbar all read it here, so "the next stop" is the same stop everywhere.
+ *
+ * The selector is the one `Modal` used. On its own it was not enough (round 0.34
+ * BUG-4): only the bare `[tabindex]` clause excluded `-1`, so a `button`, an `input` or
+ * a link taken out of the tab order still counted. A panel that ends in a roving grid —
+ * the calendar's days, the month grid, the picker sheet's rows, every one of them `-1`
+ * but the active cell — then had a "last" stop no Tab ever reaches: Tab from the real
+ * last stop was not wrapped and walked out of the open panel, and Shift+Tab from the
+ * first landed on a cell that is not a stop at all.
+ */
+// `input[type=hidden]` is no stop: a Tab never lands on it and focus() on it does nothing,
+// but its tabIndex reads 0, so a trap could take a form's hidden field for its first or last
+// stop and Shift+Tab left the dialog (0.52 code review).
+const TAB_STOP =
+  'a[href],button:not([disabled]),textarea:not([disabled]),input:not([disabled]):not([type="hidden"]),select:not([disabled]),[tabindex]:not([tabindex="-1"])';
+
+/**
+ * A stop the browser's own Tab would land on: in the tab order (`tabIndex` ≥ 0) and not
+ * inside something `hidden` or `inert`. Removes only elements a native Tab never
+ * reaches, so no correct order changes. `visibility: hidden` and closed `<details>` are
+ * still not walked — they need layout, which this rule has never read.
+ */
+function isTabStop(el: HTMLElement): boolean {
+  return el.tabIndex >= 0 && !el.closest("[hidden],[inert]");
+}
+
+export interface TabStopOptions {
+  /** Whether `el` itself counts, first, when it is a stop. Default true: the tour's
+   *  target may BE the field (refactor audit 2026-10-30, DUP-9). False for "a control
+   *  inside it" — a row, a drawer, a trap's container, a toolbar. */
+  includeSelf?: boolean;
+}
+
+/** The tab stops in `el`, in DOM order — `el` itself first when it is one, unless
+ *  `includeSelf: false`. */
+export function tabStops(el: Element, { includeSelf = true }: TabStopOptions = {}): HTMLElement[] {
+  const inside = Array.from(el.querySelectorAll<HTMLElement>(TAB_STOP)).filter(isTabStop);
+  const own = includeSelf && el instanceof HTMLElement && el.matches(TAB_STOP) && isTabStop(el);
+  return own ? [el, ...inside] : inside;
+}
+
+/** The first of {@link tabStops} — the control a person types into or presses — or null. */
+export function firstTabStop(el: Element, options?: TabStopOptions): HTMLElement | null {
+  return tabStops(el, options)[0] ?? null;
+}
+
+/**
+ * Whether the focus has fallen out of the page: onto `<body>`, onto nothing, or onto a
+ * node no longer in the document. False on the server, where nothing has focus to lose.
+ * A recovery asks this first: focus that went somewhere real (a dialog, the next field,
+ * an app's own `focus()`) is the user's or the app's, and is left where it is.
+ */
+export function focusIsLost(): boolean {
+  if (typeof document === "undefined") return false;
+  const el = document.activeElement;
+  return !el || el === document.body || !el.isConnected;
+}
+
+/**
+ * Calls `then` when a `blur`/`focusout` was the user's own move to nothing — a click on
+ * the page's background, or a click Safari answers by focusing nothing (it focuses no
+ * button or link on a click, and blurs what had the focus) — after which a note of where
+ * the focus was is stale (0.52 code review: DataTable's row, BulkActionBar's and
+ * AlertBanner's notes outlived it, and a removal much later pulled the focus, and the
+ * scroll, back to them).
+ *
+ * No element took the focus, the document holds none, and the node that lost it could
+ * still hold it. Not when it was removed, hidden, made inert or disabled: that is the page
+ * taking the focus away — the very case those notes are kept for. Not a window losing the
+ * focus either, which leaves the node the document's active element. Decided a microtask
+ * later, once the event's own work is done: a browser that blurs a node it is removing
+ * (or hiding) may do it while the node is still in place, and only after it is gone is
+ * that told apart from a click.
+ */
+export function whenFocusLeftForNothing(
+  e: { target: EventTarget | null; relatedTarget: EventTarget | null },
+  then: () => void,
+): void {
+  const el = e.target;
+  if (e.relatedTarget !== null || !(el instanceof Element)) return;
+  queueMicrotask(() => {
+    if (!el.isConnected || el.matches(":disabled") || el.closest("[hidden],[inert]")) return;
+    // `display: none`, where the browser can say (jsdom cannot).
+    if (typeof el.checkVisibility === "function" && !el.checkVisibility()) return;
+    if (focusIsLost()) then();
+  });
+}
+
+/**
+ * The tab stops around `frame`, outside it, nearest first on each side — where focus
+ * goes once `frame` is gone. Read BEFORE it goes: a removed node has no place in the
+ * document to measure from. `limit` per side keeps a long page's stops out of memory.
+ *
+ * Walked outwards from the frame, `limit` stops each way (0.52 code review,
+ * lib/focus-left.ts): read from every stop in the page, a banner under a 2000-row table
+ * read all 2000 to keep the nearest five before it.
+ */
+export function tabStopsAround(frame: Element, limit = 5): { after: HTMLElement[]; before: HTMLElement[] } {
+  const doc = frame.ownerDocument;
+  const walker = doc.createTreeWalker(doc.documentElement, NodeFilter.SHOW_ELEMENT);
+  const isStop = (node: Node): node is HTMLElement =>
+    node instanceof HTMLElement && node.matches(TAB_STOP) && isTabStop(node);
+  // After: from the first element past the frame's own subtree, in document order.
+  const after: HTMLElement[] = [];
+  walker.currentNode = frame;
+  let node: Node | null = walker.nextSibling();
+  while (!node && walker.parentNode()) node = walker.nextSibling();
+  for (; node && after.length < limit; node = walker.nextNode()) if (isStop(node)) after.push(node);
+  // Before: back from the frame, nearest first (its ancestors among them, as before).
+  const before: HTMLElement[] = [];
+  walker.currentNode = frame;
+  for (node = walker.previousNode(); node && before.length < limit; node = walker.previousNode())
+    if (isStop(node)) before.push(node);
+  return { after, before };
+}
+
+/**
+ * Focus the first of `candidates` that is still in the page and takes the focus; true
+ * when one did. Each is tried and checked, since `focus()` on a node that cannot hold it
+ * (detached, `display: none`, disabled since) fails without a word.
+ */
+export function focusFirst(candidates: Iterable<Element | null | undefined>): boolean {
+  for (const el of candidates) {
+    if (!(el instanceof HTMLElement) || !el.isConnected) continue;
+    el.focus();
+    if (document.activeElement === el) return true;
+  }
+  return false;
+}
+
+/**
+ * Focus a container that is not a tab stop of its own — a table, a list — as the place
+ * the user is in, without making it one: `tabindex="-1"` for as long as it holds the
+ * focus, unless it already carries a `tabindex` of its own.
+ */
+export function focusContainer(el: HTMLElement): void {
+  if (!el.hasAttribute("tabindex")) {
+    el.setAttribute("tabindex", "-1");
+    el.addEventListener("blur", () => el.removeAttribute("tabindex"), { once: true });
+  }
+  el.focus();
+}

package/src/lib/format.ts

@@ -1,6 +1,8 @@
 import { useMemo } from "react";
 import { useKitLocale, useKitTimeZone } from "../i18n/kit-labels";
 import { parseIsoDate } from "./dates";
+import { dateFormatter } from "./intl-cache";
+import { isBareIsoDay } from "./iso-day";
 import { formatWithMinus, type MinusStyle } from "./minus";
 import { roundHalfAway } from "./round";
 
@@ -278,9 +280,6 @@ export interface FormatDateOptions extends BaseOptions {
   timeZone?: string;
 }
 
-/** A bare ISO calendar day, `"YYYY-MM-DD"`. */
-const BARE_ISO_DAY = /^\d{4}-\d{2}-\d{2}$/;
-
 /** What {@link formatDate} and {@link formatRelativeTime} accept. */
 export type DateInput = string | number | Date | null | undefined;
 
@@ -292,22 +291,11 @@ export type DateInput = string | number | Date | null | undefined;
  */
 export function toDate(value: DateInput): Date | null {
   if (value === null || value === undefined || value === "") return null;
-  if (typeof value === "string" && BARE_ISO_DAY.test(value)) return parseIsoDate(value);
+  if (isBareIsoDay(value)) return parseIsoDate(value);
   const d = value instanceof Date ? value : new Date(value);
   return Number.isNaN(d.getTime()) ? null : d;
 }
 
-const dateFormatters = new Map<string, Intl.DateTimeFormat>();
-function dateFormatter(locale: string | undefined, options: Intl.DateTimeFormatOptions): Intl.DateTimeFormat {
-  const key = `${locale ?? ""}|${JSON.stringify(options)}`;
-  let f = dateFormatters.get(key);
-  if (!f) {
-    f = new Intl.DateTimeFormat(locale, options);
-    dateFormatters.set(key, f);
-  }
-  return f;
-}
-
 /**
  * A date or timestamp in `locale`. Takes an ISO date ("2026-07-08", read on the local
  * calendar), an ISO timestamp ("2026-07-08T14:05:00Z"), epoch milliseconds or a Date.
@@ -327,7 +315,7 @@ export function formatDate(
   // A bare "YYYY-MM-DD" is a calendar day, which has no zone: it is the day it names
   // wherever it is read, so a `timeZone` (in `options` or the style) never moves it — the
   // device's local midnight shown in a zone west of it was the day before (round 0.45, N9).
-  if (typeof value === "string" && BARE_ISO_DAY.test(value)) {
+  if (isBareIsoDay(value)) {
     const day = new Date(Date.UTC(d.getFullYear(), d.getMonth(), d.getDate()));
     return dateFormatter(options.locale, { ...base, timeZone: "UTC" }).format(day);
   }
@@ -335,8 +323,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 +358,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 +391,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 +406,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 = isBareIsoDay(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/http-status.ts

@@ -0,0 +1,38 @@
+/**
+ * The HTTP status of a thrown error, as one probe (DUP-11, refactor audit 2026-10: the
+ * session refresh carried its own copy).
+ *
+ * It lived in `auth/auth-errors.ts` until 0.52, which made `lib/session-refresh` and
+ * `/sync`'s engine import the auth folder — and put auth's English error words in the
+ * `/sync` entry's closure — for a three-line reader of `status` (refactor audit
+ * 2026-10-30, MOD-6). `auth-errors.ts` re-exports it, so nothing that imported it there
+ * moved.
+ *
+ * @internal Package-private — not re-exported from the barrel.
+ */
+
+type Bag = Record<string, unknown>;
+
+const isBag = (value: unknown): value is Bag => typeof value === "object" && value !== null;
+
+/** An HTTP status as a number, or undefined. */
+function statusOf(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isInteger(value) ? value : undefined;
+}
+
+/**
+ * The HTTP status a thrown error carries, wherever the apps' HTTP clients put it —
+ * without depending on any of them:
+ *
+ *  1. `err.response.status` — axios (all three apps' clients);
+ *  2. `err.status` — ofetch's `FetchError`, the generated OpenAPI clients' `ApiError`, and
+ *     a `Response` thrown as it came;
+ *  3. `err.statusCode` — ofetch's alias, and Node-style errors.
+ *
+ * `undefined` when none is a whole number.
+ */
+export function httpStatusOf(err: unknown): number | undefined {
+  if (!isBag(err)) return undefined;
+  const response = err.response;
+  return (isBag(response) ? statusOf(response.status) : undefined) ?? statusOf(err.status) ?? statusOf(err.statusCode);
+}

package/src/lib/intl-cache.ts

@@ -0,0 +1,25 @@
+/**
+ * One `Intl.DateTimeFormat` per locale and option set, for every date the kit prints.
+ *
+ * Constructing the formatter is the expensive part: keksdose measured 392 ms per click on
+ * a 270-row register when each cell built its own (dev#632), and kept its own renderer of
+ * the date-format preference because the kit's built one per call (refactor audit
+ * 2026-10-30, DUP-2). `lib/format` and `lib/date-format` both format through this one.
+ *
+ * @internal Not part of the barrel — `lib/format` is re-exported whole, so the cache
+ * lives apart from it.
+ */
+
+const dateFormatters = new Map<string, Intl.DateTimeFormat>();
+
+/** The cached formatter for `locale` and `options`. Throws as `Intl.DateTimeFormat` does
+ *  for a tag it refuses — and caches nothing then. */
+export function dateFormatter(locale: string | undefined, options: Intl.DateTimeFormatOptions): Intl.DateTimeFormat {
+  const key = `${locale ?? ""}|${JSON.stringify(options)}`;
+  let f = dateFormatters.get(key);
+  if (!f) {
+    f = new Intl.DateTimeFormat(locale, options);
+    dateFormatters.set(key, f);
+  }
+  return f;
+}

package/src/lib/isin.ts

@@ -9,6 +9,10 @@
  * with every letter expanded to two digits (A = 10 … Z = 35) — which is all that is
  * checked here. Whether the prefix is an assigned code, and whether the security
  * exists, is a lookup, not a checksum.
+ *
+ * Deprecated in 0.52, removed in 0.53 (decision 4 of the refactor audit 2026-10-30,
+ * MOD-5): keksdose, which they were written for, never imported them, and no other app
+ * does.
  */
 
 /** Letters to their two-digit numbers (A = 10 … Z = 35), digits as they are. */
@@ -36,6 +40,8 @@ function luhnSum(digits: string, doubleRightmost: boolean): number {
 /**
  * The ISIN as it is printed: upper case, unbroken (ISO 6166 has no grouping), with
  * the spaces and hyphens a paste from a broker's statement carries dropped.
+ *
+ * @deprecated 0.52 — none: no app checks an ISIN with it; copy lib/isin.ts (MOD-5); removed in 0.53.
  */
 export function formatIsin(value: string): string {
   return value.replace(/[\s-]/g, "").toUpperCase();
@@ -44,6 +50,8 @@ export function formatIsin(value: string): string {
 /**
  * The check digit for the first eleven characters of an ISIN (prefix and national
  * number). For BUILDING one — a test fixture, a demo — rather than checking it.
+ *
+ * @deprecated 0.52 — none: no app checks an ISIN with it; copy lib/isin.ts (MOD-5); removed in 0.53.
  */
 export function isinCheckDigit(body: string): string {
   const sum = luhnSum(expandLetters(formatIsin(body)), true);
@@ -54,6 +62,8 @@ export function isinCheckDigit(body: string): string {
  * Whether `value` is a valid ISIN: two letters, nine letters or digits, one digit,
  * and a matching Luhn check digit over the letter-expanded form. Spaces, hyphens and
  * lower case are fine (see {@link formatIsin}).
+ *
+ * @deprecated 0.52 — none: no app checks an ISIN with it; copy lib/isin.ts (MOD-5); removed in 0.53.
  */
 export function isValidIsin(value: string): boolean {
   const isin = formatIsin(value);

package/src/lib/iso-day.ts

@@ -0,0 +1,13 @@
+/**
+ * The bare ISO calendar day, `"YYYY-MM-DD"` — no time, no zone: the day it names in every
+ * zone. `toDate` and `formatDate` (lib/format), the kit's day ladder (`useDayFormatter`,
+ * lib/day-format) and the preference's renderers (lib/date-format) each kept a copy of this
+ * pattern (0.52 code review, lib/day-format.ts). Were one to learn a new shape (say
+ * `YYYY-MM-DDT00:00`) alone, the ladder would ask the provider for a different day than the
+ * kit prints. One rule.
+ *
+ * @internal Not part of the barrel: `lib/format` is re-exported whole, so it lives apart.
+ */
+export function isBareIsoDay(value: unknown): value is string {
+  return typeof value === "string" && /^\d{4}-\d{2}-\d{2}$/.test(value);
+}

package/src/lib/lazy-with-fallback.ts

@@ -0,0 +1,82 @@
+import { createContext, createElement, lazy, useCallback, useContext, useLayoutEffect, useState } from "react";
+import type { ComponentType, LazyExoticComponent } from "react";
+
+/** What a {@link lazyWithFallback} fallback is given besides the component's own props. */
+export interface LazyFallbackProps {
+  /** What the import rejected with. Already on `console.error`. */
+  error: unknown;
+  /** Fetch the module again and draw it here if it comes (back online, the deploy's
+   *  new chunk). Call it on the person's next attempt, never at once: offline, a retry
+   *  on mount would fetch in a loop. */
+  retry: () => void;
+}
+
+interface Attempt<P> {
+  Component: LazyExoticComponent<ComponentType<P>>;
+  /** Its import failed and its fallback was drawn: the next mount, or `retry`, takes a
+   *  fresh attempt. Marked when the fallback COMMITS, not when the import rejects: a
+   *  first mount that suspended is thrown away and rendered anew, and an attempt marked
+   *  at the rejection would hand that re-render a fresh import — which fails, and so on. */
+  spent: boolean;
+}
+
+const RetryContext = createContext<() => void>(() => {});
+
+/**
+ * `React.lazy` for a module the kit loads late (refactor audit 2026-10, MOD-1: the tour
+ * overlay, the search palette, the feedback dialog), where an import that fails — a tab
+ * left open across a deploy, a local-first app offline — draws `Fallback` instead of
+ * throwing.
+ *
+ * `React.lazy` keeps what its import settled to, so one failed fetch threw on every render
+ * for as long as the component stayed mounted, to the nearest error boundary. All three
+ * sit above the routes — in the provider every app mounts, in the top bar — where that
+ * boundary is the whole app's: a white page because somebody pressed ⌘K or "Take the
+ * tour" (0.52 code review, tour.tsx: the tour's own fix, written by hand with a module-level
+ * `let`, made shared here).
+ *
+ * A failure is logged and the next mount (or the fallback's `retry`) fetches again; a
+ * re-render of a mounted fallback does not. `load` resolves to the component itself,
+ * through a LITERAL relative dynamic import of its module (as feedback-submit's), so an
+ * app's bundler can split it off. Render the result under a `Suspense`, as a lazy
+ * component. (No import call is spelled out here: the build's fix-esm-extensions step
+ * reads specifiers in the .d.ts comments too, and would try to resolve an example.)
+ */
+export function lazyWithFallback<P extends object>(
+  load: () => Promise<ComponentType<P>>,
+  Fallback: ComponentType<P & LazyFallbackProps>,
+): ComponentType<P> {
+  const attempt = (): Attempt<P> => {
+    const made: Attempt<P> = {
+      spent: false,
+      Component: lazy<ComponentType<P>>(() =>
+        load().then(
+          (Loaded) => ({ default: Loaded }),
+          (error: unknown) => {
+            console.error(error);
+            function Failed(props: P) {
+              const retry = useContext(RetryContext);
+              useLayoutEffect(() => {
+                made.spent = true;
+              }, []);
+              return createElement(Fallback, { ...props, error, retry });
+            }
+            return { default: Failed };
+          },
+        ),
+      ),
+    };
+    return made;
+  };
+  let latest = attempt();
+  /** The attempt a new mount takes: the latest, or a fresh one once that has failed. */
+  const take = () => (latest.spent ? (latest = attempt()) : latest);
+
+  function LazyWithFallback(props: P) {
+    // Fixed per mount, so a re-render of a mounted fallback fetches nothing.
+    const [current, setCurrent] = useState(take);
+    const retry = useCallback(() => setCurrent(take), []);
+    return createElement(RetryContext.Provider, { value: retry }, createElement(current.Component, props));
+  }
+  return LazyWithFallback;
+}