synthesisui 0.16.497 → 0.16.498

package/dist/commands/add.js

@@ -21,7 +21,7 @@ import { describeFiltered, ruleApplies, rulesForProject, } from "../rule-filter.
 import { detectStack, resolveDeps } from "../stack.js";
 import { onlyWhatMatched } from "../their-theme.js";
 import { tongueOf } from "../their-tongue.js";
-import { pointTokensAtTheirNames } from "../their-vars.js";
+import { namesTheyDeclare, pointTokensAtTheirNames } from "../their-vars.js";
 import { tracksAnyOf } from "../tracked.js";
 /**
  * QUAL METADE DESTA PASTA UM TIME COMMITA.
@@ -252,6 +252,22 @@ export async function add(slug, opts) {
     const theirVars = await pointTokensAtTheirNames(projectRoot, payload, 
     /** O que um build anterior provou - ver `provenBefore`. Sem build aqui, é a melhor prova que há. */
     (prev?.tokenMap ?? []).map((p) => p.theirs));
+    /**
+     * O PAR QUE O `init` DECLAROU CONTINUA (jornada "o pedido livre sai mastigado", 15/10).
+     *
+     * Num projeto novo o `init` escreve os nomes do sistema no `@theme` dele e grava cada par no `.lock`. O `connect`, logo
+     * em seguida, passa por aqui - e o cruzamento acima só reconhece o nome de mesmo formato (`--ds-color-sand-50` com
+     * `--color-sand-50`), não o papel (`--ds-color-semantic-primary` com `--color-primary`). O mapa caía de 91 para 27 pares,
+     * e o template voltava a 40 valores crus no hero. O par anterior fica enquanto o CSS dele ainda declara aquele nome: o
+     * nome sumiu, o par some junto.
+     */
+    const reproved = new Set(theirVars.pairs.map((p) => p.ours));
+    const before = (prev?.tokenMap ?? []).filter((p) => !reproved.has(p.ours));
+    const stillDeclared = await namesTheyDeclare(projectRoot, before.map((p) => p.theirs));
+    const tokenMap = [
+        ...theirVars.pairs,
+        ...before.filter((p) => stillDeclared.has(p.theirs)),
+    ];
     /**
      * O `theme.css` ALINHA ONDE HÁ O QUE ALINHAR - ver `onlyWhatMatched`.
      *
@@ -416,7 +432,7 @@ export async function add(slug, opts) {
          */
         ...(theirVars.pointed > 0 ? { theirVars: theirVars.pointed } : {}),
         /** Ver `RootLock.tokenMap`: o fato, ao lado do número que ele produz. */
-        ...(theirVars.pairs.length > 0 ? { tokenMap: theirVars.pairs } : {}),
+        ...(tokenMap.length > 0 ? { tokenMap } : {}),
         ...(scope ? { scope } : {}),
         ...(systems.length > 0 ? { scopes: systems } : {}),
         ...(usage.length > 0 ? { usage } : {}),

package/dist/commands/init.js

@@ -1,13 +1,12 @@
-import { DEFAULT_CONFIG, writeProjectConfig } from "../config.js";
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { DEFAULT_CONFIG, resolveRegistry, writeProjectConfig, } from "../config.js";
+import { readProjectTheme, writeBesideTheirs, writeNewProjectRoot, writeNewProjectTheme, } from "../new-project-theme.js";
 import { body, section, snippet } from "../output.js";
+import { fetchDesignSystem } from "../registry.js";
 import { resolveDeps, stylesFor, tailwindMajor } from "../stack.js";
 import { formMix, measuredStyle } from "../styles-flavour.js";
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
-import { readProjectTheme, writeBesideTheirs, writeNewProjectRoot, writeNewProjectTheme } from "../new-project-theme.js";
 import { add } from "./add.js";
-import { resolveRegistry } from "../config.js";
-import { fetchDesignSystem } from "../registry.js";
 const whereOf = (answer) => answer === "file" || answer === "1"
     ? "file"
     : answer === "separate" || answer === "2"
@@ -195,9 +194,13 @@ export async function init(opts) {
             const tokens = version !== null
                 ? await readFile(join(slugDir, `v${version}`, "tokens.css"), "utf8").catch(() => "")
                 : "";
-            const plan = tokens ? await readProjectTheme(root, tokens, opts.ds) : null;
+            const plan = tokens
+                ? await readProjectTheme(root, tokens, opts.ds)
+                : null;
             if (plan?.kind === "new" && version !== null) {
                 const theme = await writeNewProjectTheme(root, tokens, opts.ds, version);
+                if (theme.written)
+                    await recordDeclaredNames(slugDir, theme.pairs ?? []);
                 if (theme.written) {
                     console.log("");
                     console.log(`✓ ${theme.written}: ${theme.count} names of ${opts.ds} declared in your own @theme, with the values written - your project had none of its own. They are yours: bg-accent, p-md and rounded-lg now paint the system. Fonts come from the GUIDE's next/font recipe; the alternate scheme is not wired.`);
@@ -235,8 +238,14 @@ export async function init(opts) {
             const slugDir = join(root, "_synthesisui", "ds", opts.ds);
             const lock = JSON.parse(await readFile(join(slugDir, ".lock"), "utf8").catch(() => "{}"));
             const version = typeof lock.version === "number" ? lock.version : null;
-            const tokens = version !== null ? await readFile(join(slugDir, `v${version}`, "tokens.css"), "utf8").catch(() => "") : "";
-            const theme = tokens && version !== null ? await writeNewProjectRoot(root, tokens, opts.ds, version) : null;
+            const tokens = version !== null
+                ? await readFile(join(slugDir, `v${version}`, "tokens.css"), "utf8").catch(() => "")
+                : "";
+            const theme = tokens && version !== null
+                ? await writeNewProjectRoot(root, tokens, opts.ds, version)
+                : null;
+            if (theme?.written)
+                await recordDeclaredNames(slugDir, theme.pairs ?? []);
             if (theme?.written) {
                 console.log("");
                 console.log(`✓ ${theme.written}: ${theme.count} names of ${opts.ds} declared in your own :root, with the values written - your project had none of its own. They are yours: var(--color-primary) and var(--spacing-md) now paint the system.`);
@@ -267,3 +276,24 @@ export async function init(opts) {
     console.log("  • synthesisui add <slug>              bring a design system in");
     console.log("  • synthesisui template <slug> <name>  materialize a full page");
 }
+/**
+ * O QUE O `init` ACABOU DE DECLARAR VAI PARA O `.lock` (jornada "o pedido livre sai mastigado", 15/10).
+ *
+ * O `add` roda ANTES de o tema ser escrito, quando o projeto novo ainda não nomeia nada, e grava o `tokenMap` vazio. O
+ * `template` e o `component` traduzem pela mesma `tongue` que lê esse mapa - então a primeira landing de um projeto novo
+ * vinha com ~260 valores à mão (medido na rodada com agente de 15/10: "0 references now speak the name YOUR code gives
+ * the value, and 44 carry the value"), e o agente gastava rodadas convertendo-os de volta. Os pares aqui não são palpite:
+ * são os nomes que o próprio `init` escreveu, um a um, com o valor de cada um. O que o mapa já tinha continua.
+ */
+async function recordDeclaredNames(slugDir, pairs) {
+    if (pairs.length === 0)
+        return;
+    const path = join(slugDir, ".lock");
+    const lock = JSON.parse(await readFile(path, "utf8").catch(() => "{}"));
+    const known = new Set((lock.tokenMap ?? []).map((p) => p.ours));
+    const tokenMap = [
+        ...(lock.tokenMap ?? []),
+        ...pairs.filter((p) => !known.has(p.ours)),
+    ];
+    await writeFile(path, `${JSON.stringify({ ...lock, tokenMap }, null, 2)}\n`, "utf8");
+}

package/dist/install-marks.js

@@ -333,7 +333,12 @@
  * servidor diz que uma landing pedida em palavras livres passa primeiro pelo `landing`. Uma pasta escrita antes deixa o
  * agente decidir a página inteira sozinho.
  */
-export const MATERIALISER_SINCE = "0.16.497";
+/**
+ * 0.16.497 -> 0.16.498 em 15/10, e o passo 1 dá **SIM** (o pedido livre sai mastigado, a otimização): o `init` de um projeto
+ * novo grava no `.lock` os nomes que acabou de declarar, e o `template` e o `component` passam a escrevê-los - 51 nomes e 3
+ * valores crus no hero, contra 0 e 54 antes. Uma pasta escrita antes traz a landing com os valores à mão.
+ */
+export const MATERIALISER_SINCE = "0.16.498";
 /**
  * A ÚLTIMA VERSÃO EM QUE O QUE O HOOK RODA MUDOU.
  *

package/dist/new-project-theme.js

@@ -12,7 +12,15 @@ const BOILERPLATE = new Set([
     "--font-geist-sans",
     "--font-geist-mono",
 ]);
-const SKIP = new Set(["node_modules", ".next", "dist", "build", "out", "_synthesisui", "coverage"]);
+const SKIP = new Set([
+    "node_modules",
+    ".next",
+    "dist",
+    "build",
+    "out",
+    "_synthesisui",
+    "coverage",
+]);
 const TAILWIND_IMPORT = /@import\s+[\x22\x27]tailwindcss[\x22\x27]/;
 /**
  * O COMENTÁRIO DO CSS SE ESCREVE COM `\u002a` NO FONTE, e não com o asterisco - a guarda de
@@ -78,7 +86,9 @@ export async function writeNewProjectTheme(root, tokensCss, slug, version) {
         const withoutOurs = css.replace(END_RE(slug), "\n");
         for (const m of withoutOurs.matchAll(/(?:^|[{;\s])(--[a-zA-Z0-9_-]+)\s*:/g)) {
             const name = m[1];
-            if (!name.startsWith("--ds-") && !name.startsWith("--tw-") && !BOILERPLATE.has(name))
+            if (!name.startsWith("--ds-") &&
+                !name.startsWith("--tw-") &&
+                !BOILERPLATE.has(name))
                 own.add(name);
         }
     }
@@ -112,7 +122,11 @@ export async function writeNewProjectTheme(root, tokensCss, slug, version) {
     ].join("\n");
     const base = css.replace(END_RE(slug), "\n").replace(/\n*$/, "\n");
     await writeFile(path, `${base}\n${block}\n`, "utf8");
-    return { written: relative(root, path).split("\\").join("/"), count: lines.length };
+    return {
+        written: relative(root, path).split("\\").join("/"),
+        count: lines.length,
+        pairs: systemPairs(tokensCss, (await readTheirs(root, slug)).every),
+    };
 }
 /**
  * O VOCABULÁRIO DELE E O CSS GLOBAL, para quem escreve nomes fora do `init` - o `colours` (etapa 05, 28/09). A mesma
@@ -176,11 +190,17 @@ export async function writeNewProjectRoot(root, tokensCss, slug, version) {
     ].join("\n");
     const base = css.replace(END_RE(slug), "\n").replace(/\n*$/, "\n");
     await writeFile(path, `${base}\n${block}\n`, "utf8");
-    return { written: relative(root, path).split("\\").join("/"), count: lines.length };
+    return {
+        written: relative(root, path).split("\\").join("/"),
+        count: lines.length,
+        pairs: systemPairs(tokensCss, r.every),
+    };
 }
 const importLine = (slug) => `@import "./${slug}.css";`;
 /** O CSS dele sem nada nosso: sem o bloco e sem a linha que importa o arquivo à parte. */
-const withoutOurs = (css, slug) => css.replace(END_RE(slug), "\n").replace(new RegExp(`^${escape(importLine(slug))}\\n`, "m"), "");
+const withoutOurs = (css, slug) => css
+    .replace(END_RE(slug), "\n")
+    .replace(new RegExp(`^${escape(importLine(slug))}\\n`, "m"), "");
 async function readTheirs(root, slug) {
     const sheets = await sheetsOf(root);
     const raw = new Map();
@@ -228,10 +248,13 @@ async function readTheirs(root, slug) {
     const everyRaw = new Map(raw);
     for (const full of sheets.values())
         for (const m of full.matchAll(/(?:^|[{;\s])(--[a-zA-Z0-9_-]+)\s*:\s*([^;}]+)/g))
-            if (!everyRaw.has(m[1]) && !m[1].startsWith("--ds-"))
+            if (!everyRaw.has(m[1]) &&
+                !m[1].startsWith("--ds-"))
                 everyRaw.set(m[1], m[2].trim());
     const every = resolved(everyRaw);
-    const entries = [...sheets].filter(([, css]) => TAILWIND_IMPORT.test(css)).map(([p]) => p);
+    const entries = [...sheets]
+        .filter(([, css]) => TAILWIND_IMPORT.test(css))
+        .map(([p]) => p);
     const rel = (p) => relative(root, p).split("\\").join("/");
     const top = [...counts].sort((a, b) => b[1] - a[1])[0];
     const entry = entries.length === 1 ? entries[0] : null;
@@ -254,6 +277,21 @@ async function readTheirs(root, slug) {
  * criou (`--ds-color-amber-400: var(--color-amber-400)`). Pular essas linhas encolhia o bloco na segunda
  * rodada: medido na prova de 27/09, 82 nomes viraram 38.
  */
+/** Os mesmos nomes de `systemNames`, com a variável nossa ao lado - o par que o `.lock` guarda. */
+function systemPairs(tokensCss, lookup = new Map()) {
+    const { names, values } = tongueOf([], tokensCss);
+    const out = [];
+    for (const ours of new Set([...values.keys(), ...names.keys()])) {
+        const theirs = theirNameFor(ours);
+        if (!theirs)
+            continue;
+        const pointed = names.get(ours);
+        const value = pointed ? lookup.get(pointed) : values.get(ours);
+        if (value && !value.includes("var(--ds-"))
+            out.push({ ours, theirs, value });
+    }
+    return out;
+}
 function systemNames(tokensCss, lookup = new Map()) {
     const { names, values } = tongueOf([], tokensCss);
     const out = [];
@@ -273,7 +311,9 @@ export async function readProjectTheme(root, tokensCss, slug) {
     const r = await readTheirs(root, slug);
     const base = { entry: r.entry, tokensFile: r.tokensFile };
     const colourValues = [
-        ...new Set(systemNames(tokensCss, r.every).filter(([n]) => n.startsWith("--color-")).map(([, v]) => v.toLowerCase())),
+        ...new Set(systemNames(tokensCss, r.every)
+            .filter(([n]) => n.startsWith("--color-"))
+            .map(([, v]) => v.toLowerCase())),
     ];
     const held = new Set([...r.values.values()].map((v) => v.trim().toLowerCase()));
     const matched = colourValues.filter((v) => held.has(v)).length;
@@ -284,7 +324,11 @@ export async function readProjectTheme(root, tokensCss, slug) {
         return { kind: "many-tailwind-entries", ...counts, ...base };
     if (r.own.size === 0)
         return { kind: "new", ...counts, ...base };
-    return { kind: matched * 2 >= colourValues.length && matched > 0 ? "matches" : "differs", ...counts, ...base };
+    return {
+        kind: matched * 2 >= colourValues.length && matched > 0 ? "matches" : "differs",
+        ...counts,
+        ...base,
+    };
 }
 /**
  * O BLOCO DO SISTEMA AO LADO DO DELE - o terceiro caso.
@@ -305,7 +349,9 @@ export async function readProjectTheme(root, tokensCss, slug) {
 export async function writeBesideTheirs(root, tokensCss, slug, version, where) {
     const r = await readTheirs(root, slug);
     const entryPath = r.entry ? join(root, r.entry) : null;
-    const separatePath = entryPath ? join(dirname(entryPath), `${slug}.css`) : null;
+    const separatePath = entryPath
+        ? join(dirname(entryPath), `${slug}.css`)
+        : null;
     /** Tira de todo lugar o que é nosso, antes de escrever no lugar escolhido. */
     const cleaned = new Map();
     for (const [path, css] of r.sheets) {
@@ -317,7 +363,9 @@ export async function writeBesideTheirs(root, tokensCss, slug, version, where) {
         for (const [path, css] of cleaned)
             if (css !== r.sheets.get(path))
                 await writeFile(path, css, "utf8");
-        if (separatePath && r.sheets.get(separatePath)?.startsWith(begin(slug)) && where !== "separate")
+        if (separatePath &&
+            r.sheets.get(separatePath)?.startsWith(begin(slug)) &&
+            where !== "separate")
             await rm(separatePath, { force: true });
     };
     const empty = { written: null, collisions: [], throughInline: [], added: 0 };
@@ -332,7 +380,9 @@ export async function writeBesideTheirs(root, tokensCss, slug, version, where) {
     }
     const missing = system.filter(([n]) => !r.own.has(n) && !r.values.has(n));
     const collisions = system
-        .filter(([n, v]) => r.values.has(n) && !r.inline.has(n) && !same(r.values.get(n), v))
+        .filter(([n, v]) => r.values.has(n) &&
+        !r.inline.has(n) &&
+        !same(r.values.get(n), v))
         .map(([n]) => n);
     const throughInline = [];
     const scoped = system.map(([n, v]) => {
@@ -346,7 +396,9 @@ export async function writeBesideTheirs(root, tokensCss, slug, version, where) {
     const block = [
         begin(slug),
         open(`${slug} v${version}, beside your own tokens. The @theme adds only the names your project did not have; inside the data-theme selector below every value is the system's, including the names you already use, which keep their value everywhere else. Written by \`init\`, where you chose.`),
-        ...(missing.length > 0 ? ["@theme {", ...missing.map(([n, v]) => `  ${n}: ${v};`), "}", ""] : []),
+        ...(missing.length > 0
+            ? ["@theme {", ...missing.map(([n, v]) => `  ${n}: ${v};`), "}", ""]
+            : []),
         `[data-theme="${slug}"] {`,
         ...scoped,
         "}",

package/dist/their-vars.js

@@ -1,6 +1,6 @@
 import { readdir, readFile } from "node:fs/promises";
-import { readStyleSheet } from "./doctor/scss-lens.js";
 import { join } from "node:path";
+import { readStyleSheet } from "./doctor/scss-lens.js";
 import { theirNames } from "./doctor/their-names.js";
 import { buildTable, normalizeValue, } from "./doctor/tokens.js";
 import { FAMILY_SEAM_PREFIX } from "./fonts.js";
@@ -268,3 +268,13 @@ export function danglingTheirVars(installedCss, theirs) {
     }
     return out;
 }
+/**
+ * OS NOMES QUE O CSS DELE AINDA DECLARA, dentre os pedidos - para o `add` não apagar o par que o `init` gravou
+ * (jornada "o pedido livre sai mastigado", 15/10). Ver o uso em `commands/add.ts`.
+ */
+export async function namesTheyDeclare(root, names) {
+    if (names.length === 0)
+        return new Set();
+    const theirs = await harvestTheirCss(root);
+    return new Set(names.filter((n) => theirs.byName.has(n)));
+}

package/package.json

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