@lerianstudio/sindarian-ui 1.2.0-beta.13 → 1.2.0-beta.14

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

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.delinquencyRate = delinquencyRate;
+exports.DelinquencyAging = DelinquencyAging;
+const jsx_runtime_1 = require("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.
+ */
+const lucide_react_1 = require("lucide-react");
+const typography_1 = require("../../lib/typography");
+const utils_1 = require("../../lib/utils");
+const figure_1 = require("../figure");
+const format_1 = require("../format");
+const money_math_1 = require("../money-math");
+const section_label_1 = require("../section-label");
+const threshold_gauge_1 = require("../threshold-gauge");
+const aging_buckets_1 = require("./aging-buckets");
+/** 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`.
+ */
+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) => (0, money_math_1.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 };
+}
+/** 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: lucide_react_1.ShieldCheck, tint: 'text-system-success', word: 'Saudável' },
+    warn: { Icon: lucide_react_1.TriangleAlert, tint: 'text-system-alert', word: 'Elevada' },
+    breach: { Icon: lucide_react_1.AlertOctagon, tint: 'text-credit', word: 'Em estresse' }
+};
+function DelinquencyAging({ buckets, currency, locale, rateLabel = 'Inadimplência', 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 ? (0, money_math_1.minorDigitsOf)(currency) : 2;
+    const { rate, 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. gaugeBand is strict-edge, so
+    // a rate exactly on a threshold stays in the calmer band.
+    const band = hasRate
+        ? (0, threshold_gauge_1.gaugeBand)(rate, { warn, breach }, 'higher-is-worse')
+        : 'low';
+    const { Icon, tint, word } = RATE_BAND[band];
+    const distressed = band === 'breach';
+    return ((0, jsx_runtime_1.jsxs)("div", { className: (0, utils_1.cn)('flex flex-col gap-4', className), children: [(0, jsx_runtime_1.jsxs)("header", { className: "flex items-baseline justify-between gap-3", children: [(0, jsx_runtime_1.jsx)(section_label_1.SectionLabel, { as: "span", children: rateLabel }), hasRate ? ((0, jsx_runtime_1.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: (0, utils_1.cn)('inline-flex items-center gap-1.5', tint), children: [(0, jsx_runtime_1.jsx)(Icon, { "aria-hidden": true, className: "size-4 shrink-0" }), (0, jsx_runtime_1.jsxs)("span", { className: "sr-only", children: [word, ": "] }), (0, jsx_runtime_1.jsx)(figure_1.Figure, { size: "row", className: tint, children: (0, format_1.formatPercent)(rate, { unit: 'ratio', locale }) })] })) : ((0, jsx_runtime_1.jsxs)("span", { className: "text-muted-foreground inline-flex items-center gap-1.5", children: [(0, jsx_runtime_1.jsx)("span", { className: (0, utils_1.cn)(typography_1.LABEL_VOICE_CLASS, 'tracking-normal normal-case'), children: indeterminate ? 'indeterminada' : 'sem carteira' }), (0, jsx_runtime_1.jsx)(figure_1.Figure, { size: "row", className: "text-muted-foreground", children: format_1.NO_VALUE })] }))] }), (0, jsx_runtime_1.jsx)(aging_buckets_1.AgingBuckets, { buckets: buckets, currency: currency, locale: locale, showTotal: showTotal })] }));
+}

package/dist/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/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/domain/figure/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FIGURE_CLASS = void 0;
+exports.Figure = Figure;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const utils_1 = require("../../lib/utils");
+/** 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. */
+exports.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'
+};
+function Figure({ size, children, className, as: Tag = 'span' }) {
+    return (0, jsx_runtime_1.jsx)(Tag, { className: (0, utils_1.cn)(exports.FIGURE_CLASS[size], className), children: children });
+}

package/dist/domain/format.d.ts

@@ -0,0 +1,57 @@
+/**
+ * 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;
+/** 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/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;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/domain/format.js

@@ -0,0 +1,102 @@
+"use strict";
+/**
+ * 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).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NO_VALUE = void 0;
+exports.isValidDigitCount = isValidDigitCount;
+exports.formatPercent = formatPercent;
+exports.toPercentValue = toPercentValue;
+exports.formatCount = formatCount;
+exports.humanizeDurationMs = humanizeDurationMs;
+/** No-value placeholder. A middle dot reads as "empty" without an em dash, and
+ * stays narrow enough not to disturb tabular alignment. */
+exports.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`.
+ */
+function isValidDigitCount(digits) {
+    return Number.isInteger(digits) && digits >= 0 && digits <= 100;
+}
+/**
+ * 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.
+ */
+function formatPercent(value, options = {}) {
+    if (value === null || value === undefined || !Number.isFinite(value))
+        return exports.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 exports.NO_VALUE;
+    const ratio = unit === 'percent' ? value / 100 : value;
+    return new Intl.NumberFormat(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.
+ */
+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. */
+function formatCount(value, locale) {
+    if (value === null || value === undefined || !Number.isFinite(value))
+        return exports.NO_VALUE;
+    return new Intl.NumberFormat(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.
+ */
+function humanizeDurationMs(ms) {
+    if (ms == null || !Number.isFinite(ms) || ms < 0)
+        return exports.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/domain/index.d.ts

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

package/dist/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;AAExC,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,qBAAqB,EACrB,iBAAiB,EAClB,MAAM,qBAAqB,CAAA"}

package/dist/domain/index.js

@@ -0,0 +1,43 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DelinquencyAging = exports.gaugeBand = exports.ThresholdGauge = exports.StatusRail = exports.LivePulse = exports.Dot = exports.KeyId = exports.LedgerSheet = exports.LedgerPanel = exports.BlotterRow = exports.Blotter = exports.SectionLabel = exports.Figure = exports.FIGURE_CLASS = exports.MoneyText = exports.moneyDiff = exports.toPercentValue = exports.humanizeDurationMs = exports.formatPercent = exports.formatCount = exports.NO_VALUE = void 0;
+var format_1 = require("./format");
+Object.defineProperty(exports, "NO_VALUE", { enumerable: true, get: function () { return format_1.NO_VALUE; } });
+Object.defineProperty(exports, "formatCount", { enumerable: true, get: function () { return format_1.formatCount; } });
+Object.defineProperty(exports, "formatPercent", { enumerable: true, get: function () { return format_1.formatPercent; } });
+Object.defineProperty(exports, "humanizeDurationMs", { enumerable: true, get: function () { return format_1.humanizeDurationMs; } });
+Object.defineProperty(exports, "toPercentValue", { enumerable: true, get: function () { return format_1.toPercentValue; } });
+var money_diff_1 = require("./money-diff");
+Object.defineProperty(exports, "moneyDiff", { enumerable: true, get: function () { return money_diff_1.moneyDiff; } });
+var money_text_1 = require("./money-text");
+Object.defineProperty(exports, "MoneyText", { enumerable: true, get: function () { return money_text_1.MoneyText; } });
+var figure_1 = require("./figure");
+Object.defineProperty(exports, "FIGURE_CLASS", { enumerable: true, get: function () { return figure_1.FIGURE_CLASS; } });
+Object.defineProperty(exports, "Figure", { enumerable: true, get: function () { return figure_1.Figure; } });
+var section_label_1 = require("./section-label");
+Object.defineProperty(exports, "SectionLabel", { enumerable: true, get: function () { return section_label_1.SectionLabel; } });
+var blotter_1 = require("./blotter");
+Object.defineProperty(exports, "Blotter", { enumerable: true, get: function () { return blotter_1.Blotter; } });
+Object.defineProperty(exports, "BlotterRow", { enumerable: true, get: function () { return blotter_1.BlotterRow; } });
+var ledger_sheet_1 = require("./ledger-sheet");
+Object.defineProperty(exports, "LedgerPanel", { enumerable: true, get: function () { return ledger_sheet_1.LedgerPanel; } });
+Object.defineProperty(exports, "LedgerSheet", { enumerable: true, get: function () { return ledger_sheet_1.LedgerSheet; } });
+var key_id_1 = require("./key-id");
+Object.defineProperty(exports, "KeyId", { enumerable: true, get: function () { return key_id_1.KeyId; } });
+var status_rail_1 = require("./status-rail");
+Object.defineProperty(exports, "Dot", { enumerable: true, get: function () { return status_rail_1.Dot; } });
+Object.defineProperty(exports, "LivePulse", { enumerable: true, get: function () { return status_rail_1.LivePulse; } });
+Object.defineProperty(exports, "StatusRail", { enumerable: true, get: function () { return status_rail_1.StatusRail; } });
+var threshold_gauge_1 = require("./threshold-gauge");
+Object.defineProperty(exports, "ThresholdGauge", { enumerable: true, get: function () { return threshold_gauge_1.ThresholdGauge; } });
+Object.defineProperty(exports, "gaugeBand", { enumerable: true, get: function () { return threshold_gauge_1.gaugeBand; } });
+var delinquency_aging_1 = require("./delinquency-aging");
+Object.defineProperty(exports, "DelinquencyAging", { enumerable: true, get: function () { return delinquency_aging_1.DelinquencyAging; } });

package/dist/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/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;AAiED;;;;;;;;;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"}

package/dist/domain/key-id/index.js

@@ -0,0 +1,167 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.masksByDefault = masksByDefault;
+exports.maskKeyId = maskKeyId;
+exports.KeyId = KeyId;
+const jsx_runtime_1 = require("react/jsx-runtime");
+/**
+ * KeyId — a masked, copyable, traceable identifier for Brazilian rails: a Pix
+ * key (CPF / CNPJ / email / phone / EVP-random), an End-to-End id (E2E), an
+ * idempotency key, or a generic id.
+ *
+ * Two jobs at once. PII keys (CPF/CNPJ/email/phone) are masked by default so a
+ * shared screen or a screenshot doesn't leak a person's document or contact —
+ * the middle of a document is revealed, the identifying head/tail is dotted.
+ * Long-but-not-secret ids (EVP/E2E/idempotency/generic) are merely truncated in
+ * the MIDDLE so the head and tail — the parts an operator eyeballs against a
+ * log — stay legible.
+ *
+ *   <KeyId value="529.982.247-25" kind="pix-cpf" label="Payer" copyable />
+ *   <KeyId value="E32074158202406211200abc123def456" kind="e2e" copyable />
+ *
+ * The copy button always lifts the RAW, unmasked value to the clipboard — the
+ * mask is a display concern, never a data one. The masked render and the copy
+ * affordance are what make this a client component.
+ */
+const lucide_react_1 = require("lucide-react");
+const react_1 = require("react");
+const typography_1 = require("../../lib/typography");
+const utils_1 = require("../../lib/utils");
+/** The dot used to redact a character. A bullet, not an asterisk: it reads as
+ *  "hidden" without looking like a password field's shouting. */
+const DOT = '•';
+/** Kinds that carry PII and are masked by default. The id-shaped kinds are long
+ *  but not secret, so they default to revealed (just truncated). */
+const PII_KINDS = new Set([
+    'pix-cpf',
+    'pix-cnpj',
+    'pix-email',
+    'pix-phone'
+]);
+/** 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`. */
+function masksByDefault(kind) {
+    return PII_KINDS.has(kind);
+}
+/** Keep only the digits — Brazilian documents arrive punctuated or bare. */
+function digitsOf(value) {
+    return value.replace(/\D/g, '');
+}
+/**
+ * Truncate the MIDDLE of a long value, keeping a head and tail so an operator
+ * can eyeball it against a log. Short values are returned whole.
+ */
+function truncateMiddle(value, head = 6, tail = 4) {
+    if (value.length <= head + tail + 1)
+        return value;
+    return `${value.slice(0, head)}…${value.slice(-tail)}`;
+}
+/**
+ * The fallback for a PII value that is MALFORMED for its kind. It must not be
+ * `truncateMiddle`: a short malformed value (a CPF missing a digit, a hand-typed
+ * document, a name-shaped email that failed the `@` check) is returned WHOLE by
+ * truncation, so the "masked" render leaks the very PII the mask exists to hide.
+ * A fixed-width dot run reveals nothing — not the content, not even the length.
+ *
+ * DELIBERATE DIVERGENCE from sindarian-x@0.15.0, which truncated instead. It
+ * costs the operator the ability to eyeball a malformed document against a log;
+ * that is the correct trade, because the alternative is a screenshot with a real
+ * CPF in it. An operator who needs the value passes `mask={false}` explicitly.
+ */
+function redactPii() {
+    return DOT.repeat(6);
+}
+/** Mask all but the central block of a digit string, then re-punctuate it. */
+function maskCpf(value) {
+    const d = digitsOf(value);
+    if (d.length !== 11)
+        return redactPii();
+    // Reveal the middle two blocks (456.789), dot the leading block and check digits.
+    return `${DOT.repeat(3)}.${d.slice(3, 6)}.${d.slice(6, 9)}-${DOT.repeat(2)}`;
+}
+function maskCnpj(value) {
+    const d = digitsOf(value);
+    if (d.length !== 14)
+        return redactPii();
+    // Reveal the central registration blocks, dot the head and the check digits.
+    return `${DOT.repeat(2)}.${d.slice(2, 5)}.${d.slice(5, 8)}/${d.slice(8, 12)}-${DOT.repeat(2)}`;
+}
+function maskEmail(value) {
+    const at = value.indexOf('@');
+    if (at <= 0 || at === value.length - 1)
+        return redactPii();
+    const first = value.slice(0, 1);
+    const domain = value.slice(at + 1);
+    return `${first}${DOT.repeat(3)}@${domain}`;
+}
+function maskPhone(value) {
+    const d = digitsOf(value);
+    // Expect a BR mobile in E.164-ish form: 55 + 2-digit area + 9 subscriber digits.
+    if (d.length !== 13 || !d.startsWith('55'))
+        return redactPii();
+    const area = d.slice(2, 4);
+    const last2 = d.slice(-2);
+    // Keep country + area, reveal the last two, dot the rest of the subscriber run.
+    return `+55 (${area}) ${DOT.repeat(5)}-${DOT.repeat(2)}${last2}`;
+}
+/**
+ * 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`.
+ */
+function maskKeyId(value, kind) {
+    switch (kind) {
+        case 'pix-cpf':
+            return maskCpf(value);
+        case 'pix-cnpj':
+            return maskCnpj(value);
+        case 'pix-email':
+            return maskEmail(value);
+        case 'pix-phone':
+            return maskPhone(value);
+        default:
+            return truncateMiddle(value);
+    }
+}
+function KeyId({ value, kind = 'generic', label, mask, copyable = false, className }) {
+    const masked = mask ?? masksByDefault(kind);
+    const display = masked ? maskKeyId(value, kind) : truncateMiddle(value);
+    return ((0, jsx_runtime_1.jsxs)("span", { className: (0, utils_1.cn)('inline-flex min-w-0 items-center gap-2', className), children: [label ? ((0, jsx_runtime_1.jsx)("span", { className: (0, utils_1.cn)(typography_1.LABEL_VOICE_CLASS, 'shrink-0'), children: label })) : null, (0, jsx_runtime_1.jsx)("span", { className: "text-foreground truncate font-mono text-xs tabular-nums", 
+                // The raw value as a tooltip only when nothing is hidden — never leak a
+                // masked PII value through the title attribute.
+                title: masked ? undefined : value, children: display }), copyable ? (0, jsx_runtime_1.jsx)(CopyValue, { value: value }) : null] }));
+}
+/** The copy affordance: lifts the RAW value to the clipboard and flips to a
+ *  check for a beat. The transient confirmation is announced for assistive tech;
+ *  the icon is paired with a text aria-label so the state isn't color-only. */
+function CopyValue({ value }) {
+    const [copied, setCopied] = (0, react_1.useState)(false);
+    const copy = () => {
+        // ponytail: best-effort clipboard write — no toast, no error surface. The
+        // ceiling is silent failure in an insecure context (clipboard unavailable);
+        // upgrade path is to lift a result up via an onCopy callback when a caller
+        // needs to react.
+        //
+        // The rejection handler is NOT optional: `writeText` rejects on a denied
+        // permission or a non-secure context, and an unhandled rejection in a render
+        // tree is a console error at best and a crashed handler at worst. On failure
+        // the button simply does not flip to the copied state, so the operator sees
+        // that nothing was copied rather than a false confirmation.
+        void navigator.clipboard
+            ?.writeText(value)
+            .then(() => {
+            setCopied(true);
+            setTimeout(() => setCopied(false), 1500);
+        })
+            .catch(() => {
+            setCopied(false);
+        });
+    };
+    return ((0, jsx_runtime_1.jsx)("button", { type: "button", onClick: copy, "aria-label": copied ? 'Copiado para a área de transferência' : 'Copiar valor', className: "text-muted-foreground hover:text-foreground focus:ring-ring inline-flex size-5 shrink-0 items-center justify-center rounded-sm transition-colors duration-150 ease-out focus:ring-2 focus:outline-none", children: copied ? ((0, jsx_runtime_1.jsx)(lucide_react_1.Check, { "aria-hidden": true, className: "text-system-success size-3" })) : ((0, jsx_runtime_1.jsx)(lucide_react_1.Copy, { "aria-hidden": true, className: "size-3" })) }));
+}