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

package/dist/esm/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/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;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,94 @@
+/**
+ * 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;
+}
+/**
+ * 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(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(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,22 @@
+export { NO_VALUE, formatCount, formatPercent, humanizeDurationMs, toPercentValue } from './format.js';
+export type { FormatPercentOptions, PercentUnit } from './format.js';
+export { moneyDiff } 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 { 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;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/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;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/esm/domain/key-id/index.js

@@ -0,0 +1,162 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "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.
+ */
+import { Check, Copy } from 'lucide-react';
+import { useState } from 'react';
+import { LABEL_VOICE_CLASS } from '../../lib/typography.js';
+import { cn } from '../../lib/utils.js';
+/** 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`. */
+export 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`.
+ */
+export 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);
+    }
+}
+export function KeyId({ value, kind = 'generic', label, mask, copyable = false, className }) {
+    const masked = mask ?? masksByDefault(kind);
+    const display = masked ? maskKeyId(value, kind) : truncateMiddle(value);
+    return (_jsxs("span", { className: cn('inline-flex min-w-0 items-center gap-2', className), children: [label ? (_jsx("span", { className: cn(LABEL_VOICE_CLASS, 'shrink-0'), children: label })) : null, _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 ? _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] = 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 (_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 ? (_jsx(Check, { "aria-hidden": true, className: "text-system-success size-3" })) : (_jsx(Copy, { "aria-hidden": true, className: "size-3" })) }));
+}

package/dist/esm/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/esm/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/esm/domain/ledger-sheet/index.js

@@ -0,0 +1,24 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { cn } from '../../lib/utils.js';
+/** 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'
+};
+export function LedgerSheet({ children, cols = 1, className }) {
+    return (_jsx("div", { className: 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.
+ */
+export function LedgerPanel({ children, className, as: Tag = 'section', ...rest }) {
+    return (_jsx(Tag, { className: cn('bg-card flex h-full flex-col gap-4 p-5', className), ...rest, children: children }));
+}

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

@@ -0,0 +1,23 @@
+import type { Amount } from './money-math.js';
+/** The money-comparison contract: two sides, a currency, an optional tolerance. */
+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 for the money figure. */
+    locale?: string;
+};
+export declare function moneyDiff(money: MoneyDiffInput): {
+    decimal: string | null;
+    breach: boolean;
+};
+export {};
+//# sourceMappingURL=money-diff.d.ts.map

package/dist/esm/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,mFAAmF;AACnF,KAAK,cAAc,GAAG;IACpB,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,0CAA0C;IAC1C,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/esm/domain/money-diff.js

@@ -0,0 +1,45 @@
+/**
+ * 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.
+ */
+import { minorDigitsOf, minorToDecimal, toMinor } from './money-math.js';
+export function moneyDiff(money) {
+    const scale = money.minorDigits ?? minorDigitsOf(money.currency);
+    const l = toMinor(money.left, scale);
+    const r = 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 ? 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: minorToDecimal(diff, scale), breach };
+}

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