synthesisui 0.16.310 → 0.16.312

package/dist/commands/component.js

@@ -9,7 +9,7 @@ import { body, section, snippet } from "../output.js";
 import { findCollision, reactMajorOf, readInstalledConvention, readInstalledScheme, } from "../project-facts.js";
 import { fetchComponent, RegistryError } from "../registry.js";
 import { flavourResolver } from "../styles-flavour.js";
-import { inTheirTongue, tongueOf } from "../their-tongue.js";
+import { inTheirTongue, projectTongue } from "../their-tongue.js";
 import { readCensus, unreadComment, unreadForComponent, } from "../unread-for-component.js";
 /**
  * Writes the shared `cn.ts` next to the components, built from THIS project's
@@ -98,7 +98,7 @@ export async function component(slug, name, opts) {
      * apagaria a cor. Um projeto de destino chega sem mapa no `.lock`, nada é traduzido, e a folha
      * continua sendo o caminho - o comando DIZ qual dos dois aconteceu.
      */
-    const tongue = await tongueFor(root, slug);
+    const tongue = await projectTongue(root, slug);
     const spoken = tongue ? inTheirTongue(res.css, tongue) : null;
     const css = spoken ? spoken.css : res.css;
     /**
@@ -325,35 +325,3 @@ export async function component(slug, name, opts) {
     }
     console.log("");
 }
-/**
- * O VOCABULÁRIO DESTE REPOSITÓRIO, do que o `add` já deixou na pasta - ver `tongueOf`.
- *
- * `null` quando não há mapa: é a resposta de um projeto de destino, de um repositório que nunca
- * buildou, ou de um install feito por um CLI anterior a 0.16.290. Nos três casos nada é traduzido e
- * a folha instalada continua sendo o caminho, que é o comportamento de sempre.
- */
-async function tongueFor(root, slug) {
-    const dir = join(root, "_synthesisui", "ds", slug);
-    const lock = await readFile(join(dir, ".lock"), "utf8").catch(() => null);
-    if (!lock)
-        return null;
-    let map = [];
-    let version = 0;
-    try {
-        const parsed = JSON.parse(lock);
-        map = parsed.tokenMap ?? [];
-        version = parsed.version ?? 0;
-    }
-    catch {
-        return null;
-    }
-    if (map.length === 0)
-        return null;
-    /**
-     * O VALOR COMPILADO MORA NA PASTA DA VERSÃO - a folha da raiz é um re-export de uma linha, escrito
-     * assim de propósito para que o `@import` dele nunca mude entre updates (ver `add.ts`). É de lá
-     * que sai o literal para as variáveis que não têm nome dele.
-     */
-    const installed = await readFile(join(dir, `v${version}`, "tokens.css"), "utf8").catch(() => "");
-    return tongueOf(map, installed);
-}

package/dist/commands/template.js

@@ -2,6 +2,7 @@ import { mkdir, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { readProjectConfig, resolveRegistry } from "../config.js";
 import { fetchTemplate } from "../registry.js";
+import { inTheirTongue, projectTongue } from "../their-tongue.js";
 /**
  * Materializes a whole page from a DS template into the project (hybrid
  * codegen-first): the server codegens deterministic files, we write them, and
@@ -27,14 +28,46 @@ export async function template(slug, name, opts) {
     const defaultDir = join("templates", asName ?? name);
     const pageRel = opts.out ?? join(defaultDir, pageFile.filename);
     const pageDir = dirname(join(root, pageRel));
+    /**
+     * NENHUMA MATERIALIZAÇÃO VAZA VOCABULÁRIO INTERNO (INV-VOLTA-02) - a mesma porta do
+     * `component`. Uma página inteira saía com `var(--ds-*)` cru enquanto um componente avulso
+     * falava a língua dele; a promessa é uma só. Sem mapa no `.lock`, nada é traduzido e a folha
+     * instalada continua sendo o caminho - e a saída diz qual dos dois aconteceu.
+     */
+    const tongue = await projectTongue(root, slug);
+    const speak = (code) => (tongue ? inTheirTongue(code, tongue) : null);
+    let named = 0;
+    let inlined = 0;
+    const still = new Set();
     await mkdir(pageDir, { recursive: true });
-    await writeFile(join(root, pageRel), pageFile.code, "utf8");
+    const spokenPage = speak(pageFile.code);
+    if (spokenPage) {
+        named += spokenPage.named;
+        inlined += spokenPage.inlined;
+        for (const l of spokenPage.left)
+            still.add(l);
+    }
+    await writeFile(join(root, pageRel), spokenPage ? spokenPage.css : pageFile.code, "utf8");
     console.log(`✓ wrote ${pageRel}  (${slug} v${generated.version})`);
     for (const f of siblings) {
         const rel = join(dirname(pageRel), f.filename);
-        await writeFile(join(root, rel), f.code, "utf8");
+        const spoken = speak(f.code);
+        if (spoken) {
+            named += spoken.named;
+            inlined += spoken.inlined;
+            for (const l of spoken.left)
+                still.add(l);
+        }
+        await writeFile(join(root, rel), spoken ? spoken.css : f.code, "utf8");
         console.log(`✓ wrote ${rel}`);
     }
+    if (named > 0 || inlined > 0) {
+        console.log(`  ${named} reference${named === 1 ? "" : "s"} now speak${named === 1 ? "s" : ""} the name YOUR code gives the value${inlined > 0 ? `, and ${inlined} carr${inlined === 1 ? "ies" : "y"} the value because your code names no token for it` : ""}.`);
+        if (still.size > 0) {
+            const sample = [...still].sort().slice(0, 3).join(", ");
+            console.log(`  ${still.size} still point${still.size === 1 ? "s" : ""} at our stylesheet (${sample}${still.size > 3 ? ", …" : ""}), so tokens.css is still needed here.`);
+        }
+    }
     console.log("");
     console.log("Next steps:");
     console.log(`  • use it in a route, e.g. ${join(config.pagesDir, "page.tsx")}:`);

package/dist/doctor/gap-triage.js

@@ -152,8 +152,10 @@ export function triageLedger(ledger, triagedBy) {
     };
 }
 /** `0.16.133` é mais velha que `0.16.134`. Compara número por número, e o que não é número não
- *  desempata nada - uma pré-release não é motivo para dizer que a medição está velha. */
-function isOlder(measured, current) {
+ *  desempata nada - uma pré-release não é motivo para dizer que a medição está velha.
+ *  Exportada porque é a TERCEIRA cópia desta pergunta (cli-version.ts e reinterpret.ts na web têm
+ *  as outras) e a auditoria de 26/08 a encontrou fora do twin-drift - agora ele a amarra. */
+export function isOlder(measured, current) {
     const parts = (v) => v.split(".").map((p) => Number.parseInt(p, 10));
     const a = parts(measured);
     const b = parts(current);

package/dist/guide.js

@@ -18,20 +18,6 @@ const kebab = (v) => v.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
 const cssProp = (v) => (/^[A-Z]/.test(v) ? "-" : "") + kebab(v);
 const list = (items) => items.length ? items.map((i) => `\`${i}\``).join(", ") : "_(none)_";
 const dataAttrs = (variants) => Object.entries(variants).map(([axis, opts]) => `data-${kebab(axis)}="${Object.keys(opts).join("|")}"`);
-// Famílias genéricas do CSS - fallbacks, não webfonts a carregar.
-const GENERIC_FAMILIES = new Set([
-    "sans-serif",
-    "serif",
-    "monospace",
-    "system-ui",
-    "ui-sans-serif",
-    "ui-serif",
-    "ui-monospace",
-    "cursive",
-    "fantasy",
-    "inherit",
-    "initial",
-]);
 /** Famílias custom do documento (display/body/mono), deduplicadas, sem genéricos. */
 /**
  * THE STRUCTURE, WITH WHAT EACH PART IS FOR AND WHEN IT EXISTS.

package/dist/their-tongue.js

@@ -45,3 +45,43 @@ export function tongueOf(map, installedCss) {
     }
     return { names, values };
 }
+/**
+ * NENHUMA MATERIALIZAÇÃO VAZA VOCABULÁRIO INTERNO - a regra da camada, num lugar só (dono, 26/08).
+ *
+ * Toda saída que escreve código no repositório dele passa por ESTA porta: carrega o vocabulário do
+ * projeto (`projectTongue`) e traduz (`inTheirTongue`). O `template` entregava páginas inteiras com
+ * `--ds-*` cru enquanto o `component` traduzia - a mesma promessa, duas implementações, uma delas
+ * ausente. Um mecanismo novo de materialização que chamar esta função já nasce coberto; um que não
+ * chamar é reprovado pelo gate (ver contracts/camada-6-volta.md, INV-VOLTA-02).
+ *
+ * `null` quando não há mapa: projeto de destino, repositório que nunca buildou, ou install anterior
+ * a 0.16.290. Nos três casos nada é traduzido e a folha instalada continua sendo o caminho - e quem
+ * chama DIZ qual dos dois aconteceu.
+ */
+export async function projectTongue(root, slug) {
+    const { readFile } = await import("node:fs/promises");
+    const { join } = await import("node:path");
+    const dir = join(root, "_synthesisui", "ds", slug);
+    const lock = await readFile(join(dir, ".lock"), "utf8").catch(() => null);
+    if (!lock)
+        return null;
+    let map = [];
+    let version = 0;
+    try {
+        const parsed = JSON.parse(lock);
+        map = parsed.tokenMap ?? [];
+        version = parsed.version ?? 0;
+    }
+    catch {
+        return null;
+    }
+    if (map.length === 0)
+        return null;
+    /**
+     * O VALOR COMPILADO MORA NA PASTA DA VERSÃO - a folha da raiz é um re-export de uma linha, escrito
+     * assim de propósito para que o `@import` dele nunca mude entre updates (ver `add.ts`). É de lá
+     * que sai o literal para as variáveis que não têm nome dele.
+     */
+    const installed = await readFile(join(dir, `v${version}`, "tokens.css"), "utf8").catch(() => "");
+    return tongueOf(map, installed);
+}

package/package.json

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