@aurea-uds/react 0.2.0 → 0.3.0

package/dist/feedback.js

@@ -1,101 +1,5 @@
-"use client";
-import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-// Fase 9 (achado A5): este arquivo saiu do index.tsx de 970 linhas. Um módulo por categoria
-// do registry — a taxonomia já existia e é gateada. A ordem de import entre eles é um DAG:
-// internal → system → actions → feedback → inputs → navigation → layout → data-display → resto.
-import React from "react";
-import { Popover as BasePopover } from "@base-ui/react/popover";
-import { cx, useAureaStrings, usePortalContainer, stateSeverity } from "./internal.js";
-import { Icon } from "./system.js";
-import { Button, IconButton } from "./actions.js";
-export function Badge({ variant = "neutral", className, ...props }) { return _jsx("span", { className: cx("badge", variant !== "neutral" && `badge-${variant}`, className), ...props }); }
-// Status (DIRECTION §3.6): condição OPERACIONAL — ponto + rótulo. Não é Badge: Badge é
-// metadado curto num pill; Status diz em que estado a coisa está. Reusa o .status-dot que
-// já existia solto. A variante colore só o PONTO (currentColor); o rótulo fica legível em
-// --foreground. Cor não é o único sinal — quem diz o estado é o texto (WCAG 1.4.1); o
-// ponto é decorativo e sai do leitor de tela. ponytail: rótulo é do consumidor (sem i18n
-// nova) — a variante é só a cor.
-// `state` (Parte J) é EIXO À PARTE de `variant`, e os dois convivem: a variante é a cor do
-// ponto, o estado é a condição universal. Quem passa `state` e não passa `variant` recebe a
-// cor derivada — `offline` fica com o ponto vazado que ele já tinha desde sempre, os outros
-// seis caem na gravidade. Quem passa os dois manda, porque só o consumidor sabe se aquele
-// "esperando" dele é grave. E o rótulo é o do consumidor, como sempre foi: a string universal
-// entra só quando não há filho, para o componente não passar a inventar texto.
-export function Status({ variant, state, children, className, ...props }) { const s = useAureaStrings(); const v = variant ?? (state ? (state === "offline" ? "offline" : stateSeverity(state)) : "neutral"); return _jsxs("span", { className: cx("status", v !== "neutral" && `status-${v}`, className), "data-state": state, ...props, children: [_jsx("i", { className: "status-dot", "aria-hidden": "true" }), _jsx("span", { className: "status-label", children: children ?? (state ? s.universalState[state] : null) })] }); }
-export function Alert({ variant, state, title, children, className, ...props }) { const s = useAureaStrings(); const v = variant ?? (state ? stateSeverity(state) : "info"); return _jsxs("div", { className: cx("alert", `alert-${v}`, className), role: v === "danger" ? "alert" : "status", "data-state": state, ...props, children: [title && _jsx("strong", { children: title }), children ?? (state ? s.universalState[state] : null)] }); }
-export function Banner({ variant, state, title, icon, onDismiss, children, className, ...props }) { const s = useAureaStrings(); const v = variant ?? (state ? stateSeverity(state) : "info"); return _jsxs("div", { className: cx("banner", `banner-${v}`, className), role: v === "danger" ? "alert" : "status", "data-state": state, ...props, children: [icon ? _jsx(Icon, { name: icon }) : _jsx("span", {}), _jsxs("div", { children: [title && _jsx("strong", { children: title }), children ?? (state ? s.universalState[state] : null)] }), onDismiss ? _jsx(IconButton, { variant: "ghost", size: "sm", icon: "close", label: s.close, onClick: onDismiss }) : _jsx("span", {})] }); }
-// A barra grampeava 0..100 e o `aria-valuenow` NÃO — medido ao publicar o contrato de API na
-// Parte E: com value=150 o desenho parava em 100% e o leitor de tela anunciava "150 de 100".
-// A causa é a de sempre: o grampo existia num lugar só. Agora é UMA expressão que serve os dois,
-// então não há como divergirem de novo.
-// SÓ DETERMINADA, de propósito: não há modo indeterminado nem `.progress` para ele no core. A
-// ficha dizia que havia e era falso — corrigido junto, porque contrato que promete o que não
-// existe custa mais que ausência.
-export function Progress({ value, label }) { const pct = Math.max(0, Math.min(100, value)); return _jsx("div", { children: _jsx("div", { className: "progress", role: "progressbar", "aria-label": label, "aria-valuemin": 0, "aria-valuemax": 100, "aria-valuenow": pct, children: _jsx("span", { style: { width: `${pct}%` } }) }) }); }
-export function Skeleton({ className, ...props }) { return _jsx("div", { className: cx("skeleton", className), "aria-hidden": "true", ...props }); }
-// Spinner (Lote 1 do BUILDING.md). O glifo `.spinner` existia no core desde sempre e era usado
-// SÓ por dentro do Button — nunca teve componente, então nunca teve papel acessível: quem
-// esperava carregando não ouvia nada. As três referências que o têm concordam em `role="status"`
-// com rótulo, e é o que faltava.
-// Sem escolha de "estilo" de spinner (ponto, barra, pinwheel): é UM glifo, e um sistema com
-// cinco spinners é um sistema sem spinner.
-// `decorative` existe para o caso em que ele vive DENTRO de um controle que já anuncia o estado
-// (o `Button loading` faz isso com aria-busy) — dois anúncios para o mesmo fato é ruído.
-// O default é `sm` e não `md` de propósito: o lugar natural do spinner é DENTRO de um controle,
-// ao lado de texto, e é o tamanho que ele sempre teve aqui. Um default maior mudaria a
-// aparência de todo botão em carregamento sem ninguém ter pedido.
-export function Spinner({ size = "sm", label, decorative, className, ...props }) { const s = useAureaStrings(); return _jsx("span", { className: cx("spinner", size !== "sm" && `spinner-${size}`, className), ...(decorative ? { "aria-hidden": true } : { role: "status", "aria-label": label ?? s.loading }), ...props }); }
-// titleAs: o nível do título é do DOCUMENTO, não do componente. Fixo em h3, um empty state
-// no alto de uma página vira h1→h3 e a hierarquia quebra (axe heading-order). Default h3
-// para não mexer em quem já consome; quem sabe o contexto passa o nível certo.
-// `state` aqui NÃO deriva cor nenhuma — o vazio já é neutro e um empty state colorido seria
-// alarme onde há ausência. O que ele faz é o marcador no DOM e a descrição padrão, para
-// "sem conexão" e "resultado parcial" não serem sete frases diferentes em sete telas.
-export function EmptyState({ icon = "document--blank", title, titleAs: TitleTag = "h3", description, action, state }) { const s = useAureaStrings(); const desc = description ?? (state ? s.universalState[state] : null); return _jsxs("div", { className: "empty-state", "data-state": state, children: [_jsx(Icon, { name: icon, size: "xl" }), _jsx(TitleTag, { className: "empty-title", children: title }), desc && _jsx("p", { className: "muted", children: desc }), action] }); }
-function groupNotifications(items) {
-    const out = [];
-    for (const it of items) {
-        const last = out[out.length - 1];
-        if (last && last.label === it.group)
-            last.items.push(it);
-        else
-            out.push({ label: it.group, items: [it] });
-    }
-    return out;
-}
-export function NotificationCenter({ items, onItemClick, onMarkAllRead, label, icon = "notification", side = "bottom" }) {
-    const s = useAureaStrings();
-    const portal = usePortalContainer();
-    const title = label ?? s.notificationsLabel;
-    const unread = items.filter(i => !i.read).length;
-    const groups = groupNotifications(items);
-    const baseId = React.useId();
-    const seen = React.useRef(undefined);
-    const [announce, setAnnounce] = React.useState("");
-    React.useEffect(() => {
-        const ids = new Set(items.map(i => i.id));
-        if (seen.current === undefined) {
-            seen.current = ids;
-            return;
-        }
-        const fresh = items.filter(i => !seen.current.has(i.id)).length;
-        seen.current = ids;
-        // Texto idêntico duas vezes seguidas não muta o DOM e o leitor silencia a 2ª
-        // chegada (auditoria 18/07/2026, MÉDIO 4). Um NBSP alternado no fim força a
-        // mutação sem mudar o que se ouve.
-        if (fresh)
-            setAnnounce(prev => { const text = `${fresh} ${s.notificationNew}`; return prev === text ? text + " " : text; });
-    }, [items, s.notificationNew]);
-    const renderRow = (it) => {
-        const body = _jsxs(_Fragment, { children: [_jsx("span", { className: "notification-dot", "aria-hidden": "true" }), _jsxs("span", { className: "notification-item-title", children: [it.icon && _jsx(Icon, { name: it.icon, size: "sm" }), !it.read && _jsxs("span", { className: "sr-only", children: [s.notificationUnread, " "] }), it.title] }), it.time && _jsx("span", { className: "notification-time", children: it.time }), it.description && _jsx("span", { className: "notification-item-desc", children: it.description })] });
-        return it.onClick || onItemClick
-            ? _jsx("button", { type: "button", className: "notification-item", "data-read": it.read || undefined, onClick: () => { it.onClick?.(); onItemClick?.(it); }, children: body })
-            : _jsx("div", { className: "notification-item", "data-read": it.read || undefined, children: body });
-    };
-    return _jsxs(BasePopover.Root, { children: [_jsxs("span", { className: "notification-trigger", children: [_jsx(BasePopover.Trigger, { render: _jsx(IconButton, { variant: "ghost", icon: icon, label: unread ? `${title} (${unread})` : title }) }), unread > 0 && _jsx("span", { className: "notification-count", "aria-hidden": "true", children: unread > 99 ? "99+" : unread })] }), _jsx(BasePopover.Portal, { container: portal, children: _jsx(BasePopover.Positioner, { side: side, sideOffset: 8, children: _jsxs(BasePopover.Popup, { className: "popover notification-panel", "aria-label": title, children: [_jsxs("div", { className: "notification-head", children: [_jsx(BasePopover.Title, { render: _jsx("strong", {}), children: title }), unread > 0 && onMarkAllRead && _jsx(Button, { variant: "ghost", size: "sm", onClick: onMarkAllRead, children: s.notificationMarkAll })] }), items.length
-                                ? _jsx("div", { className: "notification-list", children: groups.map((g, gi) => {
-                                        const gid = baseId + gi;
-                                        return _jsxs(React.Fragment, { children: [g.label && _jsx("p", { className: "notification-group-label", id: gid, children: g.label }), _jsx("ul", { className: "notification-sublist", "aria-labelledby": g.label ? gid : undefined, children: g.items.map(it => _jsx("li", { children: renderRow(it) }, it.id)) })] }, gi);
-                                    }) })
-                                : _jsx("p", { className: "notification-empty", children: s.notificationEmpty })] }) }) }), _jsx("span", { className: "sr-only", role: "status", "aria-live": "polite", children: announce })] });
-}
+// VITRINE da categoria — é este arquivo que `@aurea-uds/react/feedback` resolve. Sem
+// `"use client"` de propósito: a diretiva contamina o módulo inteiro e faria a marcação pura
+// chegar como cliente por vizinhança (ADR-0026; o check 26b reprova quem a puser de volta aqui).
+export * from "./feedback-client.js";
+export { Badge, Progress, Skeleton } from "./markup.js";

package/dist/file-input.js

@@ -42,6 +42,21 @@ async function somaSha256(file) {
         return undefined;
     }
 }
+// AUD-0006 (12/08/2026): um item restaurado NÃO tem os bytes — a plataforma não devolve `File` de
+// um armazenamento —, então ele não está subindo e não vai subir. Persistido como
+// `pending`/`uploading`/`paused`, ele mostrava Pausar/Retomar/Cancelar INERTES (não há controller
+// em memória para abortar, e `retomar` exige `e.file`) e contava como "em voo", o que travava o
+// recibo para sempre: `emVoo` nunca zerava.
+//
+// `canceled` é o único terminal HONESTO aqui. A transferência foi de fato abortada — pelo fim da
+// página —, e não houve falha de servidor que justificasse `error`. `pending` seria mentira dupla:
+// não está esperando nada e continuaria contando como em voo.
+//
+// E o ganho é que a marcação certa sai de graça: o ramo de `canceled` já esconde o botão de
+// repetir quando não há `File` (era uma decisão do item G1) e já oferece só a remoção. Zero string
+// nova, zero branch novo.
+const ATIVOS = new Set(["pending", "uploading", "paused"]);
+const restaurar = (q) => ({ ...q, restored: true, status: ATIVOS.has(q.status) ? "canceled" : q.status });
 function formatSize(bytes) {
     if (bytes < 1024)
         return `${bytes} B`;
@@ -60,12 +75,27 @@ export function FileInput({ accept, maxSize, multiple, onFilesChange, upload, la
     // G1: a fila restaurada entra como estado INICIAL, não como prop controlada — e a
     // palavra "inicial" é literal: um item restaurado não tem `File`, então controlá-lo
     // de fora seria prometer um round-trip que a plataforma não faz.
+    // AUD-0002 (12/08/2026): o contador SEMPRE começava em zero, e os ids restaurados vêm do
+    // consumidor — inclusive `f0`, que é exatamente o que ele gera. Restaurar `f0` e escolher um
+    // arquivo novo dava `id: "f0"` aos DOIS: remover um removia os dois (`filter` por id), `patch`
+    // atualizava os dois, e o React avisava chave duplicada. Perda de registro no fluxo oficial de
+    // persistência.
+    // O conjunto dos ids em uso faz o gerador PULAR, e por ser conjunto ele vale para id fora do
+    // padrão também — semear o contador com "o maior sufixo numérico" só resolveria `f<N>`.
     const nextId = React.useRef(0);
-    const [files, setFiles] = React.useState(() => (initialQueue ?? []).map(q => ({ ...q, restored: true })));
+    const usados = React.useRef(null);
+    if (!usados.current)
+        usados.current = new Set((initialQueue ?? []).map(q => q.id));
+    const novoId = () => { let novo; do {
+        novo = `f${nextId.current++}`;
+    } while (usados.current.has(novo)); usados.current.add(novo); return novo; };
+    const [files, setFiles] = React.useState(() => (initialQueue ?? []).map(restaurar));
     const [rejected, setRejected] = React.useState([]);
     // a soma chega DEPOIS do envio começar (é assíncrona), então a comparação lê a
     // lista atual por ref em vez da closure do início do upload.
-    const filesRef = React.useRef([]);
+    // semeada com a MESMA lista inicial do estado, e não com `[]`: com fila restaurada as duas
+    // divergiam até a primeira emissão, e é desta ref que o AUD-0009 abaixo lê a lista anterior.
+    const filesRef = React.useRef(files);
     // E guarda a PROMESSA, não só o valor: um arquivo pequeno com envio rápido termina
     // antes de o hash sair, e comparar contra `undefined` pularia a conferência em
     // silêncio — que é pior que não conferir, porque parece que conferiu. Quem achou
@@ -90,7 +120,25 @@ export function FileInput({ accept, maxSize, multiple, onFilesChange, upload, la
     // consumidor guarda; onde ele guarda — armazenamento local, servidor, nada — é
     // decisão dele, a mesma linha do estado da grade na URL (PLANO-1.0 F4).
     const paraFila = (l) => l.map(({ id, name, bytes, status, progress, restored, checksum: soma, finishedAt }) => ({ id, name, bytes, status, progress, ...(soma ? { checksum: soma } : {}), ...(finishedAt ? { finishedAt } : {}), ...(restored ? { restored: true } : {}) }));
-    const emit = (next) => { filesRef.current = next; setFiles(next); onFilesChange?.(next.flatMap(f => f.file ? [f.file] : [])); onQueueChange?.(paraFila(next)); };
+    // AUD-0009 (12/08/2026): a lista PERDE itens por dois caminhos — a troca em modo single e o
+    // "substituir" do conflito —, e a URL de objeto da prévia deles ficava viva até o desmonte. O
+    // navegador segura o blob inteiro nesse tempo, então trocar a mesma foto dez vezes acumulava dez
+    // imagens em memória com uma na tela.
+    // Revogado AQUI, num lugar só, porque `emit` é por onde toda substituição passa. Corrigir em
+    // cada chamador é exatamente o que a regra "quem MAIS tem esse problema?" existe para impedir —
+    // e por isso o `remove` deixou de revogar por conta própria: ele passa por aqui.
+    const emit = (next) => {
+        const idsNovos = new Set(next.map(e => e.id));
+        for (const e of filesRef.current)
+            if (e.preview && !idsNovos.has(e.id)) {
+                URL.revokeObjectURL(e.preview);
+                previas.current.delete(e.preview);
+            }
+        filesRef.current = next;
+        setFiles(next);
+        onFilesChange?.(next.flatMap(f => f.file ? [f.file] : []));
+        onQueueChange?.(paraFila(next));
+    };
     const patch = (fid, p) => setFiles(prev => { const next = prev.map(e => e.id === fid ? { ...e, ...p } : e); filesRef.current = next; onQueueChange?.(paraFila(next)); return next; });
     const abortId = (fid) => controllers.current.get(fid)?.abort();
     // Cada arquivo envia por conta própria (promessa independente + catch por arquivo):
@@ -149,7 +197,7 @@ export function FileInput({ accept, maxSize, multiple, onFilesChange, upload, la
                 novosConflitos.push({ file, existente: jaTem.id });
                 continue;
             }
-            ok.push({ id: `f${nextId.current++}`, file, name: file.name, bytes: file.size, status: "pending", progress: 0 });
+            ok.push({ id: novoId(), file, name: file.name, bytes: file.size, status: "pending", progress: 0 });
         }
         if (novosConflitos.length)
             setConflitos(c => [...c, ...novosConflitos]);
@@ -192,7 +240,7 @@ export function FileInput({ accept, maxSize, multiple, onFilesChange, upload, la
     // ainda está em `files` quando esta função roda — o React não re-renderizou — e ler
     // a closure deixava os DOIS na fila. Foi o teste que achou.
     const aceitarConflito = (file, base = files) => {
-        const e = { id: `f${nextId.current++}`, file, name: file.name, bytes: file.size, status: "pending", progress: 0 };
+        const e = { id: novoId(), file, name: file.name, bytes: file.size, status: "pending", progress: 0 };
         emit([...base, e]);
         if (preview && ehImagem(file)) {
             const u = URL.createObjectURL(file);
@@ -216,10 +264,10 @@ export function FileInput({ accept, maxSize, multiple, onFilesChange, upload, la
         }
         aceitarConflito(c.file);
     };
-    const remove = (rid) => { const f = files.find(x => x.id === rid); if (f?.preview) {
-        URL.revokeObjectURL(f.preview);
-        previas.current.delete(f.preview);
-    } abortId(rid); emit(files.filter(x => x.id !== rid)); setAnnounce(f ? `${s.fileRemoved}: ${f.name}` : ""); };
+    // a revogação da prévia saiu daqui: quem revoga é o `emit`, para todo item que a lista perder.
+    // Duplicar a regra em cada chamador é como o AUD-0009 nasceu — o `remove` revogava e os outros
+    // dois caminhos de substituição, não.
+    const remove = (rid) => { const f = files.find(x => x.id === rid); abortId(rid); emit(files.filter(x => x.id !== rid)); setAnnounce(f ? `${s.fileRemoved}: ${f.name}` : ""); };
     // G6: "terminou" é não haver mais nada em voo nem esperando — pausado conta como em
     // voo, porque a pessoa ainda vai retomar.
     const emVoo = files.some(f => f.status === "uploading" || f.status === "paused" || f.status === "pending");

package/dist/identity-client.d.ts

@@ -0,0 +1,9 @@
+import React, { type ReactNode } from "react";
+import type { AvatarSize } from "./markup.js";
+export declare function Avatar({ src, alt, fallback, size, className }: {
+    src?: string;
+    alt?: string;
+    fallback?: ReactNode;
+    size?: AvatarSize;
+    className?: string;
+}): React.JSX.Element;

package/dist/identity-client.js

@@ -0,0 +1,12 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+// Fase 9 (achado A5): este arquivo saiu do index.tsx de 970 linhas. Um módulo por categoria
+// do registry — a taxonomia já existia e é gateada. A ordem de import entre eles é um DAG:
+// internal → system → actions → feedback → inputs → navigation → layout → data-display → resto.
+import React from "react";
+import { cx } from "./internal.js";
+export function Avatar({ src, alt = "", fallback, size = "md", className }) {
+    const [falhou, setFalhou] = React.useState(false);
+    React.useEffect(() => { setFalhou(false); }, [src]);
+    return _jsx("span", { className: cx("avatar", size !== "md" && `avatar-${size}`, className), children: src && !falhou ? _jsx("img", { src: src, alt: alt, onError: () => setFalhou(true) }) : fallback });
+}

package/dist/identity.d.ts

@@ -1,17 +1,2 @@
-import React, { type ReactNode } from "react";
-export type AvatarSize = "sm" | "md" | "lg";
-export declare function Avatar({ src, alt, fallback, size, className }: {
-    src?: string;
-    alt?: string;
-    fallback?: ReactNode;
-    size?: AvatarSize;
-    className?: string;
-}): React.JSX.Element;
-export declare function AvatarGroup({ children, max, total, label, size, className }: {
-    children: ReactNode;
-    max?: number;
-    total?: number;
-    label?: string;
-    size?: AvatarSize;
-    className?: string;
-}): React.JSX.Element;
+export * from "./identity-client.js";
+export { AvatarGroup, type AvatarSize } from "./markup.js";

package/dist/identity.js

@@ -1,25 +1,5 @@
-"use client";
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-// Fase 9 (achado A5): este arquivo saiu do index.tsx de 970 linhas. Um módulo por categoria
-// do registry — a taxonomia já existia e é gateada. A ordem de import entre eles é um DAG:
-// internal → system → actions → feedback → inputs → navigation → layout → data-display → resto.
-import React from "react";
-import { cx } from "./internal.js";
-export function Avatar({ src, alt = "", fallback, size = "md", className }) {
-    const [falhou, setFalhou] = React.useState(false);
-    React.useEffect(() => { setFalhou(false); }, [src]);
-    return _jsx("span", { className: cx("avatar", size !== "md" && `avatar-${size}`, className), children: src && !falhou ? _jsx("img", { src: src, alt: alt, onError: () => setFalhou(true) }) : fallback });
-}
-// AvatarGroup: a pilha sobreposta com o "+N" no fim. A sobreposição já existia no core desde
-// sempre (`.avatar-group .avatar`), e o container nunca teve regra — a peça filha ficou, a mãe
-// não, exatamente como no Stepper.
-// `max` corta a lista e o excedente vira UM avatar de contagem, que é onde as referências
-// convergem. Fora de propósito: o `renderSurplus` de uma delas (callback para desenhar o "+N"),
-// que é configuração para um problema que ninguém teve ainda.
-// `role="group"` + nome: uma fila de retratos sem nome não diz de quem é.
-export function AvatarGroup({ children, max, total, label, size = "md", className }) {
-    const itens = React.Children.toArray(children);
-    const mostra = max ? itens.slice(0, max) : itens;
-    const resto = (total ?? itens.length) - mostra.length;
-    return _jsxs("div", { role: "group", "aria-label": label, className: cx("avatar-group", className), children: [mostra, resto > 0 && _jsxs("span", { className: cx("avatar", "avatar-count", size !== "md" && `avatar-${size}`), "aria-hidden": "true", children: ["+", resto] })] });
-}
+// VITRINE da categoria — é este arquivo que `@aurea-uds/react/identity` resolve. Sem
+// `"use client"` de propósito: a diretiva contamina o módulo inteiro e faria a marcação pura
+// chegar como cliente por vizinhança (ADR-0026; o check 26b reprova quem a puser de volta aqui).
+export * from "./identity-client.js";
+export { AvatarGroup } from "./markup.js";

package/dist/index.d.ts

@@ -1,5 +1,6 @@
-export { cx, defaultStrings, ptBR, defaultSpriteUrl, gridStateToParams, gridStateFromParams, universalStates, stateSeverity, type AureaStrings, type GridState, type UniversalState } from "./pure.js";
+export { cx, defaultStrings, ptBR, defaultSpriteUrl, gridStateToParams, gridStateFromParams, screenStateToParams, screenStateFromParams, universalStates, stateSeverity, type AureaStrings, type GridState, type ScreenState, type UniversalState } from "./pure.js";
 export { useAureaStrings, useSpriteUrl } from "./internal.js";
+export { Card, Stack, Cluster, Grid, KPI, DataList, Timeline, Prose, Badge, Progress, Skeleton, AvatarGroup, LogStream, MediaPlayerShell, Topbar, Kbd, Select, Textarea, Checkbox, Radio, Switch, Range, type BadgeVariant, type AvatarSize, type TopbarVariant } from "./markup.js";
 export * from "./system.js";
 export * from "./actions.js";
 export * from "./feedback.js";

package/dist/index.js

@@ -8,11 +8,14 @@
 // porta de sempre: `import {Button} from "@aurea-uds/react"` continua funcionando e traz tudo
 // que não custa dependência.
 //
-// TRÊS COMPONENTES NÃO ENTRAM AQUI, e é o ponto da fase:
+// SEIS MÓDULOS DE MOTOR OPCIONAL NÃO ENTRAM AQUI:
 //   CodeEditor  → "@aurea-uds/react/code-editor"  (CodeMirror, 6 peers opcionais)
 //   DataGrid    → "@aurea-uds/react/data-grid"    (@tanstack/react-table)
 //   QRCode      → "@aurea-uds/react/qrcode"       (qr)
-// Se estivessem neste barril, importar um Button carregaria os três — e a dependência opcional
+//   Calendar    → "@aurea-uds/react/calendar"     (react-day-picker)
+//   Chart       → "@aurea-uds/react/chart"        (recharts)
+//   DependencyGraph → "@aurea-uds/react/graph"    (@xyflow/react)
+// Se estivessem neste barril, importar um Button carregaria um peer opcional — e a dependência
 // que não estivesse instalada quebraria a importação. O peso é real, então a fronteira é real.
 // SEM `"use client"`, e é o ponto da Parte A: este barril é um módulo de SERVIDOR. Reexportar
 // componente de um módulo com a diretiva é o caminho suportado — quem importa daqui de um
@@ -25,8 +28,21 @@
 // DataGrid, de propósito: quem lê a URL num framework de RSC é o SERVIDOR, e o
 // subpath tem a diretiva. Vindo daqui — via `pure.js`, que não tem — a função é
 // chamável dos dois lados. É a mesma razão do `cx`, uma camada acima.
-export { cx, defaultStrings, ptBR, defaultSpriteUrl, gridStateToParams, gridStateFromParams, universalStates, stateSeverity } from "./pure.js";
+export { cx, defaultStrings, ptBR, defaultSpriteUrl, gridStateToParams, gridStateFromParams, screenStateToParams, screenStateFromParams, universalStates, stateSeverity } from "./pure.js";
 export { useAureaStrings, useSpriteUrl } from "./internal.js";
+// ── A LINHA DO ITEM O1, e ela é o item inteiro ───────────────────────────────────────────────
+// Estes 22 vêm do `markup.js`, que NÃO tem a diretiva, e por isso chegam como componentes de
+// SERVIDOR. Vinham dos módulos de categoria abaixo, e de lá chegavam como cliente: `Card` é uma
+// <div>, e importá-lo embarcava 9 módulos e 118,5 KB — `node scripts/measure-boundary.mjs`.
+//
+// ESTA LINHA PRECISA SER EXPLÍCITA, e o que acontece sem ela foi MEDIDO, não deduzido — a
+// primeira versão deste comentário dizia outra coisa e a prova contra o defeito a derrubou.
+// Tirando um nome daqui: o `tsc` fica VERDE, o componente continua existindo e os testes
+// continuam passando, porque o módulo de categoria abaixo o reexporta (é o que mantém o subpath
+// inteiro). O que muda é de ONDE ele vem — do módulo com a diretiva —, e aí ele volta a chegar
+// como referência de CLIENTE e os 118,5 KB voltam com ele. Não é um erro: é o ganho do item O1
+// se desfazendo em silêncio. É isso, exatamente isso, que o check 35 pega.
+export { Card, Stack, Cluster, Grid, KPI, DataList, Timeline, Prose, Badge, Progress, Skeleton, AvatarGroup, LogStream, MediaPlayerShell, Topbar, Kbd, Select, Textarea, Checkbox, Radio, Switch, Range } from "./markup.js";
 export * from "./system.js";
 export * from "./actions.js";
 export * from "./feedback.js";

package/dist/inputs-client.d.ts

@@ -0,0 +1,105 @@
+import React, { type HTMLAttributes, type InputHTMLAttributes, type RefAttributes, type ReactNode } from "react";
+import { type IconName } from "./system.js";
+export { FileInput, matchesAccept, type FileRejection, type UploadContext, type UploadFn } from "./file-input.js";
+export interface FieldProps extends HTMLAttributes<HTMLDivElement>, RefAttributes<HTMLDivElement> {
+    label: string;
+    hint?: ReactNode;
+    error?: ReactNode;
+    name?: string;
+}
+export declare function Field({ label, hint, error, children, className, id, name, ...props }: FieldProps): React.JSX.Element;
+export declare function Form({ errors, onSubmit, children, className, ...props }: Omit<React.FormHTMLAttributes<HTMLFormElement>, "onSubmit"> & RefAttributes<HTMLFormElement> & {
+    errors?: Record<string, string | string[]>;
+    onSubmit?: (values: Record<string, unknown>) => void;
+}): React.JSX.Element;
+export interface InputProps extends InputHTMLAttributes<HTMLInputElement>, RefAttributes<HTMLInputElement> {
+    formatOnBlur?: (value: string) => string;
+}
+export declare const Input: React.ForwardRefExoticComponent<Omit<InputProps, "ref"> & RefAttributes<HTMLInputElement>>;
+export declare function SearchField({ icon, className, ...props }: InputHTMLAttributes<HTMLInputElement> & RefAttributes<HTMLInputElement> & {
+    icon?: IconName;
+}): React.JSX.Element;
+export declare function NumberField({ value, defaultValue, onValueChange, min, max, step, disabled, readOnly, required, label, id, name, format, locale, className }: {
+    value?: number | null;
+    defaultValue?: number;
+    onValueChange?: (v: number | null) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    disabled?: boolean;
+    readOnly?: boolean;
+    required?: boolean;
+    label?: string;
+    id?: string;
+    name?: string;
+    format?: Intl.NumberFormatOptions;
+    locale?: string;
+    className?: string;
+}): React.JSX.Element;
+export declare function OTPField({ length, value, defaultValue, onValueChange, mask, disabled, required, label, id, className }: {
+    length: number;
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (v: string) => void;
+    mask?: boolean;
+    disabled?: boolean;
+    required?: boolean;
+    label?: string;
+    id?: string;
+    className?: string;
+}): React.JSX.Element;
+export declare function SegmentedControl({ items, value, onChange, label }: {
+    items: Array<{
+        value: string;
+        label: ReactNode;
+    }>;
+    value: string;
+    onChange: (v: string) => void;
+    label?: string;
+}): React.JSX.Element;
+export interface ComboboxOption {
+    value: string;
+    label: string;
+}
+export declare function Combobox({ items, value, onValueChange, placeholder, label, disabled, id, className, "aria-describedby": descrito, "aria-invalid": invalido }: {
+    items: ComboboxOption[];
+    value?: ComboboxOption | null;
+    onValueChange?: (v: ComboboxOption | null) => void;
+    placeholder?: string;
+    label?: ReactNode;
+    disabled?: boolean;
+    id?: string;
+    className?: string;
+    "aria-describedby"?: string;
+    "aria-invalid"?: boolean | "true" | "false";
+}): React.JSX.Element;
+export interface ComboboxOptGroup {
+    label: string;
+    items: ComboboxOption[];
+}
+export declare function MultiCombobox({ items, value, onValueChange, onInputChange, loading, placeholder, label, disabled, id, className, "aria-describedby": descrito, "aria-invalid": invalido }: {
+    items: ComboboxOption[] | ComboboxOptGroup[];
+    value?: ComboboxOption[];
+    onValueChange?: (v: ComboboxOption[]) => void;
+    onInputChange?: (query: string) => void;
+    loading?: boolean;
+    placeholder?: string;
+    label?: ReactNode;
+    disabled?: boolean;
+    id?: string;
+    className?: string;
+    "aria-describedby"?: string;
+    "aria-invalid"?: boolean | "true" | "false";
+}): React.JSX.Element;
+export interface EditorBlock {
+    id: string;
+    kind?: ReactNode;
+    children: ReactNode;
+}
+export interface BlockEditorProps extends Omit<HTMLAttributes<HTMLOListElement>, "onReorder">, RefAttributes<HTMLOListElement> {
+    blocks: EditorBlock[];
+    onReorder: (from: number, to: number) => void;
+    onRemove?: (index: number) => void;
+    label?: string;
+}
+export declare function BlockEditor({ blocks, onReorder, onRemove, label, className, ...props }: BlockEditorProps): React.JSX.Element;