synthesisui 0.16.402 → 0.16.404

package/dist/commands/add.js

@@ -8,7 +8,7 @@ import { lockReference } from "../group-role.js";
 import { buildGuide } from "../guide.js";
 import { censusScope } from "../measured-scope.js";
 import { recallAvailable } from "../memory/availability.js";
-import { nextFontWeights } from "../next-font-weights.js";
+import { nextFontFacts } from "../next-font-weights.js";
 import { body as line, section, snippet } from "../output.js";
 import { fetchDesignSystem } from "../registry.js";
 import { repoStateOf } from "../repo-state.js";
@@ -242,8 +242,8 @@ export async function add(slug, opts) {
      * arquivo que o agente dele lê antes de escrever. `null` em projeto que não é Next é a resposta
      * certa, não uma falha - lá não existe `next/font` para ter peso nenhum.
      */
-    const fontWeights = await nextFontWeights(projectRoot);
-    await writeFile(join(versionDir, "GUIDE.md"), buildGuide(payload, tools.available, fontWeights), "utf8");
+    const fontFacts = await nextFontFacts(projectRoot);
+    await writeFile(join(versionDir, "GUIDE.md"), buildGuide(payload, tools.available, fontFacts), "utf8");
     // 4. stable root re-exports for each CSS artifact → always the active version,
     //    so the consumer's @import path never changes across updates
     const cssArtifacts = Object.keys(payload.artifacts).filter((f) => f.endsWith(".css") && !(f === "shadcn.css" && !wantsShadcn));
@@ -693,7 +693,7 @@ export async function add(slug, opts) {
             slug: payload.slug,
             appDir,
             seam: payload.fontSeam,
-            weights: fontWeights,
+            facts: fontFacts,
             declaredWeights: payload.document.foundations.typography.weights,
         })
         : null;
@@ -771,7 +771,7 @@ export async function add(slug, opts) {
                 slug: payload.slug,
                 appDir: dir,
                 seam: payload.fontSeam,
-                weights: fontWeights,
+                facts: fontFacts,
                 declaredWeights: payload.document.foundations.typography.weights,
             });
             if (!plan.ok)

package/dist/font-facts.spec-input.js

@@ -0,0 +1,24 @@
+/**
+ * UM `FontFacts` COMPLETO A PARTIR DO QUE VOCÊ QUER DIZER - a porta que faltava fechar.
+ *
+ * O SUFIXO `.spec-input` DECLARA A INTENÇÃO NO PONTO DE IMPORTAÇÃO - ver `reachable.spec.ts`: este
+ * módulo existe só para alimentar spec, e é uma CATEGORIA, não uma órfã que alguém esqueceu de
+ * ligar. Ele nunca entra em código de produto.
+ *
+ * `buildGuide` e `nextFontSnippet` fecharam "esquecer o ARGUMENTO"; ficou aberto "esquecer um CAMPO
+ * dele", e isso custou 35 testes: quando `subsetsOf` nasceu, as fixtures escritas à mão em dez
+ * lugares não a tinham, o `guide.spec.ts` parou de CARREGAR, e a suíte seguiu verde com o arquivo
+ * inteiro fora da contagem. Só o `tsc` pegava, e o `tsc` dos specs não é o portão de cada rodada.
+ *
+ * Quem escreve um teste diz só o que importa para ele; os outros campos vêm completos por
+ * construção, e um campo novo neste tipo passa a chegar em toda fixture sozinho.
+ */
+export function factsOf(over = {}) {
+    const weights = over.weights ?? ["400", "500", "600"];
+    const subsets = over.subsets ?? ["latin"];
+    return {
+        weightsOf: () => weights,
+        nameOf: (family) => over.names?.[family] ?? family,
+        subsetsOf: () => subsets,
+    };
+}

package/dist/fonts.js

@@ -1,4 +1,4 @@
-import { weightsToEmit } from "./next-font-weights.js";
+import { subsetsToEmit, weightsToEmit, } from "./next-font-weights.js";
 // Fallbacks genéricos do CSS - não são webfonts.
 const GENERIC_FAMILIES = new Set([
     "sans-serif",
@@ -89,7 +89,7 @@ export function googleFontsHref(families) {
  */
 export const FAMILY_SEAM_PREFIX = "--ds-typography-families-";
 export function nextFontSnippet(input) {
-    const { families, slug, appDir = "app", seam, weights, declaredWeights, } = input;
+    const { families, slug, appDir = "app", seam, facts, declaredWeights, } = input;
     /**
      * A ORDEM É DETERMINÍSTICA e os duplicados saem: isto vira uma linha de arquivo gerado, e um
      * conjunto que muda de ordem entre rodadas produz diff onde nada mudou.
@@ -114,26 +114,70 @@ export function nextFontSnippet(input) {
      * suposição que derrubou o build de um projeto real em 08/09. Um arquivo não escrito custa uma
      * frase ao cliente; um arquivo escrito errado custa o build dele.
      */
-    if (!weights)
+    if (!facts)
         return { ok: false, why: "manifest-unreadable", families: named };
-    const importName = (name) => firstFamily(name).replace(/ /g, "_");
-    const seen = new Map(); // family name -> const name
+    /**
+     * O IDENTIFICADOR SAI DA GRAFIA DO MANIFESTO, nunca de uma regra nossa - ver `FontFacts.nameOf`.
+     *
+     * A versão anterior fazia `replace(/ /g, "_")` sobre o nome como o documento DELE o escreve, e um
+     * `font-family: instrument serif` produzia `import { instrument_serif }`, que não existe. Uma
+     * capitalização "por palavra" trocaria esse defeito por outro: `IBM Plex Mono` sairia
+     * `Ibm_Plex_Mono`.
+     *
+     * E NÃO HÁ FALLBACK, de propósito. Uma família sem grafia conhecida é uma família que o manifesto
+     * não conhece, e ela segue o mesmo caminho de sempre: sai em `unknown`, sem linha escrita. Manter
+     * a heurística como último recurso deixaria a porta aberta para reescrever exatamente o import
+     * que quebra o build dele - vigiar em vez de fechar.
+     */
+    const importName = (canonical) => canonical.replace(/ /g, "_");
+    /**
+     * A DEDUPLICAÇÃO É PELA GRAFIA CANÔNICA, e não pelo texto dele - a porta que a canonização
+     * ABRIU, achada pela revisão deste PR.
+     *
+     * Medido: um documento com `display: "Geist"` e `body: "geist, sans-serif"` - dois papéis
+     * chegando à mesma família com caixa diferente, que é o normal quando o CSS dele foi escrito por
+     * mãos e épocas distintas - produzia
+     *
+     *     import { Geist, Geist } from "next/font/google";
+     *     SyntaxError: Identifier 'Geist' has already been declared
+     *
+     * Enquanto o identificador era composto do texto dele, as duas grafias davam dois nomes
+     * diferentes (`geist` e `Geist`) - inválidos, mas distintos. Canonizar o nome sem canonizar a
+     * CHAVE trocou "dois imports errados" por "um arquivo que não parseia": o mesmo EXIT=1 da
+     * `INV-VOLTA-16`, pela porta que este próprio conserto criou.
+     *
+     * A chave é a grafia do manifesto - a mesma resposta para as duas escritas dele.
+     */
+    const seen = new Map(); // canonical family -> const name
     const importNames = [];
     const consts = [];
     /** Família cujos pesos o manifesto não conhece: não se inventa peso para ela. */
     const unknown = [];
     for (const role of roles) {
         const name = firstFamily(families[role] ?? "");
-        if (!seen.has(name)) {
-            const available = weights(name);
+        const canonical = facts.nameOf(name);
+        if (!canonical || !seen.has(canonical)) {
+            const available = facts.weightsOf(name);
             const emit = available ? weightsToEmit(available, wanted) : [];
-            if (emit.length === 0) {
-                unknown.push(name);
+            if (emit.length === 0 || !canonical) {
+                if (!unknown.includes(name))
+                    unknown.push(name);
                 continue;
             }
-            seen.set(name, role);
-            importNames.push(importName(name));
-            consts.push(`export const ${seen.get(name)} = ${importName(name)}({`, `  subsets: ["latin"],`, 
+            /**
+             * OS SUBSETS TAMBÉM SÃO LIDOS - ver `subsetsToEmit`. Era `["latin"]` fixo, e o `next` reprova
+             * subset inexistente na MESMA função em que reprova peso inexistente: 121 das 1911 famílias
+             * do manifesto não têm `latin`, então a terceira porta deste módulo levava ao mesmo EXIT=1.
+             *
+             * Lista vazia significa que a família não declara subset nenhum, e aí a chave não é escrita:
+             * o `next` desliga o preload sozinho, e escrever `["latin"]` seria afirmar o que ela não tem.
+             */
+            const subsets = subsetsToEmit(facts.subsetsOf(name) ?? []);
+            seen.set(canonical, role);
+            importNames.push(importName(canonical));
+            consts.push(`export const ${role} = ${importName(canonical)}({`, ...(subsets.length > 0
+                ? [`  subsets: [${subsets.map((x) => `"${x}"`).join(", ")}],`]
+                : []), 
             /**
              * OS PESOS SÃO OS QUE A FAMÍLIA TEM - ver `next-font-weights.ts`.
              *
@@ -145,7 +189,7 @@ export function nextFontSnippet(input) {
              * `["400","500","600"]` de antes derrubou um `create-next-app` inteiro em 08/09. Os dois
              * defeitos são o mesmo erro - afirmar sobre a fonte dele em vez de ler.
              */
-            `  weight: [${emit.map((w) => `"${w}"`).join(", ")}],`, `  variable: "--font-ds-${seen.get(name)}",`, `});`);
+            `  weight: [${emit.map((w) => `"${w}"`).join(", ")}],`, `  variable: "--font-ds-${role}",`, `});`);
         }
     }
     /** Nenhuma família sobreviveu: o manifesto existe e não conhece nenhuma delas. */
@@ -156,20 +200,29 @@ export function nextFontSnippet(input) {
         `import { ${importNames.join(", ")} } from "next/font/google";`,
         ...consts,
     ];
-    const roleVar = (role) => {
+    /**
+     * A CONST QUE ESTE PAPEL USA - uma resposta só, e é o que impede as três leituras de divergirem.
+     *
+     * O `layout`, o mapa de CSS e o `roleVar` recompunham a chave cada um do seu jeito a partir do
+     * texto dele; com a deduplicação passando a ser canônica, três recomposições são três chances de
+     * uma delas citar uma const que o arquivo não exporta.
+     */
+    const constOf = (role) => {
         const name = firstFamily(families[role] ?? "");
-        return `--font-ds-${seen.get(name)}`;
+        const canonical = facts.nameOf(name);
+        return canonical ? seen.get(canonical) : undefined;
     };
+    const roleVar = (role) => `--font-ds-${constOf(role)}`;
     /**
      * SÓ AS VAGAS QUE VIRARAM CÓDIGO - uma família descartada por peso desconhecido não pode aparecer
      * no `layout` nem no mapa de CSS: o import citaria uma const que o `fonts.ts` não exporta, e o
      * projeto dele deixaria de compilar por causa da linha que a gente mandou colar.
      */
-    const emitted = roles.filter((role) => seen.has(firstFamily(families[role] ?? "")));
+    const emitted = roles.filter((role) => constOf(role) !== undefined);
     const layout = [
         `// ${appDir}/layout.tsx`,
-        `import { ${[...new Set(emitted.map((r) => seen.get(firstFamily(families[r] ?? ""))))].join(", ")} } from "./fonts";`,
-        `<body data-ds="${slug}" className={\`${[...new Set(emitted.map((r) => `\${${seen.get(firstFamily(families[r] ?? ""))}.variable}`))].join(" ")}\`}>`,
+        `import { ${[...new Set(emitted.map(constOf))].join(", ")} } from "./fonts";`,
+        `<body data-ds="${slug}" className={\`${[...new Set(emitted.map((r) => `\${${constOf(r)}.variable}`))].join(" ")}\`}>`,
     ];
     const css = [
         `/* ${appDir}/globals.css - AFTER the tokens.css import */`,

package/dist/guide.js

@@ -293,7 +293,7 @@ toolsReachable = false,
  * essa porta; deixá-la entreaberta um nível acima seria vigiá-la em vez de fechá-la
  * (CLAUDE.md, Parte I, seção 6).
  */
-fontWeights) {
+fontFacts) {
     const { document: doc, slug, name, version } = payload;
     const { meta, foundations, motion, components } = doc;
     const semanticRoles = Object.keys(foundations.color.semantic);
@@ -341,7 +341,7 @@ fontWeights) {
         families: foundations.typography.families,
         slug,
         seam: payload.fontSeam,
-        weights: fontWeights,
+        facts: fontFacts,
         /** Os pesos que ELE declara - ver `declaredWeights`. O guia é o arquivo que o agente dele cola. */
         declaredWeights: foundations.typography.weights,
     });

package/dist/install-marks.js

@@ -170,7 +170,7 @@
  * O que o cliente ganha ao rodar `upgrade`: o agente dele no Codex passa a poder PERGUNTAR ao
  * sistema, em vez de só receber as regras e adivinhar o resto.
  */
-export const MATERIALISER_SINCE = "0.16.402";
+export const MATERIALISER_SINCE = "0.16.403";
 /**
  * A ÚLTIMA VERSÃO EM QUE O QUE O HOOK RODA MUDOU.
  *

package/dist/next-font-weights.js

@@ -22,8 +22,9 @@
  * quebra para a fonte que não tem aquele corte. `Instrument Serif` tem exatamente um peso.
  *
  * ONDE MORA A RESPOSTA, e por isso ela não é nossa: o próprio `next` que o projeto dele instalou
- * carrega o manifesto que o `next/font` usa para VALIDAR. Medido no mesmo projeto: **1942
- * famílias**, cada uma com os pesos e estilos que existem. Ler dali significa que o que a gente
+ * carrega o manifesto que o `next/font` usa para VALIDAR. *MEDIÇÃO, e a população é a versão do
+ * `next` que o projeto instalou: **1942 famílias** no `create-next-app` de 08/09, **1911** no
+ * `next` 16.2.0 deste repositório.* Cada uma com os pesos, estilos e subsets que existem. Ler dali significa que o que a gente
  * emite é exatamente o que o compilador dele aceita - e que uma família nova do Google chega junto
  * com o `npm update` dele, sem release nosso.
  *
@@ -83,16 +84,25 @@ async function loadManifest(projectRoot) {
  * (`"instrument serif"` de um `font-family` em minúsculas é a mesma família), e o manifesto guarda
  * a grafia do Google.
  */
-export async function nextFontWeights(projectRoot) {
+export async function nextFontFacts(projectRoot) {
     const manifest = await loadManifest(projectRoot);
     if (!manifest)
         return null;
-    const byLower = new Map();
+    const weights = new Map();
+    const names = new Map();
+    const subsets = new Map();
     for (const [family, entry] of Object.entries(manifest)) {
-        const weights = (entry?.weights ?? []).filter((w) => /^\d+$/.test(w));
-        byLower.set(family.toLowerCase(), weights);
+        const key = family.toLowerCase();
+        weights.set(key, (entry?.weights ?? []).filter((w) => /^\d+$/.test(w)));
+        names.set(key, family);
+        subsets.set(key, entry?.subsets ?? []);
     }
-    return (family) => byLower.get(family.trim().toLowerCase()) ?? null;
+    const key = (family) => family.trim().toLowerCase();
+    return {
+        weightsOf: (family) => weights.get(key(family)) ?? null,
+        nameOf: (family) => names.get(key(family)) ?? null,
+        subsetsOf: (family) => subsets.get(key(family)) ?? null,
+    };
 }
 /**
  * OS PESOS A EMITIR para uma família, dados os que o gerador quer e os que existem.
@@ -112,3 +122,19 @@ export function weightsToEmit(available, wanted = ["400", "500", "600"]) {
     const nearest = [...have].sort((a, b) => Math.abs(Number(a) - 400) - Math.abs(Number(b) - 400))[0];
     return [nearest];
 }
+/**
+ * OS SUBSETS A PEDIR para uma família, dados os que ela tem.
+ *
+ * `latin` quando ela o tem - é o que o texto dele usa, e pedir mais baixaria arquivo para nada.
+ * Sem `latin` mas com outros, os que ela tem: as 11 famílias nessa situação têm exatamente um
+ * (`Chenla` e `Content` são `["khmer"]`), então pedir a lista dela é pedir o único que existe.
+ *
+ * `[]` quando ela não tem subset nenhum, e aí a chave NÃO é escrita: o `next` desliga o preload
+ * sozinho nesse caso, e escrever `["latin"]` seria afirmar sobre a fonte dele um subset que ela não
+ * declara - a afirmação que este módulo existe para não fazer.
+ */
+export function subsetsToEmit(available) {
+    if (available.includes("latin"))
+        return ["latin"];
+    return [...available];
+}

package/dist/sheet-needed.js

@@ -9,18 +9,89 @@ function themeNames(themeCss) {
             out.add(m[2]);
     return [...out];
 }
+/**
+ * O VALOR DE UM ATRIBUTO DE CLASSE, QUANDO ELE É UMA EXPRESSÃO - e a regra é o ATRIBUTO, não a
+ * função.
+ *
+ * O DEFEITO, medido em 08/09 nas duas árvores do `frontend-hub`: o leitor via `className="…"` e o
+ * template direto, e não via `className={cn("…")}`.
+ *
+ * ```
+ *                            packages/ui/src   apps/web-dashboard
+ * className=" literal              346              2639
+ * className={cn( ou {clsx(          66               239     <- invisíveis
+ * ```
+ *
+ * São **305 sítios** onde o projeto dele escreve classe e a pergunta *"algo aqui precisa da nossa
+ * folha?"* era respondida sobre um texto que não continha a resposta. E o erro caía para o lado
+ * ERRADO: o cabeçalho deste módulo declara que *"o lado seguro do erro é PRECISA"*, porque um falso
+ * positivo mantém o setup sendo pedido e um falso NEGATIVO entrega um componente sem a animação que
+ * ele veste. `cn()` é o idioma de quem parte do shadcn, então a metade que faltava era a maior parte
+ * de quem chega.
+ *
+ * POR QUE A REGRA NÃO É O NOME DA FUNÇÃO. Casar `cn|clsx|twMerge` seria a lista dos casos de hoje: o
+ * próximo cliente chama a dele de `classes`, `cx` ou nada - passa um ternário direto. O que é
+ * estrutural é o ATRIBUTO: dentro do valor de um `class`/`className`, toda string literal é
+ * candidata a classe, seja ela argumento de função, ramo de ternário ou pedaço de template.
+ *
+ * O QUE ISTO NÃO ALCANÇA, e está declarado com o número: a tabela de variantes que mora numa const
+ * separada - `cva(...)` e `tv(...)`, medidos em 08/09 como **4 + 41 e 0 + 85** nas duas árvores. Ali
+ * as classes chegam ao atributo por VARIÁVEL, e cobri-las exige seguir a variável até a declaração:
+ * é outra frente, e o erro dela continua caindo para o lado de cobrar.
+ */
+function attributeExpressions(source) {
+    const out = [];
+    const ATTR = /class(?:Name)?=\{/g;
+    for (const m of source.matchAll(ATTR)) {
+        let depth = 0;
+        let i = (m.index ?? 0) + m[0].length - 1;
+        const start = i;
+        /** Aspas contam para NÃO deixar uma chave dentro de string fechar a expressão cedo. */
+        let quote = null;
+        for (; i < source.length; i += 1) {
+            const c = source[i];
+            if (quote) {
+                if (c === "\\")
+                    i += 1;
+                else if (c === quote)
+                    quote = null;
+                continue;
+            }
+            if (c === '"' || c === "'" || c === "`")
+                quote = c;
+            else if (c === "{")
+                depth += 1;
+            else if (c === "}") {
+                depth -= 1;
+                if (depth === 0)
+                    break;
+            }
+        }
+        if (depth === 0)
+            out.push(source.slice(start + 1, i));
+    }
+    return out;
+}
 /** As classes escritas no código - `hover:animate-shimmer` conta como `animate-shimmer`. */
 function classesIn(source) {
     const out = new Set();
-    for (const m of source.matchAll(/class(?:Name)?=(?:"([^"]*)"|'([^']*)'|\{`([^`]*)`\}|\{"([^"]*)"\})/g)) {
-        const body = m[1] ?? m[2] ?? m[3] ?? m[4] ?? "";
+    const collect = (body) => {
         for (const raw of body.split(/\s+/)) {
             if (!raw)
                 continue;
             const bare = raw.split(":").pop() ?? raw;
             out.add(bare.replace(/^[!-]/, ""));
         }
-    }
+    };
+    for (const m of source.matchAll(/class(?:Name)?=(?:"([^"]*)"|'([^']*)'|\{`([^`]*)`\}|\{"([^"]*)"\})/g))
+        collect(m[1] ?? m[2] ?? m[3] ?? m[4] ?? "");
+    /**
+     * E TODA STRING DENTRO DA EXPRESSÃO - ver `attributeExpressions`. As três formas de escrever uma
+     * string em JS/TS, porque quem escolhe a aspa é o formatador dele, não a gente.
+     */
+    for (const expr of attributeExpressions(source))
+        for (const lit of expr.matchAll(/"([^"]*)"|'([^']*)'|`([^`]*)`/g))
+            collect(lit[1] ?? lit[2] ?? lit[3] ?? "");
     return out;
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "synthesisui",
-  "version": "0.16.402",
+  "version": "0.16.404",
   "description": "Bring SynthesisUI design systems into any project - tokens, typed components, whole pages and an agent-ready CLAUDE.md manifest.",
   "type": "module",
   "bin": {