synthesisui 0.16.342 → 0.16.344

package/dist/commands/doctor.js

@@ -8,7 +8,7 @@ import { emptyTally, internalSpecifiers, scanComponentsInto, tallyToInventory, }
 import { checkContracts } from "../doctor/contract-check.js";
 import { describeMissing, missingDependencies, summarizeMissing, } from "../doctor/dependencies.js";
 import { findFrozenBindings } from "../doctor/frozen.js";
-import { appendEvent, COVERAGE_RULE, readEvents, suggestionsFrom, unrepresentedFrom, summarize, } from "../doctor/ledger.js";
+import { appendEvent, COVERAGE_RULE, readEvents, suggestionsFrom, summarize, unrepresentedFrom, } from "../doctor/ledger.js";
 import { bindingsFromDocument, countComponents, findOverrides, } from "../doctor/overrides.js";
 import { checkableName, readRequests, verifyAndCloseRequests, } from "../doctor/requests.js";
 import { DEFAULT_ROOT_PX, rootSizeOf, saidOfRoot, } from "../doctor/root-size.js";
@@ -156,6 +156,28 @@ export async function* walkAll(roots) {
  * doctor como se fosse um componente pedido. Uma tela que rotula errado é pior que uma que não
  * rotula: quem lê decide em cima do rótulo.
  */
+/**
+ * O EMPATE DITO EM VOZ ALTA - a metade que faltava do nome dele.
+ *
+ * O QUE ELE PERDIA: quando mais de um token DELE segura o mesmo valor, a esteira desempata por
+ * critérios lidos do repositório dele e o relatório imprimia só o vencedor, `→ {color.tier-gold}`,
+ * como se fosse fato. No sistema do dono aquele `#f59e0b` é `--color-tier-gold` E
+ * `--color-feedback-warning` - gamificação e estado, dois conceitos dele com o mesmo hex -, e a
+ * escolha entre eles nunca foi dele. Medido em 31/08 nos 26 sistemas do banco: 7 (27%) têm ao
+ * menos um valor com mais de um nome.
+ *
+ * A ESCOLHA CONTINUA SENDO FEITA, porque o `--fix` precisa de UM nome para escrever. O que muda é
+ * que ela para de passar por fato: ele vê que houve empate e pode discordar com informação, que é
+ * a diferença entre uma lacuna declarada e um silêncio.
+ *
+ * UM SÓ É NOMEADO, o resto vira contagem: dois nomes cabem na linha, cinco viram uma parede que
+ * ninguém lê - e o número já diz que a decisão existe.
+ */
+const alsoNamed = (f) => !f.theirAlso?.length
+    ? ""
+    : f.theirAlso.length === 1
+        ? ` · you also call it ${f.theirAlso[0]}`
+        : ` · you also call it ${f.theirAlso[0]} and ${f.theirAlso.length - 1} other${f.theirAlso.length - 1 === 1 ? "" : "s"}`;
 function requestLabel(r) {
     if (r.kind === "token")
         return `token ${r.value} as ${r.name}`;
@@ -1314,7 +1336,7 @@ export async function doctor(opts) {
                 const named = r.crossFamily && !r.theirToken
                     ? `  → no ${r.kind} named for it · the value lives as ${r.token}`
                     : nameToWrite(r)
-                        ? `  → ${nameToWrite(r)}`
+                        ? `  → ${nameToWrite(r)}${alsoNamed(r)}`
                         : near
                             ? `  → nearest is ${near.theirs ?? near.name} (${near.value})`
                             : "";
@@ -1338,7 +1360,7 @@ export async function doctor(opts) {
                 const named = x.crossFamily && !x.theirToken
                     ? `→ no ${x.kind} named for it · the value lives as ${x.token}`
                     : nameToWrite(x)
-                        ? `→ ${nameToWrite(x)}`
+                        ? `→ ${nameToWrite(x)}${alsoNamed(x)}`
                         : near
                             ? `→ nearest is ${near.theirs ?? near.name} (${near.value})`
                             : "→ no token holds this value yet";

package/dist/commands/mcp.js

@@ -404,9 +404,9 @@ async function findToken(root, value) {
      */
     const theirNameFor = (v) => {
         const norm = normalizeValue(v, table.rootPx);
-        for (const [key, name] of table.aliases)
+        for (const [key, theirs] of table.aliases)
             if (key.endsWith(`:${norm}`))
-                return name;
+                return theirs.name;
         return null;
     };
     const exact = tokenFor(table, value);

package/dist/doctor/scan.js

@@ -420,7 +420,8 @@ function scanCore(file, source, table) {
                 ...(/(?<!r)em$/i.test(literal.trim())
                     ? { fontRelative: true }
                     : {}),
-                ...(theirs ? { theirToken: theirs } : {}),
+                ...(theirs ? { theirToken: theirs.name } : {}),
+                ...(theirs?.also.length ? { theirAlso: theirs.also } : {}),
                 /**
                  * A COINCIDÊNCIA VIAJA COM O ACHADO - ver `tokenMatch`.
                  *
@@ -609,6 +610,7 @@ export function diagnose(files) {
                 kind: f.kind,
                 token: f.token,
                 ...(f.theirToken ? { theirToken: f.theirToken } : {}),
+                ...(f.theirAlso?.length ? { theirAlso: f.theirAlso } : {}),
                 ...(f.fontRelative ? { fontRelative: true } : {}),
                 count: 1,
                 files: new Set([f.file]),
@@ -622,6 +624,7 @@ export function diagnose(files) {
         kind: v.kind,
         token: v.token,
         ...(v.theirToken ? { theirToken: v.theirToken } : {}),
+        ...(v.theirAlso?.length ? { theirAlso: v.theirAlso } : {}),
         ...(v.fontRelative ? { fontRelative: true } : {}),
         count: v.count,
         files: v.files.size,

package/dist/doctor/their-names.js

@@ -98,6 +98,18 @@ function pick(candidates, ours, convention) {
  * `24px` pode ser raio, espaçamento ou tamanho de fonte, e sem um token nosso não há o que validasse.
  * Esses continuam saindo como "no name for it", que é verdade e é o caminho do `absorb`.
  */
+/**
+ * O VENCEDOR E OS PRETERIDOS, juntos - porque um empate silencioso é o defeito.
+ *
+ * `pick` escolhe entre nomes DELE por critérios lidos do repositório dele, e isso continua certo:
+ * o achado precisa de UM nome para escrever. O que estava errado era descartar os outros. No
+ * sistema do dono, `#f59e0b` é `--color-tier-gold` E `--color-feedback-warning` - dois conceitos
+ * dele, gamificação e estado -, e o relatório dizia `→ {color.tier-gold}` como se fosse fato.
+ */
+function escolha(candidates, ours, convention) {
+    const name = pick(candidates, ours, convention);
+    return { name, also: candidates.filter((c) => c !== name) };
+}
 export function theirNames(ours, theirs) {
     const out = new Map();
     if (theirs.byName.size === 0)
@@ -139,7 +151,7 @@ export function theirNames(ours, theirs) {
                 : candidates.filter((n) => familySays(kind, n));
             if (usable.length === 0)
                 continue;
-            out.set(key, pick(usable, name, convention));
+            out.set(key, escolha(usable, name, convention));
         }
     }
     for (const [value, candidates] of theirs.byValue) {
@@ -149,7 +161,7 @@ export function theirNames(ours, theirs) {
             const key = `${kind}:${value}`;
             if (out.has(key))
                 continue;
-            out.set(key, pick(candidates, null, convention));
+            out.set(key, escolha(candidates, null, convention));
         }
     }
     return out;

package/dist/doctor/tokens.js

@@ -418,7 +418,7 @@ kind) {
     const theirs = kind
         ? table.aliases.get(`${kind}:${normalizeValue(best.value, table.rootPx)}`)
         : undefined;
-    return theirs ? { ...best, theirs } : best;
+    return theirs ? { ...best, theirs: theirs.name } : best;
 }
 /**
  * The family a token belongs to, from the drift it was found in.

package/dist/doctor/transcribe.js

@@ -2029,8 +2029,27 @@ export function definitionSpan(source, name) {
     const decl = new RegExp(`(?:function|const|let|var)\\s+${name}\\b|${name}\\s*[:=]\\s*(?:function|\\()`).exec(source);
     if (!decl)
         return null;
+    /**
+     * O CORPO PODE NÃO TER CHAVE NENHUMA - `forwardRef((props, ref) => (<div/>))`.
+     *
+     * O QUE O CLIENTE PERDIA: esta é a forma canônica de uma biblioteca de componentes (o shadcn/ui
+     * escreve assim), e para ela `bodyBrace` não acha `{` de corpo - o arrow retorna direto. O span
+     * voltava `null`, e sem span `variantCallsIn` devolve lista vazia: a tabela `cva` do componente
+     * NÃO era ligada a ele, e o censo gravava classe vazia num componente que declara seis linhas de
+     * base. Ele abre o Studio e vê a caixa pelada.
+     *
+     * REPRODUZIDO EM 31/08, com a mesma tabela e o mesmo call site, variando só o corpo:
+     *
+     *     forwardRef(({ s }, ref) => { return <div className={cn(v({s}))}/> })   a tabela e' ligada
+     *     forwardRef(({ s }, ref) => (<div className={cn(v({s}))}/>))            lista VAZIA
+     *
+     * O corpo aqui é delimitado pelo parêntese do PRÓPRIO wrapper, e é ele que fecha o span.
+     */
     const brace = bodyBrace(source, decl.index);
     if (brace === -1) {
+        const implicito = implicitBodySpan(source, decl.index);
+        if (implicito)
+            return { from: decl.index, to: implicito };
         // The export is an alias; the body belongs to what it wraps.
         const target = aliasTarget(source, name);
         if (target)
@@ -2040,6 +2059,52 @@ export function definitionSpan(source, name) {
     const end = matchingBrace(source, brace);
     return { from: decl.index, to: end === -1 ? source.length : end + 1 };
 }
+/**
+ * ONDE FECHA UM CORPO SEM CHAVE - `= forwardRef((props, ref) => (<div/>))`, e nada mais.
+ *
+ * Ela só responde para a forma que `bodyBrace` não sabe ler: um wrapper reconhecido, seguido de um
+ * arrow cujo corpo abre em PARÊNTESE. Um arrow com chaves, uma função nomeada ou qualquer outra
+ * coisa devolve `null` e o caminho antigo segue intacto - esta é uma porta a mais, nunca um desvio
+ * do que já funcionava.
+ *
+ * O fecho é o parêntese do próprio wrapper, contado com atenção a aspas: um `)` dentro de
+ * `color = "rgba(0,0,0,.2)"` não fecha nada, e foi essa mesma armadilha que já custou a raiz de
+ * sete componentes de um cliente.
+ */
+function implicitBodySpan(source, declAt) {
+    const head = source.slice(declAt, declAt + 400);
+    const wrapper = /=\s*(?:React\.)?(?:forwardRef|memo|styled\([^)]*\))\s*(?:<[^(]*>)?\s*\(/.exec(head);
+    if (!wrapper)
+        return null;
+    const open = declAt + wrapper.index + wrapper[0].length - 1;
+    const rest = source.slice(open);
+    const arrow = /=>\s*[({]/.exec(rest);
+    /** Corpo em chave é do `bodyBrace`; aqui só entra o retorno implícito. */
+    if (!arrow || arrow[0].trimEnd().endsWith("{"))
+        return null;
+    let depth = 0;
+    let quote = null;
+    for (let i = open; i < source.length; i++) {
+        const ch = source[i];
+        if (quote) {
+            if (ch === "\\")
+                i += 1;
+            else if (ch === quote)
+                quote = null;
+            continue;
+        }
+        if (ch === '"' || ch === "'" || ch === "`")
+            quote = ch;
+        else if (ch === "(")
+            depth += 1;
+        else if (ch === ")") {
+            depth -= 1;
+            if (depth === 0)
+                return i + 1;
+        }
+    }
+    return null;
+}
 /** The `{` that opens a function body declared at `declAt`, or -1. */
 function bodyBrace(source, declAt) {
     /**

package/dist/their-vars.js

@@ -115,7 +115,7 @@ export function pointAtTheirNames(css, theirs, resolvable) {
         const kind = Object.entries(FAMILY_KIND).find(([prefix]) => name.startsWith(prefix))?.[1];
         if (!kind)
             return line;
-        const theirName = alias.get(`${kind}:${normalizeValue(value.trim(), ours.rootPx)}`);
+        const theirName = alias.get(`${kind}:${normalizeValue(value.trim(), ours.rootPx)}`)?.name;
         if (!theirName || theirName === name)
             return line;
         if (!resolvable.has(theirName)) {

package/package.json

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