@eifi1/ui-kit 0.51.6 → 0.52.0

package/dist/lib/calc.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/lib/calc.ts"],"sourcesContent":["/**\n * A tiny, dependency-free arithmetic evaluator for the numeric input fields.\n * It lets users type a calculation (e.g. \"12.50+3.20\" or \"100/3\") straight into\n * an amount field, or build one in the calculator popover, and have it resolve\n * to a number. Deliberately NOT backed by `eval`/`Function` — it's a hand-rolled\n * tokenizer + recursive-descent parser over a closed grammar (digits, decimals,\n * `+ - * /`, unary minus, parentheses), so no arbitrary code can run.\n */\n\ntype Token =\n  | { kind: \"num\"; value: number }\n  | { kind: \"op\"; value: \"+\" | \"-\" | \"*\" | \"/\" }\n  | { kind: \"lparen\" }\n  | { kind: \"rparen\" };\n\nfunction tokenize(input: string): Token[] | null {\n  const tokens: Token[] = [];\n  let i = 0;\n  while (i < input.length) {\n    const ch = input[i];\n    if (ch === \" \") {\n      i++;\n      continue;\n    }\n    if (ch === \"+\" || ch === \"-\" || ch === \"*\" || ch === \"/\") {\n      tokens.push({ kind: \"op\", value: ch });\n      i++;\n      continue;\n    }\n    if (ch === \"(\") {\n      tokens.push({ kind: \"lparen\" });\n      i++;\n      continue;\n    }\n    if (ch === \")\") {\n      tokens.push({ kind: \"rparen\" });\n      i++;\n      continue;\n    }\n    if ((ch >= \"0\" && ch <= \"9\") || ch === \".\") {\n      let j = i;\n      let dotSeen = false;\n      while (j < input.length && ((input[j] >= \"0\" && input[j] <= \"9\") || input[j] === \".\")) {\n        if (input[j] === \".\") {\n          if (dotSeen) return null; // two dots in one number → invalid\n          dotSeen = true;\n        }\n        j++;\n      }\n      const num = Number(input.slice(i, j));\n      if (!Number.isFinite(num)) return null;\n      tokens.push({ kind: \"num\", value: num });\n      i = j;\n      continue;\n    }\n    return null; // unknown character\n  }\n  return tokens;\n}\n\n/**\n * Recursive-descent parse honouring `* /` over `+ -` and left-associativity.\n * Returns `null` for any malformed input (the `null` sentinel is safe because a\n * valid result of 0 is distinct from it). Division by zero is treated as invalid.\n *\n *   expr   := term (('+' | '-') term)*\n *   term   := factor (('*' | '/') factor)*\n *   factor := ('+' | '-') factor | number | '(' expr ')'\n */\nfunction parse(tokens: Token[]): number | null {\n  let pos = 0;\n\n  function parseExpr(): number | null {\n    let value = parseTerm();\n    if (value === null) return null;\n    while (pos < tokens.length) {\n      const tok = tokens[pos];\n      if (tok.kind === \"op\" && (tok.value === \"+\" || tok.value === \"-\")) {\n        pos++;\n        const rhs = parseTerm();\n        if (rhs === null) return null;\n        value = tok.value === \"+\" ? value + rhs : value - rhs;\n      } else break;\n    }\n    return value;\n  }\n\n  function parseTerm(): number | null {\n    let value = parseFactor();\n    if (value === null) return null;\n    while (pos < tokens.length) {\n      const tok = tokens[pos];\n      if (tok.kind === \"op\" && (tok.value === \"*\" || tok.value === \"/\")) {\n        pos++;\n        const rhs = parseFactor();\n        if (rhs === null) return null;\n        if (tok.value === \"/\") {\n          if (rhs === 0) return null;\n          value = value / rhs;\n        } else {\n          value = value * rhs;\n        }\n      } else break;\n    }\n    return value;\n  }\n\n  function parseFactor(): number | null {\n    const tok = tokens[pos];\n    if (!tok) return null;\n    if (tok.kind === \"op\" && (tok.value === \"+\" || tok.value === \"-\")) {\n      pos++;\n      const operand = parseFactor();\n      if (operand === null) return null;\n      return tok.value === \"-\" ? -operand : operand;\n    }\n    if (tok.kind === \"lparen\") {\n      pos++;\n      const inner = parseExpr();\n      if (inner === null) return null;\n      if (tokens[pos]?.kind !== \"rparen\") return null;\n      pos++;\n      return inner;\n    }\n    if (tok.kind === \"num\") {\n      pos++;\n      return tok.value;\n    }\n    return null;\n  }\n\n  const result = parseExpr();\n  if (result === null) return null;\n  if (pos !== tokens.length) return null; // leftover tokens → invalid\n  return result;\n}\n\n/** Evaluate an arithmetic string, returning `null` if it isn't a valid sum.\n * Accepts the on-screen operator glyphs (`× ÷ −`) and comma decimals too. */\nexport function evaluateExpression(expr: string): number | null {\n  const normalized = expr\n    .replace(/×/g, \"*\")\n    .replace(/÷/g, \"/\")\n    .replace(/[−–—]/g, \"-\") // unicode minus / en / em dash → ascii\n    .replace(/,/g, \".\")\n    .trim();\n  if (normalized === \"\") return null;\n  const tokens = tokenize(normalized);\n  if (tokens === null || tokens.length === 0) return null;\n  const result = parse(tokens);\n  if (result === null || !Number.isFinite(result)) return null;\n  return result;\n}\n\n/** True when `s` carries arithmetic beyond a single leading minus — i.e. a plain\n * number (or a lone negative like \"-5\") is NOT an expression, but \"12+5\" is.\n * Used to decide whether a field's text should be evaluated on commit.\n *\n * The operator set is the one {@link evaluateExpression} accepts, on-screen glyphs\n * included: the calculator keypad inserts `× ÷ −`, and a `−` that this said was not\n * arithmetic went on to be read as a plain number — where the digits-only fallback\n * in {@link commitExpression} silently ate it, turning \"-42−−50\" (= 8) into a bare\n * 8 with no record that a sum had happened at all. */\nexport function looksLikeExpression(s: string): boolean {\n  const t = s.trim();\n  if (t === \"\") return false;\n  if (/^-?\\d*[.,]?\\d*$/.test(t)) return false; // plain (optionally negative) decimal\n  return /[+\\-*/×÷−–—()]/.test(t.replace(/^-/, \"\"));\n}\n\n/** Render an evaluated number back to a field-friendly string, trimming binary\n * float noise (so 0.1 + 0.2 reads \"0.3\", not \"0.30000000000000004\").\n *\n * FIXED notation, always, and that is the whole point of the function rather than a\n * detail of it. This used to end in `parseFloat(n.toFixed(10)).toString()`, and\n * `Number.prototype.toString` switches to EXPONENT notation below 1e-6 and at or\n * above 1e21 — an alphabet containing `e`, `+` and `-`. Neither function that reads a\n * field's text back accepts it: {@link tokenize} rejects `e` as an unknown character\n * and {@link sanitizeLive} deletes it. So {@link commitExpression} fell through to\n * its digits-only cleanup, which stripped the `e` and CONCATENATED the mantissa to\n * the exponent. A field committed its own output as a different number:\n *\n *     \"1/10000000\"                -> \"1e-7\"               -> \"17\"   (AmountInput: \"6\")\n *     \"999999999999*999999999999\" -> \"9.99999999998e+23\"  -> \"9.9999999999823\"\n *\n * Both controls commit on blur AND on Enter, so Enter-then-click-away was enough on\n * its own, it was silent, and it was in a money field.\n *\n * The invariant, which the test asserts directly rather than by example:\n * **`commitExpression(formatResult(n))` equals `formatResult(n)` for every finite\n * `n`.** Anything rendered here has to survive being read back. */\nexport function formatResult(n: number): string {\n  if (!Number.isFinite(n)) return \"\";\n  // At or above 1e21 `toFixed` gives up and hands back `toString`'s exponent form —\n  // but every double that large is an integer, so BigInt renders it exactly.\n  if (Math.abs(n) >= 1e21) return BigInt(n).toString();\n  return trimTrailingZeros(n.toFixed(10));\n}\n\n/** \"15.7000000000\" -> \"15.7\", \"0.0000000000\" -> \"0\". The ten decimals are where the\n *  binary float noise gets rounded off; this is only about not showing the padding. */\nfunction trimTrailingZeros(fixed: string): string {\n  if (!fixed.includes(\".\")) return fixed;\n  const trimmed = fixed.replace(/0+$/, \"\").replace(/\\.$/, \"\");\n  // `toFixed` keeps the sign on a magnitude that rounded away to nothing\n  // (\"-0.0000000000\"); `toString` did not, and \"-0\" in an amount field is noise.\n  return trimmed === \"-0\" || trimmed === \"\" ? \"0\" : trimmed;\n}\n\n/** The single \"on blur / Enter\" transform a numeric field applies: evaluate the\n * text if it's an expression, otherwise normalise it to a bare number string\n * (comma → dot, dropping stray characters, non-leading minuses and anything after\n * a second decimal point).\n *\n * The last clause is the backstop for Keksdose live #201. A field the user typed in\n * cannot reach here malformed any more — {@link sanitizeLive} runs on every change,\n * including a paste — but a value handed in from elsewhere (a recurring rule, an\n * import, a test) still can, and \"1.2.3\" is not an expression (no operator), so it\n * used to fall straight through unchanged and be read as NaN. Here the text is CUT\n * at the second dot (\"1.2\") rather than joined (\"1.23\"): with no keystroke to\n * ignore there is nothing to say which reading was meant, and the shorter one\n * cannot silently invent a bigger number. */\nexport function commitExpression(raw: string): string {\n  const s = raw.trim();\n  if (looksLikeExpression(s)) {\n    const n = evaluateExpression(s);\n    if (n !== null) return formatResult(n);\n    // Unparseable (e.g. a half-typed \"12+\"): fall through to a digits-only clean.\n  }\n  // Global, like sanitizeLive's: these two are the two halves of one rule and must\n  // not appear to state it differently. (The `[^0-9.-]` strip on the same line\n  // already ate whatever commas a non-global replace missed, so this changes no\n  // behaviour — it removes the need for the next reader to run it to find that out.)\n  const cleaned = s\n    .replace(/,/g, \".\")\n    .replace(/[^0-9.-]/g, \"\")\n    .replace(/(?!^)-/g, \"\");\n  return cleaned.replace(/^(-?\\d*\\.?\\d*).*$/, \"$1\");\n}\n\n/** The live, per-keystroke transform a numeric field applies: comma → dot and\n * drop anything that isn't a digit, decimal point, arithmetic operator (incl.\n * the on-screen `× ÷` glyphs) or paren — so a typed calculation survives\n * keystroke-by-keystroke but stray characters can't be entered. A lone leading\n * `-` is kept — in a plain field it is simply a negative amount; in a field whose\n * caller owns the sign it is read off again by {@link splitLeadingSign}. The text\n * is resolved to a plain number on blur/Enter via {@link commitExpression}. */\nexport function sanitizeLive(raw: string): string {\n  return dropExtraDots(raw.replace(/,/g, \".\").replace(/[^0-9.+\\-*/×÷()]/g, \"\"));\n}\n\n/**\n * At most ONE decimal point per number (Keksdose live #201).\n *\n * Per NUMBER, not per string: \"1.5+2.5\" is a legitimate calculation with two dots\n * in two operands, so the counter resets at every operator and parenthesis.\n *\n * A second dot inside one operand is a **no-op keystroke** — the digits after it\n * keep landing, so \"1.2\" + \".\" + \"3\" is \"1.23\". That is what every calculator does\n * with a repeated decimal point, and it is the only option that does not make the\n * field feel broken (\"my 3 disappeared\"). This runs on paste as well as on typing,\n * so the malformed value never reaches the rest of the app: everything downstream\n * reads the field with `Number()`, NaN became a silent 0, and on the create form\n * that 0 was painted with the income green — a figure that was not a number at all\n * asserting money was coming in.\n */\nfunction dropExtraDots(s: string): string {\n  let out = \"\";\n  let dotInNumber = false;\n  for (const ch of s) {\n    if (ch === \".\") {\n      if (dotInNumber) continue;\n      dotInNumber = true;\n    } else if (ch < \"0\" || ch > \"9\") {\n      // An operator or a paren ends the current operand.\n      dotInNumber = false;\n    }\n    out += ch;\n  }\n  return out;\n}\n\n/** A bare, unsigned amount: digits with at most one decimal separator and nothing\n *  else — \"42\", \"42.\", \".5\", \"0,5\". NOT \"\" (an empty field has no figure to put a\n *  sign in front of), not \"-42\", not \"12+5\". It is the only shape a DISPLAYED sign\n *  prefix makes sense in front of; an expression carries its own arithmetic and has\n *  to survive keystroke-for-keystroke. */\nexport function isBareAmount(s: string): boolean {\n  const t = s.trim();\n  return t !== \"\" && /^\\d*[.,]?\\d*$/.test(t);\n}\n\n/**\n * Split a LEADING sign off a plain signed number (Keksdose live #201 rework):\n * `\"-42\"` → `{ sign: \"-\", rest: \"42\" }`, everything else → `{ sign: \"\", rest: text }`.\n *\n * Only in front of a bare amount, because a minus with arithmetic after it IS\n * arithmetic: \"12-30\" is a subtraction, and \"-12+5\" is -7, not -(12+5). Those come\n * back untouched and are resolved by {@link commitExpression} on blur — at which\n * point the RESULT is a plain signed number and this function does get to speak.\n *\n * A lone \"-\" splits (rest \"\"): the sign is a statement about the direction the\n * moment it is typed, before any digit exists.\n */\nexport function splitLeadingSign(text: string): { sign: \"\" | \"-\" | \"+\"; rest: string } {\n  const trimmed = text.trimStart();\n  const sign = trimmed.charAt(0);\n  if (sign !== \"-\" && sign !== \"+\") return { sign: \"\", rest: text };\n  const rest = trimmed.slice(1);\n  if (rest !== \"\" && !isBareAmount(rest)) return { sign: \"\", rest: text };\n  return { sign, rest };\n}\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../../src/lib/calc.ts"],"sourcesContent":["/**\n * A tiny, dependency-free arithmetic evaluator for the numeric input fields.\n * It lets users type a calculation (e.g. \"12.50+3.20\" or \"100/3\") straight into\n * an amount field, or build one in the calculator popover, and have it resolve\n * to a number. Deliberately NOT backed by `eval`/`Function` — it's a hand-rolled\n * tokenizer + recursive-descent parser over a closed grammar (digits, decimals,\n * `+ - * /`, unary minus, parentheses), so no arbitrary code can run.\n */\n\ntype Token =\n  | { kind: \"num\"; value: number }\n  | { kind: \"op\"; value: \"+\" | \"-\" | \"*\" | \"/\" }\n  | { kind: \"lparen\" }\n  | { kind: \"rparen\" };\n\nfunction tokenize(input: string): Token[] | null {\n  const tokens: Token[] = [];\n  let i = 0;\n  while (i < input.length) {\n    const ch = input[i];\n    if (ch === \" \") {\n      i++;\n      continue;\n    }\n    if (ch === \"+\" || ch === \"-\" || ch === \"*\" || ch === \"/\") {\n      tokens.push({ kind: \"op\", value: ch });\n      i++;\n      continue;\n    }\n    if (ch === \"(\") {\n      tokens.push({ kind: \"lparen\" });\n      i++;\n      continue;\n    }\n    if (ch === \")\") {\n      tokens.push({ kind: \"rparen\" });\n      i++;\n      continue;\n    }\n    if ((ch >= \"0\" && ch <= \"9\") || ch === \".\") {\n      let j = i;\n      let dotSeen = false;\n      while (j < input.length && ((input[j] >= \"0\" && input[j] <= \"9\") || input[j] === \".\")) {\n        if (input[j] === \".\") {\n          if (dotSeen) return null; // two dots in one number → invalid\n          dotSeen = true;\n        }\n        j++;\n      }\n      const num = Number(input.slice(i, j));\n      if (!Number.isFinite(num)) return null;\n      tokens.push({ kind: \"num\", value: num });\n      i = j;\n      continue;\n    }\n    return null; // unknown character\n  }\n  return tokens;\n}\n\n/**\n * Recursive-descent parse honouring `* /` over `+ -` and left-associativity.\n * Returns `null` for any malformed input (the `null` sentinel is safe because a\n * valid result of 0 is distinct from it). Division by zero is treated as invalid.\n *\n *   expr   := term (('+' | '-') term)*\n *   term   := factor (('*' | '/') factor)*\n *   factor := ('+' | '-') factor | number | '(' expr ')'\n */\nfunction parse(tokens: Token[]): number | null {\n  let pos = 0;\n\n  function parseExpr(): number | null {\n    let value = parseTerm();\n    if (value === null) return null;\n    while (pos < tokens.length) {\n      const tok = tokens[pos];\n      if (tok.kind === \"op\" && (tok.value === \"+\" || tok.value === \"-\")) {\n        pos++;\n        const rhs = parseTerm();\n        if (rhs === null) return null;\n        value = tok.value === \"+\" ? value + rhs : value - rhs;\n      } else break;\n    }\n    return value;\n  }\n\n  function parseTerm(): number | null {\n    let value = parseFactor();\n    if (value === null) return null;\n    while (pos < tokens.length) {\n      const tok = tokens[pos];\n      if (tok.kind === \"op\" && (tok.value === \"*\" || tok.value === \"/\")) {\n        pos++;\n        const rhs = parseFactor();\n        if (rhs === null) return null;\n        if (tok.value === \"/\") {\n          if (rhs === 0) return null;\n          value = value / rhs;\n        } else {\n          value = value * rhs;\n        }\n      } else break;\n    }\n    return value;\n  }\n\n  function parseFactor(): number | null {\n    const tok = tokens[pos];\n    if (!tok) return null;\n    if (tok.kind === \"op\" && (tok.value === \"+\" || tok.value === \"-\")) {\n      pos++;\n      const operand = parseFactor();\n      if (operand === null) return null;\n      return tok.value === \"-\" ? -operand : operand;\n    }\n    if (tok.kind === \"lparen\") {\n      pos++;\n      const inner = parseExpr();\n      if (inner === null) return null;\n      if (tokens[pos]?.kind !== \"rparen\") return null;\n      pos++;\n      return inner;\n    }\n    if (tok.kind === \"num\") {\n      pos++;\n      return tok.value;\n    }\n    return null;\n  }\n\n  const result = parseExpr();\n  if (result === null) return null;\n  if (pos !== tokens.length) return null; // leftover tokens → invalid\n  return result;\n}\n\n/** Evaluate an arithmetic string, returning `null` if it isn't a valid sum.\n * Accepts the on-screen operator glyphs (`× ÷ −`) and comma decimals too. */\nexport function evaluateExpression(expr: string): number | null {\n  const normalized = expr\n    .replace(/×/g, \"*\")\n    .replace(/÷/g, \"/\")\n    .replace(/[−–—]/g, \"-\") // unicode minus / en / em dash → ascii\n    .replace(/,/g, \".\")\n    .trim();\n  if (normalized === \"\") return null;\n  const tokens = tokenize(normalized);\n  if (tokens === null || tokens.length === 0) return null;\n  const result = parse(tokens);\n  if (result === null || !Number.isFinite(result)) return null;\n  return result;\n}\n\n/** True when `s` carries arithmetic beyond a single leading minus — i.e. a plain\n * number (or a lone negative like \"-5\") is NOT an expression, but \"12+5\" is.\n * Used to decide whether a field's text should be evaluated on commit.\n *\n * The operator set is the one {@link evaluateExpression} accepts, on-screen glyphs\n * included: the calculator keypad inserts `× ÷ −`, and a `−` that this said was not\n * arithmetic went on to be read as a plain number — where the digits-only fallback\n * in {@link commitExpression} silently ate it, turning \"-42−−50\" (= 8) into a bare\n * 8 with no record that a sum had happened at all. */\nexport function looksLikeExpression(s: string): boolean {\n  const t = s.trim();\n  if (t === \"\") return false;\n  if (/^-?\\d*[.,]?\\d*$/.test(t)) return false; // plain (optionally negative) decimal\n  return /[+\\-*/×÷−–—()]/.test(t.replace(/^-/, \"\"));\n}\n\n/** Render an evaluated number back to a field-friendly string, trimming binary\n * float noise (so 0.1 + 0.2 reads \"0.3\", not \"0.30000000000000004\").\n *\n * FIXED notation, always, and that is the whole point of the function rather than a\n * detail of it. This used to end in `parseFloat(n.toFixed(10)).toString()`, and\n * `Number.prototype.toString` switches to EXPONENT notation below 1e-6 and at or\n * above 1e21 — an alphabet containing `e`, `+` and `-`. Neither function that reads a\n * field's text back accepts it: {@link tokenize} rejects `e` as an unknown character\n * and {@link sanitizeLive} deletes it. So {@link commitExpression} fell through to\n * its digits-only cleanup, which stripped the `e` and CONCATENATED the mantissa to\n * the exponent. A field committed its own output as a different number:\n *\n *     \"1/10000000\"                -> \"1e-7\"               -> \"17\"   (AmountInput: \"6\")\n *     \"999999999999*999999999999\" -> \"9.99999999998e+23\"  -> \"9.9999999999823\"\n *\n * Both controls commit on blur AND on Enter, so Enter-then-click-away was enough on\n * its own, it was silent, and it was in a money field.\n *\n * The invariant, which the test asserts directly rather than by example:\n * **`commitExpression(formatResult(n))` equals `formatResult(n)` for every finite\n * `n`.** Anything rendered here has to survive being read back. */\nexport function formatResult(n: number): string {\n  if (!Number.isFinite(n)) return \"\";\n  // At or above 1e21 `toFixed` gives up and hands back `toString`'s exponent form —\n  // but every double that large is an integer, so BigInt renders it exactly.\n  if (Math.abs(n) >= 1e21) return BigInt(n).toString();\n  return trimTrailingZeros(n.toFixed(10));\n}\n\n/** \"15.7000000000\" -> \"15.7\", \"0.0000000000\" -> \"0\". The ten decimals are where the\n *  binary float noise gets rounded off; this is only about not showing the padding. */\nfunction trimTrailingZeros(fixed: string): string {\n  if (!fixed.includes(\".\")) return fixed;\n  const trimmed = fixed.replace(/0+$/, \"\").replace(/\\.$/, \"\");\n  // `toFixed` keeps the sign on a magnitude that rounded away to nothing\n  // (\"-0.0000000000\"); `toString` did not, and \"-0\" in an amount field is noise.\n  return trimmed === \"-0\" || trimmed === \"\" ? \"0\" : trimmed;\n}\n\n/** The single \"on blur / Enter\" transform a numeric field applies: evaluate the\n * text if it's an expression, otherwise normalise it to a bare number string\n * (comma → dot, dropping stray characters, non-leading minuses and anything after\n * a second decimal point).\n *\n * The last clause is the backstop for Keksdose live #201. A field the user typed in\n * cannot reach here malformed any more — {@link sanitizeLive} runs on every change,\n * including a paste — but a value handed in from elsewhere (a recurring rule, an\n * import, a test) still can, and \"1.2.3\" is not an expression (no operator), so it\n * used to fall straight through unchanged and be read as NaN. Here the text is CUT\n * at the second dot (\"1.2\") rather than joined (\"1.23\"): with no keystroke to\n * ignore there is nothing to say which reading was meant, and the shorter one\n * cannot silently invent a bigger number. */\nexport function commitExpression(raw: string): string {\n  const s = raw.trim();\n  if (looksLikeExpression(s)) {\n    const n = evaluateExpression(s);\n    if (n !== null) return formatResult(n);\n    // Unparseable (e.g. a half-typed \"12+\"): fall through to a digits-only clean.\n  }\n  // Global, like sanitizeLive's: these two are the two halves of one rule and must\n  // not appear to state it differently. (The `[^0-9.-]` strip on the same line\n  // already ate whatever commas a non-global replace missed, so this changes no\n  // behaviour — it removes the need for the next reader to run it to find that out.)\n  const cleaned = s\n    .replace(/,/g, \".\")\n    .replace(/[^0-9.-]/g, \"\")\n    .replace(/(?!^)-/g, \"\");\n  return cleaned.replace(/^(-?\\d*\\.?\\d*).*$/, \"$1\");\n}\n\n/** The live, per-keystroke transform a numeric field applies: comma → dot and\n * drop anything that isn't a digit, decimal point, arithmetic operator (incl.\n * the on-screen `× ÷` glyphs) or paren — so a typed calculation survives\n * keystroke-by-keystroke but stray characters can't be entered. A lone leading\n * `-` is kept — in a plain field it is simply a negative amount; in a field whose\n * caller owns the sign it is read off again by {@link splitLeadingSign}. The text\n * is resolved to a plain number on blur/Enter via {@link commitExpression}.\n *\n * The typographic minus and the two dashes become \"-\" first, as in\n * {@link evaluateExpression}: U+2212 is what the kit's own `formatMoney` and\n * `formatNumber` print for every negative since 0.49, and stripping it with the\n * stray characters turned a pasted \"−1.234,50 €\" into a positive amount (refactor\n * audit 2026-10-30, INP-3). */\nexport function sanitizeLive(raw: string): string {\n  return dropExtraDots(\n    raw\n      .replace(/[−–—]/g, \"-\")\n      .replace(/,/g, \".\")\n      .replace(/[^0-9.+\\-*/×÷()]/g, \"\"),\n  );\n}\n\n/**\n * At most ONE decimal point per number (Keksdose live #201).\n *\n * Per NUMBER, not per string: \"1.5+2.5\" is a legitimate calculation with two dots\n * in two operands, so the counter resets at every operator and parenthesis.\n *\n * A second dot inside one operand is a **no-op keystroke** — the digits after it\n * keep landing, so \"1.2\" + \".\" + \"3\" is \"1.23\". That is what every calculator does\n * with a repeated decimal point, and it is the only option that does not make the\n * field feel broken (\"my 3 disappeared\"). This runs on paste as well as on typing,\n * so the malformed value never reaches the rest of the app: everything downstream\n * reads the field with `Number()`, NaN became a silent 0, and on the create form\n * that 0 was painted with the income green — a figure that was not a number at all\n * asserting money was coming in.\n */\nfunction dropExtraDots(s: string): string {\n  let out = \"\";\n  let dotInNumber = false;\n  for (const ch of s) {\n    if (ch === \".\") {\n      if (dotInNumber) continue;\n      dotInNumber = true;\n    } else if (ch < \"0\" || ch > \"9\") {\n      // An operator or a paren ends the current operand.\n      dotInNumber = false;\n    }\n    out += ch;\n  }\n  return out;\n}\n\n/** A bare, unsigned amount: digits with at most one decimal separator and nothing\n *  else — \"42\", \"42.\", \".5\", \"0,5\". NOT \"\" (an empty field has no figure to put a\n *  sign in front of), not \"-42\", not \"12+5\". It is the only shape a DISPLAYED sign\n *  prefix makes sense in front of; an expression carries its own arithmetic and has\n *  to survive keystroke-for-keystroke. */\nexport function isBareAmount(s: string): boolean {\n  const t = s.trim();\n  return t !== \"\" && /^\\d*[.,]?\\d*$/.test(t);\n}\n\n/**\n * Split a LEADING sign off a plain signed number (Keksdose live #201 rework):\n * `\"-42\"` → `{ sign: \"-\", rest: \"42\" }`, everything else → `{ sign: \"\", rest: text }`.\n *\n * Only in front of a bare amount, because a minus with arithmetic after it IS\n * arithmetic: \"12-30\" is a subtraction, and \"-12+5\" is -7, not -(12+5). Those come\n * back untouched and are resolved by {@link commitExpression} on blur — at which\n * point the RESULT is a plain signed number and this function does get to speak.\n *\n * A lone \"-\" splits (rest \"\"): the sign is a statement about the direction the\n * moment it is typed, before any digit exists.\n */\nexport function splitLeadingSign(text: string): { sign: \"\" | \"-\" | \"+\"; rest: string } {\n  const trimmed = text.trimStart();\n  const sign = trimmed.charAt(0);\n  if (sign !== \"-\" && sign !== \"+\") return { sign: \"\", rest: text };\n  const rest = trimmed.slice(1);\n  if (rest !== \"\" && !isBareAmount(rest)) return { sign: \"\", rest: text };\n  return { sign, rest };\n}\n"],"mappings":"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","names":[]}

package/dist/lib/clipboard-minus.d.ts

@@ -5,8 +5,8 @@
  * as a number: a figure copied out of a kit table and pasted into Excel landed as text.
  * So while a selection inside the page is copied, every U+2212 standing directly before a
  * number — optionally after a currency code or symbol and spaces: "−CHF 1,250.50",
- * "−€2,000", "−12%" — becomes the ASCII "-" in the clipboard, in `text/plain` AND in
- * `text/html` (Excel pastes the HTML flavour, as cells). The page keeps "−".
+ * "−€2,000", "−US$12", "−12%" — becomes the ASCII "-" in the clipboard, in `text/plain` AND
+ * in `text/html` (Excel pastes the HTML flavour, as cells). The page keeps "−".
  *
  * A copy with no such minus is left to the browser untouched, and so is any copy out of an
  * input, a textarea or an editable element: what the person typed is theirs.

package/dist/lib/clipboard-minus.js

@@ -1,5 +1,5 @@
 "use client";
-const MINUS_BEFORE_NUMBER = /\u2212(?=(?:[A-Z]{3}|\p{Sc})?[\s\u00a0\u202f]*\d)/gu;
+const MINUS_BEFORE_NUMBER = /\u2212(?=[\p{L}\p{Sc}.]{0,5}[\s\u00a0\u202f]*\d)/gu;
 function asciiMinusInNumbers(text) {
   return text.replace(MINUS_BEFORE_NUMBER, "-");
 }

package/dist/lib/clipboard-minus.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/lib/clipboard-minus.ts"],"sourcesContent":["/**\n * The copy handler for the one minus sign (0.49 KIT-1b, Marcel's follow-up to KIT-1).\n *\n * The kit prints a negative with U+2212 (lib/minus.ts). A spreadsheet does not read that\n * as a number: a figure copied out of a kit table and pasted into Excel landed as text.\n * So while a selection inside the page is copied, every U+2212 standing directly before a\n * number — optionally after a currency code or symbol and spaces: \"−CHF 1,250.50\",\n * \"−€2,000\", \"−12%\" — becomes the ASCII \"-\" in the clipboard, in `text/plain` AND in\n * `text/html` (Excel pastes the HTML flavour, as cells). The page keeps \"−\".\n *\n * A copy with no such minus is left to the browser untouched, and so is any copy out of an\n * input, a textarea or an editable element: what the person typed is theirs.\n *\n * Installed once per document by `UiKitProvider` (`copyAsciiMinus`, default `true`) —\n * the one part every app mounts, the signed-out pages included.\n */\n\n/** U+2212, then (optionally) a currency code or symbol, then spaces, then a digit. */\nconst MINUS_BEFORE_NUMBER = /\\u2212(?=(?:[A-Z]{3}|\\p{Sc})?[\\s\\u00a0\\u202f]*\\d)/gu;\n\n/**\n * `text` with each U+2212 that stands before a number (in the sense above) as the ASCII\n * hyphen-minus, every other character as it was — for text an app hands a machine that\n * did not come from a formatter's `minus: \"ascii\"`.\n */\nexport function asciiMinusInNumbers(text: string): string {\n  return text.replace(MINUS_BEFORE_NUMBER, \"-\");\n}\n\nfunction hasMinusBeforeNumber(text: string): boolean {\n  MINUS_BEFORE_NUMBER.lastIndex = 0;\n  const found = MINUS_BEFORE_NUMBER.test(text);\n  MINUS_BEFORE_NUMBER.lastIndex = 0;\n  return found;\n}\n\n/** An input, a textarea or an editable element: a copy there is the person's own text. */\nfunction isEditable(node: Node | null | undefined): boolean {\n  const el = node instanceof Element ? node : node?.parentElement;\n  if (!el) return false;\n  if (el.closest(\"input, textarea, select\")) return true;\n  return (\n    (el as HTMLElement).isContentEditable === true ||\n    el.closest('[contenteditable=\"\"], [contenteditable=\"true\"]') !== null\n  );\n}\n\n/** Table parts copied alone are wrapped back into a table, which Excel reads as cells. */\nfunction wrapTableParts(container: HTMLElement): string {\n  const first = container.firstElementChild?.tagName;\n  const html = container.innerHTML;\n  if (first === \"TD\" || first === \"TH\") return `<table><tbody><tr>${html}</tr></tbody></table>`;\n  if (first === \"TR\") return `<table><tbody>${html}</tbody></table>`;\n  if (first === \"TBODY\" || first === \"THEAD\" || first === \"TFOOT\") return `<table>${html}</table>`;\n  return html;\n}\n\nfunction onCopy(event: ClipboardEvent): void {\n  if (event.defaultPrevented || !event.clipboardData) return;\n  const doc = (event.target as Node | null)?.ownerDocument ?? document;\n  if (isEditable(event.target as Node | null) || isEditable(doc.activeElement)) return;\n  const selection = doc.getSelection();\n  if (!selection || selection.rangeCount === 0 || selection.isCollapsed) return;\n  if (isEditable(selection.anchorNode) || isEditable(selection.focusNode)) return;\n  const text = selection.toString();\n  if (!hasMinusBeforeNumber(text)) return;\n\n  const container = doc.createElement(\"div\");\n  for (let i = 0; i < selection.rangeCount; i++) container.appendChild(selection.getRangeAt(i).cloneContents());\n  const walker = doc.createTreeWalker(container, NodeFilter.SHOW_TEXT);\n  for (let node = walker.nextNode(); node; node = walker.nextNode()) {\n    node.nodeValue = asciiMinusInNumbers(node.nodeValue ?? \"\");\n  }\n  event.clipboardData.setData(\"text/plain\", asciiMinusInNumbers(text));\n  event.clipboardData.setData(\"text/html\", wrapTableParts(container));\n  event.preventDefault();\n}\n\nconst installs = new WeakMap<Document, number>();\n\n/**\n * Listen for copies on `doc` until the returned function is called. Counted: nested\n * providers install it once, and the last one to go removes it.\n */\nexport function installClipboardMinus(doc: Document = document): () => void {\n  const count = installs.get(doc) ?? 0;\n  if (count === 0) doc.addEventListener(\"copy\", onCopy);\n  installs.set(doc, count + 1);\n  let done = false;\n  return () => {\n    if (done) return;\n    done = true;\n    const left = (installs.get(doc) ?? 1) - 1;\n    installs.set(doc, left);\n    if (left === 0) doc.removeEventListener(\"copy\", onCopy);\n  };\n}\n"],"mappings":";AAkBA,MAAM,sBAAsB;AAOrB,SAAS,oBAAoB,MAAsB;AACxD,SAAO,KAAK,QAAQ,qBAAqB,GAAG;AAC9C;AAEA,SAAS,qBAAqB,MAAuB;AACnD,sBAAoB,YAAY;AAChC,QAAM,QAAQ,oBAAoB,KAAK,IAAI;AAC3C,sBAAoB,YAAY;AAChC,SAAO;AACT;AAGA,SAAS,WAAW,MAAwC;AAC1D,QAAM,KAAK,gBAAgB,UAAU,OAAO,MAAM;AAClD,MAAI,CAAC,GAAI,QAAO;AAChB,MAAI,GAAG,QAAQ,yBAAyB,EAAG,QAAO;AAClD,SACG,GAAmB,sBAAsB,QAC1C,GAAG,QAAQ,gDAAgD,MAAM;AAErE;AAGA,SAAS,eAAe,WAAgC;AACtD,QAAM,QAAQ,UAAU,mBAAmB;AAC3C,QAAM,OAAO,UAAU;AACvB,MAAI,UAAU,QAAQ,UAAU,KAAM,QAAO,qBAAqB,IAAI;AACtE,MAAI,UAAU,KAAM,QAAO,iBAAiB,IAAI;AAChD,MAAI,UAAU,WAAW,UAAU,WAAW,UAAU,QAAS,QAAO,UAAU,IAAI;AACtF,SAAO;AACT;AAEA,SAAS,OAAO,OAA6B;AAC3C,MAAI,MAAM,oBAAoB,CAAC,MAAM,cAAe;AACpD,QAAM,MAAO,MAAM,QAAwB,iBAAiB;AAC5D,MAAI,WAAW,MAAM,MAAqB,KAAK,WAAW,IAAI,aAAa,EAAG;AAC9E,QAAM,YAAY,IAAI,aAAa;AACnC,MAAI,CAAC,aAAa,UAAU,eAAe,KAAK,UAAU,YAAa;AACvE,MAAI,WAAW,UAAU,UAAU,KAAK,WAAW,UAAU,SAAS,EAAG;AACzE,QAAM,OAAO,UAAU,SAAS;AAChC,MAAI,CAAC,qBAAqB,IAAI,EAAG;AAEjC,QAAM,YAAY,IAAI,cAAc,KAAK;AACzC,WAAS,IAAI,GAAG,IAAI,UAAU,YAAY,IAAK,WAAU,YAAY,UAAU,WAAW,CAAC,EAAE,cAAc,CAAC;AAC5G,QAAM,SAAS,IAAI,iBAAiB,WAAW,WAAW,SAAS;AACnE,WAAS,OAAO,OAAO,SAAS,GAAG,MAAM,OAAO,OAAO,SAAS,GAAG;AACjE,SAAK,YAAY,oBAAoB,KAAK,aAAa,EAAE;AAAA,EAC3D;AACA,QAAM,cAAc,QAAQ,cAAc,oBAAoB,IAAI,CAAC;AACnE,QAAM,cAAc,QAAQ,aAAa,eAAe,SAAS,CAAC;AAClE,QAAM,eAAe;AACvB;AAEA,MAAM,WAAW,oBAAI,QAA0B;AAMxC,SAAS,sBAAsB,MAAgB,UAAsB;AAC1E,QAAM,QAAQ,SAAS,IAAI,GAAG,KAAK;AACnC,MAAI,UAAU,EAAG,KAAI,iBAAiB,QAAQ,MAAM;AACpD,WAAS,IAAI,KAAK,QAAQ,CAAC;AAC3B,MAAI,OAAO;AACX,SAAO,MAAM;AACX,QAAI,KAAM;AACV,WAAO;AACP,UAAM,QAAQ,SAAS,IAAI,GAAG,KAAK,KAAK;AACxC,aAAS,IAAI,KAAK,IAAI;AACtB,QAAI,SAAS,EAAG,KAAI,oBAAoB,QAAQ,MAAM;AAAA,EACxD;AACF;","names":[]}
+{"version":3,"sources":["../../src/lib/clipboard-minus.ts"],"sourcesContent":["/**\n * The copy handler for the one minus sign (0.49 KIT-1b, Marcel's follow-up to KIT-1).\n *\n * The kit prints a negative with U+2212 (lib/minus.ts). A spreadsheet does not read that\n * as a number: a figure copied out of a kit table and pasted into Excel landed as text.\n * So while a selection inside the page is copied, every U+2212 standing directly before a\n * number — optionally after a currency code or symbol and spaces: \"−CHF 1,250.50\",\n * \"−€2,000\", \"−US$12\", \"−12%\" — becomes the ASCII \"-\" in the clipboard, in `text/plain` AND\n * in `text/html` (Excel pastes the HTML flavour, as cells). The page keeps \"−\".\n *\n * A copy with no such minus is left to the browser untouched, and so is any copy out of an\n * input, a textarea or an editable element: what the person typed is theirs.\n *\n * Installed once per document by `UiKitProvider` (`copyAsciiMinus`, default `true`) —\n * the one part every app mounts, the signed-out pages included.\n */\n\n/**\n * U+2212, then up to five letters, currency symbols or dots, then spaces, then a digit.\n *\n * Five of them, not \"a code or one symbol\": English and Chinese write a currency with\n * letters before the symbol — \"−US$\", \"−CA$\", \"−A$\", \"−NZ$\", \"−HK$\", \"−R$\", \"−MX$\",\n * \"−JP¥\", \"−CN¥\" — and `narrowSymbol` with letters alone (\"−kr\", \"−zł\", \"−Kč\"). Those kept\n * U+2212 in the clipboard, and Excel pasted them as text: 35 of 351 locale × currency\n * pairs at the default display, every one English or Chinese, and 136 of 1428 with\n * `narrowSymbol` (refactor audit 2026-10-30, DSP-11). A minus with no digit after it\n * (\"x−y\", \"a − b\") is still left alone.\n */\nconst MINUS_BEFORE_NUMBER = /\\u2212(?=[\\p{L}\\p{Sc}.]{0,5}[\\s\\u00a0\\u202f]*\\d)/gu;\n\n/**\n * `text` with each U+2212 that stands before a number (in the sense above) as the ASCII\n * hyphen-minus, every other character as it was — for text an app hands a machine that\n * did not come from a formatter's `minus: \"ascii\"`.\n */\nexport function asciiMinusInNumbers(text: string): string {\n  return text.replace(MINUS_BEFORE_NUMBER, \"-\");\n}\n\nfunction hasMinusBeforeNumber(text: string): boolean {\n  MINUS_BEFORE_NUMBER.lastIndex = 0;\n  const found = MINUS_BEFORE_NUMBER.test(text);\n  MINUS_BEFORE_NUMBER.lastIndex = 0;\n  return found;\n}\n\n/** An input, a textarea or an editable element: a copy there is the person's own text. */\nfunction isEditable(node: Node | null | undefined): boolean {\n  const el = node instanceof Element ? node : node?.parentElement;\n  if (!el) return false;\n  if (el.closest(\"input, textarea, select\")) return true;\n  return (\n    (el as HTMLElement).isContentEditable === true ||\n    el.closest('[contenteditable=\"\"], [contenteditable=\"true\"]') !== null\n  );\n}\n\n/** Table parts copied alone are wrapped back into a table, which Excel reads as cells. */\nfunction wrapTableParts(container: HTMLElement): string {\n  const first = container.firstElementChild?.tagName;\n  const html = container.innerHTML;\n  if (first === \"TD\" || first === \"TH\") return `<table><tbody><tr>${html}</tr></tbody></table>`;\n  if (first === \"TR\") return `<table><tbody>${html}</tbody></table>`;\n  if (first === \"TBODY\" || first === \"THEAD\" || first === \"TFOOT\") return `<table>${html}</table>`;\n  return html;\n}\n\nfunction onCopy(event: ClipboardEvent): void {\n  if (event.defaultPrevented || !event.clipboardData) return;\n  const doc = (event.target as Node | null)?.ownerDocument ?? document;\n  if (isEditable(event.target as Node | null) || isEditable(doc.activeElement)) return;\n  const selection = doc.getSelection();\n  if (!selection || selection.rangeCount === 0 || selection.isCollapsed) return;\n  if (isEditable(selection.anchorNode) || isEditable(selection.focusNode)) return;\n  const text = selection.toString();\n  if (!hasMinusBeforeNumber(text)) return;\n\n  const container = doc.createElement(\"div\");\n  for (let i = 0; i < selection.rangeCount; i++) container.appendChild(selection.getRangeAt(i).cloneContents());\n  const walker = doc.createTreeWalker(container, NodeFilter.SHOW_TEXT);\n  for (let node = walker.nextNode(); node; node = walker.nextNode()) {\n    node.nodeValue = asciiMinusInNumbers(node.nodeValue ?? \"\");\n  }\n  event.clipboardData.setData(\"text/plain\", asciiMinusInNumbers(text));\n  event.clipboardData.setData(\"text/html\", wrapTableParts(container));\n  event.preventDefault();\n}\n\nconst installs = new WeakMap<Document, number>();\n\n/**\n * Listen for copies on `doc` until the returned function is called. Counted: nested\n * providers install it once, and the last one to go removes it.\n */\nexport function installClipboardMinus(doc: Document = document): () => void {\n  const count = installs.get(doc) ?? 0;\n  if (count === 0) doc.addEventListener(\"copy\", onCopy);\n  installs.set(doc, count + 1);\n  let done = false;\n  return () => {\n    if (done) return;\n    done = true;\n    const left = (installs.get(doc) ?? 1) - 1;\n    installs.set(doc, left);\n    if (left === 0) doc.removeEventListener(\"copy\", onCopy);\n  };\n}\n"],"mappings":";AA4BA,MAAM,sBAAsB;AAOrB,SAAS,oBAAoB,MAAsB;AACxD,SAAO,KAAK,QAAQ,qBAAqB,GAAG;AAC9C;AAEA,SAAS,qBAAqB,MAAuB;AACnD,sBAAoB,YAAY;AAChC,QAAM,QAAQ,oBAAoB,KAAK,IAAI;AAC3C,sBAAoB,YAAY;AAChC,SAAO;AACT;AAGA,SAAS,WAAW,MAAwC;AAC1D,QAAM,KAAK,gBAAgB,UAAU,OAAO,MAAM;AAClD,MAAI,CAAC,GAAI,QAAO;AAChB,MAAI,GAAG,QAAQ,yBAAyB,EAAG,QAAO;AAClD,SACG,GAAmB,sBAAsB,QAC1C,GAAG,QAAQ,gDAAgD,MAAM;AAErE;AAGA,SAAS,eAAe,WAAgC;AACtD,QAAM,QAAQ,UAAU,mBAAmB;AAC3C,QAAM,OAAO,UAAU;AACvB,MAAI,UAAU,QAAQ,UAAU,KAAM,QAAO,qBAAqB,IAAI;AACtE,MAAI,UAAU,KAAM,QAAO,iBAAiB,IAAI;AAChD,MAAI,UAAU,WAAW,UAAU,WAAW,UAAU,QAAS,QAAO,UAAU,IAAI;AACtF,SAAO;AACT;AAEA,SAAS,OAAO,OAA6B;AAC3C,MAAI,MAAM,oBAAoB,CAAC,MAAM,cAAe;AACpD,QAAM,MAAO,MAAM,QAAwB,iBAAiB;AAC5D,MAAI,WAAW,MAAM,MAAqB,KAAK,WAAW,IAAI,aAAa,EAAG;AAC9E,QAAM,YAAY,IAAI,aAAa;AACnC,MAAI,CAAC,aAAa,UAAU,eAAe,KAAK,UAAU,YAAa;AACvE,MAAI,WAAW,UAAU,UAAU,KAAK,WAAW,UAAU,SAAS,EAAG;AACzE,QAAM,OAAO,UAAU,SAAS;AAChC,MAAI,CAAC,qBAAqB,IAAI,EAAG;AAEjC,QAAM,YAAY,IAAI,cAAc,KAAK;AACzC,WAAS,IAAI,GAAG,IAAI,UAAU,YAAY,IAAK,WAAU,YAAY,UAAU,WAAW,CAAC,EAAE,cAAc,CAAC;AAC5G,QAAM,SAAS,IAAI,iBAAiB,WAAW,WAAW,SAAS;AACnE,WAAS,OAAO,OAAO,SAAS,GAAG,MAAM,OAAO,OAAO,SAAS,GAAG;AACjE,SAAK,YAAY,oBAAoB,KAAK,aAAa,EAAE;AAAA,EAC3D;AACA,QAAM,cAAc,QAAQ,cAAc,oBAAoB,IAAI,CAAC;AACnE,QAAM,cAAc,QAAQ,aAAa,eAAe,SAAS,CAAC;AAClE,QAAM,eAAe;AACvB;AAEA,MAAM,WAAW,oBAAI,QAA0B;AAMxC,SAAS,sBAAsB,MAAgB,UAAsB;AAC1E,QAAM,QAAQ,SAAS,IAAI,GAAG,KAAK;AACnC,MAAI,UAAU,EAAG,KAAI,iBAAiB,QAAQ,MAAM;AACpD,WAAS,IAAI,KAAK,QAAQ,CAAC;AAC3B,MAAI,OAAO;AACX,SAAO,MAAM;AACX,QAAI,KAAM;AACV,WAAO;AACP,UAAM,QAAQ,SAAS,IAAI,GAAG,KAAK,KAAK;AACxC,aAAS,IAAI,KAAK,IAAI;AACtB,QAAI,SAAS,EAAG,KAAI,oBAAoB,QAAQ,MAAM;AAAA,EACxD;AACF;","names":[]}

package/dist/lib/date-format.d.ts

@@ -49,6 +49,15 @@ export interface DateFormatOptions {
     /** Name the day of the week too, in the interface language ("Mo., 01.08.2026"). A date
      *  in a COLUMN carries it; a date in a SENTENCE does not (keksdose dev#546). */
     weekday?: boolean;
+    /**
+     * 0.52: the IANA zone a TIMESTAMP's day and clock are read in ("Europe/Zurich") — pass
+     * the `<UiKitProvider timeZone>` (`useKitTimeZone()`), so an app's own column says what
+     * the kit's components say for the same instant. Left out: the device's. A bare
+     * "YYYY-MM-DD" ignores it: a calendar day is the day it names in every zone. A zone
+     * `Intl` refuses reads as the device's. The renderers read it; {@link resolveDateFormat}
+     * does not.
+     */
+    timeZone?: string;
 }
 /**
  * What a date is rendered with, given the preference and the interface language
@@ -64,10 +73,36 @@ export declare function resolveDateFormat(preference: DateFormatPreference, lang
  * A date under the preference: `""` for no value, the input itself when it does not
  * parse. A bare "YYYY-MM-DD" is the calendar day it names in every zone (formatted in
  * UTC, undoing `new Date`'s UTC-midnight parse — west of Greenwich it read a day early);
- * a timestamp is an instant and stays in the reader's zone. The weekday, when asked for,
- * is rendered in the same zone, so a Sunday is never captioned Saturday.
+ * a timestamp is an instant, read in `options.timeZone`, else the reader's zone. The
+ * weekday, when asked for, is rendered in the same zone, so a Sunday is never captioned
+ * Saturday.
  */
 export declare function formatDateWithPreference(value: string | Date | null | undefined, preference: DateFormatPreference, language: string | undefined, options?: DateFormatOptions): string;
+/**
+ * The clock time of `date` as the language writes it ("14:05"), two digits each: rule 3,
+ * a clock follows the language, never the preference — `sv-SE` is a statement about the
+ * order of a date's digits, not about a 12- or 24-hour clock. `language` is read through
+ * `formatLocaleOf`, so English is the British 24-hour clock, not "02:05 PM" in a
+ * German household's app. In `timeZone` when given, else the reader's.
+ *
+ * @internal Shared with the kit's own day formatter; not part of the barrel.
+ */
+export declare function clockTime(date: Date, language: string | undefined, timeZone?: string): string;
+/**
+ * A timestamp under the preference (0.52, keksdose's `formatDateTimeFor`, refactor audit
+ * 2026-10-30, DUP-2): the date as {@link formatDateWithPreference} writes it, weekday
+ * when asked for, then the clock time in the LANGUAGE ({@link clockTime}): "01.08.2026,
+ * 14:05", "Sa., 01.08.2026, 14:05". keksdose's notification inbox and admin scheduler
+ * were where an explicit ISO choice did nothing until it wrote this. `""` for no value,
+ * the input itself when it does not parse; a bare "YYYY-MM-DD" names no moment, so it
+ * prints as the date alone.
+ *
+ * Day and clock in `options.timeZone` — pass the provider's (`useKitTimeZone()`): without
+ * it they were the device's, and an app on Zurich time read from New York printed 09:05
+ * in its own column where the kit's inbox printed 14:05 for the same instant (0.52 code
+ * review, this file).
+ */
+export declare function formatDateTimeWithPreference(value: string | Date | null | undefined, preference: DateFormatPreference, language: string | undefined, options?: DateFormatOptions): string;
 /** The sample an option is labelled with — 1 August 2026 in its shape, the shape being
  *  the whole choice (a country name would say nothing about the digit order). */
 export declare function dateFormatSample(preference: DateFormatPreference, language: string | undefined): string;

package/dist/lib/date-format.js

@@ -1,5 +1,8 @@
 "use client";
 import { formatLocaleOf } from "../i18n/languages.js";
+import { pad, toLocalIso } from "./dates.js";
+import { dateFormatter } from "./intl-cache.js";
+import { isBareIsoDay } from "./iso-day.js";
 const DATE_FORMAT_PREFERENCES = ["auto", "de-DE", "en-GB", "en-US", "sv-SE"];
 function isDateFormatPreference(value) {
   return typeof value === "string" && DATE_FORMAT_PREFERENCES.includes(value);
@@ -12,10 +15,9 @@ function resolveDateFormat(preference, language, options = {}) {
   }
   return { locale: preference, options: { year: "numeric", month: "2-digit", day: "2-digit" }, ...weekday };
 }
-const DATE_ONLY = /^\d{4}-\d{2}-\d{2}$/;
 function withWeekday(date, dateText, locale, options) {
   const isDatePart = (p) => p.type === "day" || p.type === "month" || p.type === "year";
-  const parts = new Intl.DateTimeFormat(locale, { weekday: "short", ...options }).formatToParts(date);
+  const parts = dateFormatter(locale, { weekday: "short", ...options }).formatToParts(date);
   const first = parts.findIndex(isDatePart);
   if (first === -1) return dateText;
   let last = first;
@@ -28,16 +30,38 @@ function withWeekday(date, dateText, locale, options) {
 function formatDateWithPreference(value, preference, language, options = {}) {
   if (!value) return "";
   const resolved = resolveDateFormat(preference, language, options);
-  const dateOnly = typeof value === "string" && DATE_ONLY.test(value);
+  const dateOnly = isBareIsoDay(value);
   const date = typeof value === "string" ? new Date(value) : value;
   if (Number.isNaN(date.getTime())) return String(value);
-  const intl = dateOnly ? { ...resolved.options, timeZone: "UTC" } : resolved.options;
-  try {
-    const text = date.toLocaleDateString(resolved.locale, intl);
+  const render = (timeZone) => {
+    const intl = timeZone ? { ...resolved.options, timeZone } : resolved.options;
+    const text = dateFormatter(resolved.locale, intl).format(date);
     return resolved.weekday ? withWeekday(date, text, resolved.weekday.locale, intl) : text;
-  } catch {
-    return date.toISOString().slice(0, 10);
+  };
+  if (dateOnly) return firstAccepted([() => render("UTC")], () => value);
+  return firstAccepted([() => render(options.timeZone), () => render(void 0)], () => toLocalIso(date));
+}
+function firstAccepted(renders, last) {
+  for (const render of renders) {
+    try {
+      return render();
+    } catch {
+    }
   }
+  return last();
+}
+function clockTime(date, language, timeZone) {
+  const locale = language ? formatLocaleOf(language) : void 0;
+  const clock = (zone) => dateFormatter(locale, { hour: "2-digit", minute: "2-digit", ...zone ? { timeZone: zone } : null }).format(date);
+  const reader = () => `${pad(date.getHours())}:${pad(date.getMinutes())}`;
+  return firstAccepted([() => clock(timeZone), () => clock(void 0)], reader);
+}
+function formatDateTimeWithPreference(value, preference, language, options = {}) {
+  if (!value) return "";
+  if (isBareIsoDay(value)) return formatDateWithPreference(value, preference, language, options);
+  const date = typeof value === "string" ? new Date(value) : value;
+  if (Number.isNaN(date.getTime())) return String(value);
+  return `${formatDateWithPreference(date, preference, language, options)}, ${clockTime(date, language, options.timeZone)}`;
 }
 function dateFormatSample(preference, language) {
   return formatDateWithPreference("2026-08-01", preference, language);
@@ -47,8 +71,10 @@ function dateFormatterFor(preference, language) {
 }
 export {
   DATE_FORMAT_PREFERENCES,
+  clockTime,
   dateFormatSample,
   dateFormatterFor,
+  formatDateTimeWithPreference,
   formatDateWithPreference,
   isDateFormatPreference,
   resolveDateFormat

package/dist/lib/date-format.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/lib/date-format.ts"],"sourcesContent":["import { formatLocaleOf } from \"../i18n/languages\";\nimport type { KitDateFormatter } from \"../i18n/kit-labels\";\n\n/**\n * The date-format preference (0.46, lifted from keksdose's `date-format-store.ts`,\n * feedback #180): how a DAY is written — the order of day, month and year and the\n * separator between them — as a choice of its own, apart from the interface language.\n * \"Read the app in English and still see German dates\", or ISO everywhere.\n *\n * keksdose's rules, which the kit keeps:\n *\n * 1. **A label that identifies a day follows the preference** — anything that prints\n *    day, month and year goes through {@link formatDateWithPreference} (or the\n *    provider's `formatDate`, {@link dateFormatterFor}, for the kit's own date fields).\n * 2. **A label without a day follows the language**: \"August 2026\", a month or weekday\n *    NAME has no order to arrange. {@link dateFormatterFor} answers `\"\"` for a month or a\n *    year, so the kit keeps its own rendering in the language.\n * 3. **A clock time follows the language**: `sv-SE` is a statement about digit order in\n *    a date, not about a 12- or 24-hour clock.\n * 4. **A weekday's NAME follows the language** (dev#546): `sv-SE` means \"year first,\n *    with dashes\", not \"the reader speaks Swedish\" — so with `weekday` the day's name is\n *    the language's, joined to the date the preference renders.\n *\n * The preference is the APP's to keep — keksdose holds it per device (a persisted store,\n * not an account column: nothing server-written formats a date for the reader). The kit\n * owns the vocabulary, the resolver, the renderer and the settings field\n * ({@link DateFormatSetting}).\n */\n\n/** `\"auto\"` follows the interface language (the default — nobody's dates move until\n *  they ask); the rest are BCP 47 tags chosen for the SHAPE they produce: German\n *  01.08.2026, British 01/08/2026, US 08/01/2026, ISO 2026-08-01. */\nexport type DateFormatPreference = \"auto\" | \"de-DE\" | \"en-GB\" | \"en-US\" | \"sv-SE\";\n\n/** The options in the order the setting lists them: `auto` first (the default), then\n *  German → UK → US → ISO. */\nexport const DATE_FORMAT_PREFERENCES: readonly DateFormatPreference[] = [\"auto\", \"de-DE\", \"en-GB\", \"en-US\", \"sv-SE\"];\n\n/** Whether `value` is one of {@link DATE_FORMAT_PREFERENCES} — for a value read back from\n *  storage, where anything else falls back to `\"auto\"`. */\nexport function isDateFormatPreference(value: unknown): value is DateFormatPreference {\n  return typeof value === \"string\" && (DATE_FORMAT_PREFERENCES as readonly string[]).includes(value);\n}\n\n/** A resolved preference: the locale and `Intl` options the date itself is rendered\n *  with, and — only when asked for — the locale the weekday's NAME comes from. */\nexport interface ResolvedDateFormat {\n  locale: string | undefined;\n  options: Intl.DateTimeFormatOptions;\n  /** The language's format locale, present when `weekday` was asked for. */\n  weekday?: { locale: string | undefined };\n}\n\n/** What {@link resolveDateFormat} and the renderers take beyond the preference. */\nexport interface DateFormatOptions {\n  /** Name the day of the week too, in the interface language (\"Mo., 01.08.2026\"). A date\n   *  in a COLUMN carries it; a date in a SENTENCE does not (keksdose dev#546). */\n  weekday?: boolean;\n}\n\n/**\n * What a date is rendered with, given the preference and the interface language\n * (`language`: a code or tag — `\"de\"`, `\"en\"`, i18next's `resolvedLanguage`; it is read\n * through `formatLocaleOf`, so English is British and an unshipped tag stays itself).\n *\n * `\"auto\"` keeps the short-month shape (\"01 Aug 2026\", \"01. Aug. 2026\"); every explicit\n * choice is all-numeric, the only way it produces the shape its option promises —\n * `month: \"short\"` under `sv-SE` would print \"2026 aug. 01\", not ISO.\n */\nexport function resolveDateFormat(\n  preference: DateFormatPreference,\n  language: string | undefined,\n  options: DateFormatOptions = {},\n): ResolvedDateFormat {\n  const languageLocale = language ? formatLocaleOf(language) : undefined;\n  const weekday = options.weekday ? { weekday: { locale: languageLocale } } : {};\n  if (preference === \"auto\") {\n    return { locale: languageLocale, options: { year: \"numeric\", month: \"short\", day: \"2-digit\" }, ...weekday };\n  }\n  return { locale: preference, options: { year: \"numeric\", month: \"2-digit\", day: \"2-digit\" }, ...weekday };\n}\n\n/** A bare calendar day: no time, no zone. */\nconst DATE_ONLY = /^\\d{4}-\\d{2}-\\d{2}$/;\n\n/**\n * `dateText`, already rendered under the preference, with the day's NAME around it in\n * `locale` (the language's). Not \"weekday alone + comma\": German says \"So\" alone and\n * \"So., 06.09.2026\" in company. The full date is formatted in the language and split\n * into parts; what that language puts before the first and after the last day/month/\n * year part (the weekday, its comma) frames the preference's digits — so where the two\n * locales coincide the output is the native string, character for character.\n */\nfunction withWeekday(date: Date, dateText: string, locale: string | undefined, options: Intl.DateTimeFormatOptions) {\n  const isDatePart = (p: Intl.DateTimeFormatPart) => p.type === \"day\" || p.type === \"month\" || p.type === \"year\";\n  const parts = new Intl.DateTimeFormat(locale, { weekday: \"short\", ...options }).formatToParts(date);\n  const first = parts.findIndex(isDatePart);\n  if (first === -1) return dateText;\n  let last = first;\n  parts.forEach((p, i) => {\n    if (isDatePart(p)) last = i;\n  });\n  const join = (ps: Intl.DateTimeFormatPart[]) => ps.map((p) => p.value).join(\"\");\n  return join(parts.slice(0, first)) + dateText + join(parts.slice(last + 1));\n}\n\n/**\n * A date under the preference: `\"\"` for no value, the input itself when it does not\n * parse. A bare \"YYYY-MM-DD\" is the calendar day it names in every zone (formatted in\n * UTC, undoing `new Date`'s UTC-midnight parse — west of Greenwich it read a day early);\n * a timestamp is an instant and stays in the reader's zone. The weekday, when asked for,\n * is rendered in the same zone, so a Sunday is never captioned Saturday.\n */\nexport function formatDateWithPreference(\n  value: string | Date | null | undefined,\n  preference: DateFormatPreference,\n  language: string | undefined,\n  options: DateFormatOptions = {},\n): string {\n  if (!value) return \"\";\n  const resolved = resolveDateFormat(preference, language, options);\n  const dateOnly = typeof value === \"string\" && DATE_ONLY.test(value);\n  const date = typeof value === \"string\" ? new Date(value) : value;\n  if (Number.isNaN(date.getTime())) return String(value);\n  const intl: Intl.DateTimeFormatOptions = dateOnly ? { ...resolved.options, timeZone: \"UTC\" } : resolved.options;\n  try {\n    const text = date.toLocaleDateString(resolved.locale, intl);\n    return resolved.weekday ? withWeekday(date, text, resolved.weekday.locale, intl) : text;\n  } catch {\n    // A language tag `Intl` refuses: the ISO day rather than nothing (keksdose's fallback).\n    return date.toISOString().slice(0, 10);\n  }\n}\n\n/** The sample an option is labelled with — 1 August 2026 in its shape, the shape being\n *  the whole choice (a country name would say nothing about the digit order). */\nexport function dateFormatSample(preference: DateFormatPreference, language: string | undefined): string {\n  return formatDateWithPreference(\"2026-08-01\", preference, language);\n}\n\n/**\n * The `<UiKitProvider formatDate>` for a preference — so the kit's own date fields\n * (DatePicker, DateRangePicker, DateMark) write a day as the app's dates do. A day\n * follows the preference, with the weekday where the kit suggests it; a month or a year\n * answers `\"\"` and keeps the kit's rendering in the language (rule 2). Rebuild it when\n * the preference or the language changes (a `useMemo` on both).\n */\nexport function dateFormatterFor(preference: DateFormatPreference, language: string | undefined): KitDateFormatter {\n  return (iso, { unit, weekday, locale }) =>\n    unit === \"day\" ? formatDateWithPreference(iso, preference, locale ?? language, { weekday }) : \"\";\n}\n"],"mappings":";AAAA,SAAS,sBAAsB;AAoCxB,MAAM,0BAA2D,CAAC,QAAQ,SAAS,SAAS,SAAS,OAAO;AAI5G,SAAS,uBAAuB,OAA+C;AACpF,SAAO,OAAO,UAAU,YAAa,wBAA8C,SAAS,KAAK;AACnG;AA2BO,SAAS,kBACd,YACA,UACA,UAA6B,CAAC,GACV;AACpB,QAAM,iBAAiB,WAAW,eAAe,QAAQ,IAAI;AAC7D,QAAM,UAAU,QAAQ,UAAU,EAAE,SAAS,EAAE,QAAQ,eAAe,EAAE,IAAI,CAAC;AAC7E,MAAI,eAAe,QAAQ;AACzB,WAAO,EAAE,QAAQ,gBAAgB,SAAS,EAAE,MAAM,WAAW,OAAO,SAAS,KAAK,UAAU,GAAG,GAAG,QAAQ;AAAA,EAC5G;AACA,SAAO,EAAE,QAAQ,YAAY,SAAS,EAAE,MAAM,WAAW,OAAO,WAAW,KAAK,UAAU,GAAG,GAAG,QAAQ;AAC1G;AAGA,MAAM,YAAY;AAUlB,SAAS,YAAY,MAAY,UAAkB,QAA4B,SAAqC;AAClH,QAAM,aAAa,CAAC,MAA+B,EAAE,SAAS,SAAS,EAAE,SAAS,WAAW,EAAE,SAAS;AACxG,QAAM,QAAQ,IAAI,KAAK,eAAe,QAAQ,EAAE,SAAS,SAAS,GAAG,QAAQ,CAAC,EAAE,cAAc,IAAI;AAClG,QAAM,QAAQ,MAAM,UAAU,UAAU;AACxC,MAAI,UAAU,GAAI,QAAO;AACzB,MAAI,OAAO;AACX,QAAM,QAAQ,CAAC,GAAG,MAAM;AACtB,QAAI,WAAW,CAAC,EAAG,QAAO;AAAA,EAC5B,CAAC;AACD,QAAM,OAAO,CAAC,OAAkC,GAAG,IAAI,CAAC,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE;AAC9E,SAAO,KAAK,MAAM,MAAM,GAAG,KAAK,CAAC,IAAI,WAAW,KAAK,MAAM,MAAM,OAAO,CAAC,CAAC;AAC5E;AASO,SAAS,yBACd,OACA,YACA,UACA,UAA6B,CAAC,GACtB;AACR,MAAI,CAAC,MAAO,QAAO;AACnB,QAAM,WAAW,kBAAkB,YAAY,UAAU,OAAO;AAChE,QAAM,WAAW,OAAO,UAAU,YAAY,UAAU,KAAK,KAAK;AAClE,QAAM,OAAO,OAAO,UAAU,WAAW,IAAI,KAAK,KAAK,IAAI;AAC3D,MAAI,OAAO,MAAM,KAAK,QAAQ,CAAC,EAAG,QAAO,OAAO,KAAK;AACrD,QAAM,OAAmC,WAAW,EAAE,GAAG,SAAS,SAAS,UAAU,MAAM,IAAI,SAAS;AACxG,MAAI;AACF,UAAM,OAAO,KAAK,mBAAmB,SAAS,QAAQ,IAAI;AAC1D,WAAO,SAAS,UAAU,YAAY,MAAM,MAAM,SAAS,QAAQ,QAAQ,IAAI,IAAI;AAAA,EACrF,QAAQ;AAEN,WAAO,KAAK,YAAY,EAAE,MAAM,GAAG,EAAE;AAAA,EACvC;AACF;AAIO,SAAS,iBAAiB,YAAkC,UAAsC;AACvG,SAAO,yBAAyB,cAAc,YAAY,QAAQ;AACpE;AASO,SAAS,iBAAiB,YAAkC,UAAgD;AACjH,SAAO,CAAC,KAAK,EAAE,MAAM,SAAS,OAAO,MACnC,SAAS,QAAQ,yBAAyB,KAAK,YAAY,UAAU,UAAU,EAAE,QAAQ,CAAC,IAAI;AAClG;","names":[]}
+{"version":3,"sources":["../../src/lib/date-format.ts"],"sourcesContent":["import { formatLocaleOf } from \"../i18n/languages\";\nimport type { KitDateFormatter } from \"../i18n/kit-labels\";\nimport { pad, toLocalIso } from \"./dates\";\nimport { dateFormatter } from \"./intl-cache\";\nimport { isBareIsoDay } from \"./iso-day\";\n\n/**\n * The date-format preference (0.46, lifted from keksdose's `date-format-store.ts`,\n * feedback #180): how a DAY is written — the order of day, month and year and the\n * separator between them — as a choice of its own, apart from the interface language.\n * \"Read the app in English and still see German dates\", or ISO everywhere.\n *\n * keksdose's rules, which the kit keeps:\n *\n * 1. **A label that identifies a day follows the preference** — anything that prints\n *    day, month and year goes through {@link formatDateWithPreference} (or the\n *    provider's `formatDate`, {@link dateFormatterFor}, for the kit's own date fields).\n * 2. **A label without a day follows the language**: \"August 2026\", a month or weekday\n *    NAME has no order to arrange. {@link dateFormatterFor} answers `\"\"` for a month or a\n *    year, so the kit keeps its own rendering in the language.\n * 3. **A clock time follows the language**: `sv-SE` is a statement about digit order in\n *    a date, not about a 12- or 24-hour clock.\n * 4. **A weekday's NAME follows the language** (dev#546): `sv-SE` means \"year first,\n *    with dashes\", not \"the reader speaks Swedish\" — so with `weekday` the day's name is\n *    the language's, joined to the date the preference renders.\n *\n * The preference is the APP's to keep — keksdose holds it per device (a persisted store,\n * not an account column: nothing server-written formats a date for the reader). The kit\n * owns the vocabulary, the resolver, the renderer and the settings field\n * ({@link DateFormatSetting}).\n */\n\n/** `\"auto\"` follows the interface language (the default — nobody's dates move until\n *  they ask); the rest are BCP 47 tags chosen for the SHAPE they produce: German\n *  01.08.2026, British 01/08/2026, US 08/01/2026, ISO 2026-08-01. */\nexport type DateFormatPreference = \"auto\" | \"de-DE\" | \"en-GB\" | \"en-US\" | \"sv-SE\";\n\n/** The options in the order the setting lists them: `auto` first (the default), then\n *  German → UK → US → ISO. */\nexport const DATE_FORMAT_PREFERENCES: readonly DateFormatPreference[] = [\"auto\", \"de-DE\", \"en-GB\", \"en-US\", \"sv-SE\"];\n\n/** Whether `value` is one of {@link DATE_FORMAT_PREFERENCES} — for a value read back from\n *  storage, where anything else falls back to `\"auto\"`. */\nexport function isDateFormatPreference(value: unknown): value is DateFormatPreference {\n  return typeof value === \"string\" && (DATE_FORMAT_PREFERENCES as readonly string[]).includes(value);\n}\n\n/** A resolved preference: the locale and `Intl` options the date itself is rendered\n *  with, and — only when asked for — the locale the weekday's NAME comes from. */\nexport interface ResolvedDateFormat {\n  locale: string | undefined;\n  options: Intl.DateTimeFormatOptions;\n  /** The language's format locale, present when `weekday` was asked for. */\n  weekday?: { locale: string | undefined };\n}\n\n/** What {@link resolveDateFormat} and the renderers take beyond the preference. */\nexport interface DateFormatOptions {\n  /** Name the day of the week too, in the interface language (\"Mo., 01.08.2026\"). A date\n   *  in a COLUMN carries it; a date in a SENTENCE does not (keksdose dev#546). */\n  weekday?: boolean;\n  /**\n   * 0.52: the IANA zone a TIMESTAMP's day and clock are read in (\"Europe/Zurich\") — pass\n   * the `<UiKitProvider timeZone>` (`useKitTimeZone()`), so an app's own column says what\n   * the kit's components say for the same instant. Left out: the device's. A bare\n   * \"YYYY-MM-DD\" ignores it: a calendar day is the day it names in every zone. A zone\n   * `Intl` refuses reads as the device's. The renderers read it; {@link resolveDateFormat}\n   * does not.\n   */\n  timeZone?: string;\n}\n\n/**\n * What a date is rendered with, given the preference and the interface language\n * (`language`: a code or tag — `\"de\"`, `\"en\"`, i18next's `resolvedLanguage`; it is read\n * through `formatLocaleOf`, so English is British and an unshipped tag stays itself).\n *\n * `\"auto\"` keeps the short-month shape (\"01 Aug 2026\", \"01. Aug. 2026\"); every explicit\n * choice is all-numeric, the only way it produces the shape its option promises —\n * `month: \"short\"` under `sv-SE` would print \"2026 aug. 01\", not ISO.\n */\nexport function resolveDateFormat(\n  preference: DateFormatPreference,\n  language: string | undefined,\n  options: DateFormatOptions = {},\n): ResolvedDateFormat {\n  const languageLocale = language ? formatLocaleOf(language) : undefined;\n  const weekday = options.weekday ? { weekday: { locale: languageLocale } } : {};\n  if (preference === \"auto\") {\n    return { locale: languageLocale, options: { year: \"numeric\", month: \"short\", day: \"2-digit\" }, ...weekday };\n  }\n  return { locale: preference, options: { year: \"numeric\", month: \"2-digit\", day: \"2-digit\" }, ...weekday };\n}\n\n/**\n * `dateText`, already rendered under the preference, with the day's NAME around it in\n * `locale` (the language's). Not \"weekday alone + comma\": German says \"So\" alone and\n * \"So., 06.09.2026\" in company. The full date is formatted in the language and split\n * into parts; what that language puts before the first and after the last day/month/\n * year part (the weekday, its comma) frames the preference's digits — so where the two\n * locales coincide the output is the native string, character for character.\n */\nfunction withWeekday(date: Date, dateText: string, locale: string | undefined, options: Intl.DateTimeFormatOptions) {\n  const isDatePart = (p: Intl.DateTimeFormatPart) => p.type === \"day\" || p.type === \"month\" || p.type === \"year\";\n  const parts = dateFormatter(locale, { weekday: \"short\", ...options }).formatToParts(date);\n  const first = parts.findIndex(isDatePart);\n  if (first === -1) return dateText;\n  let last = first;\n  parts.forEach((p, i) => {\n    if (isDatePart(p)) last = i;\n  });\n  const join = (ps: Intl.DateTimeFormatPart[]) => ps.map((p) => p.value).join(\"\");\n  return join(parts.slice(0, first)) + dateText + join(parts.slice(last + 1));\n}\n\n/**\n * A date under the preference: `\"\"` for no value, the input itself when it does not\n * parse. A bare \"YYYY-MM-DD\" is the calendar day it names in every zone (formatted in\n * UTC, undoing `new Date`'s UTC-midnight parse — west of Greenwich it read a day early);\n * a timestamp is an instant, read in `options.timeZone`, else the reader's zone. The\n * weekday, when asked for, is rendered in the same zone, so a Sunday is never captioned\n * Saturday.\n */\nexport function formatDateWithPreference(\n  value: string | Date | null | undefined,\n  preference: DateFormatPreference,\n  language: string | undefined,\n  options: DateFormatOptions = {},\n): string {\n  if (!value) return \"\";\n  const resolved = resolveDateFormat(preference, language, options);\n  const dateOnly = isBareIsoDay(value);\n  const date = typeof value === \"string\" ? new Date(value) : value;\n  if (Number.isNaN(date.getTime())) return String(value);\n  const render = (timeZone: string | undefined) => {\n    const intl: Intl.DateTimeFormatOptions = timeZone ? { ...resolved.options, timeZone } : resolved.options;\n    // Through the shared cache (refactor audit 2026-10-30, DUP-2): a `toLocaleDateString`\n    // builds a formatter per call, which is why keksdose kept its own copy of this\n    // renderer — 392 ms per click on a 270-row register (dev#632).\n    const text = dateFormatter(resolved.locale, intl).format(date);\n    return resolved.weekday ? withWeekday(date, text, resolved.weekday.locale, intl) : text;\n  };\n  if (dateOnly) return firstAccepted([() => render(\"UTC\")], () => value);\n  // A zone `Intl` refuses: the reader's own day, as `clockTime` reads the reader's own\n  // clock — never the UTC day `toISOString` gave, a day off around midnight (0.52 code\n  // review, this file).\n  return firstAccepted([() => render(options.timeZone), () => render(undefined)], () => toLocalIso(date));\n}\n\n/** The first of `renders` that `Intl` accepts — a language tag or a zone it refuses\n *  throws — else `last()`: the ISO day or the clock rather than nothing (keksdose's\n *  fallback). */\nfunction firstAccepted(renders: readonly (() => string)[], last: () => string): string {\n  for (const render of renders) {\n    try {\n      return render();\n    } catch {\n      // Refused: the next.\n    }\n  }\n  return last();\n}\n\n/**\n * The clock time of `date` as the language writes it (\"14:05\"), two digits each: rule 3,\n * a clock follows the language, never the preference — `sv-SE` is a statement about the\n * order of a date's digits, not about a 12- or 24-hour clock. `language` is read through\n * `formatLocaleOf`, so English is the British 24-hour clock, not \"02:05 PM\" in a\n * German household's app. In `timeZone` when given, else the reader's.\n *\n * @internal Shared with the kit's own day formatter; not part of the barrel.\n */\nexport function clockTime(date: Date, language: string | undefined, timeZone?: string): string {\n  const locale = language ? formatLocaleOf(language) : undefined;\n  const clock = (zone: string | undefined) =>\n    dateFormatter(locale, { hour: \"2-digit\", minute: \"2-digit\", ...(zone ? { timeZone: zone } : null) }).format(date);\n  // A zone `Intl` refuses: the reader's own clock, as `isoDayIn` reads the reader's own\n  // day — the UTC clock `toISOString` gave printed 13:05 for 14:05 in Zurich, an hour or\n  // more off with no error (0.52 code review, this file).\n  const reader = () => `${pad(date.getHours())}:${pad(date.getMinutes())}`;\n  return firstAccepted([() => clock(timeZone), () => clock(undefined)], reader);\n}\n\n/**\n * A timestamp under the preference (0.52, keksdose's `formatDateTimeFor`, refactor audit\n * 2026-10-30, DUP-2): the date as {@link formatDateWithPreference} writes it, weekday\n * when asked for, then the clock time in the LANGUAGE ({@link clockTime}): \"01.08.2026,\n * 14:05\", \"Sa., 01.08.2026, 14:05\". keksdose's notification inbox and admin scheduler\n * were where an explicit ISO choice did nothing until it wrote this. `\"\"` for no value,\n * the input itself when it does not parse; a bare \"YYYY-MM-DD\" names no moment, so it\n * prints as the date alone.\n *\n * Day and clock in `options.timeZone` — pass the provider's (`useKitTimeZone()`): without\n * it they were the device's, and an app on Zurich time read from New York printed 09:05\n * in its own column where the kit's inbox printed 14:05 for the same instant (0.52 code\n * review, this file).\n */\nexport function formatDateTimeWithPreference(\n  value: string | Date | null | undefined,\n  preference: DateFormatPreference,\n  language: string | undefined,\n  options: DateFormatOptions = {},\n): string {\n  if (!value) return \"\";\n  if (isBareIsoDay(value)) return formatDateWithPreference(value, preference, language, options);\n  const date = typeof value === \"string\" ? new Date(value) : value;\n  if (Number.isNaN(date.getTime())) return String(value);\n  return `${formatDateWithPreference(date, preference, language, options)}, ${clockTime(date, language, options.timeZone)}`;\n}\n\n/** The sample an option is labelled with — 1 August 2026 in its shape, the shape being\n *  the whole choice (a country name would say nothing about the digit order). */\nexport function dateFormatSample(preference: DateFormatPreference, language: string | undefined): string {\n  return formatDateWithPreference(\"2026-08-01\", preference, language);\n}\n\n/**\n * The `<UiKitProvider formatDate>` for a preference — so the kit's own date fields\n * (DatePicker, DateRangePicker, DateMark) write a day as the app's dates do. A day\n * follows the preference, with the weekday where the kit suggests it; a month or a year\n * answers `\"\"` and keeps the kit's rendering in the language (rule 2). Rebuild it when\n * the preference or the language changes (a `useMemo` on both).\n */\nexport function dateFormatterFor(preference: DateFormatPreference, language: string | undefined): KitDateFormatter {\n  return (iso, { unit, weekday, locale }) =>\n    unit === \"day\" ? formatDateWithPreference(iso, preference, locale ?? language, { weekday }) : \"\";\n}\n"],"mappings":"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","names":[]}

package/dist/lib/day-format.d.ts

@@ -0,0 +1,46 @@
+import { type DateInput, type FormatDateStyle } from "./format.js";
+/**
+ * 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 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 declare function useDayFormatter<V extends DateInput = DateInput>(prop?: ((value: V) => string) | null, localeProp?: string): DayFormatter<V>;

package/dist/lib/day-format.js

@@ -0,0 +1,46 @@
+"use client";
+import { useCallback } from "react";
+import { useKitDateFormatter, useKitLocale, useKitTimeZone } from "../i18n/kit-labels.js";
+import { toLocalIso } from "./dates.js";
+import { clockTime } from "./date-format.js";
+import { EMPTY_FORMATTED_VALUE, formatDate, toDate } from "./format.js";
+import { dateFormatter } from "./intl-cache.js";
+import { isBareIsoDay } from "./iso-day.js";
+function isoDayIn(date, timeZone) {
+  if (!timeZone) return toLocalIso(date);
+  try {
+    const parts = dateFormatter("en-CA", { timeZone, year: "numeric", month: "2-digit", day: "2-digit" }).formatToParts(
+      date
+    );
+    const part = (type) => parts.find((p) => p.type === type)?.value ?? "";
+    return `${part("year")}-${part("month")}-${part("day")}`;
+  } catch {
+    return toLocalIso(date);
+  }
+}
+function useDayFormatter(prop, localeProp) {
+  const locale = useKitLocale(localeProp);
+  const timeZone = useKitTimeZone();
+  const fromProvider = useKitDateFormatter();
+  return useCallback(
+    (value, options = {}) => {
+      const own = prop?.(value);
+      if (own) return own;
+      if (value === null || value === void 0 || 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]
+  );
+}
+export {
+  useDayFormatter
+};
+//# sourceMappingURL=day-format.js.map

package/dist/lib/day-format.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/day-format.ts"],"sourcesContent":["import { useCallback } from \"react\";\nimport { useKitDateFormatter, useKitLocale, useKitTimeZone } from \"../i18n/kit-labels\";\nimport { toLocalIso } from \"./dates\";\nimport { clockTime } from \"./date-format\";\nimport { EMPTY_FORMATTED_VALUE, formatDate, toDate, type DateInput, type FormatDateStyle } from \"./format\";\nimport { dateFormatter } from \"./intl-cache\";\nimport { isBareIsoDay } from \"./iso-day\";\n\n/**\n * How a kit component prints a day — ONE ladder (refactor audit 2026-10-30, DUP-2):\n *\n *  1. the component's own prop (`formatDate`, `renderDate`), when the app gave one and it\n *     answers;\n *  2. else the `<UiKitProvider formatDate>` (keksdose K12: the app's date-format\n *     preference), asked for the calendar day with `source: \"dateMark\"`;\n *  3. else the kit's `formatDate` in the provider's locale AND `timeZone` (0.46).\n *\n * 0.46's rule — \"a label that identifies a day follows the preference\" — held only where\n * a component wrote that ladder itself: four copies (admin's `useDayText`, AccountStateChip,\n * DateMark, the feedback table), while about twelve components took their own prop or\n * nothing and went straight to `lib/format`. keksdose set the provider's `formatDate` and\n * still passed it into six components by hand; and the 10 that imported the raw\n * `formatDate` ignored the provider's `timeZone`.\n *\n * @internal Not part of the barrel: the components' props are the public way in.\n */\n\n/** What a {@link DayFormatter} call may ask for. */\nexport interface DayTextOptions {\n  /**\n   * Name the day of the week — what the provider's formatter is told (its `weekday`).\n   * keksdose's rule: a date in a COLUMN carries it, a date in a SENTENCE does not\n   * (dev#546). Default `false`. The kit's own rendering follows `style`, not this.\n   */\n  weekday?: boolean;\n  /** Add the clock time, in the language (date-format rule 3): a timestamp. Default false. */\n  time?: boolean;\n  /** The kit's own rendering (step 3). Default `\"medium\"`, `\"dateTime\"` with `time`. */\n  style?: FormatDateStyle | Intl.DateTimeFormatOptions;\n  /** `false`: skip the provider (step 2) — a component's explicit style wins over it,\n   *  as `DateMark`'s `dateStyle` does. Default `true`. */\n  preference?: boolean;\n  /** Printed for no value. Default \"—\". */\n  empty?: string;\n}\n\n/** A component's day printer: a value in, its text out. */\nexport type DayFormatter<V extends DateInput = DateInput> = (value: V, options?: DayTextOptions) => string;\n\n/** The calendar day `date` falls on in `timeZone`, as \"YYYY-MM-DD\" — so the day the\n *  provider is asked for is the day the kit's own rendering would print. */\nfunction isoDayIn(date: Date, timeZone: string | undefined): string {\n  if (!timeZone) return toLocalIso(date);\n  try {\n    // `en-CA` writes YYYY-MM-DD with Latin digits.\n    const parts = dateFormatter(\"en-CA\", { timeZone, year: \"numeric\", month: \"2-digit\", day: \"2-digit\" }).formatToParts(\n      date,\n    );\n    const part = (type: Intl.DateTimeFormatPartTypes) => parts.find((p) => p.type === type)?.value ?? \"\";\n    return `${part(\"year\")}-${part(\"month\")}-${part(\"day\")}`;\n  } catch {\n    return toLocalIso(date);\n  }\n}\n\n/**\n * The component's day printer, bound to its `prop`, the provider's `formatDate`, locale\n * and `timeZone`. `prop` is called with the value as the component passed it, and wins\n * whenever it answers non-empty. A value that does not parse is printed as it came\n * (a bug upstream is better seen than hidden behind a dash).\n */\nexport function useDayFormatter<V extends DateInput = DateInput>(\n  prop?: ((value: V) => string) | null,\n  localeProp?: string,\n): DayFormatter<V> {\n  const locale = useKitLocale(localeProp);\n  const timeZone = useKitTimeZone();\n  const fromProvider = useKitDateFormatter();\n  return useCallback<DayFormatter<V>>(\n    (value, options = {}) => {\n      const own = prop?.(value);\n      if (own) return own;\n      if (value === null || value === undefined || value === \"\") return options.empty ?? EMPTY_FORMATTED_VALUE;\n      const date = toDate(value);\n      if (!date) return String(value);\n      const bareDay = isBareIsoDay(value);\n      if (fromProvider && options.preference !== false) {\n        const iso = bareDay ? value : isoDayIn(date, timeZone);\n        const day = fromProvider(iso, { unit: \"day\", source: \"dateMark\", locale, weekday: options.weekday ?? false });\n        if (day) return options.time && !bareDay ? `${day}, ${clockTime(date, locale, timeZone)}` : day;\n      }\n      return formatDate(value, options.style ?? (options.time ? \"dateTime\" : \"medium\"), { locale, timeZone });\n    },\n    [prop, fromProvider, locale, timeZone],\n  );\n}\n"],"mappings":";AAAA,SAAS,mBAAmB;AAC5B,SAAS,qBAAqB,cAAc,sBAAsB;AAClE,SAAS,kBAAkB;AAC3B,SAAS,iBAAiB;AAC1B,SAAS,uBAAuB,YAAY,cAAoD;AAChG,SAAS,qBAAqB;AAC9B,SAAS,oBAAoB;AA6C7B,SAAS,SAAS,MAAY,UAAsC;AAClE,MAAI,CAAC,SAAU,QAAO,WAAW,IAAI;AACrC,MAAI;AAEF,UAAM,QAAQ,cAAc,SAAS,EAAE,UAAU,MAAM,WAAW,OAAO,WAAW,KAAK,UAAU,CAAC,EAAE;AAAA,MACpG;AAAA,IACF;AACA,UAAM,OAAO,CAAC,SAAuC,MAAM,KAAK,CAAC,MAAM,EAAE,SAAS,IAAI,GAAG,SAAS;AAClG,WAAO,GAAG,KAAK,MAAM,CAAC,IAAI,KAAK,OAAO,CAAC,IAAI,KAAK,KAAK,CAAC;AAAA,EACxD,QAAQ;AACN,WAAO,WAAW,IAAI;AAAA,EACxB;AACF;AAQO,SAAS,gBACd,MACA,YACiB;AACjB,QAAM,SAAS,aAAa,UAAU;AACtC,QAAM,WAAW,eAAe;AAChC,QAAM,eAAe,oBAAoB;AACzC,SAAO;AAAA,IACL,CAAC,OAAO,UAAU,CAAC,MAAM;AACvB,YAAM,MAAM,OAAO,KAAK;AACxB,UAAI,IAAK,QAAO;AAChB,UAAI,UAAU,QAAQ,UAAU,UAAa,UAAU,GAAI,QAAO,QAAQ,SAAS;AACnF,YAAM,OAAO,OAAO,KAAK;AACzB,UAAI,CAAC,KAAM,QAAO,OAAO,KAAK;AAC9B,YAAM,UAAU,aAAa,KAAK;AAClC,UAAI,gBAAgB,QAAQ,eAAe,OAAO;AAChD,cAAM,MAAM,UAAU,QAAQ,SAAS,MAAM,QAAQ;AACrD,cAAM,MAAM,aAAa,KAAK,EAAE,MAAM,OAAO,QAAQ,YAAY,QAAQ,SAAS,QAAQ,WAAW,MAAM,CAAC;AAC5G,YAAI,IAAK,QAAO,QAAQ,QAAQ,CAAC,UAAU,GAAG,GAAG,KAAK,UAAU,MAAM,QAAQ,QAAQ,CAAC,KAAK;AAAA,MAC9F;AACA,aAAO,WAAW,OAAO,QAAQ,UAAU,QAAQ,OAAO,aAAa,WAAW,EAAE,QAAQ,SAAS,CAAC;AAAA,IACxG;AAAA,IACA,CAAC,MAAM,cAAc,QAAQ,QAAQ;AAAA,EACvC;AACF;","names":[]}

package/dist/lib/decimal-marks.d.ts

@@ -11,7 +11,13 @@ export declare 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

package/dist/lib/decimal-marks.js

@@ -11,10 +11,13 @@ function decimalMark(locale) {
 function normalizeTypedMarks(raw, mark) {
   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 grouping2 = operand.lastIndexOf(mark) > operand.lastIndexOf(other) ? other : mark;
+      return operand.split(grouping2).join("");
+    }
+    const grouping = count > 1 || mark === "," && /^[1-9]\d{0,2}(\.\d{3})+$/.test(operand);
     return grouping ? operand.split(other).join("") : operand;
   });
 }

package/dist/lib/decimal-marks.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/lib/decimal-marks.ts"],"sourcesContent":["/**\n * The locale's decimal mark and the reading of typed grouping marks, shared by the\n * kit's numeric text fields: {@link AmountInput}, {@link NumberInput} and, through\n * NumberInput, {@link NumberField} and {@link MoneyField}.\n *\n * Package-private — not re-exported from the barrel. It lives here rather than in\n * `calc.ts` because that module is re-exported wholesale (`export * from\n * \"./lib/calc\"`), and these are the fields' plumbing, not API.\n *\n * WHY ONE MODULE. AmountInput learned the locale's mark (kastlan 40) and the grouping\n * parse (keksdose G1); NumberInput learned neither, so the same \"1.234,56\" a German\n * user typed into a money field read as 1234.56 and, typed into the budget-goal field\n * next to it, as 1.23456 (keksdose K5). Two private copies of the same rule are how\n * that happened, so the rule now has one home.\n */\nimport { sanitizeLive } from \"./calc\";\n\n/**\n * The locale's decimal mark, as far as a field can type it: \",\" or \".\" (kastlan 40).\n * A mark outside those two (Arabic's \"٫\") is not one {@link sanitizeLive} lets\n * through, so those locales keep the dot rather than get a field that eats the key it\n * shows. `undefined` is the runtime's own locale, which is what `Intl` reads it as.\n */\nexport function decimalMark(locale: string | undefined): \",\" | \".\" {\n  try {\n    const part = new Intl.NumberFormat(locale).formatToParts(1.5).find((p) => p.type === \"decimal\");\n    return part?.value === \",\" ? \",\" : \".\";\n  } catch {\n    // An invalid tag throws a RangeError; a typo in a locale must not take the form down.\n    return \".\";\n  }\n}\n\n/**\n * Which typed mark is the decimal one (keksdose G1). {@link sanitizeLive} folds every\n * \",\" into \".\", so on its own it read the German \"1.234,56\" as 1.23456 — and a money\n * field's settle then made that 1.23, final. This decides per operand, from the\n * typist's own text, before that fold:\n *\n * - both marks present: the one that is not the locale's is grouping, and goes;\n * - in a \",\" locale, only \".\" present: grouping when it cannot be a decimal as a\n *   German reader writes it — twice (\"1.234.567\"), or in thousands shape (\"1.234\",\n *   \"12.500\") — otherwise a decimal (\"1.5\", typed by a dot-decimal habit). A first\n *   group that starts with 0 is never thousands: \"0.500\" is a half, not five hundred\n *   (BUG-6, refactor audit 2026-10);\n * - in a \".\" locale, only \",\" present: grouping when it appears twice (\"1,234,567\");\n *   once it stays a decimal, because Swiss and German typists write \"1,5\" in a\n *   de-CH form (kastlan 40) and a unit price \"1,789\" is a decimal.\n *\n * Only a keystroke's text comes through here. A calculator result is dot-decimal\n * already, and \"1.234\" from `100/81.03…` is never a thousand.\n */\nexport function normalizeTypedMarks(raw: string, mark: \",\" | \".\"): string {\n  const other = mark === \",\" ? \".\" : \",\";\n  return raw.replace(/[0-9.,]+/g, (operand) => {\n    const hasMark = operand.includes(mark);\n    const count = operand.split(other).length - 1;\n    if (count === 0) return operand;\n    const grouping = hasMark ? true : count > 1 || (mark === \",\" && /^[1-9]\\d{0,2}(\\.\\d{3})+$/.test(operand));\n    return grouping ? operand.split(other).join(\"\") : operand;\n  });\n}\n\n/** What a keystroke's raw text reports: grouping read off, then the field's live\n *  sanitising (comma → dot, stray characters out, one decimal point per operand). */\nexport function readTyped(raw: string, mark: \",\" | \".\"): string {\n  return sanitizeLive(normalizeTypedMarks(raw, mark));\n}\n\n// Spacing a typist uses to group digits — a space, the no-break and narrow no-break\n// spaces `Intl` itself writes for fr-CH (\"1 234,5\" with U+202F), and the Swiss\n// apostrophes (\"1'234.50\"). The live sanitising drops them, so they never reach the\n// value; the draft may still show them.\nconst GROUP_SPACING = /[\\s'’\\u00a0\\u202f]/g;\n\n/**\n * Whether the field may keep SHOWING `raw` — the typist's own text — while it holds\n * `canonical` (dot-decimal, as `onChange` reported it).\n *\n * Showing the typed text rather than re-spelling the value is what keeps the caret\n * where the typist put it, and what keeps a grouping \".\" from being turned into a \",\"\n * under their fingers — after which no rule could tell the two apart (keksdose G1).\n * But only text that says the same as the value, and says it with nothing the field\n * would have DROPPED: a letter, or a second decimal point in one operand (\"1.2.3\"),\n * must not stay on screen while the value says \"1.23\" (Keksdose live #201 is the bug\n * that showing it would bring back). Grouping marks and grouping spaces may stay.\n */\nexport function showsTyped(raw: string, mark: \",\" | \".\", canonical: string): boolean {\n  const read = normalizeTypedMarks(raw, mark).replace(GROUP_SPACING, \"\");\n  const sanitized = sanitizeLive(read);\n  // Nothing dropped: the read text is the sanitised one, but for which mark it uses.\n  return sanitized === read.replace(/,/g, \".\") && sanitized === sanitizeLive(canonical);\n}\n\n/** A dot-decimal text spelt in `mark` — display only, one character for one, so a\n *  re-spelling never moves a caret. */\nexport function localizeMark(text: string, mark: \",\" | \".\"): string {\n  return mark === \",\" ? text.replace(/\\./g, \",\") : text;\n}\n"],"mappings":";AAeA,SAAS,oBAAoB;AAQtB,SAAS,YAAY,QAAuC;AACjE,MAAI;AACF,UAAM,OAAO,IAAI,KAAK,aAAa,MAAM,EAAE,cAAc,GAAG,EAAE,KAAK,CAAC,MAAM,EAAE,SAAS,SAAS;AAC9F,WAAO,MAAM,UAAU,MAAM,MAAM;AAAA,EACrC,QAAQ;AAEN,WAAO;AAAA,EACT;AACF;AAqBO,SAAS,oBAAoB,KAAa,MAAyB;AACxE,QAAM,QAAQ,SAAS,MAAM,MAAM;AACnC,SAAO,IAAI,QAAQ,aAAa,CAAC,YAAY;AAC3C,UAAM,UAAU,QAAQ,SAAS,IAAI;AACrC,UAAM,QAAQ,QAAQ,MAAM,KAAK,EAAE,SAAS;AAC5C,QAAI,UAAU,EAAG,QAAO;AACxB,UAAM,WAAW,UAAU,OAAO,QAAQ,KAAM,SAAS,OAAO,2BAA2B,KAAK,OAAO;AACvG,WAAO,WAAW,QAAQ,MAAM,KAAK,EAAE,KAAK,EAAE,IAAI;AAAA,EACpD,CAAC;AACH;AAIO,SAAS,UAAU,KAAa,MAAyB;AAC9D,SAAO,aAAa,oBAAoB,KAAK,IAAI,CAAC;AACpD;AAMA,MAAM,gBAAgB;AAcf,SAAS,WAAW,KAAa,MAAiB,WAA4B;AACnF,QAAM,OAAO,oBAAoB,KAAK,IAAI,EAAE,QAAQ,eAAe,EAAE;AACrE,QAAM,YAAY,aAAa,IAAI;AAEnC,SAAO,cAAc,KAAK,QAAQ,MAAM,GAAG,KAAK,cAAc,aAAa,SAAS;AACtF;AAIO,SAAS,aAAa,MAAc,MAAyB;AAClE,SAAO,SAAS,MAAM,KAAK,QAAQ,OAAO,GAAG,IAAI;AACnD;","names":[]}
+{"version":3,"sources":["../../src/lib/decimal-marks.ts"],"sourcesContent":["/**\n * The locale's decimal mark and the reading of typed grouping marks, shared by the\n * kit's numeric text fields: {@link AmountInput}, {@link NumberInput} and, through\n * NumberInput, {@link NumberField} and {@link MoneyField}.\n *\n * Package-private — not re-exported from the barrel. It lives here rather than in\n * `calc.ts` because that module is re-exported wholesale (`export * from\n * \"./lib/calc\"`), and these are the fields' plumbing, not API.\n *\n * WHY ONE MODULE. AmountInput learned the locale's mark (kastlan 40) and the grouping\n * parse (keksdose G1); NumberInput learned neither, so the same \"1.234,56\" a German\n * user typed into a money field read as 1234.56 and, typed into the budget-goal field\n * next to it, as 1.23456 (keksdose K5). Two private copies of the same rule are how\n * that happened, so the rule now has one home.\n */\nimport { sanitizeLive } from \"./calc\";\n\n/**\n * The locale's decimal mark, as far as a field can type it: \",\" or \".\" (kastlan 40).\n * A mark outside those two (Arabic's \"٫\") is not one {@link sanitizeLive} lets\n * through, so those locales keep the dot rather than get a field that eats the key it\n * shows. `undefined` is the runtime's own locale, which is what `Intl` reads it as.\n */\nexport function decimalMark(locale: string | undefined): \",\" | \".\" {\n  try {\n    const part = new Intl.NumberFormat(locale).formatToParts(1.5).find((p) => p.type === \"decimal\");\n    return part?.value === \",\" ? \",\" : \".\";\n  } catch {\n    // An invalid tag throws a RangeError; a typo in a locale must not take the form down.\n    return \".\";\n  }\n}\n\n/**\n * Which typed mark is the decimal one (keksdose G1). {@link sanitizeLive} folds every\n * \",\" into \".\", so on its own it read the German \"1.234,56\" as 1.23456 — and a money\n * field's settle then made that 1.23, final. This decides per operand, from the\n * typist's own text, before that fold:\n *\n * - both marks present: the LAST one is the decimal mark, whichever the locale's is, and\n *   the other is grouping and goes. The order says the convention the figure was written\n *   in — \"1.234,56\" German, \"1,234.56\" English — and a figure pasted from another app or\n *   locale keeps it. Taking the non-locale mark as grouping wherever it stood read\n *   \"1.234,56\" in a \".\" locale (en, de-CH) as 1.23456, which a money field then settled\n *   to 1.23 (refactor audit 2026-10-30, INP-3). Typed in the locale's own convention, its\n *   mark comes last and nothing changes;\n * - in a \",\" locale, only \".\" present: grouping when it cannot be a decimal as a\n *   German reader writes it — twice (\"1.234.567\"), or in thousands shape (\"1.234\",\n *   \"12.500\") — otherwise a decimal (\"1.5\", typed by a dot-decimal habit). A first\n *   group that starts with 0 is never thousands: \"0.500\" is a half, not five hundred\n *   (BUG-6, refactor audit 2026-10);\n * - in a \".\" locale, only \",\" present: grouping when it appears twice (\"1,234,567\");\n *   once it stays a decimal, because Swiss and German typists write \"1,5\" in a\n *   de-CH form (kastlan 40) and a unit price \"1,789\" is a decimal.\n *\n * Only a keystroke's text comes through here. A calculator result is dot-decimal\n * already, and \"1.234\" from `100/81.03…` is never a thousand.\n */\nexport function normalizeTypedMarks(raw: string, mark: \",\" | \".\"): string {\n  const other = mark === \",\" ? \".\" : \",\";\n  return raw.replace(/[0-9.,]+/g, (operand) => {\n    const count = operand.split(other).length - 1;\n    if (count === 0) return operand;\n    if (operand.includes(mark)) {\n      const grouping = operand.lastIndexOf(mark) > operand.lastIndexOf(other) ? other : mark;\n      return operand.split(grouping).join(\"\");\n    }\n    const grouping = count > 1 || (mark === \",\" && /^[1-9]\\d{0,2}(\\.\\d{3})+$/.test(operand));\n    return grouping ? operand.split(other).join(\"\") : operand;\n  });\n}\n\n/** What a keystroke's raw text reports: grouping read off, then the field's live\n *  sanitising (comma → dot, stray characters out, one decimal point per operand). */\nexport function readTyped(raw: string, mark: \",\" | \".\"): string {\n  return sanitizeLive(normalizeTypedMarks(raw, mark));\n}\n\n// Spacing a typist uses to group digits — a space, the no-break and narrow no-break\n// spaces `Intl` itself writes for fr-CH (\"1 234,5\" with U+202F), and the Swiss\n// apostrophes (\"1'234.50\"). The live sanitising drops them, so they never reach the\n// value; the draft may still show them.\nconst GROUP_SPACING = /[\\s'’\\u00a0\\u202f]/g;\n\n/**\n * Whether the field may keep SHOWING `raw` — the typist's own text — while it holds\n * `canonical` (dot-decimal, as `onChange` reported it).\n *\n * Showing the typed text rather than re-spelling the value is what keeps the caret\n * where the typist put it, and what keeps a grouping \".\" from being turned into a \",\"\n * under their fingers — after which no rule could tell the two apart (keksdose G1).\n * But only text that says the same as the value, and says it with nothing the field\n * would have DROPPED: a letter, or a second decimal point in one operand (\"1.2.3\"),\n * must not stay on screen while the value says \"1.23\" (Keksdose live #201 is the bug\n * that showing it would bring back). Grouping marks and grouping spaces may stay.\n */\nexport function showsTyped(raw: string, mark: \",\" | \".\", canonical: string): boolean {\n  const read = normalizeTypedMarks(raw, mark).replace(GROUP_SPACING, \"\");\n  const sanitized = sanitizeLive(read);\n  // Nothing dropped: the read text is the sanitised one, but for which mark it uses.\n  return sanitized === read.replace(/,/g, \".\") && sanitized === sanitizeLive(canonical);\n}\n\n/** A dot-decimal text spelt in `mark` — display only, one character for one, so a\n *  re-spelling never moves a caret. */\nexport function localizeMark(text: string, mark: \",\" | \".\"): string {\n  return mark === \",\" ? text.replace(/\\./g, \",\") : text;\n}\n"],"mappings":";AAeA,SAAS,oBAAoB;AAQtB,SAAS,YAAY,QAAuC;AACjE,MAAI;AACF,UAAM,OAAO,IAAI,KAAK,aAAa,MAAM,EAAE,cAAc,GAAG,EAAE,KAAK,CAAC,MAAM,EAAE,SAAS,SAAS;AAC9F,WAAO,MAAM,UAAU,MAAM,MAAM;AAAA,EACrC,QAAQ;AAEN,WAAO;AAAA,EACT;AACF;AA2BO,SAAS,oBAAoB,KAAa,MAAyB;AACxE,QAAM,QAAQ,SAAS,MAAM,MAAM;AACnC,SAAO,IAAI,QAAQ,aAAa,CAAC,YAAY;AAC3C,UAAM,QAAQ,QAAQ,MAAM,KAAK,EAAE,SAAS;AAC5C,QAAI,UAAU,EAAG,QAAO;AACxB,QAAI,QAAQ,SAAS,IAAI,GAAG;AAC1B,YAAMA,YAAW,QAAQ,YAAY,IAAI,IAAI,QAAQ,YAAY,KAAK,IAAI,QAAQ;AAClF,aAAO,QAAQ,MAAMA,SAAQ,EAAE,KAAK,EAAE;AAAA,IACxC;AACA,UAAM,WAAW,QAAQ,KAAM,SAAS,OAAO,2BAA2B,KAAK,OAAO;AACtF,WAAO,WAAW,QAAQ,MAAM,KAAK,EAAE,KAAK,EAAE,IAAI;AAAA,EACpD,CAAC;AACH;AAIO,SAAS,UAAU,KAAa,MAAyB;AAC9D,SAAO,aAAa,oBAAoB,KAAK,IAAI,CAAC;AACpD;AAMA,MAAM,gBAAgB;AAcf,SAAS,WAAW,KAAa,MAAiB,WAA4B;AACnF,QAAM,OAAO,oBAAoB,KAAK,IAAI,EAAE,QAAQ,eAAe,EAAE;AACrE,QAAM,YAAY,aAAa,IAAI;AAEnC,SAAO,cAAc,KAAK,QAAQ,MAAM,GAAG,KAAK,cAAc,aAAa,SAAS;AACtF;AAIO,SAAS,aAAa,MAAc,MAAyB;AAClE,SAAO,SAAS,MAAM,KAAK,QAAQ,OAAO,GAAG,IAAI;AACnD;","names":["grouping"]}

package/dist/lib/describe-failure.d.ts

@@ -0,0 +1,14 @@
+import type { ReactNode } from "react";
+/**
+ * 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 declare function describeFailure(own: ReactNode | undefined, fallback: ReactNode): ReactNode;

package/dist/lib/describe-failure.js

@@ -0,0 +1,9 @@
+"use client";
+import { hasContent } from "./presence.js";
+function describeFailure(own, fallback) {
+  return hasContent(own) ? own : fallback;
+}
+export {
+  describeFailure
+};
+//# sourceMappingURL=describe-failure.js.map

package/dist/lib/describe-failure.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/describe-failure.ts"],"sourcesContent":["import type { ReactNode } from \"react\";\nimport { hasContent } from \"./presence\";\n\n/**\n * The failure ladder, once: the app's words for a failure when it has any, else the\n * kit's `fallback`.\n *\n * \"Any\" is {@link hasContent}, so an app's `describeError` answering `\"\"` (nothing to say\n * about this one) gets the kit's sentence. Written as `own ?? fallback` in the auth forms,\n * where `\"\"` printed an empty alert, and both ways within one file in the reviewer scope\n * editor; it lived in the notification cards' parts only (refactor audit 2026-10-30,\n * DUP-14).\n *\n * @internal Package-private — not re-exported from the barrel.\n */\nexport function describeFailure(own: ReactNode | undefined, fallback: ReactNode): ReactNode {\n  return hasContent(own) ? own : fallback;\n}\n"],"mappings":";AACA,SAAS,kBAAkB;AAcpB,SAAS,gBAAgB,KAA4B,UAAgC;AAC1F,SAAO,WAAW,GAAG,IAAI,MAAM;AACjC;","names":[]}

package/dist/lib/direction.d.ts

@@ -20,3 +20,19 @@ export declare function isRtl(el: Element | null | undefined): boolean;
  * any other key. ArrowRight is forward in LTR and backward in RTL.
  */
 export declare function horizontalStep(key: string, el: Element | null | undefined): 1 | -1 | 0;
+/**
+ * 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 declare function rovingTarget(key: string, dir: Direction, at: number, count: number, wrap: boolean): number | undefined;

package/dist/lib/direction.js

@@ -11,9 +11,17 @@ function horizontalStep(key, el) {
   const forward = key === "ArrowRight" !== isRtl(el);
   return forward ? 1 : -1;
 }
+function rovingTarget(key, dir, at, count, wrap) {
+  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 : void 0;
+  if (to === void 0 || count <= 0) return void 0;
+  return wrap ? (to % count + count) % count : Math.max(0, Math.min(count - 1, to));
+}
 export {
   dirOf,
   horizontalStep,
-  isRtl
+  isRtl,
+  rovingTarget
 };
 //# sourceMappingURL=direction.js.map