synthesisui 0.16.402 → 0.16.403

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/package.json

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