@lerianstudio/sindarian-ui 1.2.0 → 1.3.0-beta.2

package/dist/esm/domain/delinquency-aging/index.js

@@ -0,0 +1,209 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * DelinquencyAging — a loan/receivable delinquency surface: the ordered overdue
+ * aging distribution PLUS the headline delinquency rate (the share of portfolio
+ * value that is past due).
+ *
+ *   <DelinquencyAging
+ *     currency="BRL"
+ *     locale="pt-BR"
+ *     warn={0.05}
+ *     breach={0.1}
+ *     buckets={[
+ *       { label: 'A vencer', count: 312, total: '1840500.00', overdue: false },
+ *       { label: '1–30',     count: 84,  total: '402300.00',  overdue: true },
+ *       { label: '31–60',    count: 21,  total: '118900.00',  overdue: true },
+ *       { label: '61–90',    count: 9,   total: '54200.00',   overdue: true },
+ *       { label: '90+',      count: 4,   total: '38100.00',   overdue: true }
+ *     ]}
+ *   />
+ *
+ * The distribution is delegated whole to `AgingBuckets`: it owns the ordered
+ * current → 90+ schedule, the per-bucket count/total, the ordinal band cue, and
+ * the money-math-exact grand total. This composite adds only the one fact aging
+ * alone does not state — the delinquency RATE.
+ *
+ * THIRD RAIL (money): the rate is overdueTotal / portfolioTotal, and BOTH totals
+ * are summed in integer minor units (BigInt, at the currency's CLDR scale) via
+ * `money-math` — never an IEEE-754 sum of decimals (0.1 + 0.2 ≠ 0.3 in float, a
+ * silent basis-point error on a portfolio). The single floating-point operation
+ * is the FINAL division of two already-exact integers, which is the correct,
+ * lossless-enough place for it (a ratio is not money). A zero portfolio yields a
+ * null rate — an explicit empty readout, never a NaN. A single unparseable
+ * bucket total poisons the rate to indeterminate rather than reporting a wrong
+ * share.
+ *
+ * NON-COLOR CUE (WCAG 1.4.1): the rate band (healthy / elevated / distressed) is
+ * resolved through the gauge's strict-edge `gaugeBand` (higher-is-worse: more
+ * overdue is worse) and named with a glyph + an sr-only word + a tint — the tint
+ * is reinforcement only, so the band survives grayscale and color-vision
+ * deficiency. A distressed rate reads loud (credit-red, role='alert').
+ *
+ * Pure display: no directive, no interactivity, server-safe for RSC.
+ */
+import { AlertOctagon, ShieldCheck, TriangleAlert } from 'lucide-react';
+import { LABEL_VOICE_CLASS } from '../../lib/typography.js';
+import { cn } from '../../lib/utils.js';
+import { Figure } from '../figure/index.js';
+import { formatPercent, NO_VALUE } from '../format.js';
+import { minorDigitsOf, toMinor } from '../money-math.js';
+import { SectionLabel } from '../section-label/index.js';
+import { AgingBuckets } from './aging-buckets.js';
+/** Fixed-point scale for the rate division: 1e12 keeps twelve decimal places of
+ *  a 0..1 ratio, and both it and any in-range scaled quotient stay well inside
+ *  the exact-integer range of a double (2^53), so the conversion is lossless. */
+const RATE_PRECISION = 1000000000000n;
+/**
+ * THIRD RAIL: the delinquency rate = overdue total / portfolio total, with both
+ * totals summed through integer minor units (BigInt) at `scale`. The only float
+ * operation is the final division of two EXACT integers — never a float sum of
+ * decimals. A zero portfolio gives a null rate (explicit empty, no NaN); an
+ * unparseable total poisons everything to indeterminate. Pure: unit-tested.
+ *
+ * Internal: exported for its unit tests, never from `src/domain/index.ts`.
+ */
+export function delinquencyRate(buckets, scale) {
+    // Parse each bucket exactly once: the sums and the per-bucket SIGN check both
+    // come off the same pass, so the two can never disagree about the same input.
+    const parsed = buckets.map((b) => toMinor(b.total, scale));
+    if (parsed.some((m) => m === null)) {
+        return {
+            rate: null,
+            overdueMinor: null,
+            totalMinor: null,
+            indeterminate: true
+        };
+    }
+    let totalMinor = 0n;
+    let overdueMinor = 0n;
+    let hasNegativeBucket = false;
+    parsed.forEach((m, i) => {
+        const minor = m;
+        if (minor < 0n)
+            hasNegativeBucket = true;
+        totalMinor += minor;
+        if (buckets[i].overdue)
+            overdueMinor += minor;
+    });
+    // A NEGATIVE bucket total is parseable but not interpretable as a share of a
+    // portfolio: overdue/total stops being bounded by 0..1 the moment a component
+    // is negative (a -50 current band against a 100 overdue band yields "200%
+    // delinquent"), and it can also cancel the denominator toward zero. A credit
+    // adjustment is real data, but it is not aging data, so the honest answer is
+    // that the RATE cannot be determined — the sums stay, since they are still
+    // correct, and the readout takes the no-value path. Legacy divided anyway and
+    // printed the out-of-range percentage.
+    if (hasNegativeBucket) {
+        return { rate: null, overdueMinor, totalMinor, indeterminate: true };
+    }
+    // A zero portfolio has no rate to report — null, never overdueMinor/0 (NaN).
+    if (totalMinor === 0n) {
+        return { rate: null, overdueMinor, totalMinor, indeterminate: false };
+    }
+    // The division is done as a BOUNDED BigInt ratio first, then converted once.
+    // Converting the two totals to Number separately overflowed on a large
+    // portfolio: past ~1.8e308 each side becomes Infinity and Infinity/Infinity is
+    // NaN — a portfolio big enough to matter reported no rate at all. Scaling the
+    // numerator by RATE_PRECISION keeps the quotient the size of a ratio (not the
+    // size of the money), so the single Number() sees a value it can hold exactly.
+    const scaled = (overdueMinor * RATE_PRECISION) / totalMinor;
+    const rate = Number(scaled) / Number(RATE_PRECISION);
+    // A ratio that still cannot be represented is no rate at all — the readout
+    // shows the no-value placeholder rather than a NaN/Infinity artifact.
+    if (!Number.isFinite(rate)) {
+        return { rate: null, overdueMinor, totalMinor, indeterminate: false };
+    }
+    return { rate, overdueMinor, totalMinor, indeterminate: false };
+}
+/** Fixed-point scale for comparing the ratio against a float threshold as exact
+ *  integers. 1e18 is well past the ~1e-16 relative precision a double carries,
+ *  so the comparison is exact to the limit of the threshold value itself. */
+const THRESHOLD_SCALE = 10n ** 18n;
+/**
+ * THIRD RAIL: `overdue / total > threshold`, decided on EXACT integers.
+ *
+ * The float `rate` is a TRUNCATED view of the ratio — RATE_PRECISION drops every
+ * digit past 1e-12 — so a rate a hair ABOVE a threshold rounds down onto it, and
+ * the strict-edge rule then reads it as the calmer band. 500000000001 /
+ * 10000000000000 is 0.0500000000001, genuinely past a 0.05 warn edge, and
+ * truncates to exactly 0.05, which reported "Saudável" on a portfolio that had
+ * crossed into "Elevada". Cross-multiplying keeps the comparison in integers,
+ * where no digit is dropped.
+ */
+function ratioExceeds(overdue, total, threshold) {
+    // A non-finite threshold is no threshold: nothing can be past it.
+    if (!Number.isFinite(threshold))
+        return false;
+    // Scaling overflows to ±Infinity for a threshold that is finite but huge —
+    // 1e300 is enough, MAX_VALUE certainly — and `BigInt(Infinity)` throws a
+    // RangeError, mid-render, taking the surface down. Both overflow directions
+    // have an EXACT answer, so this degrades to the right result rather than a
+    // merely safe one: an overflowed positive threshold is one no 0..1 ratio could
+    // ever reach (not exceeded), an overflowed negative one sits below every ratio
+    // (always exceeded).
+    const scaled = Math.round(threshold * Number(THRESHOLD_SCALE));
+    if (!Number.isFinite(scaled))
+        return scaled < 0;
+    let scaledInt = BigInt(scaled);
+    // A threshold FINER than one unit of the scale rounds to zero, and a zero
+    // threshold means "anything above zero is past it" — the exact opposite of what
+    // a tiny positive threshold asks for. 4e-19 scaled to 0, so a ratio of 1e-19
+    // was reported as exceeding it. Clamp to one unit instead, keeping the sign, so
+    // a sub-scale threshold behaves as the finest one this comparison supports.
+    //
+    // ponytail: the floor is 1e-18 (THRESHOLD_SCALE), so a threshold between 0 and
+    // 1e-18 is treated as 1e-18 and a ratio in that sliver reads calmer than the
+    // literal number asks. Immaterial for a delinquency ratio — a portfolio would
+    // need ~1e18 currency units for one minor unit to land there — and the honest
+    // alternative is exact rational threshold conversion, which buys nothing real.
+    // An EXACT zero is left alone: every positive ratio does exceed it.
+    if (scaledInt === 0n && threshold !== 0) {
+        scaledInt = threshold < 0 ? -1n : 1n;
+    }
+    return overdue * THRESHOLD_SCALE > scaledInt * total;
+}
+/**
+ * The rate band, resolved from the exact minor-unit ratio. Mirrors `gaugeBand`'s
+ * higher-is-worse STRICT-edge canon (a ratio exactly ON a threshold stays in the
+ * calmer band) rather than calling it: `gaugeBand` takes a float, and handing it
+ * the truncated rate is precisely the defect above.
+ */
+function exactBand(overdue, total, warn, breach) {
+    if (ratioExceeds(overdue, total, breach))
+        return 'breach';
+    if (ratioExceeds(overdue, total, warn))
+        return 'warn';
+    return 'low';
+}
+/** Band → glyph + tint + accessible word. The glyph and sr-only word are the
+ *  load-bearing cue; the tint only reinforces, so the band survives grayscale
+ *  and color-vision deficiency. Mirrors the gauge's three-band canon, renamed
+ *  to the delinquency vocabulary. */
+const RATE_BAND = {
+    low: { Icon: ShieldCheck, tint: 'text-system-success', word: 'Saudável' },
+    warn: { Icon: TriangleAlert, tint: 'text-system-alert', word: 'Elevada' },
+    breach: { Icon: AlertOctagon, tint: 'text-credit', word: 'Em estresse' }
+};
+export function DelinquencyAging({ buckets, currency, locale, rateLabel = 'Inadimplência', rateBandLabels, emptyLabel = 'sem carteira', indeterminateLabel = 'indeterminada', bucketLabels, warn = 0.05, breach = 0.1, showTotal = false, className }) {
+    // THIRD RAIL: the rate scale and the two totals come from money-math, never
+    // float. The division below is of two exact BigInt-derived integers.
+    const scale = currency ? minorDigitsOf(currency) : 2;
+    const { rate, overdueMinor, totalMinor, indeterminate } = delinquencyRate(buckets, scale);
+    // The band is only meaningful when there is a rate; an empty/indeterminate
+    // portfolio has no band to name (rendered as the explicit no-value readout).
+    const hasRate = rate !== null;
+    // higher-is-worse: more value past due is worse. The band comes off the EXACT
+    // minor-unit ratio, never `rate` — that float is truncated at 1e-12 and is for
+    // DISPLAY only (one decimal place, where the truncation cannot show).
+    const band = hasRate && overdueMinor !== null && totalMinor !== null
+        ? exactBand(overdueMinor, totalMinor, warn, breach)
+        : 'low';
+    const { Icon, tint, word } = RATE_BAND[band];
+    // Shallow merge: an unlisted band keeps its pt-BR default.
+    const bandWord = rateBandLabels?.[band] ?? word;
+    const distressed = band === 'breach';
+    return (_jsxs("div", { className: cn('flex flex-col gap-4', className), children: [_jsxs("header", { className: "flex items-baseline justify-between gap-3", children: [_jsx(SectionLabel, { as: "span", children: rateLabel }), hasRate ? (_jsxs("span", { 
+                        // A distressed rate is a credit alarm: announced the moment it
+                        // crosses the band, so assistive tech does not lean on the tint.
+                        role: distressed ? 'alert' : undefined, className: cn('inline-flex items-center gap-1.5', tint), children: [_jsx(Icon, { "aria-hidden": true, className: "size-4 shrink-0" }), _jsxs("span", { className: "sr-only", children: [bandWord, ": "] }), _jsx(Figure, { size: "row", className: tint, children: formatPercent(rate, { unit: 'ratio', locale }) })] })) : (_jsxs("span", { className: "text-muted-foreground inline-flex items-center gap-1.5", children: [_jsx("span", { className: cn(LABEL_VOICE_CLASS, 'tracking-normal normal-case'), children: indeterminate ? indeterminateLabel : emptyLabel }), _jsx(Figure, { size: "row", className: "text-muted-foreground", children: NO_VALUE })] }))] }), _jsx(AgingBuckets, { buckets: buckets, currency: currency, locale: locale, showTotal: showTotal, labels: bucketLabels })] }));
+}

package/dist/esm/domain/figure/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Figure — the locked mono figure type scale of the enterprise console.
+ *
+ * All numbers are the hero: mono, tabular, visually dominant. This file is the
+ * single source of truth for the canonical figure sizes so screens stop
+ * re-typing `font-mono … tabular-nums` strings and drifting on
+ * size/weight/tracking. Use `<Figure size>` for new markup, or import the
+ * `FIGURE_CLASS` constants when composing className strings inline.
+ *
+ * Scale:
+ *  - hero  : the dominant in-bar figure   — text-4xl/5xl, semibold, tracking-tight
+ *  - panel : compliance / exposure        — text-3xl, semibold, tracking-tight
+ *  - count : ledger count                 — text-2xl, semibold, tracking-tight
+ *  - row   : inline / row figure          — text-sm
+ *  - tick  : ruler / micro figure         — text-[10px], leading-none
+ */
+import type { ElementType, ReactNode } from 'react';
+export type FigureSize = 'hero' | 'panel' | 'count' | 'row' | 'tick';
+/** Canonical class strings per figure size. The `tabular-nums` and `font-mono`
+ *  invariants live here so they can never be forgotten at a call site. */
+export declare const FIGURE_CLASS: Record<FigureSize, string>;
+export type FigureProps = {
+    size: FigureSize;
+    children: ReactNode;
+    className?: string;
+    /** Render element. Defaults to `span` so figures nest inside `dd`/`p`/etc. */
+    as?: ElementType;
+};
+export declare function Figure({ size, children, className, as: Tag }: FigureProps): import("react").JSX.Element;
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/domain/figure/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/domain/figure/index.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAInD,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,GAAG,KAAK,GAAG,MAAM,CAAA;AAEpE;0EAC0E;AAC1E,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,UAAU,EAAE,MAAM,CAMnD,CAAA;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,UAAU,CAAA;IAChB,QAAQ,EAAE,SAAS,CAAA;IACnB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,8EAA8E;IAC9E,EAAE,CAAC,EAAE,WAAW,CAAA;CACjB,CAAA;AAED,wBAAgB,MAAM,CAAC,EACrB,IAAI,EACJ,QAAQ,EACR,SAAS,EACT,EAAE,EAAE,GAAY,EACjB,EAAE,WAAW,+BAEb"}

package/dist/esm/domain/figure/index.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { cn } from '../../lib/utils.js';
+/** Canonical class strings per figure size. The `tabular-nums` and `font-mono`
+ *  invariants live here so they can never be forgotten at a call site. */
+export const FIGURE_CLASS = {
+    hero: 'font-mono text-4xl font-semibold tracking-tight tabular-nums lg:text-5xl',
+    panel: 'font-mono text-3xl font-semibold tracking-tight tabular-nums',
+    count: 'font-mono text-2xl font-semibold tracking-tight tabular-nums',
+    row: 'font-mono text-sm tabular-nums',
+    tick: 'font-mono text-[10px] leading-none tabular-nums'
+};
+export function Figure({ size, children, className, as: Tag = 'span' }) {
+    return _jsx(Tag, { className: cn(FIGURE_CLASS[size], className), children: children });
+}

package/dist/esm/domain/format.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Ledger-kit formatting helpers. Pure functions, no React. `MoneyText` owns
+ * monetary formatting; these cover percent, integer counts, and humanized
+ * durations (e.g. an average resolution time arriving as milliseconds).
+ */
+/** No-value placeholder. A middle dot reads as "empty" without an em dash, and
+ * stays narrow enough not to disturb tabular alignment. */
+export declare const NO_VALUE = "\u00B7";
+/**
+ * Whether a digit count is one `Intl.NumberFormat` (and `Number#toFixed`, and
+ * `String#repeat`) will actually accept: a finite integer in 0..100. Anything
+ * else — a negative, a fraction, NaN, Infinity — makes those constructors throw
+ * a RangeError, which on a money surface means a blank screen instead of a
+ * number. Every caller turns an invalid count into the no-value path instead.
+ *
+ * Internal: shared by `format`, `money-text` and `money-math` so the three
+ * cannot drift on what "valid" means. Never exported from `src/domain/index.ts`.
+ */
+export declare function isValidDigitCount(digits: number): boolean;
+/**
+ * A locale tag `Intl` will accept, or `undefined` — which every `Intl`
+ * constructor reads as "the runtime locale", the documented default for every
+ * `locale` prop in this layer.
+ *
+ * A structurally invalid tag makes EVERY `Intl` constructor throw a RangeError:
+ * `''`, `'en_US'` (underscore for hyphen — the commonest mistake, and what a
+ * POSIX `LANG` value looks like), a truncated tag out of a stored user
+ * preference. Unguarded, that RangeError escapes during render, so one bad
+ * preference string takes down the whole money surface instead of printing a
+ * number with the wrong decimal mark. `Intl.getCanonicalLocales` rejects exactly
+ * the tags the formatters reject, so it is the predicate rather than a
+ * hand-rolled BCP 47 regex.
+ *
+ * The locale is the least important input to a figure — the DIGITS are the
+ * point — so an unusable tag degrades to the runtime locale and the number still
+ * renders.
+ *
+ * Internal: shared by `format`, `money-text` and `number-input` so they cannot
+ * drift. Never exported from `src/domain/index.ts`.
+ */
+export declare function safeLocale(locale?: string): string | undefined;
+/** Whether an input rate is a 0..1 ratio or an already-scaled 0..100 percent.
+ * Defaults to 'ratio' — no guessing from magnitude. */
+export type PercentUnit = 'ratio' | 'percent';
+export type FormatPercentOptions = {
+    /** Fraction digits. Defaults to 1. */
+    digits?: number;
+    /** How to interpret `value`. 'ratio' (default) ×100; 'percent' is already 0..100. */
+    unit?: PercentUnit;
+    /** BCP 47 locale for the decimal mark. Defaults to the runtime locale. */
+    locale?: string;
+};
+/**
+ * Format a rate as a percent string. `unit` is explicit, never inferred from
+ * magnitude: 'ratio' (default) treats `value` as 0..1 and scales ×100;
+ * 'percent' treats `value` as already 0..100.
+ *
+ * Uses Intl style:'percent' for correct rounding and a locale-aware decimal
+ * mark. Intl multiplies its input by 100, so we always feed it the RATIO —
+ * a 'percent' input is divided by 100 first.
+ */
+export declare function formatPercent(value: number | null | undefined, options?: FormatPercentOptions): string;
+/**
+ * Normalize a rate to the 0..100 range for chart geometry. `unit` is explicit:
+ * 'ratio' (default) scales a 0..1 input ×100; 'percent' is already 0..100.
+ */
+export declare function toPercentValue(value: number | null | undefined, unit?: PercentUnit): number;
+/** Thousands-grouped integer count. `locale` defaults to the runtime locale. */
+export declare function formatCount(value: number | null | undefined, locale?: string): string;
+/**
+ * Humanize a millisecond duration into the largest two sensible units.
+ * 0ms → "0s". Sub-minute → seconds. Otherwise the two most-significant
+ * CONTIGUOUS d/h/m units from the largest non-zero unit down — so "2d 0h 5m"
+ * renders as "2d 0h", not the misleading "2d 5m".
+ *
+ * Note: the d/h/m/s suffixes are English; localizing them is deferred.
+ */
+export declare function humanizeDurationMs(ms: number | null | undefined): string;
+//# sourceMappingURL=format.d.ts.map

package/dist/esm/domain/format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../../src/domain/format.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;2DAC2D;AAC3D,eAAO,MAAM,QAAQ,WAAM,CAAA;AAE3B;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,UAAU,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAQ9D;AAED;uDACuD;AACvD,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,SAAS,CAAA;AAE7C,MAAM,MAAM,oBAAoB,GAAG;IACjC,sCAAsC;IACtC,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,qFAAqF;IACrF,IAAI,CAAC,EAAE,WAAW,CAAA;IAClB,0EAA0E;IAC1E,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AAED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAChC,OAAO,GAAE,oBAAyB,GACjC,MAAM,CAaR;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAChC,IAAI,GAAE,WAAqB,GAC1B,MAAM,CAIR;AAED,gFAAgF;AAChF,wBAAgB,WAAW,CACzB,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAChC,MAAM,CAAC,EAAE,MAAM,GACd,MAAM,CAMR;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAuBxE"}

package/dist/esm/domain/format.js

@@ -0,0 +1,128 @@
+/**
+ * Ledger-kit formatting helpers. Pure functions, no React. `MoneyText` owns
+ * monetary formatting; these cover percent, integer counts, and humanized
+ * durations (e.g. an average resolution time arriving as milliseconds).
+ */
+/** No-value placeholder. A middle dot reads as "empty" without an em dash, and
+ * stays narrow enough not to disturb tabular alignment. */
+export const NO_VALUE = '·';
+/**
+ * Whether a digit count is one `Intl.NumberFormat` (and `Number#toFixed`, and
+ * `String#repeat`) will actually accept: a finite integer in 0..100. Anything
+ * else — a negative, a fraction, NaN, Infinity — makes those constructors throw
+ * a RangeError, which on a money surface means a blank screen instead of a
+ * number. Every caller turns an invalid count into the no-value path instead.
+ *
+ * Internal: shared by `format`, `money-text` and `money-math` so the three
+ * cannot drift on what "valid" means. Never exported from `src/domain/index.ts`.
+ */
+export function isValidDigitCount(digits) {
+    return Number.isInteger(digits) && digits >= 0 && digits <= 100;
+}
+/**
+ * A locale tag `Intl` will accept, or `undefined` — which every `Intl`
+ * constructor reads as "the runtime locale", the documented default for every
+ * `locale` prop in this layer.
+ *
+ * A structurally invalid tag makes EVERY `Intl` constructor throw a RangeError:
+ * `''`, `'en_US'` (underscore for hyphen — the commonest mistake, and what a
+ * POSIX `LANG` value looks like), a truncated tag out of a stored user
+ * preference. Unguarded, that RangeError escapes during render, so one bad
+ * preference string takes down the whole money surface instead of printing a
+ * number with the wrong decimal mark. `Intl.getCanonicalLocales` rejects exactly
+ * the tags the formatters reject, so it is the predicate rather than a
+ * hand-rolled BCP 47 regex.
+ *
+ * The locale is the least important input to a figure — the DIGITS are the
+ * point — so an unusable tag degrades to the runtime locale and the number still
+ * renders.
+ *
+ * Internal: shared by `format`, `money-text` and `number-input` so they cannot
+ * drift. Never exported from `src/domain/index.ts`.
+ */
+export function safeLocale(locale) {
+    if (locale === undefined)
+        return undefined;
+    try {
+        Intl.getCanonicalLocales(locale);
+        return locale;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Format a rate as a percent string. `unit` is explicit, never inferred from
+ * magnitude: 'ratio' (default) treats `value` as 0..1 and scales ×100;
+ * 'percent' treats `value` as already 0..100.
+ *
+ * Uses Intl style:'percent' for correct rounding and a locale-aware decimal
+ * mark. Intl multiplies its input by 100, so we always feed it the RATIO —
+ * a 'percent' input is divided by 100 first.
+ */
+export function formatPercent(value, options = {}) {
+    if (value === null || value === undefined || !Number.isFinite(value))
+        return NO_VALUE;
+    const { digits = 1, unit = 'ratio', locale } = options;
+    // A caller-supplied digit count reaches Intl directly; an out-of-range one
+    // would throw a RangeError and take the whole surface down with it.
+    if (!isValidDigitCount(digits))
+        return NO_VALUE;
+    const ratio = unit === 'percent' ? value / 100 : value;
+    return new Intl.NumberFormat(safeLocale(locale), {
+        style: 'percent',
+        minimumFractionDigits: digits,
+        maximumFractionDigits: digits
+    }).format(ratio);
+}
+/**
+ * Normalize a rate to the 0..100 range for chart geometry. `unit` is explicit:
+ * 'ratio' (default) scales a 0..1 input ×100; 'percent' is already 0..100.
+ */
+export function toPercentValue(value, unit = 'ratio') {
+    if (value === null || value === undefined || !Number.isFinite(value))
+        return 0;
+    const pct = unit === 'percent' ? value : value * 100;
+    return Math.max(0, Math.min(100, pct));
+}
+/** Thousands-grouped integer count. `locale` defaults to the runtime locale. */
+export function formatCount(value, locale) {
+    if (value === null || value === undefined || !Number.isFinite(value))
+        return NO_VALUE;
+    return new Intl.NumberFormat(safeLocale(locale), {
+        maximumFractionDigits: 0
+    }).format(value);
+}
+/**
+ * Humanize a millisecond duration into the largest two sensible units.
+ * 0ms → "0s". Sub-minute → seconds. Otherwise the two most-significant
+ * CONTIGUOUS d/h/m units from the largest non-zero unit down — so "2d 0h 5m"
+ * renders as "2d 0h", not the misleading "2d 5m".
+ *
+ * Note: the d/h/m/s suffixes are English; localizing them is deferred.
+ */
+export function humanizeDurationMs(ms) {
+    if (ms == null || !Number.isFinite(ms) || ms < 0)
+        return NO_VALUE;
+    if (ms === 0)
+        return '0s';
+    const totalSeconds = Math.round(ms / 1000);
+    if (totalSeconds < 60)
+        return `${totalSeconds}s`;
+    const days = Math.floor(totalSeconds / 86400);
+    const hours = Math.floor((totalSeconds % 86400) / 3600);
+    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    // Two contiguous units starting at the largest non-zero unit, in order.
+    const units = [
+        [days, 'd'],
+        [hours, 'h'],
+        [minutes, 'm']
+    ];
+    const start = units.findIndex(([n]) => n > 0);
+    if (start === -1)
+        return `${minutes}m`;
+    return units
+        .slice(start, start + 2)
+        .map(([n, suffix]) => `${n}${suffix}`)
+        .join(' ');
+}

package/dist/esm/domain/index.d.ts

@@ -0,0 +1,23 @@
+export { NO_VALUE, formatCount, formatPercent, humanizeDurationMs, toPercentValue } from './format.js';
+export type { FormatPercentOptions, PercentUnit } from './format.js';
+export { moneyDiff } from './money-diff.js';
+export type { MoneyDiffInput } from './money-diff.js';
+export { MoneyText } from './money-text/index.js';
+export type { MoneyTextProps } from './money-text/index.js';
+export { FIGURE_CLASS, Figure } from './figure/index.js';
+export type { FigureProps, FigureSize } from './figure/index.js';
+export { SectionLabel } from './section-label/index.js';
+export type { SectionLabelProps } from './section-label/index.js';
+export { Blotter, BlotterRow } from './blotter/index.js';
+export type { BlotterProps, BlotterRowProps } from './blotter/index.js';
+export { LedgerPanel, LedgerSheet } from './ledger-sheet/index.js';
+export type { LedgerPanelProps, LedgerSheetProps } from './ledger-sheet/index.js';
+export { KeyId } from './key-id/index.js';
+export type { KeyIdKind, KeyIdProps } from './key-id/index.js';
+export { Dot, LivePulse, StatusRail } from './status-rail/index.js';
+export type { StatusRailChip, StatusRailItem, StatusRailProps } from './status-rail/index.js';
+export { ThresholdGauge, gaugeBand } from './threshold-gauge/index.js';
+export type { GaugeBand, GaugeDirection, GaugeEdges, GaugeFormat, GaugeThresholds, ThresholdGaugeProps } from './threshold-gauge/index.js';
+export { DelinquencyAging } from './delinquency-aging/index.js';
+export type { AgingBand, AgingBucketsLabels, DelinquencyAgingProps, DelinquencyBucket } from './delinquency-aging/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/domain/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/domain/index.ts"],"names":[],"mappings":"AASA,OAAO,EACL,QAAQ,EACR,WAAW,EACX,aAAa,EACb,kBAAkB,EAClB,cAAc,EACf,MAAM,UAAU,CAAA;AACjB,YAAY,EAAE,oBAAoB,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAEjE,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AACxC,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAElD,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AACxC,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAElD,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AAC/C,YAAY,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAEvD,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAC9C,YAAY,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AAExD,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AAC/C,YAAY,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,WAAW,CAAA;AAE9D,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AACzD,YAAY,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AAExE,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAA;AAChC,YAAY,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAErD,OAAO,EAAE,GAAG,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAC1D,YAAY,EACV,cAAc,EACd,cAAc,EACd,eAAe,EAChB,MAAM,eAAe,CAAA;AAEtB,OAAO,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAA;AAC7D,YAAY,EACV,SAAS,EACT,cAAc,EACd,UAAU,EACV,WAAW,EACX,eAAe,EACf,mBAAmB,EACpB,MAAM,mBAAmB,CAAA;AAE1B,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;AACtD,YAAY,EACV,SAAS,EACT,kBAAkB,EAClB,qBAAqB,EACrB,iBAAiB,EAClB,MAAM,qBAAqB,CAAA"}

package/dist/esm/domain/index.js

@@ -0,0 +1,19 @@
+// Owned by lane domain — see docs/plans/2026-08-26-sindarian-x-retirement/
+//
+// The finance domain grammar absorbed from @lerianstudio/sindarian-x@0.15.0.
+// Exports are NAMED (never `export *`) on purpose: the port census freezes the
+// public surface to exactly the symbols the four migrating apps import, and the
+// money-math internals (`toMinor`, `Amount`, `sumMinor`, `formatMoneyParts`,
+// `maskKeyId`, `AgingBuckets`, …) stay module-private so they never become an
+// API this package has to keep.
+export { NO_VALUE, formatCount, formatPercent, humanizeDurationMs, toPercentValue } from './format.js';
+export { moneyDiff } from './money-diff.js';
+export { MoneyText } from './money-text/index.js';
+export { FIGURE_CLASS, Figure } from './figure/index.js';
+export { SectionLabel } from './section-label/index.js';
+export { Blotter, BlotterRow } from './blotter/index.js';
+export { LedgerPanel, LedgerSheet } from './ledger-sheet/index.js';
+export { KeyId } from './key-id/index.js';
+export { Dot, LivePulse, StatusRail } from './status-rail/index.js';
+export { ThresholdGauge, gaugeBand } from './threshold-gauge/index.js';
+export { DelinquencyAging } from './delinquency-aging/index.js';

package/dist/esm/domain/key-id/index.d.ts

@@ -0,0 +1,31 @@
+export type KeyIdKind = 'pix-cpf' | 'pix-cnpj' | 'pix-email' | 'pix-phone' | 'pix-evp' | 'e2e' | 'idempotency' | 'generic';
+export interface KeyIdProps {
+    value: string;
+    /** What the value is. Drives the mask shape and the default mask state. */
+    kind?: KeyIdKind;
+    /** Optional uppercase tag rendered before the value (e.g. 'Payer', 'E2E'). */
+    label?: string;
+    /** Override the per-kind mask default. PII kinds default true, ids default false. */
+    mask?: boolean;
+    /** Show a button that copies the RAW (unmasked) value to the clipboard. */
+    copyable?: boolean;
+    /** BCP 47 locale — reserved for future locale-aware id formatting. */
+    locale?: string;
+    className?: string;
+}
+/** Whether a kind masks by default (PII) — used when `mask` is not supplied.
+ *  Internal: exported for its unit tests, never from `src/domain/index.ts`. */
+export declare function masksByDefault(kind: KeyIdKind): boolean;
+/**
+ * Mask a key for display. PII kinds get a structured mask that reveals a
+ * non-identifying middle and dots the rest; a value MALFORMED for its kind is
+ * redacted outright (see `redactPii`) rather than truncated, so a mask can never
+ * fall through to the raw secret. Id-shaped kinds are always middle-truncated
+ * (long, not secret). The copy path never uses this — it always sends the raw
+ * value.
+ *
+ * Internal: exported for its unit tests, never from `src/domain/index.ts`.
+ */
+export declare function maskKeyId(value: string, kind: KeyIdKind): string;
+export declare function KeyId({ value, kind, label, mask, copyable, className }: KeyIdProps): import("react").JSX.Element;
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/domain/key-id/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/domain/key-id/index.tsx"],"names":[],"mappings":"AA2BA,MAAM,MAAM,SAAS,GACjB,SAAS,GACT,UAAU,GACV,WAAW,GACX,WAAW,GACX,SAAS,GACT,KAAK,GACL,aAAa,GACb,SAAS,CAAA;AAEb,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,MAAM,CAAA;IACb,2EAA2E;IAC3E,IAAI,CAAC,EAAE,SAAS,CAAA;IAChB,8EAA8E;IAC9E,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,qFAAqF;IACrF,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,2EAA2E;IAC3E,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,sEAAsE;IACtE,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAeD;+EAC+E;AAC/E,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO,CAEvD;AAuED;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,GAAG,MAAM,CAahE;AAED,wBAAgB,KAAK,CAAC,EACpB,KAAK,EACL,IAAgB,EAChB,KAAK,EACL,IAAI,EACJ,QAAgB,EAChB,SAAS,EACV,EAAE,UAAU,+BAsBZ"}