@eifi1/ui-kit 0.53.0 → 0.55.0

package/src/lib/qr-encode.ts

@@ -1,444 +0,0 @@
-/**
- * A QR code encoder: text in, a square of dark / light modules out (ISO/IEC 18004).
- *
- * WHY IT IS IN THE KIT rather than a dependency. `TwoFactorSetting` needs one QR code —
- * an `otpauth://` URI, around 100–200 bytes — and every app that shows it was pulling
- * in `qrcode.react` plus `react-dom/server` to render that one code to a static SVG
- * string, then base64-encoding it so the kit could draw it back as an `<img>`.
- * A dependency here would land in all three apps whether they show 2FA or not; an
- * optional peer would mean a lazy import and a loading state for something that is
- * a few hundred lines of arithmetic. So it is those lines: pure, no imports, no module
- * state beyond two constant tables, safe under `sideEffects: false`, and
- * tree-shaken out of every app that never renders a {@link QrCode}.
- *
- * Scope, chosen for what the kit renders: BYTE mode only (UTF-8), all 40 versions,
- * all four error-correction levels, automatic version and mask selection. Numeric,
- * alphanumeric and Kanji modes are denser for their alphabets but would not shrink an
- * otpauth URI (lower-case letters are not in the alphanumeric set). The algorithm and
- * its penalty rules follow the reference implementation by Project Nayuki (MIT),
- * which is also what `qrcode.react` wraps — so for the same input, level and boost
- * the modules match that library's output exactly (the test suite pins a matrix).
- */
-
-export type QrErrorCorrection = "L" | "M" | "Q" | "H";
-
-export interface QrEncodeOptions {
-  /** How much of the code may be damaged and still read. Default `"M"` (~15 %). */
-  errorCorrection?: QrErrorCorrection;
-  /** Raise the level as far as the chosen version still fits, for free. Default true. */
-  boostErrorCorrection?: boolean;
-}
-
-export interface QrMatrix {
-  /** 1–40. */
-  version: number;
-  /** Modules per side: `version * 4 + 17`. */
-  size: number;
-  /** The level actually used — higher than asked when boosted. */
-  errorCorrection: QrErrorCorrection;
-  /** 0–7. */
-  mask: number;
-  /** `modules[y][x]`, true = dark. No quiet zone: the renderer adds its own. */
-  modules: boolean[][];
-}
-
-const LEVELS: QrErrorCorrection[] = ["L", "M", "Q", "H"];
-/** The two format-information bits per level (not in ordinal order: M is 00). */
-const FORMAT_BITS: Record<QrErrorCorrection, number> = { L: 1, M: 0, Q: 3, H: 2 };
-
-// Index 0 is padding; rows are L, M, Q, H.
-const ECC_CODEWORDS_PER_BLOCK: readonly (readonly number[])[] = [
-  [
-    -1, 7, 10, 15, 20, 26, 18, 20, 24, 30, 18, 20, 24, 26, 30, 22, 24, 28, 30, 28, 28, 28, 28, 30, 30, 26, 28, 30, 30,
-    30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
-  ],
-  [
-    -1, 10, 16, 26, 18, 24, 16, 18, 22, 22, 26, 30, 22, 22, 24, 24, 28, 28, 26, 26, 26, 26, 28, 28, 28, 28, 28, 28, 28,
-    28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
-  ],
-  [
-    -1, 13, 22, 18, 26, 18, 24, 18, 22, 20, 24, 28, 26, 24, 20, 30, 24, 28, 28, 26, 30, 28, 30, 30, 30, 30, 28, 30, 30,
-    30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
-  ],
-  [
-    -1, 17, 28, 22, 16, 22, 28, 26, 26, 24, 28, 24, 28, 22, 24, 24, 30, 28, 28, 26, 28, 30, 24, 30, 30, 30, 30, 30, 30,
-    30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
-  ],
-];
-const NUM_ERROR_CORRECTION_BLOCKS: readonly (readonly number[])[] = [
-  [
-    -1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 4, 4, 4, 4, 4, 6, 6, 6, 6, 7, 8, 8, 9, 9, 10, 12, 12, 12, 13, 14, 15, 16, 17, 18, 19,
-    19, 20, 21, 22, 24, 25,
-  ],
-  [
-    -1, 1, 1, 1, 2, 2, 4, 4, 4, 5, 5, 5, 8, 9, 9, 10, 10, 11, 13, 14, 16, 17, 17, 18, 20, 21, 23, 25, 26, 28, 29, 31,
-    33, 35, 37, 38, 40, 43, 45, 47, 49,
-  ],
-  [
-    -1, 1, 1, 2, 2, 4, 4, 6, 6, 8, 8, 8, 10, 12, 16, 12, 17, 16, 18, 21, 20, 23, 23, 25, 27, 29, 34, 34, 35, 38, 40, 43,
-    45, 48, 51, 53, 56, 59, 62, 65, 68,
-  ],
-  [
-    -1, 1, 1, 2, 4, 4, 4, 5, 6, 8, 8, 11, 11, 16, 16, 18, 16, 19, 21, 25, 25, 25, 34, 30, 32, 35, 37, 40, 42, 45, 48,
-    51, 54, 57, 60, 63, 66, 70, 74, 77, 81,
-  ],
-];
-
-/** Encode `text` (as UTF-8 bytes). Throws a `RangeError` past version 40's capacity. */
-export function encodeQr(text: string, options: QrEncodeOptions = {}): QrMatrix {
-  const bytes = Array.from(new TextEncoder().encode(text));
-  let level = LEVELS.indexOf(options.errorCorrection ?? "M");
-
-  // The smallest version that holds the data at the requested level.
-  let version = 1;
-  let usedBits: number;
-  for (; ; version++) {
-    const countBits = version <= 9 ? 8 : 16;
-    usedBits = bytes.length < 1 << countBits ? 4 + countBits + bytes.length * 8 : Infinity;
-    if (usedBits <= dataCodewords(version, level) * 8) break;
-    if (version >= 40) throw new RangeError("QR data too long");
-  }
-  if (options.boostErrorCorrection ?? true) {
-    for (let higher = level + 1; higher < LEVELS.length; higher++) {
-      if (usedBits <= dataCodewords(version, higher) * 8) level = higher;
-    }
-  }
-
-  // Mode, count, data; then terminator, byte padding and the 0xEC/0x11 fill.
-  const bits: number[] = [];
-  const append = (value: number, length: number) => {
-    for (let i = length - 1; i >= 0; i--) bits.push((value >>> i) & 1);
-  };
-  append(0b0100, 4);
-  append(bytes.length, version <= 9 ? 8 : 16);
-  for (const b of bytes) append(b, 8);
-  const capacity = dataCodewords(version, level) * 8;
-  append(0, Math.min(4, capacity - bits.length));
-  append(0, (8 - (bits.length % 8)) % 8);
-  for (let pad = 0xec; bits.length < capacity; pad ^= 0xec ^ 0x11) append(pad, 8);
-
-  const data: number[] = [];
-  for (let i = 0; i < bits.length; i += 8) {
-    let byte = 0;
-    for (let j = 0; j < 8; j++) byte = (byte << 1) | bits[i + j];
-    data.push(byte);
-  }
-
-  const grid = new Grid(version, LEVELS[level]);
-  grid.drawFunctionPatterns();
-  grid.drawCodewords(interleaveWithEcc(data, version, level));
-
-  let bestMask = 0;
-  let bestPenalty = Infinity;
-  for (let mask = 0; mask < 8; mask++) {
-    grid.applyMask(mask);
-    grid.drawFormatBits(mask);
-    const penalty = grid.penalty();
-    if (penalty < bestPenalty) {
-      bestMask = mask;
-      bestPenalty = penalty;
-    }
-    grid.applyMask(mask); // XOR again undoes it
-  }
-  grid.applyMask(bestMask);
-  grid.drawFormatBits(bestMask);
-
-  return {
-    version,
-    size: grid.size,
-    errorCorrection: LEVELS[level],
-    mask: bestMask,
-    modules: grid.modules,
-  };
-}
-
-function rawDataModules(version: number): number {
-  let result = (16 * version + 128) * version + 64;
-  if (version >= 2) {
-    const numAlign = Math.floor(version / 7) + 2;
-    result -= (25 * numAlign - 10) * numAlign - 55;
-    if (version >= 7) result -= 36;
-  }
-  return result;
-}
-
-function dataCodewords(version: number, level: number): number {
-  return (
-    Math.floor(rawDataModules(version) / 8) -
-    ECC_CODEWORDS_PER_BLOCK[level][version] * NUM_ERROR_CORRECTION_BLOCKS[level][version]
-  );
-}
-
-/** Split into blocks, append each block's Reed–Solomon codewords, interleave. */
-function interleaveWithEcc(data: number[], version: number, level: number): number[] {
-  const numBlocks = NUM_ERROR_CORRECTION_BLOCKS[level][version];
-  const eccLen = ECC_CODEWORDS_PER_BLOCK[level][version];
-  const rawCodewords = Math.floor(rawDataModules(version) / 8);
-  const numShortBlocks = numBlocks - (rawCodewords % numBlocks);
-  const shortBlockLen = Math.floor(rawCodewords / numBlocks);
-  const divisor = reedSolomonDivisor(eccLen);
-
-  const blocks: number[][] = [];
-  for (let i = 0, k = 0; i < numBlocks; i++) {
-    const block = data.slice(k, k + shortBlockLen - eccLen + (i < numShortBlocks ? 0 : 1));
-    k += block.length;
-    const ecc = reedSolomonRemainder(block, divisor);
-    if (i < numShortBlocks) block.push(0); // placeholder, skipped below
-    blocks.push(block.concat(ecc));
-  }
-
-  const result: number[] = [];
-  for (let i = 0; i < blocks[0].length; i++) {
-    blocks.forEach((block, j) => {
-      if (i !== shortBlockLen - eccLen || j >= numShortBlocks) result.push(block[i]);
-    });
-  }
-  return result;
-}
-
-function gfMultiply(x: number, y: number): number {
-  let z = 0;
-  for (let i = 7; i >= 0; i--) {
-    z = (z << 1) ^ ((z >>> 7) * 0x11d);
-    z ^= ((y >>> i) & 1) * x;
-  }
-  return z;
-}
-
-function reedSolomonDivisor(degree: number): number[] {
-  const result = new Array<number>(degree).fill(0);
-  result[degree - 1] = 1;
-  let root = 1;
-  for (let i = 0; i < degree; i++) {
-    for (let j = 0; j < degree; j++) {
-      result[j] = gfMultiply(result[j], root);
-      if (j + 1 < degree) result[j] ^= result[j + 1];
-    }
-    root = gfMultiply(root, 0x02);
-  }
-  return result;
-}
-
-function reedSolomonRemainder(data: number[], divisor: number[]): number[] {
-  const result = new Array<number>(divisor.length).fill(0);
-  for (const b of data) {
-    const factor = b ^ (result.shift() as number);
-    result.push(0);
-    divisor.forEach((coef, i) => {
-      result[i] ^= gfMultiply(coef, factor);
-    });
-  }
-  return result;
-}
-
-const bit = (value: number, i: number) => ((value >>> i) & 1) !== 0;
-
-class Grid {
-  readonly size: number;
-  readonly modules: boolean[][];
-  private readonly reserved: boolean[][];
-  private readonly version: number;
-  private readonly level: QrErrorCorrection;
-
-  constructor(version: number, level: QrErrorCorrection) {
-    this.version = version;
-    this.level = level;
-    this.size = version * 4 + 17;
-    this.modules = Array.from({ length: this.size }, () => new Array<boolean>(this.size).fill(false));
-    this.reserved = Array.from({ length: this.size }, () => new Array<boolean>(this.size).fill(false));
-  }
-
-  private set(x: number, y: number, dark: boolean) {
-    this.modules[y][x] = dark;
-    this.reserved[y][x] = true;
-  }
-
-  drawFunctionPatterns() {
-    const { size } = this;
-    for (let i = 0; i < size; i++) {
-      this.set(6, i, i % 2 === 0);
-      this.set(i, 6, i % 2 === 0);
-    }
-    this.drawFinder(3, 3);
-    this.drawFinder(size - 4, 3);
-    this.drawFinder(3, size - 4);
-    const align = this.alignmentPositions();
-    const n = align.length;
-    for (let i = 0; i < n; i++) {
-      for (let j = 0; j < n; j++) {
-        const corner = (i === 0 && j === 0) || (i === 0 && j === n - 1) || (i === n - 1 && j === 0);
-        if (!corner) this.drawAlignment(align[i], align[j]);
-      }
-    }
-    this.drawFormatBits(0); // reserves the area; redrawn once the mask is chosen
-    this.drawVersion();
-  }
-
-  private drawFinder(x: number, y: number) {
-    for (let dy = -4; dy <= 4; dy++) {
-      for (let dx = -4; dx <= 4; dx++) {
-        const dist = Math.max(Math.abs(dx), Math.abs(dy));
-        const xx = x + dx;
-        const yy = y + dy;
-        if (xx >= 0 && xx < this.size && yy >= 0 && yy < this.size) {
-          this.set(xx, yy, dist !== 2 && dist !== 4);
-        }
-      }
-    }
-  }
-
-  private drawAlignment(x: number, y: number) {
-    for (let dy = -2; dy <= 2; dy++) {
-      for (let dx = -2; dx <= 2; dx++) {
-        this.set(x + dx, y + dy, Math.max(Math.abs(dx), Math.abs(dy)) !== 1);
-      }
-    }
-  }
-
-  private alignmentPositions(): number[] {
-    if (this.version === 1) return [];
-    const numAlign = Math.floor(this.version / 7) + 2;
-    const step = Math.floor((this.version * 8 + numAlign * 3 + 5) / (numAlign * 4 - 4)) * 2;
-    const result = [6];
-    for (let pos = this.size - 7; result.length < numAlign; pos -= step) result.splice(1, 0, pos);
-    return result;
-  }
-
-  drawFormatBits(mask: number) {
-    const data = (FORMAT_BITS[this.level] << 3) | mask;
-    let rem = data;
-    for (let i = 0; i < 10; i++) rem = (rem << 1) ^ ((rem >>> 9) * 0x537);
-    const bits = ((data << 10) | rem) ^ 0x5412;
-    const { size } = this;
-    for (let i = 0; i <= 5; i++) this.set(8, i, bit(bits, i));
-    this.set(8, 7, bit(bits, 6));
-    this.set(8, 8, bit(bits, 7));
-    this.set(7, 8, bit(bits, 8));
-    for (let i = 9; i < 15; i++) this.set(14 - i, 8, bit(bits, i));
-    for (let i = 0; i < 8; i++) this.set(size - 1 - i, 8, bit(bits, i));
-    for (let i = 8; i < 15; i++) this.set(8, size - 15 + i, bit(bits, i));
-    this.set(8, size - 8, true); // the always-dark module
-  }
-
-  private drawVersion() {
-    if (this.version < 7) return;
-    let rem = this.version;
-    for (let i = 0; i < 12; i++) rem = (rem << 1) ^ ((rem >>> 11) * 0x1f25);
-    const bits = (this.version << 12) | rem;
-    for (let i = 0; i < 18; i++) {
-      const dark = bit(bits, i);
-      const a = this.size - 11 + (i % 3);
-      const b = Math.floor(i / 3);
-      this.set(a, b, dark);
-      this.set(b, a, dark);
-    }
-  }
-
-  /** The zig-zag placement: two-module columns, right to left, alternating up and down. */
-  drawCodewords(data: number[]) {
-    const { size } = this;
-    let i = 0;
-    for (let right = size - 1; right >= 1; right -= 2) {
-      if (right === 6) right = 5; // skip the vertical timing column
-      for (let vert = 0; vert < size; vert++) {
-        for (let j = 0; j < 2; j++) {
-          const x = right - j;
-          const upward = ((right + 1) & 2) === 0;
-          const y = upward ? size - 1 - vert : vert;
-          if (!this.reserved[y][x] && i < data.length * 8) {
-            this.modules[y][x] = bit(data[i >>> 3], 7 - (i & 7));
-            i++;
-          }
-        }
-      }
-    }
-  }
-
-  applyMask(mask: number) {
-    for (let y = 0; y < this.size; y++) {
-      for (let x = 0; x < this.size; x++) {
-        if (!this.reserved[y][x] && maskBit(mask, x, y)) this.modules[y][x] = !this.modules[y][x];
-      }
-    }
-  }
-
-  penalty(): number {
-    const { size, modules } = this;
-    let result = 0;
-    const line = (get: (a: number, b: number) => boolean) => {
-      for (let a = 0; a < size; a++) {
-        let runColor = false;
-        let run = 0;
-        const history = [0, 0, 0, 0, 0, 0, 0];
-        for (let b = 0; b < size; b++) {
-          if (get(a, b) === runColor) {
-            run++;
-            if (run === 5) result += 3;
-            else if (run > 5) result++;
-          } else {
-            this.addHistory(run, history);
-            if (!runColor) result += this.countFinderLike(history) * 40;
-            runColor = get(a, b);
-            run = 1;
-          }
-        }
-        if (runColor) {
-          this.addHistory(run, history);
-          run = 0;
-        }
-        this.addHistory(run + size, history);
-        result += this.countFinderLike(history) * 40;
-      }
-    };
-    line((y, x) => modules[y][x]);
-    line((x, y) => modules[y][x]);
-
-    for (let y = 0; y < size - 1; y++) {
-      for (let x = 0; x < size - 1; x++) {
-        const c = modules[y][x];
-        if (c === modules[y][x + 1] && c === modules[y + 1][x] && c === modules[y + 1][x + 1]) {
-          result += 3;
-        }
-      }
-    }
-
-    let dark = 0;
-    for (const row of modules) for (const m of row) if (m) dark++;
-    const total = size * size;
-    result += (Math.ceil(Math.abs(dark * 20 - total * 10) / total) - 1) * 10;
-    return result;
-  }
-
-  private addHistory(run: number, history: number[]) {
-    if (history[0] === 0) run += this.size; // the light border before the first run
-    history.pop();
-    history.unshift(run);
-  }
-
-  private countFinderLike(h: number[]): number {
-    const n = h[1];
-    const core = n > 0 && h[2] === n && h[3] === n * 3 && h[4] === n && h[5] === n;
-    return (core && h[0] >= n * 4 && h[6] >= n ? 1 : 0) + (core && h[6] >= n * 4 && h[0] >= n ? 1 : 0);
-  }
-}
-
-function maskBit(mask: number, x: number, y: number): boolean {
-  switch (mask) {
-    case 0:
-      return (x + y) % 2 === 0;
-    case 1:
-      return y % 2 === 0;
-    case 2:
-      return x % 3 === 0;
-    case 3:
-      return (x + y) % 3 === 0;
-    case 4:
-      return (Math.floor(x / 3) + Math.floor(y / 2)) % 2 === 0;
-    case 5:
-      return ((x * y) % 2) + ((x * y) % 3) === 0;
-    case 6:
-      return (((x * y) % 2) + ((x * y) % 3)) % 2 === 0;
-    default:
-      return (((x + y) % 2) + ((x * y) % 3)) % 2 === 0;
-  }
-}

package/src/lib/quiet-focus.ts

@@ -1,32 +0,0 @@
-/**
- * Focus that is not a request to open anything (0.50.1, keksdose B1).
- *
- * A guided tour focuses a field step's first control on arrival (tours §11.8). The kit's
- * pickers that open their list on focus — Combobox (and the category pickers built on it),
- * Autocomplete, InlineEntityCombobox — opened it then too, and the list, a later layer
- * (§11.6), covered the tour card with its Next and "Leave empty".
- *
- * {@link focusQuietly} marks the element for the length of its synchronous `focus()` call;
- * a picker's `onFocus` asks {@link isQuietFocus} and, when it is, takes the focus without
- * opening. React dispatches `onFocus` inside the native `focusin`, which `focus()` fires
- * synchronously, so the mark is seen by exactly that focus and by no later one. A click or
- * Tab of the person's own opens as before; from a quiet focus, ArrowDown, typing or a click
- * opens the list.
- */
-let quiet: Element | null = null;
-
-/** `el.focus(options)`, telling the kit's open-on-focus pickers not to open. */
-export function focusQuietly(el: HTMLElement, options?: FocusOptions): void {
-  const before = quiet;
-  quiet = el;
-  try {
-    el.focus(options);
-  } finally {
-    quiet = before;
-  }
-}
-
-/** True while `el` is being focused by {@link focusQuietly}. */
-export function isQuietFocus(el: Element): boolean {
-  return quiet === el;
-}

package/src/lib/reduced-motion.ts

@@ -1,22 +0,0 @@
-/**
- * Whether the user has asked for no motion (`prefers-reduced-motion: reduce`), read NOW —
- * not at mount: the setting can change under a long-lived page. The kit's one copy
- * (DUP-11, refactor audit 2026-10: the settings focus and the exit timers each had their
- * own, with opposite answers where `matchMedia` is missing).
- *
- * Where there is no `matchMedia` to ask (SSR, jsdom) the answer is `whereUnknown`,
- * default `false`: motion allowed — the platform's own default, `no-preference`, which
- * is what a browser that cannot say otherwise has. A smooth scroll there is harmless.
- *
- * An exit animation passes `true` (`skipsExitAnimation` in `hooks/use-close-transition`):
- * without `matchMedia` nothing is painting, and a timer that holds an unpainted panel on
- * screen only delays its `onClose` — every test suite, the kit's and the apps', reads a
- * closed overlay as gone at once.
- *
- * Public since 0.52 (DUP-8, refactor audit 2026-10-30): Kurvenschmiede's chain animation
- * carried a copy of its own.
- */
-export function prefersReducedMotion(whereUnknown = false): boolean {
-  if (typeof window === "undefined" || typeof window.matchMedia !== "function") return whereUnknown;
-  return window.matchMedia("(prefers-reduced-motion: reduce)").matches;
-}

package/src/lib/refs.ts

@@ -1,22 +0,0 @@
-/** Internal (not exported from the package): the kit's ref plumbing. Here, rather than in
- *  components/field-parts (which re-exports both), since round 0.35: Tooltip needs them,
- *  and field-parts renders a Tooltip, so importing them from there closed a cycle. */
-import type { Ref, RefCallback } from "react";
-
-/** Point a ref — a callback or an object — at `node`. `undefined` and `null` are no ref. */
-export function assignRef<T>(ref: Ref<T> | undefined, node: T | null): void {
-  if (typeof ref === "function") ref(node);
-  else if (ref) (ref as { current: T | null }).current = node;
-}
-
-/**
- * One callback ref feeding several — the caller's forwarded `ref` and a field's own
- * (DUP-11: AmountInput, FormActions, ScrollArea and SearchField each wrote this by hand).
- * Wrap it in `useCallback` (or `useMemo`) over the same refs where a new callback every
- * render would detach and re-attach the node.
- */
-export function mergeRefs<T>(...refs: Array<Ref<T> | undefined>): RefCallback<T> {
-  return (node) => {
-    for (const ref of refs) assignRef(ref, node);
-  };
-}

package/src/lib/round.ts

@@ -1,43 +0,0 @@
-/**
- * Decimal rounding, half away from zero — the one copy behind {@link roundToCurrency}
- * and AmountInput's settle (BUG-11, refactor audit 2026-10).
- *
- * Package-private — not re-exported from the barrel; `format.ts` and `calc.ts` are
- * re-exported wholesale, so a helper there would become API.
- *
- * WHY THE STRING SHIFT. `Math.round(1.005 * 100)` is 100, because 1.005 is 1.00499…
- * in binary. Shifting the decimal point in the number's SHORTEST spelling instead
- * ("1.005e2" is exactly 100.5) rounds the figure a person typed. Both helpers did that
- * by gluing `e${digits}` onto `String(n)` — but `String(n)` is itself in exponent form
- * below 1e-6 and at or above 1e21, and "5.55e-17e2" is NaN: `roundToCurrency(0.1 + 0.2
- * - 0.3, "EUR")` was NaN, and AmountInput blanked a typed "0.0000001" on blur (U-2's
- * class, 2026-08-24). {@link shiftDecimal} moves the exponent the string already has.
- */
-
-/** `value × 10^by`, by moving the exponent of its shortest spelling ("1.005" → "1.005e2",
- *  "5.55e-17" → "5.55e-15"), so no binary multiplication creeps in. */
-function shiftDecimal(value: number, by: number): number {
-  const [mantissa, exponent = "0"] = String(value).split("e");
-  return Number(`${mantissa}e${Number(exponent) + by}`);
-}
-
-/**
- * `n` rounded to `digits` decimals, half away from zero, in decimal arithmetic:
- * 1.005 → 1.01, -2.5 at 0 → -3. Never NaN for a finite `n`, and never -0 — `formatMoney`
- * prints -0 as "-0,00 €", so a negative that rounds away comes back as 0. A non-finite
- * `n` comes back unchanged. `digits` counts in whole decimals, as `toFixed` takes it: 2.5
- * is 2, and NaN is 0.
- */
-export function roundHalfAway(n: number, digits: number): number {
-  if (!Number.isFinite(n)) return n;
-  // "1.2345e2.5" is NaN, and `|| 0` below made it 0: MeasuredGrid's `digits`, which went to
-  // `toFixed` before DUP-14 brought it here, wrote every computed cell of a table with a
-  // fractional one as "0" (0.52 code review, deep, charts, finding 5).
-  const places = Math.trunc(digits) || 0;
-  const abs = Math.abs(n);
-  // Every double from 2^53 up is a whole number already, and scaling one near
-  // Number.MAX_VALUE up would overflow to Infinity.
-  const magnitude = abs >= 2 ** 53 ? abs : shiftDecimal(Math.round(shiftDecimal(abs, places)), -places);
-  // The sign goes back on after rounding, so `|| 0` must see the signed result.
-  return (n < 0 ? -magnitude : magnitude) || 0;
-}

package/src/lib/safe-storage.ts

@@ -1,119 +0,0 @@
-/**
- * `localStorage` that cannot take the page down with it.
- *
- * Accessing `window.localStorage` **throws** — rather than returning null — when a
- * browser has site data blocked: Safari private browsing, Chrome with third-party
- * site data disabled, a partitioned webview. Three places in this package already
- * knew that and wrapped their calls in try/catch (`logger.ts`, and the DataTable's
- * `loadPersisted`/`savePersisted`). One did not: `AppShell` read the sidebar's
- * collapse flag straight out of a `useState` initialiser, so the throw happened
- * during render of the application's top-level shell. That is not a lost preference
- * — nothing mounts, in every consumer of this package at once.
- *
- * So the guard lives here, once, and the next storage-backed preference cannot
- * forget it. A read that cannot happen is indistinguishable from a key that was
- * never set, which is the right answer for every caller: the default.
- *
- * Since 0.34 (DUP-11, refactor audit 2026-10) it also removes, and guards
- * `sessionStorage` the same way: `landing/routing`, `billing/checkout-processing` and
- * the demo banner each wrote that guard again by hand.
- *
- * Since 0.52 all of it but {@link storedKeys} is public, with a JSON pair beside it
- * (DUP-8, refactor audit 2026-10-30). Kept package-private, the guard was written again
- * four times in the kit's showcase and in 16 files across the three apps, some of them
- * without it: a token read that throws where storage is blocked takes every request
- * down with it. (The kit's own DevMenu, 0.51, wrote the session pair a second time too.)
- */
-
-/** `access` on the storage area, or `fallback` where there is none (SSR) or it throws. */
-function guarded<T>(area: "localStorage" | "sessionStorage", fallback: T, access: (storage: Storage) => T): T {
-  if (typeof window === "undefined") return fallback;
-  try {
-    return access(window[area]);
-  } catch {
-    // private mode, quota, partitioned or blocked storage
-    return fallback;
-  }
-}
-
-/** The stored string for `key`, or null when absent, unreadable, or blocked. */
-export function readStored(key: string): string | null {
-  return guarded("localStorage", null, (storage) => storage.getItem(key));
-}
-
-/** Store `value` under `key`, silently doing nothing when storage is unavailable
- *  or full. A preference that cannot be persisted is not worth an exception. `null`
- *  removes the key, as {@link writeSessionStored}'s does (0.52; the two pairs wrote
- *  differently, and `null` past the types stored the string "null" — 0.52 code review). */
-export function writeStored(key: string, value: string | null): void {
-  guarded("localStorage", undefined, (storage) =>
-    value === null ? storage.removeItem(key) : storage.setItem(key, value),
-  );
-}
-
-/** Forget `key`, silently doing nothing when storage is blocked — there is nothing to
- *  forget then. */
-export function removeStored(key: string): void {
-  guarded("localStorage", undefined, (storage) => storage.removeItem(key));
-}
-
-/** {@link readStored} for `sessionStorage`: this tab's value, or null. */
-export function readSessionStored(key: string): string | null {
-  return guarded("sessionStorage", null, (storage) => storage.getItem(key));
-}
-
-/** {@link writeStored} for `sessionStorage`; `null` removes the key. */
-export function writeSessionStored(key: string, value: string | null): void {
-  guarded("sessionStorage", undefined, (storage) =>
-    value === null ? storage.removeItem(key) : storage.setItem(key, value),
-  );
-}
-
-/**
- * The JSON stored under `key`, when it parses and `isShape` accepts it; else `null`. Absent,
- * blocked, malformed and another shape all read as "never set" — the caller's default —
- * which is what the six hand-written `JSON.parse(readStored(key))` reads in the kit each
- * answered in their own try/catch (DUP-8). `isShape` gets the parsed value as `unknown`:
- * the shape check is the one part that is the caller's. A shape check that throws reads
- * as another shape: null.
- */
-export function readStoredJson<T>(key: string, isShape: (value: unknown) => value is T): T | null {
-  const text = readStored(key);
-  if (text === null) return null;
-  try {
-    const value: unknown = JSON.parse(text);
-    return isShape(value) ? value : null;
-  } catch {
-    // not JSON, or a shape check that read past what is there
-    return null;
-  }
-}
-
-/** Store `value` as JSON under `key`, silently doing nothing when storage is unavailable
- *  or full, or the value has no JSON form (a cycle, a BigInt) — {@link writeStored}'s rule. */
-export function writeStoredJson(key: string, value: unknown): void {
-  let text: string | undefined;
-  try {
-    text = JSON.stringify(value);
-  } catch {
-    return;
-  }
-  // `undefined` (and a function) has no JSON form either: stringify answers undefined.
-  if (text !== undefined) writeStored(key, text);
-}
-
-/**
- * Every key in `area` that starts with `prefix`, or `[]` where storage refuses — for the
- * reset of this device's settings, which removes a table's views by their prefix
- * (docs/settings-harmonization.md §11.4). Package-private: the reset's alone.
- */
-export function storedKeys(prefix: string, area: "local" | "session" = "local"): string[] {
-  return guarded(area === "session" ? "sessionStorage" : "localStorage", [], (storage) => {
-    const keys: string[] = [];
-    for (let i = 0; i < storage.length; i++) {
-      const key = storage.key(i);
-      if (key !== null && key.startsWith(prefix)) keys.push(key);
-    }
-    return keys;
-  });
-}