synthesisui 0.16.182 → 0.16.184

package/dist/commands/doctor.js

@@ -922,11 +922,17 @@ export async function doctor(opts) {
             for (const r of repeats) {
                 const where = `${r.count}\u00d7 in ${r.files} file${r.files === 1 ? "" : "s"}`;
                 const near = r.token ? null : nearestToken(table, r.literal);
-                const named = r.token
-                    ? `  → ${r.token}`
-                    : near
-                        ? `  → nearest is ${near.name} (${near.value})`
-                        : "";
+                /**
+                 * COINCIDÊNCIA NÃO É RESPOSTA - ver `crossFamily` em `scan.ts`. Para aquele `kind` o
+                 * sistema não tem nome; o valor mora noutra família, e dizer só a seta afirma o contrário.
+                 */
+                const named = r.crossFamily
+                    ? `  → no ${r.kind} named for it · the value lives as ${r.token}`
+                    : r.token
+                        ? `  → ${r.token}`
+                        : near
+                            ? `  → nearest is ${near.name} (${near.value})`
+                            : "";
                 say(`      ${r.literal.padEnd(w)}  ${where}${named}`);
             }
         }
@@ -942,11 +948,13 @@ export async function doctor(opts) {
                 // A dead end with a neighbour is not a dead end. Only for lengths -
                 // "nearly the same blue" is the guess this tool must never make.
                 const near = x.token ? null : nearestToken(table, x.literal);
-                const named = x.token
-                    ? `→ ${x.token}`
-                    : near
-                        ? `→ nearest is ${near.name} (${near.value})`
-                        : "→ no token holds this value yet";
+                const named = x.crossFamily
+                    ? `→ no ${x.kind} named for it · the value lives as ${x.token}`
+                    : x.token
+                        ? `→ ${x.token}`
+                        : near
+                            ? `→ nearest is ${near.name} (${near.value})`
+                            : "→ no token holds this value yet";
                 say(`      ${String(x.line).padStart(4)}  ${x.literal}  ${named}`);
             }
             if (f.findings.length > shown.length) {
@@ -1264,8 +1272,19 @@ export async function doctor(opts) {
      * mentir por omissão. Muda a ordem e muda quantos de cada aparecem no teto de cinco.
      */
     const migrating = intent.intent === "migrate";
-    const named = d.repeats.filter((x) => x.token);
-    const unnamed = d.repeats.filter((x) => !x.token);
+    /**
+     * UMA COINCIDÊNCIA NÃO ENTRA NA LISTA DE BARATOS - ver `crossFamily` em `scan.ts`.
+     *
+     * A lista dos "cheap" existe para quem tem dez minutos: trocar o literal pelo token e pronto. Um
+     * match de outra família não é isso - `--fix` o recusa, e o trabalho ali é decidir se aquele
+     * `kind` merece um nome. Medido no repo do dono em 08/08: `2rem` era oferecido como raio porque
+     * existe como degrau de tipo, dez vezes.
+     *
+     * Ele não some: vai para o grupo de quem NÃO tem nome, que é literalmente o que ele é para
+     * aquele kind - e a linha diz onde o valor mora hoje.
+     */
+    const named = d.repeats.filter((x) => x.token && !x.crossFamily);
+    const unnamed = d.repeats.filter((x) => !x.token || x.crossFamily);
     for (const r of named.slice(0, migrating ? 2 : 3)) {
         plan.push({
             rank: migrating ? 4 : 3,
@@ -1280,7 +1299,9 @@ export async function doctor(opts) {
             rank: migrating ? 3 : 4,
             what: near
                 ? `${r.literal} - name it, or snap to ${near.name}`
-                : `${r.literal} - the system has no name for it`,
+                : r.crossFamily
+                    ? `${r.literal} - no ${r.kind} named for it, and the value lives as ${r.token} in another family`
+                    : `${r.literal} - the system has no name for it`,
             size: `${r.files} file${r.files === 1 ? "" : "s"}`,
             cheap: false,
         });

package/dist/doctor/ci-format.js

@@ -82,7 +82,9 @@ export function compareToBaseline(d, base, now) {
 /** O que a mensagem de uma anotação diz, e é a mesma frase nos dois formatos. */
 function messageFor(f) {
     return f.token
-        ? `${f.literal} is written by hand, and this project's system already names it: var(${f.token}). Use the token.`
+        ? f.crossFamily
+            ? `${f.literal} is written by hand, and this project's system has no ${f.kind} named for it. The value does exist elsewhere in the system - as \`${f.token}\`, in another family - so this is a decision to make, not a swap: name a ${f.kind}, or leave it.`
+            : `${f.literal} is written by hand, and this project's system already names it: var(${f.token}). Use the token.`
         : `${f.literal} is a ${f.kind} value written by hand, and the system has no name for it yet. Name it, or file a token request: npx synthesisui request token`;
 }
 /**

package/dist/doctor/scan.js

@@ -489,6 +489,7 @@ export function diagnose(files) {
                 token: f.token,
                 count: 1,
                 files: new Set([f.file]),
+                ...(f.crossFamily ? { crossFamily: true } : {}),
             });
         }
     }
@@ -499,6 +500,7 @@ export function diagnose(files) {
         token: v.token,
         count: v.count,
         files: v.files.size,
+        ...(v.crossFamily ? { crossFamily: true } : {}),
     }))
         .filter((r) => r.count > 1)
         .sort((a, b) => b.count - a.count);

package/dist/doctor/style-ledger.js

@@ -83,6 +83,7 @@ export function buildLedger(cli, seen) {
             files: 0,
             because: BECAUSE[reason],
             examples: [],
+            unreadable: [],
             seenFiles: new Set(),
         };
         group.uses += 1;
@@ -94,6 +95,30 @@ export function buildLedger(cli, seen) {
                 line: f.line,
                 text: f.text.replace(/\s+/g, " ").trim().slice(0, 160),
             });
+        /**
+         * SÓ `shape-not-read`, E SÓ TEXTO DISTINTO - as duas restrições vieram de medir, não de supor.
+         *
+         * DAS QUATRO RAZÕES, uma só é alcançável por um leitor novo. `value-not-read` diz que a forma FOI
+         * lida e o valor está fora das escalas deles - texto não ensina nada a leitor nenhum. `computed`
+         * é montado em runtime e não existe na fonte. `component-not-admitted` é o portão, não a leitura.
+         * Sobra `shape-not-read`: "nenhum leitor desta versão entende esta forma", que é exatamente a
+         * frase que um leitor novo responde.
+         *
+         * E TEXTO DISTINTO, porque a primeira versão disto reprovou no spec do repo vivo: guardar todo
+         * fragmento deu 723 215 bytes no dashboard dele, contra um teto de 65 536. Oito mil cópias da
+         * mesma string não ensinam mais que uma - o que um leitor precisa é da variedade de FORMAS.
+         *
+         * O teto de 512 é declarado e não mudo: `uses` continua contando tudo, então a diferença entre o
+         * contado e o que viajou é visível em vez de silenciosa.
+         */
+        if (reason === "shape-not-read" &&
+            group.unreadable.length < 512 &&
+            !group.unreadable.some((u) => u.text === f.text))
+            group.unreadable.push({
+                file: f.file,
+                line: f.line,
+                text: f.text.replace(/\s+/g, " ").trim().slice(0, 400),
+            });
         groups.set(key, group);
     }
     return {

package/package.json

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