@eifi1/ui-kit 0.53.0 → 0.54.0

package/src/account/delete-account-setting.tsx

@@ -146,8 +146,9 @@ function isConsequence(item: DeleteAccountConsequence): item is DangerConsequenc
  * and the password. They are the tile's own {@link TypedConfirmField} and
  * {@link CurrentPasswordInput}, drawn in its fields slot and held by
  * `confirmDisabledReason` with the tile's own sentences, rather than its built-in
- * `phrase` / `requirePassword` — those have no error of their own, and a wrong password
- * belongs under the password. Its consequences are the app's list, plus
+ * `phrase` / `requirePassword` — those share ONE `error` (0.54, under the password), and
+ * this card's refusals go to two fields: a wrong password under the password, a
+ * mismatched address under the address. Its consequences are the app's list, plus
  * Kurvenschmiede's hand-over line (`handOverCount`, §2.7: shared work goes to an
  * administrator, never a refusal). The typed address goes to `onRequest` as typed, so
  * the server re-checks it (`confirm_email_matches`).

package/src/auth/auth-errors.ts

@@ -1,3 +1,4 @@
+import type { BillingLabels } from "../billing/billing-labels";
 import { httpStatusOf } from "../lib/http-status";
 
 /**
@@ -254,6 +255,74 @@ export function isBillingError(err: unknown, code?: BillingErrorCode): boolean {
   return found !== undefined && BILLING_CODES.has(found as BillingErrorCode) && (code === undefined || found === code);
 }
 
+/** Who reads a `billing_read_only` refusal — {@link billingRefusalText}'s third argument,
+ *  `useBillingLockReason`'s two options. */
+export interface BillingRefusalTextOptions {
+  /** The reader is a GUEST in someone else's item (§12.6): the words never say why. */
+  guest?: boolean;
+  /** A guest's item, by its own name ("Household 2026"). Ignored for the payer. */
+  item?: string;
+}
+
+type RefusalWords = (labels: BillingLabels, options: BillingRefusalTextOptions) => string;
+
+/**
+ * Each billing refusal's words in the `billing` labels. A `Record` over the whole union, so
+ * a code server-kit adds is a type error here until it has words.
+ */
+const BILLING_REFUSAL_WORDS: Record<BillingErrorCode, RefusalWords> = {
+  billing_disabled: (labels) => labels.disabled,
+  // The lock's own sentence (`useBillingLockReason`): a guest's never says why (§12.6).
+  billing_read_only: (labels, options) => (options.guest ? labels.guestReadOnly(options.item) : labels.lockReason),
+  // The notice's first line. The figure and the way to more are `isPlanLimit`'s, for
+  // `PlanLimitNotice` or `usePlanLimitToast`.
+  plan_limit: (labels) => labels.limitReached,
+  billing_not_configured: (labels) => labels.notConfigured,
+  billing_provider_unavailable: (labels) => labels.providerUnavailable,
+  billing_not_at_provider: (labels) => labels.notAtProvider,
+  billing_already_subscribed: (labels) => labels.alreadySubscribed,
+  billing_plan_not_sold: (labels) => labels.planNotSold,
+  billing_not_subscribed: (labels) => labels.notSubscribed,
+  billing_plan_unchanged: (labels) => labels.planUnchanged,
+};
+
+/**
+ * The words for a billing refusal, in `labels` (an app's `useBillingLabels()`, or its
+ * `billing` catalogue outside React), or `null` when `err` is not one — for the toast or
+ * the dialog after a billing call failed, with the app's own words for anything else
+ * (kastlan reuse audit 2026-11-02, proposal 4).
+ *
+ * All three apps mapped the codes to the labels by hand: kastlan's
+ * `billing-refusal-dialog.tsx`, keksdose's `subscription-cards.tsx` and Kurvenschmiede's
+ * `api/client.ts`, the same eight codes each. This follows the most complete of them:
+ * every {@link BillingErrorCode}, so it is `null` only for an error that is not billing's.
+ *
+ * - `billing_read_only` — the write lock's sentence, as `useBillingLockReason` says it:
+ *   the payer's `lockReason`, or with `{ guest: true, item }` a guest's `guestReadOnly`,
+ *   which never says why (§12.6) — kastlan's dialog, which passes `guest: !isAdmin`.
+ * - `plan_limit` — `limitReached`, "Plan limit reached". Where the figure fits, read
+ *   `isPlanLimit` first and show `PlanLimitNotice` or `usePlanLimitToast`, as kastlan does.
+ * - the eight others — their labels: `disabled`, `notConfigured`, `providerUnavailable`,
+ *   `notAtProvider`, `alreadySubscribed`, `planNotSold`, `notSubscribed`, `planUnchanged`.
+ *
+ * Reads the code wherever {@link authErrorCode} does (axios, ofetch, a generated client,
+ * FastAPI's nested `detail`).
+ *
+ *     catch (err) {
+ *       toast.error(billingRefusalText(err, labels) ?? describeError(err));
+ *     }
+ */
+export function billingRefusalText(
+  err: unknown,
+  labels: BillingLabels,
+  options: BillingRefusalTextOptions = {},
+): string | null {
+  const found = authErrorCode(err);
+  return found !== undefined && BILLING_CODES.has(found as BillingErrorCode)
+    ? BILLING_REFUSAL_WORDS[found as BillingErrorCode](labels, options)
+    : null;
+}
+
 /**
  * The parsed body that carries a code, wherever {@link authErrorCode} would find it (in
  * the same order) — the object with the `code`, so FastAPI's nested `detail` when the code

package/src/components/amount-input.tsx

@@ -149,7 +149,8 @@ export interface AmountInputProps extends FieldHelpProps, DataAttributes {
   currencyNames?: Record<string, string>;
   /** Offer only these ISO codes in the chip's list, in this order — `CurrencySelect`'s
    *  `options`, since the chip renders CurrencySelect's list (round 0.34 Wave 2, DUP-4).
-   *  Default every currency the kit knows. */
+   *  Default every currency the kit knows but a `retired` one (the lev), which only the
+   *  field that holds it lists. */
   currencyOptions?: string[];
   /** Focus the field on mount — on mobile this also opens the numpad sheet, so a
    *  new-transaction form can jump straight to amount entry (feedback #70). */

package/src/components/calendar-heatmap.tsx

@@ -3,6 +3,7 @@ import type { ComponentPropsWithRef, CSSProperties, KeyboardEvent, ReactNode } f
 import { cn } from "../lib/cn";
 import { dirOf, horizontalStep } from "../lib/direction";
 import { addMonthsClamped, localeWeekStart, parseIsoDate, toLocalIso } from "../lib/dates";
+import { dateFormatter } from "../lib/intl-cache";
 import { useKitLabels, useKitLocale, useKitWeekStart, type LabelOverride } from "../i18n/kit-labels";
 import { lerpHex, textOn } from "../theme/chart-palette";
 import { parseHex } from "../theme/color";
@@ -154,6 +155,8 @@ const DAY_NAME_FORMAT: Intl.DateTimeFormatOptions = {
   month: "long",
   year: "numeric",
 };
+/** A month's name over its first column ("Sep"). */
+const MONTH_LABEL_FORMAT: Intl.DateTimeFormatOptions = { month: "short" };
 
 /** The empty day: a wash of the text colour, like `--bg-hover`, so it reads as a cell
  *  on both themes without claiming any value. */
@@ -345,7 +348,10 @@ export function CalendarHeatmap({
     };
   }, [layout, firstIso, lastIso]);
 
-  const formatDay = (d: Date) => d.toLocaleDateString(locale, DAY_NAME_FORMAT);
+  // Every day cell names its date, so through the kit's formatter cache, as the month
+  // labels are: `toLocaleDateString` built one per cell and render, 365 for a year's grid
+  // (keksdose audit follow-up, 2026-11-01).
+  const formatDay = (d: Date) => dateFormatter(locale, DAY_NAME_FORMAT).format(d);
 
   const weekdayLabels = useMemo(() => {
     const ref = new Date(2024, 0, 7 + weekStart); // 7 January 2024 was a Sunday
@@ -503,7 +509,7 @@ export function CalendarHeatmap({
       for (let r = 0; r < 7; r++) {
         const d = dayAt(w * 7 + r);
         if (d && (d.getDate() === 1 || (w === 0 && r === lead && d.getDate() <= 14))) {
-          return d.toLocaleDateString(locale, { month: "short" });
+          return dateFormatter(locale, MONTH_LABEL_FORMAT).format(d);
         }
       }
       return "";

package/src/components/currency-option-list.tsx

@@ -73,7 +73,8 @@ export interface CurrencyOptionListProps {
   /** A currency was picked. The host closes the list. */
   onChoose: (code: string) => void;
   /** Only these ISO codes, in this order; codes the kit has no definition for are
-   *  dropped. Default every one of {@link CURRENCIES}. */
+   *  dropped. Default every one of {@link CURRENCIES} that is not `retired` (the chosen
+   *  one too, if it is). A retired code named here stays: the list is the caller's. */
   codes?: readonly string[];
   /** Translated names by code — see {@link currencyName}. */
   currencyNames?: Record<string, string>;
@@ -112,19 +113,27 @@ export function CurrencyOptionList({
   searchPlaceholder,
   sheetTitle,
 }: CurrencyOptionListProps) {
+  const held = getCurrency(value);
+  const chosen = held?.code;
+  // A retired currency the field holds — the one the default list keeps for it. Its own
+  // key, so a change of an ordinary value does not rebuild the rows and their names.
+  const heldRetired = held?.retired ? held.code : undefined;
   // Keyed on the codes' CONTENTS: an inline `options={["EUR", "CHF"]}` is a new array
   // every render.
   const codesKey = codes?.join(",");
   const pool = useMemo(
     () =>
       codesKey === undefined
-        ? CURRENCIES
+        ? // No currency that was replaced (the lev, since Bulgaria's euro: keksdose audit
+          // follow-up, 2026-11-01) — unless the field holds it, which then opens on its
+          // own row, checked, rather than on a list where nothing is chosen.
+          CURRENCIES.filter((c) => !c.retired || c.code === heldRetired)
         : // The caller's order; codes the kit has no definition for are dropped.
           codesKey
             .split(",")
             .map((code) => getCurrency(code))
             .filter((c): c is CurrencyOption => c !== undefined),
-    [codesKey],
+    [codesKey, heldRetired],
   );
   const named = useMemo(
     () => pool.map((c) => ({ c, name: currencyName(c, currencyNames, locale) })),
@@ -147,7 +156,6 @@ export function CurrencyOptionList({
     }));
   }, [named, query, locale]);
 
-  const chosen = getCurrency(value)?.code;
   return (
     <ComboboxPanel
       // The core with the currency filter's rows in place of its own.

package/src/components/currency-select.tsx

@@ -41,7 +41,9 @@ export interface CurrencySelectProps extends Omit<ComponentPropsWithoutRef<"div"
   /**
    * Restrict the pickable currencies to these ISO codes (e.g. only the
    * currencies actually present in a budget). Order is preserved. Defaults to
-   * the full {@link CURRENCIES} list.
+   * the full {@link CURRENCIES} list but a `retired` currency (the lev, since
+   * Bulgaria's euro), which only a field that holds it lists. A retired code named
+   * here is offered: the list is the caller's.
    */
   options?: string[];
   /** Required and unanswered — {@link FIELD_INVALID}, the same rose border the

package/src/components/danger-confirm.tsx

@@ -6,6 +6,7 @@ import { useKitLabels, type LabelOverride } from "../i18n/kit-labels";
 import { Button } from "./button";
 import { Input } from "./input";
 import { Label } from "./field-base";
+import { FIELD_ERROR_CLASS } from "./field-parts";
 import { Spinner } from "./spinner";
 import type { ButtonVariant } from "./button-look";
 import type { InputProps } from "./input";
@@ -536,6 +537,27 @@ export interface DangerConfirmProps extends Omit<ComponentPropsWithRef<"div">, "
    * confirm, so a keyboard user can retry or Shift+Tab to the field to correct (0.24).
    */
   busy?: boolean;
+  /**
+   * Why the last confirm failed ("Wrong password"), in the tile beside the field it is
+   * about rather than in a toast away from it (keksdose audit follow-up, 2026-11-01:
+   * PasswordDangerCard toasted its `password_incorrect` for want of this). The app sets
+   * it from the failure and words it — a 400 is a wrong password, a 500 is not.
+   *
+   * Drawn as the field's own `error`, as {@link ReauthDialog} draws its own: under the
+   * password with `requirePassword`, else under the typed phrase — the field painted,
+   * `aria-invalid`, the message its `aria-describedby` — and in a tile with neither, as
+   * a line above the buttons. Announced as it appears (`role="alert"`): it arrives
+   * after the press, with focus on the confirm, where a field's description alone is
+   * not heard. Passed at all — even as `undefined` — the field keeps its box, as with
+   * Input's `error`, so the message going away does not rebuild the field mid-edit.
+   *
+   * Hidden while the next attempt runs, once the user edits the tick, the phrase or the
+   * password (it is about what was submitted), and when the tile arms or disarms, until
+   * the next confirm; shown again when a confirm fails with it still set. So a
+   * mutation's error can be handed over as it is:
+   * `error={mut.error ? message(mut.error) : undefined}`.
+   */
+  error?: ReactNode;
   /** The arm button is disabled. */
   disabled?: boolean;
   /**
@@ -628,30 +650,32 @@ function firstSlotField(slot: HTMLElement | null): HTMLElement | null {
  * destructive button itself), and disarming moves it back to the arm button, so the
  * keyboard user is never left on an element that just vanished.
  */
-export function DangerConfirm({
-  onConfirm,
-  requirePassword,
-  requireAcknowledge,
-  consequences,
-  phrase,
-  phraseMatch = "trim",
-  prompt,
-  tone = "danger",
-  confirmVariant,
-  confirmDisabledReason,
-  children,
-  armLabel,
-  confirmLabel,
-  busy: busyProp,
-  disabled,
-  lockedReason: ownLockedReason,
-  commit,
-  armed: armedProp,
-  onArmedChange,
-  labels: labelsProp,
-  className,
-  ...rest
-}: DangerConfirmProps) {
+export function DangerConfirm(props: DangerConfirmProps) {
+  const {
+    onConfirm,
+    requirePassword,
+    requireAcknowledge,
+    consequences,
+    phrase,
+    phraseMatch = "trim",
+    prompt,
+    tone = "danger",
+    confirmVariant,
+    confirmDisabledReason,
+    children,
+    armLabel,
+    confirmLabel,
+    busy: busyProp,
+    error,
+    disabled,
+    lockedReason: ownLockedReason,
+    commit,
+    armed: armedProp,
+    onArmedChange,
+    labels: labelsProp,
+    className,
+    ...rest
+  } = props;
   const labels = useKitLabels("dangerConfirm", DEFAULT_DANGER_CONFIRM_LABELS, labelsProp);
   const lockedReason = useCommitReason(commit, ownLockedReason);
   const [armedState, setArmedState] = useState(false);
@@ -659,6 +683,9 @@ export function DangerConfirm({
   const [password, setPassword] = useState("");
   const [typed, setTyped] = useState("");
   const [acknowledged, setAcknowledged] = useState(false);
+  // The `error` describes what was submitted: an edit, an arm or a disarm leaves it
+  // describing nothing on screen. Cleared by the next confirm — ReauthDialog's `edited`.
+  const [errorStale, setErrorStale] = useState(false);
   const { pending, run } = usePromisePending();
   const busy = Boolean(busyProp) || pending;
   // `readOnly` rather than `disabled` on the fields while busy: disabling the field
@@ -686,6 +713,8 @@ export function DangerConfirm({
   const [wasArmed, setWasArmed] = useState(armed);
   if (wasArmed !== armed) {
     setWasArmed(armed);
+    // An `error` still passed is about the attempt before: not shown until a confirm.
+    setErrorStale(true);
     if (!armed) {
       setPassword("");
       setTyped("");
@@ -785,11 +814,22 @@ export function DangerConfirm({
       ...(asksAcknowledge && { acknowledged: true as const }),
     };
     confirmed.current = true;
+    setErrorStale(false);
     // Disarms when it resolves; a rejection leaves it armed, fields kept: the caller
     // shows why, the user retries.
     run(onConfirm(values.password, values), () => setArmed(false));
   };
 
+  // The failure's message, under the field it is about: the password, else the phrase,
+  // else (a tile with neither) a line of its own. Not while the next attempt runs.
+  const shownError = errorStale || busy ? undefined : error;
+  const errorAlert = hasContent(shownError) ? <span role="alert">{shownError}</span> : undefined;
+  const errorOn = requirePassword ? "password" : phrase !== undefined ? "phrase" : "line";
+  // Passed at all, the carrying field keeps its box (Input's `error` rule): only then.
+  const fieldError = (field: "password" | "phrase") =>
+    "error" in props && errorOn === field ? { error: errorAlert } : {};
+  const edited = () => setErrorStale(true);
+
   // The first field takes focus on arm: the tick, then the phrase, then the password —
   // the order they are drawn in.
   const firstField = asksAcknowledge ? "acknowledge" : phrase !== undefined ? "phrase" : "password";
@@ -880,7 +920,9 @@ export function DangerConfirm({
             // Not `disabled` while busy, for the same reason the fields are readOnly:
             // the box may hold the focus. A change while busy is simply not taken.
             onCheckedChange={(next) => {
-              if (!busy) setAcknowledged(next);
+              if (busy) return;
+              setAcknowledged(next);
+              edited();
             }}
           />
         )}
@@ -890,11 +932,15 @@ export function DangerConfirm({
             target={phrase}
             match={phraseMatch}
             value={typed}
-            onValueChange={setTyped}
+            onValueChange={(next) => {
+              setTyped(next);
+              edited();
+            }}
             busy={busy}
             // Already resolved through this tile's own `labels` prop; handed on so a
             // per-instance phrase wording reaches the field.
             labels={{ phrase: labels.phrase, phrasePlaceholder: labels.phrasePlaceholder }}
+            {...fieldError("phrase")}
           />
         )}
         {requirePassword && (
@@ -903,9 +949,16 @@ export function DangerConfirm({
             label={labels.password}
             value={password}
             busy={busy}
-            onValueChange={setPassword}
+            onValueChange={(next) => {
+              setPassword(next);
+              edited();
+            }}
+            {...fieldError("password")}
           />
         )}
+        {errorOn === "line" && errorAlert !== undefined && (
+          <p className={cn(FIELD_ERROR_CLASS, "mt-0")}>{errorAlert}</p>
+        )}
         <div className="flex flex-wrap gap-2">
           <Button id={cancelId} type="button" variant="ghost" disabled={busy} onClick={() => setArmed(false)}>
             {labels.cancel}

package/src/components/data-table-filter-popover.tsx

@@ -40,7 +40,8 @@ interface FilterPopoverProps<T> {
  * The contents of a column's filter Popover. Renders the right control set for
  * the column's filter type — text search, select checklist, date range (presets
  * + {@link MiniCalendar} + from/to inputs), or numeric min/max with an abs
- * toggle — driving the shared {@link FilterValue} state.
+ * toggle (none for `numberFilter(getValue, { abs: false })`) — driving the shared
+ * {@link FilterValue} state.
  */
 export function FilterPopover<T>({
   column,
@@ -219,6 +220,11 @@ export function FilterPopover<T>({
   }
 
   // number
+  // `abs: false` on the filter: no "Absolute value" box, and a state that carries `abs`
+  // anyway (a view stored before the column lost the box) is handed on without it at the
+  // first bound typed — there is no box to untick it with (kastlan reuse audit
+  // 2026-11-02, proposal 7).
+  const absBox = filter.abs !== false;
   const v = state.type === "number" ? state : { type: "number" as const, min: "", max: "", abs: false };
   // The bounds were native `type="number"` inputs, the one numeric entry in the kit that
   // bypassed decimal-marks (BUG-10, refactor audit 2026-10): where the browser refuses a
@@ -237,7 +243,7 @@ export function FilterPopover<T>({
       type: "number",
       min: bound === "min" ? read : v.min,
       max: bound === "max" ? read : v.max,
-      abs: v.abs,
+      abs: absBox && v.abs,
     });
   };
   return (
@@ -266,15 +272,17 @@ export function FilterPopover<T>({
           />
         </label>
       </div>
-      <label className="flex items-center gap-2 text-sm text-secondary">
-        <input
-          type="checkbox"
-          checked={v.abs}
-          onChange={(e) => onChange({ type: "number", min: v.min, max: v.max, abs: e.target.checked })}
-          className="size-3.5"
-        />
-        {labels.numberAbs}
-      </label>
+      {absBox && (
+        <label className="flex items-center gap-2 text-sm text-secondary">
+          <input
+            type="checkbox"
+            checked={v.abs}
+            onChange={(e) => onChange({ type: "number", min: v.min, max: v.max, abs: e.target.checked })}
+            className="size-3.5"
+          />
+          {labels.numberAbs}
+        </label>
+      )}
       {clearRow}
     </div>
   );

package/src/components/data-table-filters.ts

@@ -8,7 +8,15 @@ export type ColumnFilter<T> =
   | { type: "text"; getValue: (row: T) => string }
   | { type: "select"; getValue: (row: T) => string; options?: { value: string; label?: string }[] }
   | { type: "date"; getValue: (row: T) => string | null | undefined }
-  | { type: "number"; getValue: (row: T) => number | null | undefined };
+  | {
+      type: "number";
+      getValue: (row: T) => number | null | undefined;
+      /** `false`: no "Absolute value" box, for a figure that is never negative (a year, a
+       *  count, a size), where the box only offers a choice that changes nothing. A state
+       *  or a link that carries `abs` anyway is read without it. Default `true`. See
+       *  {@link numberFilter}. */
+      abs?: boolean;
+    };
 
 /** The current state of a column's filter (what the user has entered). */
 export type FilterValue =
@@ -46,8 +54,15 @@ export function isFilterActive(v: FilterValue | undefined): boolean {
  * match every row while the column showed its filter as active; `Number(" ")` is 0, and
  * a blank bound kept every negative row out. The popover hands in the dot-decimal text
  * its locale's marks read (`readTyped`); anything else is no bound.
+ *
+ * Exported for a server-side table (`serverPagination`), which sends the bounds to its
+ * server instead of comparing here: send what this reads, and leave out a `null`. The box
+ * holds a half-typed "-" or "5e" while the user types, and kastlan's server tables sent
+ * that text on to `col >= :bound` until they wrote this rule again for themselves (kastlan
+ * reuse audit 2026-11-02, proposal 7). And send `abs` only beside a bound: on its own it
+ * narrows nothing.
  */
-function numberBound(raw: string): number | null {
+export function numberBound(raw: string): number | null {
   if (raw.trim() === "") return null;
   const n = Number(raw);
   return Number.isFinite(n) ? n : null;
@@ -108,7 +123,9 @@ export function rowMatches<T>(col: DataTableColumn<T>, row: T, state: FilterValu
       const min = numberBound(state.min);
       const max = numberBound(state.max);
       if (raw == null || Number.isNaN(raw)) return min === null && max === null;
-      const x = state.abs ? Math.abs(raw) : raw;
+      // A column without the box (`abs: false`) compares the figure as it is, whatever
+      // the state says: there is nothing on screen to untick.
+      const x = state.abs && filter.abs !== false ? Math.abs(raw) : raw;
       if (min !== null && x < min) return false;
       if (max !== null && x > max) return false;
       return true;
@@ -204,9 +221,12 @@ export function decodeFilterValueOfType(type: FilterValue["type"], raw: string):
   }
 }
 
-/** Inverse of {@link encodeFilterValue}, typed by the column's filter config. */
+/** Inverse of {@link encodeFilterValue}, typed by the column's filter config. A number
+ *  filter without the "Absolute value" box (`abs: false`) drops a link's `!`: kept, a
+ *  server-side table would send `abs` that nobody can see or untick. */
 export function decodeFilterValue<T>(filter: ColumnFilter<T>, raw: string): FilterValue {
-  return decodeFilterValueOfType(filter.type, raw);
+  const value = decodeFilterValueOfType(filter.type, raw);
+  return value.type === "number" && filter.type === "number" && filter.abs === false ? { ...value, abs: false } : value;
 }
 
 // ---------- Filter builders ----------
@@ -244,9 +264,17 @@ export function dateFilter<T>(getValue: (row: T) => string | null | undefined):
   return { type: "date", getValue };
 }
 
-/** A min/max (and absolute-value) filter over a number. */
-export function numberFilter<T>(getValue: (row: T) => number | null | undefined): ColumnFilter<T> {
-  return { type: "number", getValue };
+/**
+ * A min/max (and absolute-value) filter over a number. `{ abs: false }` leaves out the
+ * "Absolute value" box, for a figure that is never negative — a year, a count, a size —
+ * where it only offers a choice that changes nothing (kastlan reuse audit 2026-11-02,
+ * proposal 7: its server tables drew it under construction years and file sizes).
+ */
+export function numberFilter<T>(
+  getValue: (row: T) => number | null | undefined,
+  options?: { abs?: boolean },
+): ColumnFilter<T> {
+  return options?.abs === false ? { type: "number", getValue, abs: false } : { type: "number", getValue };
 }
 
 /**

package/src/components/dialog-frame.tsx

@@ -26,7 +26,9 @@ export { DEFAULT_DIALOG_FRAME_LABELS };
  * `onKeyDown`, a `data-tour` anchor, still reaches the `Modal` — and since 0.35 `ref`
  * (round 0.35 R4): the panel, the `role="dialog"` element the frame's header, body and
  * actions sit in. `busy` too (DUP-3): it holds the frame's X and the `close` that
- * `actions` and `headerActions` receive, since both are the `Modal`'s own close.
+ * `actions` and `headerActions` receive, since both are the `Modal`'s own close. And
+ * `held` (keksdose audit follow-up, 2026-11-01), which holds the same and shows the X
+ * disabled — see {@link ModalProps.held}.
  */
 export interface DialogFrameProps extends Omit<ModalProps, "labelledBy" | "children" | "title"> {
   /** The heading, and therefore the dialog's accessible name (`aria-labelledby`). */
@@ -187,7 +189,7 @@ export function DialogFrame({
             <FrameHeaderActions actions={headerActions} onClose={modal.onClose} />
           )}
         </div>
-        {closeButton && <FrameClose label={closeLabel} onClose={modal.onClose} />}
+        {closeButton && <FrameClose label={closeLabel} onClose={modal.onClose} held={modal.held} />}
       </div>
       {hasBody && (
         <div
@@ -210,8 +212,10 @@ export function DialogFrame({
 }
 
 /** The X. A component of its own so it can read the panel's animated close, which
- *  only exists INSIDE the `Modal` (the frame's own body runs outside it). */
-function FrameClose({ label, onClose }: { label?: string; onClose: () => void }) {
+ *  only exists INSIDE the `Modal` (the frame's own body runs outside it). Disabled
+ *  while `held`; under `busy` it stays enabled and the `Modal` drops its press (see
+ *  {@link ModalProps.held} for why the two differ). */
+function FrameClose({ label, onClose, held = false }: { label?: string; onClose: () => void; held?: boolean }) {
   const close = useContext(ModalCloseContext) ?? onClose;
   const labels = useKitLabels(
     "dialogFrame",
@@ -222,9 +226,13 @@ function FrameClose({ label, onClose }: { label?: string; onClose: () => void })
     <button
       type="button"
       onClick={close}
+      disabled={held}
       aria-label={labels.close}
       className={cn(
         "-me-1.5 -mt-1 shrink-0 rounded p-1.5 text-muted outline-none hover:bg-hover hover:text-secondary",
+        // The kit's disabled look (Button, IconButton), and the resting look pinned under
+        // `disabled:hover:` so a refused X does not light up under the pointer.
+        "disabled:cursor-not-allowed disabled:opacity-50 disabled:hover:bg-transparent disabled:hover:text-muted",
         FOCUS_RING,
       )}
     >

package/src/components/mini-calendar.tsx

@@ -8,6 +8,7 @@ import { FOCUS_RING, FOCUS_RING_WIDTH } from "./focus-ring";
 import { horizontalStep } from "../lib/direction";
 import { useAnnounce } from "../hooks/use-announce";
 import { addMonthsClamped, localeWeekStart, monthKey, parseIsoDate, sameYmd, toLocalIso } from "../lib/dates";
+import { dateFormatter } from "../lib/intl-cache";
 import { useKitLabels, useKitLocale, useKitWeekStart, type LabelOverride } from "../i18n/kit-labels";
 import { DEFAULT_MINI_CALENDAR_LABELS } from "./mini-calendar-labels";
 
@@ -355,8 +356,10 @@ export function MiniCalendar({
   // The first letter only, not CSS `capitalize`, which upper-cased every word: Spanish
   // read "Septiembre De 2026" and Hungarian "2026. Szeptember" (refactor audit
   // 2026-10-30, DUP-11) — while the same panel with `monthJump` read them right.
-  const monthLabel = upperFirst(firstOfMonth.toLocaleDateString(locale, { month: "long", year: "numeric" }), locale);
-  const formatDay = (d: Date) => d.toLocaleDateString(locale, DAY_NAME_FORMAT);
+  // Both through the kit's formatter cache: every day cell names its date, which was a
+  // formatter per cell and render (keksdose audit follow-up, 2026-11-01).
+  const monthLabel = upperFirst(dateFormatter(locale, { month: "long", year: "numeric" }).format(firstOfMonth), locale);
+  const formatDay = (d: Date) => dateFormatter(locale, DAY_NAME_FORMAT).format(d);
 
   // Weekday labels via locale, from the week's first day: the narrow one for the
   // column head, the long one as its accessible name — "M" is the same letter for