@aurea-uds/react 0.1.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,53 @@
+# @aurea-uds/react
+
+React components for **Aurea Universal Design System**.
+
+```bash
+pnpm add @aurea-uds/react @aurea-uds/core @aurea-uds/fonts @aurea-uds/icons
+```
+
+## Use
+
+Load the fonts **before** the stylesheet — the core no longer embeds IBM Plex.
+
+```js
+import "@aurea-uds/fonts/css";
+import "@aurea-uds/core/css";
+import {AureaProvider, Button} from "@aurea-uds/react";
+
+export default () => (
+  <AureaProvider spriteUrl="/aurea-icons.svg">
+    <Button variant="primary">Ship it</Button>
+  </AureaProvider>
+);
+```
+
+`spriteUrl` points at the file from `@aurea-uds/icons` — copy it into whatever your app
+serves as static assets. It is configuration, so it belongs to the provider, not to every
+component that draws an icon.
+
+## Subpath imports
+
+The barrel works, but each category is also its own entry point, so you can take a part of
+the system without the rest:
+
+```js
+import {Button} from "@aurea-uds/react/actions";
+```
+
+Three components carry a heavy optional dependency and are therefore **outside the barrel** —
+importing a Button must never pull in a code editor:
+
+| Import | Needs you to install |
+|---|---|
+| `@aurea-uds/react/code-editor` | `codemirror` and its `@codemirror/*` packages |
+| `@aurea-uds/react/data-grid` | `@tanstack/react-table` |
+| `@aurea-uds/react/qrcode` | `qr` |
+
+## Requirements
+
+React 19 or later. `ref` is a plain prop in React 19, and the types depend on that.
+
+## Licence
+
+Apache-2.0.

package/dist/actions.d.ts

@@ -0,0 +1,33 @@
+import React, { type ButtonHTMLAttributes, type HTMLAttributes, type RefAttributes } from "react";
+import { type IconName } from "./system.js";
+export type ButtonVariant = "primary" | "secondary" | "outline" | "ghost" | "danger" | "danger-outline" | "danger-ghost" | "link" | "link-primary" | "link-danger" | "nav";
+export type ComponentSize = "xs" | "sm" | "md" | "lg" | "xl";
+export interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement>, RefAttributes<HTMLButtonElement> {
+    variant?: ButtonVariant;
+    size?: ComponentSize;
+    loading?: boolean;
+    leadingIcon?: IconName;
+    trailingIcon?: IconName;
+    href?: string;
+    fullWidth?: boolean;
+    pressed?: boolean;
+    kbd?: string;
+}
+export declare const Button: React.ForwardRefExoticComponent<Omit<ButtonProps, "ref"> & RefAttributes<HTMLButtonElement>>;
+export interface IconButtonProps extends Omit<ButtonProps, "children"> {
+    label: string;
+    icon: IconName;
+}
+export declare const IconButton: React.ForwardRefExoticComponent<Omit<IconButtonProps, "ref"> & RefAttributes<HTMLButtonElement>>;
+export declare function ButtonGroup({ label, className, ...props }: HTMLAttributes<HTMLDivElement> & RefAttributes<HTMLDivElement> & {
+    label?: string;
+}): React.JSX.Element;
+export declare function Toolbar({ orientation, label, className, ...props }: HTMLAttributes<HTMLDivElement> & RefAttributes<HTMLDivElement> & {
+    orientation?: "horizontal" | "vertical";
+    label?: string;
+}): React.JSX.Element;
+export declare function ToolbarGroup({ label, className, ...props }: HTMLAttributes<HTMLDivElement> & RefAttributes<HTMLDivElement> & {
+    label?: string;
+}): React.JSX.Element;
+export declare function ToolbarSeparator({ className, ...props }: HTMLAttributes<HTMLDivElement> & RefAttributes<HTMLDivElement>): React.JSX.Element;
+export declare const ToolbarButton: React.ForwardRefExoticComponent<Omit<ButtonProps, "ref"> & RefAttributes<HTMLButtonElement>>;

package/dist/actions.js

@@ -0,0 +1,32 @@
+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 { forwardRef } from "react";
+import { Toolbar as BaseToolbar } from "@base-ui/react/toolbar";
+import { cx, useAureaStrings, Kbd } from "./internal.js";
+import { Icon } from "./system.js";
+// type="button" por default: o default do HTML é submit, e um "Cancelar"/"Remover"
+// dentro de <form> dispararia a ação principal (auditoria 18/07/2026, ALTO 1).
+// Quem quer submeter passa type="submit" explícito (como o MessageComposer faz).
+export const Button = forwardRef(function Button({ variant = "secondary", size = "md", loading, leadingIcon, trailingIcon, className, children, disabled, type = "button", href, fullWidth, pressed, kbd, ...props }, ref) {
+    const cls = cx("btn", `btn-${variant}`, size !== "md" && `btn-${size}`, fullWidth && "btn-block", className);
+    // kbd dentro do botão: mostra o atalho E o anuncia (aria-keyshortcuts), senão é enfeite.
+    const inner = _jsxs(_Fragment, { children: [loading && _jsx("span", { className: "spinner" }), leadingIcon && _jsx(Icon, { name: leadingIcon }), _jsx("span", { children: children }), kbd && _jsx(Kbd, { children: kbd }), trailingIcon && _jsx(Icon, { name: trailingIcon })] });
+    const off = disabled || loading;
+    const shared = { "aria-keyshortcuts": kbd || undefined, "aria-busy": loading || undefined };
+    if (href !== undefined)
+        return _jsx("a", { ref: ref, className: cls, ...(off ? { "aria-disabled": true } : { href }), ...shared, ...props, children: inner });
+    return _jsx("button", { ref: ref, type: type, className: cls, disabled: off, "aria-pressed": pressed, ...shared, ...props, children: inner });
+});
+// default ghost (não secondary): um ícone-ação solto — hambúrguer, tema, fechar — é sem
+// caixa por convenção (pedido do Victor: hambúrguer sem borda). Quem quer a caixa passa
+// variant. Alinha o React ao HTML dos docs, onde .btn-icon já é transparente.
+export const IconButton = forwardRef(function IconButton({ label, icon, variant = "ghost", className, ...props }, ref) { return _jsx(Button, { ref: ref, variant: variant, className: cx("btn-icon", className), "aria-label": label, ...props, children: _jsx(Icon, { name: icon }) }); });
+// ButtonGroup: agrupamento semântico. Sem roving tabindex — cada botão continua tabulável (use Toolbar para roving).
+export function ButtonGroup({ label, className, ...props }) { const s = useAureaStrings(); return _jsx("div", { role: "group", "aria-label": label ?? s.optionsLabel, className: cx("btn-group", className), ...props }); }
+// Toolbar: roving tabindex (setas navegam, Tab entra/sai) via Base UI.
+export function Toolbar({ orientation = "horizontal", label, className, ...props }) { const s = useAureaStrings(); return _jsx(BaseToolbar.Root, { orientation: orientation, "aria-label": label ?? s.toolbarLabel, className: cx("toolbar", className), ...props }); }
+export function ToolbarGroup({ label, className, ...props }) { return _jsx(BaseToolbar.Group, { "aria-label": label, className: cx("toolbar-group", className), ...props }); }
+export function ToolbarSeparator({ className, ...props }) { return _jsx(BaseToolbar.Separator, { className: cx("toolbar-sep", className), ...props }); }
+export const ToolbarButton = forwardRef(function ToolbarButton({ variant = "ghost", ...props }, ref) { return _jsx(BaseToolbar.Button, { ref: ref, disabled: props.disabled, render: _jsx(Button, { variant: variant, ...props }) }); });

package/dist/code-editor.d.ts

@@ -0,0 +1,18 @@
+import React from "react";
+import { type Extension } from "@codemirror/state";
+import { HighlightStyle } from "@codemirror/language";
+export declare const aureaEditorTheme: Extension;
+export declare const aureaHighlightStyle: HighlightStyle;
+export interface CodeEditorProps {
+    /** Conteúdo inicial. Não controlado (precedente MediaPlayer/FileInput): mudanças depois da montagem não recarregam o doc. */
+    defaultValue?: string;
+    /** Notificado a cada edição com o texto atual. */
+    onChange?: (value: string) => void;
+    /** Extensões do consumidor: a extensão de LINGUAGEM (@codemirror/lang-*) e o que mais quiser. Memorize o array para não reconfigurar à toa. */
+    extensions?: Extension[];
+    readOnly?: boolean;
+    /** Nome acessível do editor; default vem da i18n (`codeEditor`). */
+    ariaLabel?: string;
+    className?: string;
+}
+export declare function CodeEditor({ defaultValue, onChange, extensions, readOnly, ariaLabel, className }: CodeEditorProps): React.JSX.Element;

package/dist/code-editor.js

@@ -0,0 +1,111 @@
+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.
+// SUBPATH PRÓPRIO (ver ./qrcode): é o único componente que precisa do CodeMirror — seis
+// pacotes, todos peer OPCIONAIS. Antes, quem instalava a biblioteca para usar um Button
+// baixava um editor de código inteiro. Era o achado A5.
+import React from "react";
+import { EditorView } from "@codemirror/view";
+import { EditorState, Compartment } from "@codemirror/state";
+import { HighlightStyle, syntaxHighlighting } from "@codemirror/language";
+import { tags as t } from "@lezer/highlight";
+import { basicSetup } from "codemirror";
+import { cx, useAureaStrings } from "./internal.js";
+// CodeEditor (Fase 5 etapa 3): CodeMirror 6 com tema Aurea via tokens. O MOTOR de
+// edição é do CodeMirror (como o vídeo é do browser no MediaPlayer) — o componente
+// só monta a EditorView, dá a pele Aurea e liga defaultValue/onChange. Dependência
+// nova AUTORIZADA aqui (07/2026: codemirror 6.0.2 / @codemirror/view 6.43.6 /
+// @codemirror/state 6.7.1 / @codemirror/language 6.12.4 / @lezer/highlight 1.2.3 —
+// tudo MIT, ativamente mantido, versões atuais medidas no pacote instalado).
+//
+// LINGUAGENS FICAM FORA (regra da etapa): não embutimos nenhuma extensão de
+// linguagem — o consumidor passa a dele em `extensions` (ex.: @codemirror/lang-*).
+// Assim o peso e a escolha de linguagem são dele, e a lista de deps não incha.
+//
+// SEM COR HARDCODED FORA DE TOKEN: o tema só referencia var(--*) do core. Uso só
+// tokens que VIRAM entre dark/light (foreground, muted-foreground, os semânticos
+// success/warning/danger/info-400 que têm override no [data-theme="light"], e
+// selection/border/surface). NÃO uso --primary como cor de texto de sintaxe: o
+// amarelo é invariável e falha contraste sobre o inset claro. --primary fica só em
+// realce de par de brackets/seleção de autocomplete (14% — idioma do tree-node).
+// Sem CSS novo no core: a pele vive no EditorView.theme (StyleModule injetado pelo
+// próprio CodeMirror), não no stylesheet do core — o core/os baselines não mudam.
+// /*@__PURE__*/: as factories rodam no topo do módulo; sem a anotação o bundler
+// não prova que são puras e mantém o CodeMirror mesmo em quem importa só o Button
+// (auditoria 18/07/2026, ALTO 5). Com a anotação + sideEffects:false, o tema e o
+// CodeEditor (e o CodeMirror) somem quando não usados. Split por subpath = decisão do Victor.
+export const aureaEditorTheme = /*@__PURE__*/ EditorView.theme({
+    "&": { backgroundColor: "var(--surface-inset)", color: "var(--foreground)", border: "var(--border-width) solid var(--border)", borderRadius: "var(--radius-lg)", fontSize: "var(--text-xs)" },
+    "&.cm-focused": { outline: "2px solid var(--focus-strong)", outlineOffset: "-2px" },
+    ".cm-scroller": { fontFamily: "var(--font-code)", lineHeight: "var(--leading-relaxed)", borderRadius: "inherit" },
+    ".cm-content": { caretColor: "var(--foreground)", padding: "var(--space-2) 0" },
+    ".cm-line": { padding: "0 var(--space-3)" },
+    ".cm-cursor, .cm-dropCursor": { borderLeftColor: "var(--foreground)" },
+    "&.cm-focused .cm-cursor": { borderLeftColor: "var(--foreground)" },
+    ".cm-selectionBackground, ::selection": { backgroundColor: "var(--selection)" },
+    "&.cm-focused .cm-selectionBackground": { backgroundColor: "var(--selection)" },
+    ".cm-selectionMatch": { backgroundColor: "var(--selection)" },
+    ".cm-activeLine": { backgroundColor: "color-mix(in srgb,var(--foreground) 5%,transparent)" },
+    ".cm-gutters": { backgroundColor: "var(--surface-inset)", color: "var(--muted-foreground)", border: "none", borderRight: "var(--border-width) solid var(--border)" },
+    ".cm-gutterElement": { padding: "0 var(--space-2)" },
+    ".cm-activeLineGutter": { backgroundColor: "color-mix(in srgb,var(--foreground) 5%,transparent)", color: "var(--foreground)" },
+    ".cm-matchingBracket, &.cm-focused .cm-matchingBracket": { backgroundColor: "color-mix(in srgb,var(--foreground) 16%,transparent)", color: "var(--foreground)", outline: "none" },
+    ".cm-nonmatchingBracket": { color: "var(--danger-400)" },
+    ".cm-searchMatch": { backgroundColor: "color-mix(in srgb,var(--warning-400) 30%,transparent)" },
+    ".cm-searchMatch.cm-searchMatch-selected": { backgroundColor: "var(--selection)" },
+    ".cm-panels": { backgroundColor: "var(--surface-2)", color: "var(--foreground)" },
+    ".cm-panels.cm-panels-top": { borderBottom: "var(--border-width) solid var(--border)" },
+    ".cm-panels.cm-panels-bottom": { borderTop: "var(--border-width) solid var(--border)" },
+    ".cm-tooltip": { backgroundColor: "var(--popover)", color: "var(--popover-foreground)", border: "var(--border-width) solid var(--border)", borderRadius: "var(--radius-md)" },
+    ".cm-tooltip-autocomplete ul li[aria-selected]": { backgroundColor: "color-mix(in srgb,var(--primary) 14%,transparent)", color: "var(--foreground)" },
+    ".cm-completionLabel": { color: "var(--foreground)" },
+});
+// HighlightStyle: tags do @lezer/highlight → tokens. Só cores que viram entre temas.
+// A default fallback do basicSetup fica só para tags que não cobrimos (fallback:true).
+export const aureaHighlightStyle = /*@__PURE__*/ HighlightStyle.define([
+    { tag: [t.comment, t.lineComment, t.blockComment, t.docComment], color: "var(--muted-foreground)", fontStyle: "italic" },
+    { tag: [t.keyword, t.controlKeyword, t.moduleKeyword, t.operatorKeyword, t.definitionKeyword, t.modifier, t.self, t.atom, t.bool, t.null, t.typeName, t.className, t.namespace, t.tagName], color: "var(--info-400)" },
+    { tag: [t.string, t.character, t.docString, t.regexp, t.escape, t.special(t.string)], color: "var(--success-400)" },
+    { tag: [t.number, t.integer, t.float, t.unit], color: "var(--warning-400)" },
+    { tag: [t.propertyName, t.attributeName, t.labelName], color: "var(--foreground)" },
+    { tag: t.function(t.variableName), color: "var(--foreground)", fontWeight: "600" },
+    { tag: t.invalid, color: "var(--danger-400)" },
+    { tag: [t.link, t.url], color: "var(--info-400)", textDecoration: "underline" },
+    { tag: t.heading, fontWeight: "700" },
+    { tag: t.strong, fontWeight: "700" },
+    { tag: t.emphasis, fontStyle: "italic" },
+    { tag: t.strikethrough, textDecoration: "line-through" },
+]);
+export function CodeEditor({ defaultValue = "", onChange, extensions, readOnly = false, ariaLabel, className }) {
+    const s = useAureaStrings();
+    const host = React.useRef(null);
+    const view = React.useRef(null);
+    const dyn = React.useRef(new Compartment());
+    // onChange por ref: notifica sempre o mais recente sem recriar o listener (logo sem remontar).
+    const onChangeRef = React.useRef(onChange);
+    onChangeRef.current = onChange;
+    const label = ariaLabel ?? s.codeEditor;
+    // Parte reconfigurável (linguagem/readOnly/rótulo) num Compartment: troca sem
+    // remontar o editor — preserva doc, seleção e histórico.
+    const dynExt = () => [
+        EditorState.readOnly.of(readOnly),
+        EditorView.editable.of(!readOnly),
+        EditorView.contentAttributes.of({ "aria-label": label }),
+        ...(extensions ?? []),
+    ];
+    React.useEffect(() => {
+        const v = new EditorView({ parent: host.current, state: EditorState.create({ doc: defaultValue, extensions: [
+                    basicSetup,
+                    aureaEditorTheme,
+                    syntaxHighlighting(aureaHighlightStyle),
+                    EditorView.updateListener.of(u => { if (u.docChanged)
+                        onChangeRef.current?.(u.state.doc.toString()); }),
+                    dyn.current.of(dynExt()),
+                ] }) });
+        view.current = v;
+        return () => { v.destroy(); view.current = null; };
+    }, []); // defaultValue só na montagem (não controlado).
+    React.useEffect(() => { view.current?.dispatch({ effects: dyn.current.reconfigure(dynExt()) }); }, [readOnly, label, extensions]);
+    return _jsx("div", { ref: host, className: cx("code-editor", className) });
+}

package/dist/code.d.ts

@@ -0,0 +1,13 @@
+export declare function CodeBlock({ children, language, copyable, className }: {
+    children: string;
+    language?: string;
+    copyable?: boolean;
+    className?: string;
+}): import("react").JSX.Element;
+export declare function LogStream({ lines }: {
+    lines: Array<{
+        time?: string;
+        level?: string;
+        text: string;
+    }>;
+}): import("react").JSX.Element;

package/dist/code.js

@@ -0,0 +1,18 @@
+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 { cx, useAureaStrings } from "./internal.js";
+import { Icon } from "./system.js";
+// copyable: o gatilho é marcado com data-aurea-copy e o COMPORTAMENTO mora no aurea.js do
+// core (uma implementação para React e para HTML puro). O onClick daqui atende quem só
+// carrega o pacote React; ele para a propagação pro core não copiar duas vezes.
+export function CodeBlock({ children, language = "text", copyable, className }) {
+    const s = useAureaStrings();
+    const pre = _jsx("pre", { className: cx("code-block", !copyable && className), "data-language": language, children: _jsx("code", { children: children }) });
+    if (!copyable)
+        return pre;
+    const onCopy = (e) => { e.stopPropagation(); window.Aurea?.copy?.(e.currentTarget) ?? navigator.clipboard?.writeText(children); };
+    return _jsxs("div", { className: cx("code-block-wrap", className), "data-aurea-copy-scope": true, children: [_jsxs("button", { type: "button", className: "btn btn-icon btn-ghost copy-code", "data-aurea-copy": true, "aria-label": s.copyCode, onClick: onCopy, children: [_jsx(Icon, { name: "copy", size: "sm", className: "c-copy" }), _jsx(Icon, { name: "checkmark", size: "sm", className: "c-done" })] }), pre] });
+}
+export function LogStream({ lines }) { return _jsx("div", { className: "log-stream", role: "log", "aria-live": "polite", children: lines.map((l, n) => _jsxs("div", { className: cx("log-line", l.level && `log-${l.level}`), children: [_jsx("time", { children: l.time }), _jsx("span", { children: l.text })] }, n)) }); }

package/dist/communication.d.ts

@@ -0,0 +1,31 @@
+import React, { type ReactNode } from "react";
+import { type IconName } from "./system.js";
+import { type BadgeVariant } from "./feedback.js";
+export interface ChatMessage {
+    id: string;
+    body: ReactNode;
+    author?: ReactNode;
+    time?: ReactNode;
+    avatar?: {
+        src?: string;
+        fallback?: ReactNode;
+    };
+    status?: {
+        label: ReactNode;
+        variant?: BadgeVariant;
+    };
+}
+export declare function MessageList({ messages, label, className }: {
+    messages: ChatMessage[];
+    label?: string;
+    className?: string;
+}): React.JSX.Element;
+export declare function MessageComposer({ onSend, placeholder, label, icon, sendLabel, disabled, className }: {
+    onSend: (text: string) => void;
+    placeholder?: string;
+    label?: string;
+    icon?: IconName;
+    sendLabel?: string;
+    disabled?: boolean;
+    className?: string;
+}): React.JSX.Element;

package/dist/communication.js

@@ -0,0 +1,27 @@
+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, useAureaStrings } from "./internal.js";
+import { Icon } from "./system.js";
+import { IconButton } from "./actions.js";
+import { Avatar } from "./identity.js";
+import { Badge } from "./feedback.js";
+export function MessageList({ messages, label, className }) {
+    const s = useAureaStrings();
+    return _jsx("div", { className: cx("stack", className), role: "log", "aria-live": "polite", "aria-label": label ?? s.chatLabel, children: messages.map(m => _jsxs("div", { className: "message", children: [m.avatar ? _jsx(Avatar, { src: m.avatar.src, fallback: m.avatar.fallback }) : _jsx("span", {}), _jsxs("div", { className: "message-bubble", children: [(m.author || m.time) && _jsxs("div", { className: "label", children: [_jsx("span", { children: m.author }), m.time && _jsx("span", { className: "hint", children: m.time })] }), m.body, m.status && _jsx("div", { className: "message-status", children: _jsxs(Badge, { variant: m.status.variant, children: [_jsx("i", { className: "status-dot" }), m.status.label] }) })] })] }, m.id)) });
+}
+// Composer: <form> sobre .input-wrap + .input; Enter envia (submit nativo) e limpa.
+// Texto é estado interno (não controlado — controlar de fora só com demanda real,
+// precedente MediaPlayer/FileInput). Não envia texto vazio/só-espaço; o botão de
+// envio desabilita enquanto vazio. O input sempre tem nome acessível (aria-label),
+// pois placeholder não serve de nome. ponytail: input de uma linha; textarea +
+// Shift+Enter quando surgir demanda de multilinha.
+export function MessageComposer({ onSend, placeholder, label, icon, sendLabel, disabled, className }) {
+    const s = useAureaStrings();
+    const [text, setText] = React.useState("");
+    const submit = (e) => { e.preventDefault(); const t = text.trim(); if (!t)
+        return; onSend(t); setText(""); };
+    return _jsxs("form", { className: cx("message-composer", className), onSubmit: submit, children: [_jsxs("div", { className: "input-wrap", children: [icon && _jsx(Icon, { name: icon }), _jsx("input", { className: "input", value: text, disabled: disabled, placeholder: placeholder, "aria-label": label ?? s.chatMessage, onChange: e => setText(e.target.value) })] }), _jsx(IconButton, { type: "submit", variant: "primary", icon: "send", label: sendLabel ?? s.chatSend, disabled: disabled || !text.trim() })] });
+}

package/dist/data-display.d.ts

@@ -0,0 +1,23 @@
+import React, { type HTMLAttributes, type RefAttributes, type ReactNode } from "react";
+export { Kbd } from "./internal.js";
+export declare function KPI({ label, value, trend, className, ...props }: HTMLAttributes<HTMLDivElement> & RefAttributes<HTMLDivElement> & {
+    label: ReactNode;
+    value: ReactNode;
+    trend?: ReactNode;
+}): React.JSX.Element;
+export declare function DataList({ items }: {
+    items: Array<{
+        term: ReactNode;
+        value: ReactNode;
+    }>;
+}): React.JSX.Element;
+export declare function Timeline({ items }: {
+    items: Array<{
+        title: ReactNode;
+        description?: ReactNode;
+        time?: ReactNode;
+    }>;
+}): React.JSX.Element;
+export declare function Table({ caption, children, className, ...props }: HTMLAttributes<HTMLTableElement> & RefAttributes<HTMLTableElement> & {
+    caption?: ReactNode;
+}): React.JSX.Element;

package/dist/data-display.js

@@ -0,0 +1,13 @@
+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, useAureaStrings } from "./internal.js";
+import { Card } from "./layout.js";
+// Kbd é implementado em ./internal (o Button depende dele); a casa PÚBLICA dele é esta.
+export { Kbd } from "./internal.js";
+export function KPI({ label, value, trend, className, ...props }) { return _jsxs(Card, { className: cx("kpi", className), ...props, children: [_jsx("span", { className: "muted", children: label }), _jsx("strong", { children: value }), trend && _jsx("small", { children: trend })] }); }
+export function DataList({ items }) { return _jsx("dl", { className: "data-list", children: items.map((i, n) => _jsxs(React.Fragment, { children: [_jsx("dt", { children: i.term }), _jsx("dd", { children: i.value })] }, n)) }); }
+export function Timeline({ items }) { return _jsx("ol", { className: "timeline", children: items.map((i, n) => _jsxs("li", { children: [_jsx("span", { className: "timeline-dot" }), _jsxs("div", { children: [_jsx("strong", { children: i.title }), i.description && _jsx("p", { children: i.description }), i.time && _jsx("small", { className: "muted", children: i.time })] })] }, n)) }); }
+export function Table({ caption, children, className, ...props }) { const s = useAureaStrings(); return _jsx("div", { className: "table-region", role: "region", "aria-label": typeof caption === "string" ? caption : s.tableLabel, tabIndex: 0, children: _jsxs("table", { className: cx("table", className), ...props, children: [caption && _jsx("caption", { children: caption }), children] }) }); }

package/dist/data-grid.d.ts

@@ -0,0 +1,14 @@
+import React from "react";
+import { type ColumnDef } from "@tanstack/react-table";
+export type { ColumnDef } from "@tanstack/react-table";
+export declare function DataGrid<T>({ data, columns, label, filterable, pageSize, selectable, onSelectionChange, getRowId, className }: {
+    data: T[];
+    columns: Array<ColumnDef<T, any>>;
+    label?: string;
+    filterable?: boolean;
+    pageSize?: number;
+    selectable?: boolean;
+    onSelectionChange?: (rows: T[]) => void;
+    getRowId?: (row: T, index: number) => string;
+    className?: string;
+}): React.JSX.Element;