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

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

@@ -0,0 +1,174 @@
+'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();
+    // EXACTLY one '@', or it is not an address and the domain half cannot be
+    // trusted to be a domain. `a@private@domain.test` split on the FIRST '@' and
+    // published `private@domain.test` verbatim as the "domain" — the local part of
+    // a second address, revealed in a view whose whole purpose is to hide it.
+    // Malformed PII redacts, exactly like a wrong-length CPF.
+    if (value.indexOf('@', at + 1) !== -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" })) }));
+}

package/dist/domain/ledger-sheet/index.d.ts

@@ -0,0 +1,45 @@
+/**
+ * LedgerSheet + LedgerPanel — the connected-cell layout of the console.
+ *
+ * Do NOT float hairline cards in whitespace. Build connected sheets: a
+ * `bg-border` wrapper with `gap-px`, cells `bg-card`. The 1px gaps reveal the
+ * border color as hairline seams, so the panels read as one ruled ledger sheet.
+ *
+ *   <LedgerSheet cols={3}>
+ *     <LedgerPanel>…</LedgerPanel>
+ *     <LedgerPanel>…</LedgerPanel>
+ *     <LedgerPanel>…</LedgerPanel>
+ *   </LedgerSheet>
+ *
+ * The `cols` prop drives the responsive column count; on mobile every sheet
+ * collapses to a single column. When a panel self-hides, pass the reduced
+ * `cols` so the remaining panels stretch (e.g. 3 → 2 when a panel returns null).
+ */
+import type { ComponentPropsWithoutRef, ReactNode } from 'react';
+/** Desktop column count. Only 1..4 are mapped (Tailwind needs literal class names). */
+type Cols = 1 | 2 | 3 | 4;
+export type LedgerSheetProps = {
+    children: ReactNode;
+    /** Desktop column count (1..4). Mobile always collapses to a single column. */
+    cols?: Cols;
+    className?: string;
+};
+export declare function LedgerSheet({ children, cols, className }: LedgerSheetProps): import("react").JSX.Element;
+export type LedgerPanelProps = {
+    children: ReactNode;
+    className?: string;
+    /** Render element. Defaults to `section` (a labeled console panel). */
+    as?: 'section' | 'div';
+} & Omit<ComponentPropsWithoutRef<'section'>, 'children' | 'className'>;
+/**
+ * One cell of a ledger sheet. Flush — no own border or shadow — with `bg-card`,
+ * internal `p-5` padding and `flex h-full flex-col gap-4` so panels stretch to
+ * equal height. Start each panel with a `<SectionLabel>` as its heading.
+ *
+ * Remaining props land on the rendered element, so a composed panel can carry
+ * its own `data-*` hooks (StatCard's `data-tone`, for one) without wrapping the
+ * cell in an extra div that would break the hairline seams.
+ */
+export declare function LedgerPanel({ children, className, as: Tag, ...rest }: LedgerPanelProps): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/domain/ledger-sheet/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/domain/ledger-sheet/index.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,EAAE,wBAAwB,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAIhE,uFAAuF;AACvF,KAAK,IAAI,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;AAUzB,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,EAAE,SAAS,CAAA;IACnB,+EAA+E;IAC/E,IAAI,CAAC,EAAE,IAAI,CAAA;IACX,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,wBAAgB,WAAW,CAAC,EAC1B,QAAQ,EACR,IAAQ,EACR,SAAS,EACV,EAAE,gBAAgB,+BAYlB;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,EAAE,SAAS,CAAA;IACnB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,uEAAuE;IACvE,EAAE,CAAC,EAAE,SAAS,GAAG,KAAK,CAAA;CACvB,GAAG,IAAI,CAAC,wBAAwB,CAAC,SAAS,CAAC,EAAE,UAAU,GAAG,WAAW,CAAC,CAAA;AAEvE;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,EAC1B,QAAQ,EACR,SAAS,EACT,EAAE,EAAE,GAAe,EACnB,GAAG,IAAI,EACR,EAAE,gBAAgB,+BASlB"}

package/dist/domain/ledger-sheet/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LedgerSheet = LedgerSheet;
+exports.LedgerPanel = LedgerPanel;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const utils_1 = require("../../lib/utils");
+/** Tailwind needs literal class names to survive purge; map cols → class. */
+const COLS_CLASS = {
+    1: 'lg:grid-cols-1',
+    2: 'lg:grid-cols-2',
+    3: 'lg:grid-cols-3',
+    4: 'lg:grid-cols-4'
+};
+function LedgerSheet({ children, cols = 1, className }) {
+    return ((0, jsx_runtime_1.jsx)("div", { className: (0, utils_1.cn)('border-border bg-border grid grid-cols-1 gap-px overflow-hidden rounded-lg border', COLS_CLASS[cols] ?? COLS_CLASS[1], className), children: children }));
+}
+/**
+ * One cell of a ledger sheet. Flush — no own border or shadow — with `bg-card`,
+ * internal `p-5` padding and `flex h-full flex-col gap-4` so panels stretch to
+ * equal height. Start each panel with a `<SectionLabel>` as its heading.
+ *
+ * Remaining props land on the rendered element, so a composed panel can carry
+ * its own `data-*` hooks (StatCard's `data-tone`, for one) without wrapping the
+ * cell in an extra div that would break the hairline seams.
+ */
+function LedgerPanel({ children, className, as: Tag = 'section', ...rest }) {
+    return ((0, jsx_runtime_1.jsx)(Tag, { className: (0, utils_1.cn)('bg-card flex h-full flex-col gap-4 p-5', className), ...rest, children: children }));
+}

package/dist/domain/money-diff.d.ts

@@ -0,0 +1,28 @@
+import type { Amount } from './money-math';
+/** The money-comparison contract: two sides, a currency, an optional tolerance.
+ *  Exported so a consumer can name the argument type it is already passing. */
+export type MoneyDiffInput = {
+    /** Left amount (canonical decimal string preferred for lossless math). */
+    left: Amount;
+    /** Right amount. The difference is left − right. */
+    right: Amount;
+    /** ISO 4217 currency code, e.g. "BRL". Drives the minor-unit scale. */
+    currency: string;
+    /** Override the currency-derived minor-unit scale. When omitted, the scale
+     *  derives from the currency (2 for an unknown one), never a hardcoded 2. */
+    minorDigits?: number;
+    /** Absolute tolerance in MAJOR units. `|left − right| > tolerance` is a breach. */
+    tolerance?: Amount;
+    /** BCP 47 locale. CURRENTLY UNUSED: `moneyDiff` returns `{ decimal, breach }`
+     *  and formats nothing, so this value has no effect on the result. It stays in
+     *  the contract because removing it would break every consumer that passes it
+     *  (an object literal with an unknown member is an excess-property error), and
+     *  because the formatting side of the pair — `MoneyText` — takes a locale of
+     *  its own. Pass the locale THERE, at the point the figure is rendered. */
+    locale?: string;
+};
+export declare function moneyDiff(money: MoneyDiffInput): {
+    decimal: string | null;
+    breach: boolean;
+};
+//# sourceMappingURL=money-diff.d.ts.map

package/dist/domain/money-diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"money-diff.d.ts","sourceRoot":"","sources":["../../src/domain/money-diff.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAE1C;+EAC+E;AAC/E,MAAM,MAAM,cAAc,GAAG;IAC3B,0EAA0E;IAC1E,IAAI,EAAE,MAAM,CAAA;IACZ,oDAAoD;IACpD,KAAK,EAAE,MAAM,CAAA;IACb,uEAAuE;IACvE,QAAQ,EAAE,MAAM,CAAA;IAChB;iFAC6E;IAC7E,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,mFAAmF;IACnF,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB;;;;;+EAK2E;IAC3E,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,cAAc,GAAG;IAChD,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,MAAM,EAAE,OAAO,CAAA;CAChB,CA6BA"}

package/dist/domain/money-diff.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.moneyDiff = moneyDiff;
+/**
+ * moneyDiff — the signed difference between two reconciliation sides, computed
+ * on integer minor units and never on floats.
+ *
+ * THIRD RAIL (money): `left − right` runs through `toMinor` on both operands →
+ * BigInt subtraction → `minorToDecimal`, and the tolerance breach test compares
+ * MAGNITUDES in minor units. A float subtraction of two decimals would drift by
+ * a cent at reconciliation scale, which is the difference between a matched and
+ * an unmatched pair.
+ *
+ * A null `decimal` means an unparseable operand — surfaced, never coerced to
+ * zero, so a caller renders the no-value placeholder rather than a fabricated
+ * tie.
+ */
+const money_math_1 = require("./money-math");
+function moneyDiff(money) {
+    const scale = money.minorDigits ?? (0, money_math_1.minorDigitsOf)(money.currency);
+    const l = (0, money_math_1.toMinor)(money.left, scale);
+    const r = (0, money_math_1.toMinor)(money.right, scale);
+    if (l === null || r === null)
+        return { decimal: null, breach: false };
+    const diff = l - r;
+    // A tolerance that was SUPPLIED but does not parse ('', 'oops', '-.') is not
+    // the same thing as no tolerance at all. Degrading to the no-tolerance rule
+    // made every nonzero difference a breach, so one typo in a tolerance field
+    // turned a reconciled book into a screen of false breaches — the loudest
+    // possible wrong answer. A supplied-invalid tolerance is INDETERMINATE,
+    // exactly like an unparseable operand: no number, no verdict.
+    const supplied = money.tolerance != null;
+    const rawTol = supplied ? (0, money_math_1.toMinor)(money.tolerance, scale) : null;
+    if (supplied && rawTol === null)
+        return { decimal: null, breach: false };
+    // A tolerance is a BAND WIDTH, so only its magnitude is meaningful. Taken
+    // signed, a negative tolerance made `|diff| > tol` true for every value
+    // including an exact tie (0n > -5n), flagging perfectly reconciled pairs as
+    // breaches. Normalizing to the magnitude means `-0.05` and `0.05` describe the
+    // same band, which is the only reading of a negative tolerance that is not a
+    // silent false alarm.
+    const tol = rawTol === null ? null : rawTol < 0n ? -rawTol : rawTol;
+    const abs = diff < 0n ? -diff : diff;
+    // A breach is a magnitude STRICTLY beyond the band; no tolerance → no band, so
+    // any nonzero difference is itself the breach.
+    const breach = tol === null ? diff !== 0n : abs > tol;
+    return { decimal: (0, money_math_1.minorToDecimal)(diff, scale), breach };
+}

package/dist/domain/money-math.d.ts

@@ -0,0 +1,32 @@
+/**
+ * money-math — exact integer-minor-unit arithmetic for the double-entry third rail.
+ *
+ * INTERNAL to the domain layer: nothing here is re-exported from
+ * `src/domain/index.ts`, so `toMinor`/`Amount`/`sumMinor` are NOT part of
+ * `@lerianstudio/sindarian-ui`'s public API. The consumers that need exact money
+ * arithmetic reach it through the components that own it (`moneyDiff`,
+ * `MoneyText`, `DelinquencyAging`).
+ *
+ * Amounts parse to integer minor units (BigInt) at a fixed scale; sums never
+ * round-trip through IEEE-754. Pass amounts as canonical decimal STRINGS for
+ * lossless math — numbers are converted via toFixed, which is float-bounded
+ * (fine for display-scale magnitudes, exact for strings).
+ */
+export type Amount = string | number | null | undefined;
+/**
+ * Amount -> integer minor units at `scale`, or null if unparseable.
+ *
+ * `scale` is validated before it reaches `toFixed`/`repeat`: an out-of-range
+ * scale (a caller passing `minorDigits: -1`) would throw a RangeError mid-render
+ * rather than degrade. It is the single choke point every money path in this
+ * layer routes through (`sumMinor`, `moneyDiff`, `delinquencyRate`,
+ * `sumBucketTotals`), so guarding it here guards all of them.
+ */
+export declare function toMinor(value: Amount, scale: number): bigint | null;
+/** Sum amounts to minor units; null if ANY operand is unparseable (indeterminate). */
+export declare function sumMinor(values: Amount[], scale: number): bigint | null;
+/** Currency's minor-unit digit count via CLDR (BRL/USD->2, JPY->0, BHD->3), or fallback. */
+export declare function minorDigitsOf(currency: string, fallback?: number): number;
+/** Minor units -> canonical decimal string (lossless), for handing to MoneyText. */
+export declare function minorToDecimal(minor: bigint, scale: number): string;
+//# sourceMappingURL=money-math.d.ts.map

package/dist/domain/money-math.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"money-math.d.ts","sourceRoot":"","sources":["../../src/domain/money-math.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAIH,MAAM,MAAM,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,CAAA;AAcvD;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAyBnE;AAED,sFAAsF;AACtF,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAQvE;AAED,4FAA4F;AAC5F,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,SAAI,GAAG,MAAM,CAWpE;AAED,oFAAoF;AACpF,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAMnE"}

package/dist/domain/money-math.js

@@ -0,0 +1,104 @@
+"use strict";
+/**
+ * money-math — exact integer-minor-unit arithmetic for the double-entry third rail.
+ *
+ * INTERNAL to the domain layer: nothing here is re-exported from
+ * `src/domain/index.ts`, so `toMinor`/`Amount`/`sumMinor` are NOT part of
+ * `@lerianstudio/sindarian-ui`'s public API. The consumers that need exact money
+ * arithmetic reach it through the components that own it (`moneyDiff`,
+ * `MoneyText`, `DelinquencyAging`).
+ *
+ * Amounts parse to integer minor units (BigInt) at a fixed scale; sums never
+ * round-trip through IEEE-754. Pass amounts as canonical decimal STRINGS for
+ * lossless math — numbers are converted via toFixed, which is float-bounded
+ * (fine for display-scale magnitudes, exact for strings).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toMinor = toMinor;
+exports.sumMinor = sumMinor;
+exports.minorDigitsOf = minorDigitsOf;
+exports.minorToDecimal = minorToDecimal;
+const format_1 = require("./format");
+// Round half-away-from-zero on the first dropped fraction digit.
+function roundsUp(fraction, scale) {
+    return fraction.length > scale && fraction.charCodeAt(scale) - 48 >= 5;
+}
+/** Normalize to a canonical signed decimal: trim, unicode-minus, accounting parens. */
+function canonical(raw) {
+    let s = raw.trim().replace(/−/g, '-');
+    if (/^\(.*\)$/.test(s))
+        s = '-' + s.slice(1, -1).trim(); // (1.23) -> -1.23
+    return s;
+}
+/**
+ * Amount -> integer minor units at `scale`, or null if unparseable.
+ *
+ * `scale` is validated before it reaches `toFixed`/`repeat`: an out-of-range
+ * scale (a caller passing `minorDigits: -1`) would throw a RangeError mid-render
+ * rather than degrade. It is the single choke point every money path in this
+ * layer routes through (`sumMinor`, `moneyDiff`, `delinquencyRate`,
+ * `sumBucketTotals`), so guarding it here guards all of them.
+ */
+function toMinor(value, scale) {
+    if (!(0, format_1.isValidDigitCount)(scale))
+        return null;
+    if (value === null || value === undefined || value === '')
+        return null;
+    let s = typeof value === 'number'
+        ? Number.isFinite(value)
+            ? value.toFixed(scale)
+            : ''
+        : canonical(value);
+    if (s === '' || s === '-' || s === '.' || !/^-?\d*(\.\d*)?$/.test(s))
+        return null;
+    const neg = s.startsWith('-');
+    if (neg)
+        s = s.slice(1);
+    const [intPart = '', fracPart = ''] = s.split('.');
+    // DELIBERATE DIVERGENCE from sindarian-x@0.15.0: the legacy regex admits a
+    // digitless token ('-.', and '.' once the sign is stripped) and coerced it to
+    // an exact 0n. A fabricated exact zero is the worst possible answer in
+    // reconciliation — it reads as a perfect tie and hides the bad input — so a
+    // digitless amount is now indeterminate (null), like every other garbage
+    // token. This mirrors the guard the legacy `rateFraction` already had.
+    if (intPart === '' && fracPart === '')
+        return null;
+    const frac = (fracPart + '0'.repeat(scale)).slice(0, scale);
+    let minor = BigInt((intPart || '0') + frac);
+    if (roundsUp(fracPart, scale))
+        minor += 1n;
+    return neg ? -minor : minor;
+}
+/** Sum amounts to minor units; null if ANY operand is unparseable (indeterminate). */
+function sumMinor(values, scale) {
+    let total = 0n;
+    for (const v of values) {
+        const m = toMinor(v, scale);
+        if (m === null)
+            return null;
+        total += m;
+    }
+    return total;
+}
+/** Currency's minor-unit digit count via CLDR (BRL/USD->2, JPY->0, BHD->3), or fallback. */
+function minorDigitsOf(currency, fallback = 2) {
+    try {
+        const opts = new Intl.NumberFormat('en', {
+            style: 'currency',
+            currency,
+            currencyDisplay: 'code'
+        }).resolvedOptions();
+        return opts.maximumFractionDigits ?? fallback;
+    }
+    catch {
+        return fallback;
+    }
+}
+/** Minor units -> canonical decimal string (lossless), for handing to MoneyText. */
+function minorToDecimal(minor, scale) {
+    const neg = minor < 0n;
+    const abs = (neg ? -minor : minor).toString().padStart(scale + 1, '0');
+    const intPart = abs.slice(0, abs.length - scale) || '0';
+    const fracPart = scale > 0 ? '.' + abs.slice(abs.length - scale) : '';
+    return (neg ? '-' : '') + intPart + fracPart;
+}

package/dist/domain/money-text/index.d.ts

@@ -0,0 +1,37 @@
+export type MoneyTextProps = {
+    amount: string | number | null | undefined;
+    /** ISO 4217 currency code, e.g. "BRL", "USD". */
+    currency?: string | null;
+    /** Number of fraction digits. Defaults to 2. */
+    fractionDigits?: number;
+    /** Hide the trailing currency code. */
+    hideCurrency?: boolean;
+    /** Color negative values red. Defaults to true. */
+    signColor?: boolean;
+    /** BCP 47 locale for grouping/decimal marks. Defaults to the runtime locale. */
+    locale?: string;
+    className?: string;
+};
+/**
+ * Normalize a raw amount into a string the Intl formatter accepts while
+ * preserving precision: trim, convert the unicode minus U+2212 to ASCII '-',
+ * and rewrite accounting parens `(123.45)` → `-123.45`. Returns null when the
+ * input is empty after trimming (→ NO_VALUE upstream).
+ *
+ * Internal: exported for its unit tests, never from `src/domain/index.ts`.
+ */
+export declare function normalizeAmount(amount: string | number): string | null;
+/**
+ * Pure money formatting: normalize the amount, format it via Intl (preserving
+ * precision through the ES2020 string overload), and derive sign + finiteness
+ * from the formatted parts — so color and glyph can never disagree. Returns
+ * null for empty, non-finite, or unparseable input (→ NO_VALUE upstream).
+ *
+ * Internal: exported for its unit tests, never from `src/domain/index.ts`.
+ */
+export declare function formatMoneyParts(amount: string | number, fractionDigits: number, locale?: string): {
+    formatted: string;
+    negative: boolean;
+} | null;
+export declare function MoneyText({ amount, currency, fractionDigits, hideCurrency, signColor, locale, className }: MoneyTextProps): import("react").JSX.Element;
+//# sourceMappingURL=index.d.ts.map

package/dist/domain/money-text/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/domain/money-text/index.tsx"],"names":[],"mappings":"AAwBA,MAAM,MAAM,cAAc,GAAG;IAC3B,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,CAAA;IAC1C,iDAAiD;IACjD,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,gDAAgD;IAChD,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,uCAAuC;IACvC,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,mDAAmD;IACnD,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,gFAAgF;IAChF,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,CAAA;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,CAOtE;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,MAAM,GAAG,MAAM,EACvB,cAAc,EAAE,MAAM,EACtB,MAAM,CAAC,EAAE,MAAM,GACd;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,CAiDjD;AAED,wBAAgB,SAAS,CAAC,EACxB,MAAM,EACN,QAAQ,EACR,cAAkB,EAClB,YAAoB,EACpB,SAAgB,EAChB,MAAM,EACN,SAAS,EACV,EAAE,cAAc,+BA8BhB"}

package/dist/domain/money-text/index.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeAmount = normalizeAmount;
+exports.formatMoneyParts = formatMoneyParts;
+exports.MoneyText = MoneyText;
+const jsx_runtime_1 = require("react/jsx-runtime");
+/**
+ * MoneyText renders a monetary amount with optional ISO currency code,
+ * tabular figures so columns line up. The amount is formatted losslessly: when
+ * passed as a string, `Intl.NumberFormat.format()` (ES2020+) parses it as an
+ * arbitrary-precision value and rounds to `fractionDigits` without ever
+ * round-tripping through an IEEE-754 double — so 16+ significant-digit tokens
+ * keep every digit. Pass the raw decimal string (not a pre-coerced Number) to
+ * preserve that guarantee.
+ *
+ * The currency code is shown as a suffix rather than a symbol so mixed-currency
+ * ledgers stay unambiguous. Negative amounts get the destructive color;
+ * null/undefined/empty render the muted no-value placeholder.
+ *
+ * SIGN COLOR IS NOT THE CREDIT ROLE. `--destructive` marks a negative/alarm
+ * amount; `--credit` is the accounting reading of a credit amount. They are two
+ * roles, and a consumer layers the credit role on top (matcher's fork passes
+ * `signColor={false}` with `tone="credit"` precisely so the two never fight).
+ * Collapsing the sign color into `text-credit` would erase that distinction —
+ * this class stays `text-destructive`, as in sindarian-x@0.15.0.
+ */
+const utils_1 = require("../../lib/utils");
+const format_1 = require("../format");
+/**
+ * Normalize a raw amount into a string the Intl formatter accepts while
+ * preserving precision: trim, convert the unicode minus U+2212 to ASCII '-',
+ * and rewrite accounting parens `(123.45)` → `-123.45`. Returns null when the
+ * input is empty after trimming (→ NO_VALUE upstream).
+ *
+ * Internal: exported for its unit tests, never from `src/domain/index.ts`.
+ */
+function normalizeAmount(amount) {
+    let s = String(amount).trim();
+    if (s === '')
+        return null;
+    s = s.replace(/−/g, '-');
+    const parens = s.match(/^\((.*)\)$/);
+    if (parens)
+        s = `-${parens[1].trim()}`;
+    return s;
+}
+/**
+ * Pure money formatting: normalize the amount, format it via Intl (preserving
+ * precision through the ES2020 string overload), and derive sign + finiteness
+ * from the formatted parts — so color and glyph can never disagree. Returns
+ * null for empty, non-finite, or unparseable input (→ NO_VALUE upstream).
+ *
+ * Internal: exported for its unit tests, never from `src/domain/index.ts`.
+ */
+function formatMoneyParts(amount, fractionDigits, locale) {
+    // Reject non-finite numeric inputs (NaN / ±Infinity) before they reach Intl,
+    // which would otherwise render literal "NaN" / "∞".
+    if (typeof amount === 'number' && !Number.isFinite(amount))
+        return null;
+    // A caller-supplied digit count reaches Intl directly; an out-of-range one
+    // would throw a RangeError and blank the amount instead of degrading to
+    // NO_VALUE.
+    if (!(0, format_1.isValidDigitCount)(fractionDigits))
+        return null;
+    const normalized = normalizeAmount(amount);
+    if (normalized === null)
+        return null;
+    // DELIBERATE DIVERGENCE from sindarian-x@0.15.0: an exact zero written with a
+    // sign ('-0', '-0.00', '(0)') formatted as "-0.00" and reported negative:true,
+    // which painted a zero balance in the destructive sign color. Zero is neither
+    // positive nor negative — a signed-zero ledger cell is a rendering artifact of
+    // the input notation, never a fact about the money. The sign is dropped for an
+    // EXACT zero only; '-0.004' still rounds to "-0.00" and stays negative,
+    // because that one really is below zero.
+    const exactZero = /\d/.test(normalized) && /^-?0*(\.0*)?$/.test(normalized);
+    const forFormat = exactZero ? normalized.replace(/^-/, '') : normalized;
+    // A malformed tag would throw a RangeError out of this constructor and take
+    // the whole amount down; degrade to the runtime locale instead.
+    const formatter = new Intl.NumberFormat((0, format_1.safeLocale)(locale), {
+        minimumFractionDigits: fractionDigits,
+        maximumFractionDigits: fractionDigits,
+        signDisplay: 'auto'
+    });
+    // The bundled lib types only model a `number | bigint` overload; the ES2020
+    // string overload (which preserves precision) is unmodelled, so the
+    // normalized amount is cast at the boundary.
+    //
+    // RUNTIME FLOOR: this relies on a V8 with exact decimal-STRING Intl support
+    // (Node >= 20, evergreen browsers) — the whole point is that a 20-digit amount
+    // never round-trips through an IEEE-754 double. There is deliberately NO
+    // Number-coercion fallback for older runtimes: that fallback would silently
+    // reintroduce the precision loss this function exists to prevent.
+    const parts = formatter.formatToParts(forFormat);
+    // Intl emits a literal "nan"/"∞" part for non-finite values; treat those as
+    // no-value rather than rendering them.
+    if (parts.some((p) => p.type === 'nan' || p.type === 'infinity'))
+        return null;
+    return {
+        formatted: parts.map((p) => p.value).join(''),
+        negative: parts.some((p) => p.type === 'minusSign')
+    };
+}
+function MoneyText({ amount, currency, fractionDigits = 2, hideCurrency = false, signColor = true, locale, className }) {
+    const noValue = ((0, jsx_runtime_1.jsx)("span", { className: (0, utils_1.cn)('text-muted-foreground tabular-nums', className), children: format_1.NO_VALUE }));
+    if (amount === null || amount === undefined || amount === '')
+        return noValue;
+    // Sign and finiteness are derived from the formatted parts, not a raw string
+    // prefix — so color and glyph can never disagree, and "-0" / "(0)" are
+    // treated as the non-negative zero Intl renders.
+    const result = formatMoneyParts(amount, fractionDigits, locale);
+    if (result === null)
+        return noValue;
+    const { formatted, negative } = result;
+    return ((0, jsx_runtime_1.jsxs)("span", { className: (0, utils_1.cn)('tabular-nums', signColor && negative && 'text-destructive', className), children: [formatted, !hideCurrency && currency ? ((0, jsx_runtime_1.jsx)("span", { className: "text-muted-foreground ml-1 text-xs", children: currency })) : null] }));
+}