@eifi1/ui-kit 0.53.0 → 0.55.0

package/src/lib/chip-edge-snap.ts

@@ -1,212 +0,0 @@
-// Chip's edge snapping: the module-level engine (one ResizeObserver, one `resize`
-// listener and one resolution query for every snapped chip on the page, and the state
-// they share) and the hook a chip hangs it on. Moved out of components/chip.tsx as it
-// was (MOD-9, refactor audit 2026-10); chip.tsx still exports `refreshChipEdges`.
-import { useCallback, useLayoutEffect, useRef } from "react";
-
-/* ── Edge snapping (fractional device-pixel ratios) ──────────────────────────
- *
- * WHY. At a device-pixel ratio of 1.25 (a 125 % Windows display, or 125 % browser
- * zoom) Chrome snaps a box to whole CSS pixels and only then scales it, so a 1px
- * border is 1.25 device pixels wide and starts at a quarter-pixel phase that depends
- * on where the edge lands. A chip's left edge follows whatever stands before it, its
- * right edge follows its own text, so the two land on unrelated phases: one rasterises
- * as a crisp pixel, the other as a two-pixel smear at half strength — and a 60 %-alpha
- * border (`--danger-border`) makes the smeared side read as a THINNER line (keksdose
- * dev #576).
- *
- * WHAT FIXES IT. The two edges rasterise as mirror images exactly when their device
- * positions sum to a whole number: `(2·left + width) · dpr` integral, `left` being the
- * edge's snapped CSS x. Rounding the WIDTH alone to the ratio's grid (4px at 1.25)
- * makes the phases EQUAL, which is not the same thing: measured with keksdose's
- * playwright harness across every left phase at 1.25, width-only rounding mirrored the
- * edges at two of the four phases and left the other two as lopsided as before (mean
- * peak asymmetry 16.5, worse than the unsnapped 10.9 a random width gets by luck); the
- * position-aware width below took it to 0 at every phase. Inset rings, whole-pixel
- * starts, compositing hints and fractional border widths were measured by keksdose
- * and do not help — Chrome rounds a sub-pixel border back up to 1px.
- *
- * So the fix needs the chip's position, which is why it is opt-in (`snapEdges`): it
- * reads layout. Cheaply — every snapped chip on the page shares one ResizeObserver,
- * one `resize` listener and one resolution media query, and a pass is batched into a
- * frame as read-all / write-all, not a forced layout per chip. At an integer ratio,
- * and at a half one (1.5, 2.5: grid 2 — measured symmetric already, both edges a
- * pixel and a half on the same pattern), there is nothing to fix and a pass
- * writes nothing.
- */
-
-/** The smallest whole CSS-pixel count `n` with `n × dpr` whole — 4 at 1.25, 2 at 1.5,
- *  1 at an integer ratio. 0 for a ratio no step up to 4px fits (110 % zoom wants 10px;
- *  a chip growing by up to 9px is a layout change, not a hairline fix). */
-function chipEdgeGrid(dpr: number): number {
-  for (let n = 1; n <= 4; n++) if (Math.abs(n * dpr - Math.round(n * dpr)) < 1e-3) return n;
-  return 0;
-}
-
-/**
- * The width (whole CSS px, at least `natural`) that mirrors a box's two edges at
- * `dpr`, for a box whose left edge sits at CSS x `left`. `natural` back when the ratio
- * needs nothing.
- */
-function snappedChipEdgeWidth(natural: number, left: number, dpr: number): number {
-  const n = chipEdgeGrid(dpr);
-  if (n <= 2) return natural;
-  const l = Math.round(left);
-  // A hair under a whole pixel is that pixel: 59.999 is a 60px chip, not a 61px one.
-  let w = Math.ceil(natural - 0.01);
-  while ((((2 * l + w) % n) + n) % n !== 0) w++;
-  return w;
-}
-
-const snapped = new Set<HTMLElement>();
-/** The min-width each chip was given by a pass — so a pass only ever clears its own. */
-const written = new WeakMap<HTMLElement, string>();
-let snapFrame = 0;
-let snapObserver: ResizeObserver | null = null;
-let ratioQuery: MediaQueryList | null = null;
-
-function clearOwn(el: HTMLElement) {
-  const own = written.get(el);
-  if (own !== undefined && el.style.minWidth === own) el.style.minWidth = "";
-  written.delete(el);
-}
-
-/**
- * Re-snap every chip rendered with `snapEdges`, now. The kit already re-snaps when a
- * chip renders, resizes, or the window or the ratio changes; call this after moving
- * chips some other way (a side panel sliding in beside a table of status chips),
- * since a move is not something an observer can see.
- */
-export function refreshChipEdges(): void {
-  if (snapFrame) {
-    cancelAnimationFrame(snapFrame);
-    snapFrame = 0;
-  }
-  if (typeof window === "undefined" || !snapped.size) return;
-  const dpr = window.devicePixelRatio || 1;
-  const els = [...snapped];
-  // Write: back to the natural width, so what is read below is the chip, not our pin.
-  for (const el of els) clearOwn(el);
-  const n = chipEdgeGrid(dpr);
-  if (n <= 2) return;
-  // A chip whose own end decides where it starts (RTL, `justify-end`) moves when it
-  // grows, so a pass re-reads what it wrote and steps on by a pixel until the edges
-  // agree — `n` steps cover every residue. Each pass is ONE layout for every chip
-  // together. A chip that never agrees (a centred one moves both edges at once) is
-  // given its natural width back rather than kept wider for nothing.
-  let pending = els;
-  for (let pass = 0; pass <= n && pending.length; pass++) {
-    const reads = pending.map((el) => {
-      const r = el.getBoundingClientRect();
-      // The text label (chip.tsx's CHIP_LABEL_TRUNCATE; `.truncate` before 0.33).
-      const label = el.querySelector<HTMLElement>(".truncate-until-large");
-      // Not laid out (a hidden ancestor, jsdom), or truncated at its container's edge,
-      // where a wider chip would overflow: leave it alone. So too a label wrapped onto
-      // a second line at Large (0.32.1): the chip is already as wide as its row lets it
-      // be, and a min-width past that would push it over the edge just the same.
-      if (!r.width || (label && (label.scrollWidth > label.clientWidth || labelWraps(label)))) return null;
-      const width = Math.round(r.width * 64) / 64;
-      const target = snappedChipEdgeWidth(width, r.left + window.scrollX, dpr);
-      return target === width ? null : target;
-    });
-    const next: HTMLElement[] = [];
-    pending.forEach((el, i) => {
-      const target = reads[i];
-      if (target == null) return;
-      if (pass === n) {
-        clearOwn(el);
-        return;
-      }
-      const own = written.get(el);
-      const value = `${pass > 0 && own !== undefined ? parseFloat(own) + 1 : target}px`;
-      el.style.minWidth = value;
-      written.set(el, value);
-      next.push(el);
-    });
-    pending = next;
-  }
-}
-
-/** Whether a chip's label runs to more than one line — taller than one and a half of
- *  its line height. A line height of `normal` (no number to compare) counts as one line. */
-function labelWraps(label: HTMLElement): boolean {
-  const line = Number.parseFloat(getComputedStyle(label).lineHeight);
-  return line > 0 && label.clientHeight > 1.5 * line;
-}
-
-function scheduleChipEdges() {
-  if (snapFrame || typeof requestAnimationFrame === "undefined") return;
-  snapFrame = requestAnimationFrame(() => {
-    snapFrame = 0;
-    refreshChipEdges();
-  });
-}
-
-/** The resolution query for the CURRENT ratio: it stops matching when the ratio
- *  changes (a window dragged to another display), which a `resize` need not fire. */
-function watchRatio() {
-  ratioQuery?.removeEventListener("change", onRatioChange);
-  ratioQuery =
-    typeof window.matchMedia === "function"
-      ? window.matchMedia(`(resolution: ${window.devicePixelRatio || 1}dppx)`)
-      : null;
-  ratioQuery?.addEventListener("change", onRatioChange);
-}
-
-function onRatioChange() {
-  watchRatio();
-  scheduleChipEdges();
-}
-
-function registerSnap(el: HTMLElement) {
-  if (snapped.has(el)) return;
-  if (!snapped.size) {
-    if (typeof ResizeObserver !== "undefined") snapObserver = new ResizeObserver(scheduleChipEdges);
-    window.addEventListener("resize", scheduleChipEdges);
-    watchRatio();
-  }
-  snapped.add(el);
-  snapObserver?.observe(el);
-  scheduleChipEdges();
-}
-
-function unregisterSnap(el: HTMLElement) {
-  if (!snapped.delete(el)) return;
-  snapObserver?.unobserve(el);
-  clearOwn(el);
-  if (snapped.size) return;
-  snapObserver?.disconnect();
-  snapObserver = null;
-  window.removeEventListener("resize", scheduleChipEdges);
-  ratioQuery?.removeEventListener("change", onRatioChange);
-  ratioQuery = null;
-}
-
-/** The ref a chip hangs on its visible pill, plus a re-snap after every render (its
- *  label or its neighbours may have changed). */
-export function useSnapEdges(on: boolean) {
-  const node = useRef<HTMLElement | null>(null);
-  const ref = useCallback(
-    (el: HTMLElement | null) => {
-      if (el === node.current) return;
-      const prev = node.current;
-      node.current = el;
-      // React detaches and re-attaches a ref whose callback changed identity (a
-      // consumer's inline ref) — the same element, a moment apart. Unregistering on
-      // the detach would clear the pin and paint one frame unsnapped, so the drop
-      // waits a microtask and is skipped if the element came straight back.
-      if (prev) queueMicrotask(() => node.current !== prev && unregisterSnap(prev));
-      if (el && on) registerSnap(el);
-    },
-    [on],
-  );
-  useLayoutEffect(() => {
-    const el = node.current;
-    if (!el) return;
-    if (on) {
-      registerSnap(el);
-      scheduleChipEdges();
-    } else unregisterSnap(el);
-  });
-  return ref;
-}

package/src/lib/clipboard-minus.ts

@@ -1,107 +0,0 @@
-/**
- * The copy handler for the one minus sign (0.49 KIT-1b, Marcel's follow-up to KIT-1).
- *
- * The kit prints a negative with U+2212 (lib/minus.ts). A spreadsheet does not read that
- * 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", "−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.
- *
- * Installed once per document by `UiKitProvider` (`copyAsciiMinus`, default `true`) —
- * the one part every app mounts, the signed-out pages included.
- */
-
-/**
- * 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
- * hyphen-minus, every other character as it was — for text an app hands a machine that
- * did not come from a formatter's `minus: "ascii"`.
- */
-export function asciiMinusInNumbers(text: string): string {
-  return text.replace(MINUS_BEFORE_NUMBER, "-");
-}
-
-function hasMinusBeforeNumber(text: string): boolean {
-  MINUS_BEFORE_NUMBER.lastIndex = 0;
-  const found = MINUS_BEFORE_NUMBER.test(text);
-  MINUS_BEFORE_NUMBER.lastIndex = 0;
-  return found;
-}
-
-/** An input, a textarea or an editable element: a copy there is the person's own text. */
-function isEditable(node: Node | null | undefined): boolean {
-  const el = node instanceof Element ? node : node?.parentElement;
-  if (!el) return false;
-  if (el.closest("input, textarea, select")) return true;
-  return (
-    (el as HTMLElement).isContentEditable === true ||
-    el.closest('[contenteditable=""], [contenteditable="true"]') !== null
-  );
-}
-
-/** Table parts copied alone are wrapped back into a table, which Excel reads as cells. */
-function wrapTableParts(container: HTMLElement): string {
-  const first = container.firstElementChild?.tagName;
-  const html = container.innerHTML;
-  if (first === "TD" || first === "TH") return `<table><tbody><tr>${html}</tr></tbody></table>`;
-  if (first === "TR") return `<table><tbody>${html}</tbody></table>`;
-  if (first === "TBODY" || first === "THEAD" || first === "TFOOT") return `<table>${html}</table>`;
-  return html;
-}
-
-function onCopy(event: ClipboardEvent): void {
-  if (event.defaultPrevented || !event.clipboardData) return;
-  const doc = (event.target as Node | null)?.ownerDocument ?? document;
-  if (isEditable(event.target as Node | null) || isEditable(doc.activeElement)) return;
-  const selection = doc.getSelection();
-  if (!selection || selection.rangeCount === 0 || selection.isCollapsed) return;
-  if (isEditable(selection.anchorNode) || isEditable(selection.focusNode)) return;
-  const text = selection.toString();
-  if (!hasMinusBeforeNumber(text)) return;
-
-  const container = doc.createElement("div");
-  for (let i = 0; i < selection.rangeCount; i++) container.appendChild(selection.getRangeAt(i).cloneContents());
-  const walker = doc.createTreeWalker(container, NodeFilter.SHOW_TEXT);
-  for (let node = walker.nextNode(); node; node = walker.nextNode()) {
-    node.nodeValue = asciiMinusInNumbers(node.nodeValue ?? "");
-  }
-  event.clipboardData.setData("text/plain", asciiMinusInNumbers(text));
-  event.clipboardData.setData("text/html", wrapTableParts(container));
-  event.preventDefault();
-}
-
-const installs = new WeakMap<Document, number>();
-
-/**
- * Listen for copies on `doc` until the returned function is called. Counted: nested
- * providers install it once, and the last one to go removes it.
- */
-export function installClipboardMinus(doc: Document = document): () => void {
-  const count = installs.get(doc) ?? 0;
-  if (count === 0) doc.addEventListener("copy", onCopy);
-  installs.set(doc, count + 1);
-  let done = false;
-  return () => {
-    if (done) return;
-    done = true;
-    const left = (installs.get(doc) ?? 1) - 1;
-    installs.set(doc, left);
-    if (left === 0) doc.removeEventListener("copy", onCopy);
-  };
-}

package/src/lib/clipping.ts

@@ -1,34 +0,0 @@
-/** Internal (not exported from the package): the Tooltip's auto-portal check. The
- *  attribute name itself IS exported, as `CLIPS_ATTRIBUTE` from the tooltip module. */
-
-/**
- * The explicit "this element clips or scrolls" marker. A container carrying it counts
- * as clipping whatever its computed `overflow` says.
- *
- * Why a marker as well as the computed style: the kit's containers get their
- * `overflow` from Tailwind classes, and jsdom computes no stylesheet — so under test
- * every scroller reads `overflow: visible`, the Tooltip stays in place, and its always-
- * mounted bubble shows up in the cell's text (keksdose 0.10: "CheckingChecking"). The
- * browser and the test then disagreed about where the bubble lives, and apps pinned
- * `portal` on every tooltip in a table to make them agree. The kit's own scrollers
- * (DataTable's body, Table's wrapper) carry the marker, so the answer is the same in
- * both; an app marks its own with `{ [CLIPS_ATTRIBUTE]: "" }` or a literal `data-clips`.
- */
-export const CLIPS_ATTRIBUTE = "data-clips";
-
-/** Whether anything between `el` and `<body>` clips or scrolls its content — the
- *  containers an absolutely positioned bubble would be cut off by, or would widen.
- *  Either the computed `overflow` says so or the element carries
- *  {@link CLIPS_ATTRIBUTE}. `<body>` and `<html>` are not counted: their `overflow`
- *  belongs to the viewport (a dialog's scroll lock sets it), and the viewport clips a
- *  portalled bubble just the same. */
-export function hasClippingAncestor(el: Element | null): boolean {
-  if (typeof window === "undefined" || !el) return false;
-  for (let node = el.parentElement; node; node = node.parentElement) {
-    if (node === document.body || node === document.documentElement) return false;
-    if (node.hasAttribute(CLIPS_ATTRIBUTE)) return true;
-    const style = window.getComputedStyle(node);
-    if (style.overflowX !== "visible" || style.overflowY !== "visible") return true;
-  }
-  return false;
-}

package/src/lib/cn.ts

@@ -1,28 +0,0 @@
-import { clsx } from "clsx";
-import { extendTailwindMerge } from "tailwind-merge";
-
-/**
- * tailwind-merge, told about the kit's own font sizes (docs/text-size-harmonization.md
- * §3.2): `text-micro` and `text-caption` are `@theme` sizes in tokens.css, which
- * tailwind-merge cannot see. Unknown, a `text-<word>` is taken for a COLOUR, so
- * `cn("text-caption text-[var(--text-muted)]")` dropped the size — the later colour
- * "won" over it — and `cn("text-xs", "text-caption")` kept both sizes. Registered as
- * sizes, they merge like `text-xs`: a later size replaces an earlier one, a colour sits
- * beside them.
- *
- * The same for the focus frame's width (0.34, refactor audit DOC-7): `ring-focus` and
- * `outline-focus` are `@theme inline` WIDTHS, and unknown, a `ring-<word>` is taken for a
- * colour — so `cn(FOCUS_RING, "focus-visible:ring-strong")` dropped the width and the
- * ring was gone. Registered as widths, they merge like `ring-2` / `outline-2`, as the
- * arbitrary `length:` widths they replaced did. (No class is spelt out here: an app's
- * Tailwind scans the built source maps too, and would generate it.)
- */
-const merge = extendTailwindMerge({
-  extend: {
-    theme: { text: ["micro", "caption"] },
-    classGroups: { "ring-w": [{ ring: ["focus"] }], "outline-w": [{ outline: ["focus"] }] },
-  },
-});
-
-/** Merge class lists with Tailwind conflict resolution (later wins). */
-export const cn = (...inputs: Parameters<typeof clsx>) => merge(clsx(inputs));

package/src/lib/column-mapping.ts

@@ -1,234 +0,0 @@
-/**
- * Which column of a table plays which part — the headless half of {@link ColumnMapper}.
- *
- * Two apps built this by hand, the same way. Kurvenschmiede's columns input
- * (`features/control/columns-input.tsx`) reads a recorder's export and asks which
- * column is the time, the setpoint and the actual; keksdose's bank-file import
- * (`import-map-step.tsx`, `use-file-import.ts`) shows a bank's CSV and asks which
- * column is the booking date, the amount, the payee. Both then have the same four
- * rules, and keksdose wrote them down after getting each one wrong once:
- *
- * * **A role sits on one column at most, and a column carries one role.** Picking a
- *   role for a column MOVES it there from wherever it was ({@link assignColumnRole});
- *   the column it left falls back to "ignore" in the same step. There is no error
- *   state, because there is nothing wrong to report.
- * * **What is still missing is named**, not left to a disabled button
- *   ({@link missingRoles}). A required role can be one of a group: a bank export that
- *   splits debit and credit has no amount column and needs none, so `required` may
- *   name a group, satisfied by any one of its members (keksdose's "money").
- * * **A mapping is indexes into ONE table.** When the column count changes, the
- *   indexes mean nothing any more and are guessed afresh; when it does not (the
- *   header line toggled), they still point where they did — keksdose's `keepRoles`.
- * * **The rows a role cannot read are reported by line**, not dropped in silence
- *   ({@link readMappedTable}): a footer under a recording, a total under a statement.
- *
- * Pure functions over plain data, so a two-step wizard can hold the mapping in its own
- * state between steps, and a table the server sniffed (keksdose's) can be mapped with
- * the same rules as one parsed here.
- */
-import { tableNumber } from "./table-text";
-import type { TableLine, TextTable } from "./table-text";
-
-/** One part a column can play, defined by the caller. */
-export interface ColumnRole<R extends string = string> {
-  /** The key the mapping is stored under. */
-  value: R;
-  /** What the role select shows — translated by the caller. */
-  label: string;
-  /**
-   * `true`: the table cannot be used until a column plays this role. A string names a
-   * GROUP: the table needs any one of the roles that share it — keksdose's amount,
-   * debit and credit, any of which carries the money.
-   */
-  required?: boolean | string;
-  /**
-   * Every cell this role reads must be a number in the table's decimal convention
-   * ({@link tableNumber}). A row where one is not — a footer, a units line, a total
-   * with a grouping mark — is moved to `unread` with its line number instead of being
-   * handed over. Kurvenschmiede's time, setpoint and actual. The cells stay strings:
-   * converting is the caller's, with `tableNumber(cell, result.decimalComma)`.
-   */
-  numeric?: boolean;
-}
-
-/** Role → column index. A role that is absent or `null` sits on no column — so a
- *  mapping with nullable fields (keksdose's `CsvMapping`) is one as it stands. */
-export type ColumnMapping<R extends string = string> = Partial<Record<R, number | null>>;
-
-/** What the table is, read through a mapping. */
-export interface ColumnMapperResult<R extends string = string> extends TextTable {
-  mapping: ColumnMapping<R>;
-  /** What the table still needs before it can be used: one entry per gap, each the
-   *  roles any of which would fill it (one role, or a required group). */
-  missing: R[][];
-  /** Every required role placed, and at least one row read. */
-  complete: boolean;
-}
-
-const placedAt = <R extends string>(mapping: ColumnMapping<R>, role: R, width?: number): number | null => {
-  const column = mapping[role];
-  if (typeof column !== "number") return null;
-  return width === undefined || column < width ? column : null;
-};
-
-/** The role on this column, or `null` for an ignored one. */
-export function roleOfColumn<R extends string>(
-  roles: readonly ColumnRole<R>[],
-  mapping: ColumnMapping<R>,
-  column: number,
-): R | null {
-  return roles.find((role) => mapping[role.value] === column)?.value ?? null;
-}
-
-/**
- * Put `role` on `column` — or, with `null`, take the column's role off it.
- *
- * Whatever this column played before stops, and the role moves here from any other
- * column, in one new mapping (keksdose's `assignColumn`: "both halves are patches to
- * the same object"). Other fields of the mapping are kept as they are.
- */
-export function assignColumnRole<R extends string, M extends ColumnMapping<R>>(
-  roles: readonly ColumnRole<R>[],
-  mapping: M,
-  column: number,
-  role: R | null,
-): M {
-  const next = { ...mapping } as Record<string, unknown>;
-  for (const { value } of roles) {
-    if (mapping[value] === column) next[value] = null;
-  }
-  if (role !== null) next[role] = column;
-  return next as M;
-}
-
-/**
- * The gaps: each required role with no column, and each required group none of whose
- * roles has one. In the order of `roles`. A column index past `width` is no column.
- */
-export function missingRoles<R extends string>(
-  roles: readonly ColumnRole<R>[],
-  mapping: ColumnMapping<R>,
-  width?: number,
-): R[][] {
-  const gaps: R[][] = [];
-  const groups = new Set<string>();
-  for (const role of roles) {
-    if (role.required === true) {
-      if (placedAt(mapping, role.value, width) === null) gaps.push([role.value]);
-    } else if (typeof role.required === "string" && !groups.has(role.required)) {
-      groups.add(role.required);
-      const members = roles.filter((other) => other.required === role.required);
-      if (members.every((member) => placedAt(mapping, member.value, width) === null)) {
-        gaps.push(members.map((member) => member.value));
-      }
-    }
-  }
-  return gaps;
-}
-
-const normalised = (text: string) => text.trim().toLowerCase();
-
-/**
- * A first mapping for a table nobody has mapped yet.
- *
- * A column whose header IS a role's label or key gets that role. The required roles
- * left over then take the free columns in order — Kurvenschmiede's "time, setpoint,
- * actual are the first three columns", which is how a recorder writes them. Optional
- * roles are not guessed by position: in a bank
- * export of twelve columns, "the fourth role is the fourth column" is a wrong answer
- * presented as a suggestion, and an "ignore" is the honest one.
- */
-export function guessMapping<R extends string>(
-  roles: readonly ColumnRole<R>[],
-  header: readonly string[] | null,
-  width: number,
-): ColumnMapping<R> {
-  const mapping: ColumnMapping<R> = {};
-  const taken = new Set<number>();
-  if (header) {
-    for (const role of roles) {
-      const names = [normalised(role.label), normalised(role.value)];
-      const column = header.findIndex((name, index) => !taken.has(index) && names.includes(normalised(name)));
-      if (column >= 0) {
-        mapping[role.value] = column;
-        taken.add(column);
-      }
-    }
-  }
-  const free = Array.from({ length: width }, (_, index) => index).filter((index) => !taken.has(index));
-  for (const role of roles) {
-    if (role.required !== true || typeof mapping[role.value] === "number") continue;
-    const column = free.shift();
-    if (column === undefined) break;
-    mapping[role.value] = column;
-  }
-  return mapping;
-}
-
-/**
- * The table read through the mapping: the rows every `numeric` role can read, the
- * others moved to `unread` (in line order, with the parse's own), what is missing,
- * and whether the table can be used. Column indexes past the table's width count as
- * unplaced.
- */
-export function readMappedTable<R extends string>(
-  table: TextTable,
-  roles: readonly ColumnRole<R>[],
-  mapping: ColumnMapping<R>,
-): ColumnMapperResult<R> {
-  const numeric = roles
-    .filter((role) => role.numeric)
-    .map((role) => placedAt(mapping, role.value, table.width))
-    .filter((column): column is number => column !== null);
-  const rows: string[][] = [];
-  const lines: TableLine[] = [];
-  const refused: TableLine[] = [];
-  table.rows.forEach((row, index) => {
-    if (numeric.every((column) => Number.isFinite(tableNumber(row[column] ?? "", table.decimalComma)))) {
-      rows.push(row);
-      lines.push(table.lines[index]);
-    } else {
-      refused.push(table.lines[index]);
-    }
-  });
-  const unread = refused.length ? [...table.unread, ...refused].sort((a, b) => a.line - b.line) : table.unread;
-  const missing = missingRoles(roles, mapping, table.width);
-  return {
-    ...table,
-    rows,
-    lines,
-    unread,
-    mapping,
-    missing,
-    complete: missing.length === 0 && rows.length > 0,
-  };
-}
-
-/**
- * A dropped or chosen file's text — UTF-8 when it is UTF-8, else Windows-1252.
- *
- * A German bank or bench export is very often written in Windows-1252, and reading it
- * as UTF-8 turns every "ä" in a column name into "�" — no error, just a header nobody
- * recognises. So the bytes are tried as strict UTF-8 first and read as Windows-1252
- * when that fails (keksdose's server sniffs the encoding for the same reason; a file
- * read in the browser had nothing doing it). Falls back to `FileReader` where a `File`
- * has no `arrayBuffer` (Kurvenschmiede's `readText`).
- */
-export async function readTextFile(file: Blob): Promise<string> {
-  const bytes = await bytesOf(file);
-  try {
-    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
-  } catch {
-    return new TextDecoder("windows-1252").decode(bytes);
-  }
-}
-
-function bytesOf(file: Blob): Promise<ArrayBuffer> {
-  if (typeof file.arrayBuffer === "function") return file.arrayBuffer();
-  return new Promise((resolve, reject) => {
-    const reader = new FileReader();
-    reader.onload = () => resolve(reader.result as ArrayBuffer);
-    reader.onerror = () => reject(reader.error ?? new Error("read failed"));
-    reader.readAsArrayBuffer(file);
-  });
-}