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

package/dist/domain/threshold-gauge/index.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gaugeBand = gaugeBand;
+exports.ThresholdGauge = ThresholdGauge;
+const jsx_runtime_1 = require("react/jsx-runtime");
+/**
+ * ThresholdGauge — where a value sits across ordered, NAMED bands.
+ *
+ * A metric is rarely interesting in isolation; what matters is which band it has
+ * crossed. A credit utilization of 95% is a breach; a liquidity coverage ratio
+ * of 95% may be perfectly calm. So a gauge that paints a smooth red→green
+ * gradient is lying by implication — it suggests a continuum where the business
+ * has hard thresholds. This atom STATES the thresholds: it resolves the current
+ * band (low / warn / breach), names it with a glyph + an sr-only word + a tint,
+ * and marks the band edges on the bar so the reader sees the line the value
+ * crossed, not a vibe.
+ *
+ *   <ThresholdGauge value={0.92} max={1} warn={0.8} breach={0.9} format="percent"
+ *     direction="higher-is-worse" label="Utilização do limite" />   // breach
+ *   <ThresholdGauge value={1.18} max={2} warn={1} breach={0.9} format="ratio"
+ *     direction="lower-is-worse" label="Índice de cobertura" />      // low (calm)
+ *
+ * DIRECTION is mandatory because the same numbers mean opposite things:
+ *  - higher-is-worse: the value climbs INTO danger (warn < breach). Utilization,
+ *    concentration, error rate.
+ *  - lower-is-worse: the value FALLS into danger (breach < warn). Coverage,
+ *    liquidity, capital adequacy.
+ *
+ * INVARIANT (strict edges by DEFAULT): a band escalation requires the value to
+ * be STRICTLY beyond the edge. A value sitting exactly ON a threshold belongs to
+ * the calmer band, not the louder one — `gaugeBand` encodes this so an on-edge
+ * utilization of exactly the breach line still reads as warn, never a surprise
+ * breach. A consumer whose own enforcement is INCLUSIVE (a quota blocking at
+ * `used >= limit`) opts out with `edges="inclusive"`, which escalates ON the
+ * edge in both directions.
+ *
+ * The current band is the load-bearing signal and it never rides on color alone
+ * (WCAG 1.4.1): a glyph leads, an sr-only word names it, the tint only
+ * reinforces. The numeric position reads via a mono `Figure`, never inferred
+ * from the bar geometry — and a consumer forced to clamp `value` to keep
+ * `aria-valuenow` in range can still print the true figure via `displayValue`.
+ *
+ * Pure display: server-safe, no directive.
+ */
+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_text_1 = require("../money-text");
+/** 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. The words are pt-BR defaults — a consumer in
+ *  another locale overrides them via the `bandLabels` prop. */
+const BAND = {
+    low: {
+        Icon: lucide_react_1.ShieldCheck,
+        tint: 'text-system-success',
+        word: 'Dentro do limite'
+    },
+    warn: {
+        Icon: lucide_react_1.TriangleAlert,
+        tint: 'text-system-alert',
+        word: 'Próximo do limite'
+    },
+    breach: {
+        Icon: lucide_react_1.OctagonX,
+        tint: 'text-destructive',
+        word: 'Limite ultrapassado'
+    }
+};
+/** Track fill tint per band — kept distinct from the glyph tint so the bar can
+ *  use the softer wash while the glyph carries the full tint. */
+const BAND_FILL = {
+    low: 'bg-system-success',
+    warn: 'bg-system-alert',
+    breach: 'bg-destructive'
+};
+/**
+ * Resolve which band a value occupies. Pure — the testable heart of the atom.
+ *
+ * STRICT edges by default: a value exactly ON a threshold stays in the CALMER
+ * band; escalation needs the value strictly past.
+ *
+ *  - higher-is-worse: `value > breach` → breach; `value > warn` → warn; else low.
+ *  - lower-is-worse:  `value < breach` → breach; `value < warn` → warn; else low.
+ *
+ * `thresholds.edges = 'inclusive'` opts into `>=` / `<=` instead, for a consumer
+ * whose enforcement is inclusive. Omitted or 'strict' → the behaviour above.
+ *
+ * Non-finite input degrades to 'low' rather than throwing — a missing reading is
+ * not, by itself, an alarm.
+ */
+function gaugeBand(value, thresholds, direction) {
+    if (!Number.isFinite(value))
+        return 'low';
+    const { warn, breach, edges = 'strict' } = thresholds;
+    const beyond = direction === 'higher-is-worse'
+        ? (edge) => (edges === 'inclusive' ? value >= edge : value > edge)
+        : (edge) => (edges === 'inclusive' ? value <= edge : value < edge);
+    if (beyond(breach))
+        return 'breach';
+    if (beyond(warn))
+        return 'warn';
+    return 'low';
+}
+/**
+ * An empty or whitespace-only string is not a name. `??` only skips null and
+ * undefined, so `ariaLabel=""` or `bandLabels={{ breach: '' }}` won the fallback
+ * chain and produced an EMPTY accessible name — worse than the missing one it
+ * was meant to fix, because `aria-label=""` also suppresses the element's other
+ * naming routes. Normalizing to undefined lets the chain fall through properly.
+ */
+function nonEmpty(value) {
+    return value != null && value.trim() !== '' ? value : undefined;
+}
+/** Clamp a value into [min, max] then normalize to a 0..1 fraction of the
+ *  track. A zero-width track (max <= min) collapses to 0 rather than dividing by
+ *  zero. */
+function trackFraction(value, min, max) {
+    if (!Number.isFinite(value) || max <= min)
+        return 0;
+    const clamped = Math.max(min, Math.min(max, value));
+    return (clamped - min) / (max - min);
+}
+/** Format the value for the mono readout per `format`. Money routes through
+ *  MoneyText (never a hand-rolled string); the rest through the format helpers. */
+function readout(value, format, currency, locale) {
+    if (!Number.isFinite(value))
+        return format_1.NO_VALUE;
+    if (format === 'money') {
+        return ((0, jsx_runtime_1.jsx)(money_text_1.MoneyText, { amount: value, currency: currency, signColor: false, locale: locale }));
+    }
+    if (format === 'percent')
+        return (0, format_1.formatPercent)(value, { unit: 'percent', locale });
+    if (format === 'ratio')
+        return (0, format_1.formatPercent)(value, { unit: 'ratio', locale });
+    return (0, format_1.formatCount)(value, locale);
+}
+function ThresholdGauge({ value, displayValue, min = 0, max, warn, breach, edges, direction, format = 'percent', currency, locale, label, ariaLabel, bandLabels, className }) {
+    const band = gaugeBand(value, { warn, breach, edges }, direction);
+    const { Icon, tint } = BAND[band];
+    // The sr-only word is the band's only non-chromatic cue, so it is also the
+    // string a trilingual consumer has to translate. pt-BR default, override wins.
+    // Every rung of the naming chain is normalized: an empty override must fall
+    // through to the next source rather than win with a blank string.
+    const word = nonEmpty(bandLabels?.[band]) ?? BAND[band].word;
+    const caption = nonEmpty(label);
+    // A `role="meter"` with no accessible name is announced as a naked number.
+    // The band word is always present and always meaningful, so the meter is named
+    // even when a consumer renders the gauge without a visible caption.
+    const meterName = nonEmpty(ariaLabel) ?? caption ?? word;
+    const valuePct = trackFraction(value, min, max) * 100;
+    const warnPct = trackFraction(warn, min, max) * 100;
+    const breachPct = trackFraction(breach, min, max) * 100;
+    return ((0, jsx_runtime_1.jsxs)("div", { className: (0, utils_1.cn)('flex flex-col gap-2', className), children: [(0, jsx_runtime_1.jsxs)("div", { className: "flex items-baseline justify-between gap-3", children: [caption != null ? ((0, jsx_runtime_1.jsx)("span", { className: typography_1.LABEL_VOICE_CLASS, children: caption })) : ((0, jsx_runtime_1.jsx)("span", {})), (0, jsx_runtime_1.jsxs)("span", { 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: readout(displayValue ?? value, format, currency, locale) })] })] }), (0, jsx_runtime_1.jsxs)("div", { role: "meter", "aria-valuenow": Number.isFinite(value) ? value : undefined, "aria-valuemin": min, "aria-valuemax": max, "aria-label": meterName, className: "border-border bg-muted relative h-2 w-full overflow-hidden rounded-full border", children: [(0, jsx_runtime_1.jsx)("div", { "aria-hidden": true, className: (0, utils_1.cn)('absolute inset-y-0 left-0 rounded-full', BAND_FILL[band]), style: { width: `${valuePct}%` } }), (0, jsx_runtime_1.jsx)("span", { "aria-hidden": true, className: "bg-system-alert absolute inset-y-0 w-px", style: { left: `${warnPct}%` } }), (0, jsx_runtime_1.jsx)("span", { "aria-hidden": true, className: "bg-destructive absolute inset-y-0 w-px", style: { left: `${breachPct}%` } })] })] }));
+}

package/dist/enterprise/alert-banner/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * AlertBanner — the console's semantic message box. A rounded, hairline-bordered
+ * panel with a tinted background whose tone escalates by severity. The title
+ * carries the tone color (font-medium); the body stays foreground for
+ * readability; an optional `detail` slot renders mono diagnostic text (an error
+ * code, a failed id) below the body.
+ *
+ *   <AlertBanner tone="destructive" title="Import failed">
+ *     The file could not be parsed. No rows were ingested.
+ *   </AlertBanner>
+ *
+ * Renders `role="alert"`. Tones map to sindarian-ui's `system-*` semantic token
+ * families, so they track the active light/dark palette automatically.
+ */
+import type { ReactNode } from 'react';
+export type AlertBannerTone = 'destructive' | 'warning' | 'info' | 'success' | 'neutral';
+export type AlertBannerProps = {
+    tone?: AlertBannerTone;
+    /** Bold lead line, carries the tone color. */
+    title?: ReactNode;
+    /** Body copy (foreground, for readability). */
+    children?: ReactNode;
+    /** Optional mono diagnostic detail rendered below the body. */
+    detail?: ReactNode;
+    /** Optional leading icon (e.g. a lucide glyph), aligned to the title. */
+    icon?: ReactNode;
+    className?: string;
+};
+export declare function AlertBanner({ tone, title, children, detail, icon, className }: AlertBannerProps): import("react").JSX.Element;
+//# sourceMappingURL=index.d.ts.map

package/dist/enterprise/alert-banner/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/enterprise/alert-banner/index.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAItC,MAAM,MAAM,eAAe,GACzB,aAAa,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,GAAG,SAAS,CAAA;AAoB5D,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,CAAC,EAAE,eAAe,CAAA;IACtB,8CAA8C;IAC9C,KAAK,CAAC,EAAE,SAAS,CAAA;IACjB,+CAA+C;IAC/C,QAAQ,CAAC,EAAE,SAAS,CAAA;IACpB,+DAA+D;IAC/D,MAAM,CAAC,EAAE,SAAS,CAAA;IAClB,yEAAyE;IACzE,IAAI,CAAC,EAAE,SAAS,CAAA;IAChB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,wBAAgB,WAAW,CAAC,EAC1B,IAAgB,EAChB,KAAK,EACL,QAAQ,EACR,MAAM,EACN,IAAI,EACJ,SAAS,EACV,EAAE,gBAAgB,+BAmClB"}

package/dist/enterprise/alert-banner/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlertBanner = AlertBanner;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const utils_1 = require("../../lib/utils");
+/** Container tint + border per tone. The title color is applied separately so
+ *  the body copy stays high-contrast foreground. */
+const TONE_CONTAINER = {
+    destructive: 'border-system-error-border bg-system-error-surface',
+    warning: 'border-system-alert-border bg-system-alert-surface',
+    info: 'border-system-info-border bg-system-info-surface',
+    success: 'border-system-success-border bg-system-success-surface',
+    neutral: 'border-border bg-muted/50'
+};
+const TONE_TITLE = {
+    destructive: 'text-system-error-text',
+    warning: 'text-system-alert-text',
+    info: 'text-system-info-text',
+    success: 'text-system-success-text',
+    neutral: 'text-foreground'
+};
+function AlertBanner({ tone = 'neutral', title, children, detail, icon, className }) {
+    return ((0, jsx_runtime_1.jsxs)("div", { role: "alert", "data-tone": tone, className: (0, utils_1.cn)('flex gap-3 rounded-md border px-4 py-3', TONE_CONTAINER[tone], className), children: [icon != null ? ((0, jsx_runtime_1.jsx)("span", { className: (0, utils_1.cn)('mt-0.5 shrink-0', TONE_TITLE[tone]), "aria-hidden": true, children: icon })) : null, (0, jsx_runtime_1.jsxs)("div", { className: "min-w-0 flex-1 space-y-1", children: [title != null ? ((0, jsx_runtime_1.jsx)("p", { className: (0, utils_1.cn)('text-sm font-medium', TONE_TITLE[tone]), children: title })) : null, children != null ? ((0, jsx_runtime_1.jsx)("div", { className: "text-foreground text-xs leading-relaxed", children: children })) : null, detail != null ? ((0, jsx_runtime_1.jsx)("pre", { className: "text-muted-foreground overflow-x-auto font-mono text-xs break-words whitespace-pre-wrap", children: detail })) : null] })] }));
+}

package/dist/enterprise/app-shell/index.d.ts

@@ -0,0 +1,61 @@
+/**
+ * AppShell — the console frame: a sidebar rail, an optional sticky header row,
+ * and a centered, scrollable content column. This is the whole screen, not a
+ * fragment, so it deliberately OWNS the SidebarProvider — the consumer drops a
+ * sindarian-ui sidebar (`SidebarRoot` + its parts) into `sidebar` and a
+ * `SidebarExpandButton` into `header`, and the collapse behavior comes free,
+ * no extra wrapper required.
+ *
+ * Landmark contract (the a11y-correct frame):
+ *   SidebarProvider
+ *     div (the shell ROW — carries `className`)
+ *       a.sr-only (skip link, if labelled)    // FIRST focusable in the document,
+ *                                             //   targets <main> — bypasses the nav
+ *       {sidebar}
+ *       div[data-slot=sidebar-inset]          // the inset COLUMN — a plain div
+ *         header (banner, if given)           // SIBLING of <main>, not nested
+ *         main#<id> tabIndex=-1               // the ONE main: skip-linkable + ref-able
+ *           div (centered content container) → {children}
+ *
+ * The skip link is the FIRST child inside the shell row — before the sidebar —
+ * so a keyboard user's very first Tab lands on it and Enter jumps past the
+ * entire nav to the content <main>. That is the whole point of WCAG 2.4.1
+ * "Bypass Blocks": a skip link placed AFTER the nav would be reached only after
+ * tabbing through every nav item, defeating its purpose. The inset column is a
+ * <div>, not a <main>, so AppShell can own the single inner <main> for the
+ * content. The page header passed via `header` becomes a top-level banner
+ * SIBLING of <main> (one banner); a PageHeader rendered inside `children` lands
+ * inside <main> and is content, not a top-level landmark.
+ *
+ * Client by construction: it calls React.useId() to wire the skip link to the
+ * content <main>, and forwards a ref to that <main> so a consumer can focus it
+ * on route change — both are client concerns, hence the "use client" directive.
+ */
+import * as React from 'react';
+export type AppShellProps = {
+    sidebar?: React.ReactNode;
+    /**
+     * App-bar CONTENT, rendered INSIDE the shell's <header> banner landmark. Pass
+     * banner content only — the sidebar trigger, a screen title, header actions.
+     *
+     * Do NOT pass an element that renders its OWN <header>/landmark (e.g.
+     * <PageHeader>, which is itself a <header>). Nesting a <header> in this banner
+     * produces a SECOND banner — a <header> is not sectioning content, so the
+     * inner one stays body-scoped — which violates WCAG's at-most-one-banner rule.
+     * Page-level title blocks (<PageHeader>) belong in `children`, where they land
+     * inside <main> and are correctly page content, not a top-level landmark.
+     */
+    header?: React.ReactNode;
+    children: React.ReactNode;
+    className?: string;
+    contentClassName?: string;
+    /**
+     * When set, renders a "skip to content" link as the FIRST focusable element;
+     * activating it jumps focus to the content <main>. Omit it and no skip link
+     * renders. The link/target wiring (the <main> id) is internal — generated with
+     * React.useId() so it is stable and unique without a required id prop.
+     */
+    skipToContentLabel?: string;
+};
+export declare const AppShell: React.ForwardRefExoticComponent<AppShellProps & React.RefAttributes<HTMLElement>>;
+//# sourceMappingURL=index.d.ts.map

package/dist/enterprise/app-shell/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/enterprise/app-shell/index.tsx"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAK9B,MAAM,MAAM,aAAa,GAAG;IAC1B,OAAO,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;IACzB;;;;;;;;;;OAUG;IACH,MAAM,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;IACxB,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;IACzB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB;;;;;OAKG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAC5B,CAAA;AAED,eAAO,MAAM,QAAQ,mFAgEpB,CAAA"}

package/dist/enterprise/app-shell/index.js

@@ -0,0 +1,87 @@
+'use client';
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppShell = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+/**
+ * AppShell — the console frame: a sidebar rail, an optional sticky header row,
+ * and a centered, scrollable content column. This is the whole screen, not a
+ * fragment, so it deliberately OWNS the SidebarProvider — the consumer drops a
+ * sindarian-ui sidebar (`SidebarRoot` + its parts) into `sidebar` and a
+ * `SidebarExpandButton` into `header`, and the collapse behavior comes free,
+ * no extra wrapper required.
+ *
+ * Landmark contract (the a11y-correct frame):
+ *   SidebarProvider
+ *     div (the shell ROW — carries `className`)
+ *       a.sr-only (skip link, if labelled)    // FIRST focusable in the document,
+ *                                             //   targets <main> — bypasses the nav
+ *       {sidebar}
+ *       div[data-slot=sidebar-inset]          // the inset COLUMN — a plain div
+ *         header (banner, if given)           // SIBLING of <main>, not nested
+ *         main#<id> tabIndex=-1               // the ONE main: skip-linkable + ref-able
+ *           div (centered content container) → {children}
+ *
+ * The skip link is the FIRST child inside the shell row — before the sidebar —
+ * so a keyboard user's very first Tab lands on it and Enter jumps past the
+ * entire nav to the content <main>. That is the whole point of WCAG 2.4.1
+ * "Bypass Blocks": a skip link placed AFTER the nav would be reached only after
+ * tabbing through every nav item, defeating its purpose. The inset column is a
+ * <div>, not a <main>, so AppShell can own the single inner <main> for the
+ * content. The page header passed via `header` becomes a top-level banner
+ * SIBLING of <main> (one banner); a PageHeader rendered inside `children` lands
+ * inside <main> and is content, not a top-level landmark.
+ *
+ * Client by construction: it calls React.useId() to wire the skip link to the
+ * content <main>, and forwards a ref to that <main> so a consumer can focus it
+ * on route change — both are client concerns, hence the "use client" directive.
+ */
+const React = __importStar(require("react"));
+const sidebar_1 = require("../../components/ui/sidebar");
+const utils_1 = require("../../lib/utils");
+exports.AppShell = React.forwardRef(function AppShell({ sidebar, header, children, className, contentClassName, skipToContentLabel }, ref) {
+    // The content <main> id — wires the skip link to its target and gives the
+    // <main> a stable, focusable anchor. Internal: no consumer-facing id prop.
+    const mainId = React.useId();
+    // sindarian-ui's SidebarProvider is context-only (it renders no DOM and
+    // takes no className), so the shell owns the flex row itself and `className`
+    // lands on it — the same element the legacy provider's className reached.
+    return ((0, jsx_runtime_1.jsx)(sidebar_1.SidebarProvider, { children: (0, jsx_runtime_1.jsxs)("div", { className: (0, utils_1.cn)('flex h-svh w-full overflow-hidden', className), children: [skipToContentLabel ? ((0, jsx_runtime_1.jsx)("a", { href: `#${mainId}`, className: "focus:bg-background focus:text-foreground sr-only focus:not-sr-only focus:absolute focus:z-50 focus:m-2 focus:rounded focus:px-3 focus:py-2 focus:shadow", children: skipToContentLabel })) : null, sidebar, (0, jsx_runtime_1.jsxs)("div", { "data-slot": "sidebar-inset", className: "bg-background relative flex w-full min-w-0 flex-1 flex-col", children: [header ? ((0, jsx_runtime_1.jsx)("header", { className: "border-border bg-background sticky top-0 z-10 flex items-center gap-3 border-b px-6 py-3", children: header })) : null, (0, jsx_runtime_1.jsx)("main", { id: mainId, ref: ref, tabIndex: -1, 
+                            // min-h-0 lets this flex child shrink below its content height —
+                            // without it `flex-1` keeps min-height:auto and nothing scrolls.
+                            className: "min-h-0 flex-1 overflow-y-auto outline-none", children: (0, jsx_runtime_1.jsx)("div", { className: (0, utils_1.cn)('mx-auto w-full max-w-7xl px-6 py-8 lg:px-8', contentClassName), children: children }) })] })] }) }));
+});
+exports.AppShell.displayName = 'AppShell';

package/dist/enterprise/cursor-pager/index.d.ts

@@ -0,0 +1,21 @@
+export type CursorPagerProps = {
+    /** From the page envelope: more pages exist after this one. */
+    hasMore?: boolean;
+    /** From the page envelope: cursor for the next page. */
+    nextCursor?: string | null;
+    /** From the page envelope: cursor for the previous page. */
+    prevCursor?: string | null;
+    /** Called with the cursor to load (undefined => first page). */
+    onCursorChange: (cursor: string | undefined) => void;
+    /** Disable both controls (e.g. while fetching). */
+    disabled?: boolean;
+    /** Optional summary, e.g. "50 per page" or a loaded-count string. */
+    summary?: string;
+    /** Label for the previous-page control. Defaults to "Previous". */
+    previousLabel?: string;
+    /** Label for the next-page control. Defaults to "Next". */
+    nextLabel?: string;
+    className?: string;
+};
+export declare function CursorPager({ hasMore, nextCursor, prevCursor, onCursorChange, disabled, summary, previousLabel, nextLabel, className }: CursorPagerProps): import("react").JSX.Element;
+//# sourceMappingURL=index.d.ts.map

package/dist/enterprise/cursor-pager/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/enterprise/cursor-pager/index.tsx"],"names":[],"mappings":"AAoBA,MAAM,MAAM,gBAAgB,GAAG;IAC7B,+DAA+D;IAC/D,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,wDAAwD;IACxD,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,4DAA4D;IAC5D,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,gEAAgE;IAChE,cAAc,EAAE,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,KAAK,IAAI,CAAA;IACpD,mDAAmD;IACnD,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,qEAAqE;IACrE,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,mEAAmE;IACnE,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,2DAA2D;IAC3D,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,wBAAgB,WAAW,CAAC,EAC1B,OAAO,EACP,UAAU,EACV,UAAU,EACV,cAAc,EACd,QAAgB,EAChB,OAAO,EACP,aAA0B,EAC1B,SAAkB,EAClB,SAAS,EACV,EAAE,gBAAgB,+BAmClB"}

package/dist/enterprise/cursor-pager/index.js

@@ -0,0 +1,26 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CursorPager = CursorPager;
+const jsx_runtime_1 = require("react/jsx-runtime");
+/**
+ * CursorPager drives the cursor-pagination envelope
+ *   { items, hasMore, nextCursor, prevCursor, limit }
+ * shared by the console's cursor-paged list endpoints (do not use it on
+ * offset-based endpoints).
+ *
+ * It is controlled: the parent owns the active cursor (the value it passes to
+ * the list hook) and reacts to `onCursorChange`. Pass the page envelope's
+ * `hasMore`, `nextCursor`, `prevCursor`. "Previous" is enabled when the page
+ * reports a `prevCursor`; "Next" when `hasMore` and a `nextCursor` exist.
+ *
+ * `onCursorChange(undefined)` requests the first page (no cursor).
+ */
+const lucide_react_1 = require("lucide-react");
+const button_1 = require("../../components/ui/button");
+const utils_1 = require("../../lib/utils");
+function CursorPager({ hasMore, nextCursor, prevCursor, onCursorChange, disabled = false, summary, previousLabel = 'Previous', nextLabel = 'Next', className }) {
+    const canPrev = !disabled && !!prevCursor;
+    const canNext = !disabled && !!hasMore && !!nextCursor;
+    return ((0, jsx_runtime_1.jsxs)("div", { className: (0, utils_1.cn)('flex items-center justify-between gap-4 pt-3', className), children: [(0, jsx_runtime_1.jsx)("p", { className: "text-muted-foreground text-xs", children: summary ?? '' }), (0, jsx_runtime_1.jsxs)("div", { className: "flex items-center gap-2", children: [(0, jsx_runtime_1.jsx)(button_1.Button, { type: "button", variant: "outline", size: "small", icon: (0, jsx_runtime_1.jsx)(lucide_react_1.ChevronLeft, { "aria-hidden": true }), iconPlacement: "start", disabled: !canPrev, onClick: () => onCursorChange(prevCursor ?? undefined), children: previousLabel }), (0, jsx_runtime_1.jsx)(button_1.Button, { type: "button", variant: "outline", size: "small", icon: (0, jsx_runtime_1.jsx)(lucide_react_1.ChevronRight, { "aria-hidden": true }), iconPlacement: "end", disabled: !canNext, onClick: () => onCursorChange(nextCursor ?? undefined), children: nextLabel })] })] }));
+}

package/dist/enterprise/data-table/index.d.ts

@@ -0,0 +1,88 @@
+import { type ColumnDef, type OnChangeFn, type RowData, type RowSelectionState } from '@tanstack/react-table';
+import { type EmptyStateProps } from '../empty-state';
+/**
+ * Per-column opt-in for ledger numeric alignment. Set `meta: { numeric: true }`
+ * on a money/number `ColumnDef` and DataTable right-aligns both the header and
+ * its body cells (mono tabular figures).
+ */
+declare module '@tanstack/react-table' {
+    interface ColumnMeta<TData extends RowData, TValue> {
+        numeric?: boolean;
+    }
+}
+/**
+ * Row selection is CONTROLLED-ONLY — the contract sindarian-x shipped: the
+ * component holds no selection state and only mirrors `rowSelection` back into
+ * TanStack. Legacy typed all three props as independently optional, so opting
+ * into `enableRowSelection` without wiring the other two compiled fine and then
+ * rendered checkboxes that could never toggle (state pinned to a constant `{}`,
+ * no updater). Same runtime contract here, honest types: enabling selection
+ * requires the controlled pair, and leaving it off forbids them.
+ */
+type RowSelectionProps<TData> = {
+    enableRowSelection?: false;
+    rowSelection?: never;
+    onRowSelectionChange?: never;
+    getRowSelectionLabel?: never;
+} | {
+    enableRowSelection: true;
+    /** Controlled selection state (TanStack `RowSelectionState`, keyed by row id). */
+    rowSelection: RowSelectionState;
+    /** Controlled selection updater (TanStack `OnChangeFn`). */
+    onRowSelectionChange: OnChangeFn<RowSelectionState>;
+    /**
+     * Accessible name for a row's checkbox. Defaults to `Select row <id>`,
+     * which announces the raw row id (`Select row 0` with the default index
+     * ids) — pass a builder to name the record the way a user recognises it,
+     * e.g. ``(row) => `Select settlement ${row.reference}` ``.
+     */
+    getRowSelectionLabel?: (row: TData) => string;
+};
+type DataTableBaseProps<TData> = {
+    columns: ColumnDef<TData, unknown>[];
+    data: TData[];
+    /** Show skeleton rows instead of data/empty state. */
+    loading?: boolean;
+    /** Number of skeleton rows when loading. Defaults to 8. */
+    skeletonRows?: number;
+    /** Announced by the persistent status region while loading. Defaults to "Loading table rows". */
+    loadingLabel?: string;
+    /** Empty-state config when data resolves to zero rows. */
+    empty?: EmptyStateProps;
+    /** Stable row id accessor; defaults to TanStack's index-based id. */
+    getRowId?: (row: TData, index: number) => string;
+    /**
+     * Drop the rounded-card framing (radius, hairline border, bg-card) so the
+     * table runs full-bleed inside an already-framed surface. Margin tweaks like
+     * `-mx-5` stay the caller's job via `className`.
+     */
+    flush?: boolean;
+    /**
+     * Row density. `comfortable` (default) keeps the table's standard padding;
+     * `compact` tightens cell padding for the veteran "more rows per screen"
+     * view. Applied as a per-cell padding override on THIS table only.
+     */
+    density?: 'comfortable' | 'compact';
+    /**
+     * Opt into the roving-focus keyboard layer. Presence of this callback
+     * enables row tabIndex/focus/keydown handling; Enter calls it with the
+     * focused row's data. DataTable stays router-agnostic — consumers
+     * navigate inside the callback. Default off: rows render exactly as
+     * before, with no tabIndex and no handlers.
+     */
+    onRowActivate?: (row: TData) => void;
+    /**
+     * Optional href builder pairing with `onRowActivate`: when present,
+     * Cmd/Ctrl+Enter on a focused row opens the built href in a new tab via
+     * `window.open(href, '_blank', 'noopener,noreferrer')` — the keyboard twin
+     * of cmd-clicking the row's in-cell link. Build hrefs with the router's
+     * own URL builder, never string concatenation. Sheet-based tables (no
+     * routable destination) simply omit it and keep modified Enter a no-op.
+     */
+    rowHref?: (row: TData) => string;
+    className?: string;
+};
+export type DataTableProps<TData> = DataTableBaseProps<TData> & RowSelectionProps<TData>;
+export declare function DataTable<TData>({ columns, data, loading, skeletonRows, loadingLabel, empty, getRowId, flush, density, enableRowSelection, rowSelection, onRowSelectionChange, getRowSelectionLabel, onRowActivate, rowHref, className }: DataTableProps<TData>): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/enterprise/data-table/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/enterprise/data-table/index.tsx"],"names":[],"mappings":"AAmCA,OAAO,EAIL,KAAK,SAAS,EACd,KAAK,UAAU,EAEf,KAAK,OAAO,EACZ,KAAK,iBAAiB,EAEvB,MAAM,uBAAuB,CAAA;AAY9B,OAAO,EAAc,KAAK,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAEjE;;;;GAIG;AACH,OAAO,QAAQ,uBAAuB,CAAC;IAIrC,UAAU,UAAU,CAAC,KAAK,SAAS,OAAO,EAAE,MAAM;QAChD,OAAO,CAAC,EAAE,OAAO,CAAA;KAClB;CACF;AAED;;;;;;;;GAQG;AACH,KAAK,iBAAiB,CAAC,KAAK,IACxB;IACE,kBAAkB,CAAC,EAAE,KAAK,CAAA;IAC1B,YAAY,CAAC,EAAE,KAAK,CAAA;IACpB,oBAAoB,CAAC,EAAE,KAAK,CAAA;IAC5B,oBAAoB,CAAC,EAAE,KAAK,CAAA;CAC7B,GACD;IACE,kBAAkB,EAAE,IAAI,CAAA;IACxB,kFAAkF;IAClF,YAAY,EAAE,iBAAiB,CAAA;IAC/B,4DAA4D;IAC5D,oBAAoB,EAAE,UAAU,CAAC,iBAAiB,CAAC,CAAA;IACnD;;;;;OAKG;IACH,oBAAoB,CAAC,EAAE,CAAC,GAAG,EAAE,KAAK,KAAK,MAAM,CAAA;CAC9C,CAAA;AAEL,KAAK,kBAAkB,CAAC,KAAK,IAAI;IAC/B,OAAO,EAAE,SAAS,CAAC,KAAK,EAAE,OAAO,CAAC,EAAE,CAAA;IACpC,IAAI,EAAE,KAAK,EAAE,CAAA;IACb,sDAAsD;IACtD,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,2DAA2D;IAC3D,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,iGAAiG;IACjG,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,0DAA0D;IAC1D,KAAK,CAAC,EAAE,eAAe,CAAA;IACvB,qEAAqE;IACrE,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,KAAK,MAAM,CAAA;IAChD;;;;OAIG;IACH,KAAK,CAAC,EAAE,OAAO,CAAA;IACf;;;;OAIG;IACH,OAAO,CAAC,EAAE,aAAa,GAAG,SAAS,CAAA;IACnC;;;;;;OAMG;IACH,aAAa,CAAC,EAAE,CAAC,GAAG,EAAE,KAAK,KAAK,IAAI,CAAA;IACpC;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,KAAK,KAAK,MAAM,CAAA;IAChC,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,MAAM,MAAM,cAAc,CAAC,KAAK,IAAI,kBAAkB,CAAC,KAAK,CAAC,GAC3D,iBAAiB,CAAC,KAAK,CAAC,CAAA;AA4E1B,wBAAgB,SAAS,CAAC,KAAK,EAAE,EAC/B,OAAO,EACP,IAAI,EACJ,OAAe,EACf,YAAgB,EAChB,YAAmC,EACnC,KAAK,EACL,QAAQ,EACR,KAAa,EACb,OAAuB,EACvB,kBAA0B,EAC1B,YAAY,EACZ,oBAAoB,EACpB,oBAAoB,EACpB,aAAa,EACb,OAAO,EACP,SAAS,EACV,EAAE,cAAc,CAAC,KAAK,CAAC,+BA+RvB"}