synthesisui 0.16.328 → 0.16.329

package/dist/doctor/transcribe.js

@@ -2253,14 +2253,103 @@ export function rootClasses(source, name) {
     if (end === -1)
         return [];
     const tag = source.slice(open, end);
-    const at = tag.search(/className\s*=/);
-    if (at === -1)
+    /**
+     * O `className` DO PRÓPRIO ELEMENTO, e não o primeiro que aparece no texto.
+     *
+     * ═══ O DEFEITO, medido em 28/08 ═══
+     *
+     * Era `tag.search(/className\s*=/)` seguido de casar todo literal de string até o fim da tag.
+     * Numa tag de abertura que carrega JSX dentro de uma prop, o primeiro `className=` do texto é o
+     * daquele JSX aninhado - e as classes dele eram atribuídas à RAIZ.
+     *
+     *     <ReactMarkdown components={{ p: (props) => <p className={"py-2 " + className} /> }}>
+     *
+     * A raiz ali não escreve classe nenhuma, e o leitor lhe dava `py-2` - junto com pedaços de código
+     * (`}`, `/>`, `...props`) que a varredura de literais recolhia pelo caminho.
+     *
+     * A consequência VISÍVEL, medida: o contrato `editions-performance-list` chegava com
+     * `animation: var(--animate-spin)` na raiz. O giro é de um spinner que vive dentro de uma prop, e
+     * a receita dizia que o componente inteiro gira.
+     *
+     * ═══ A PROPRIEDADE ═══
+     *
+     * Uma classe só pode ser atribuída a um elemento se AQUELE elemento a escreveu. Classe de JSX
+     * aninhado em prop, callback, render prop ou objeto não pertence à raiz.
+     *
+     * A regra é ESTRUTURAL e não tem exceção por nome: nada aqui conhece `components`, `ReactMarkdown`
+     * ou qualquer exemplar. O atributo do elemento é o que está em profundidade ZERO dentro da tag de
+     * abertura, e é só ele que é lido.
+     *
+     * E o VALOR também é delimitado, não varrido até o fim: um `className="a"` seguido de
+     * `onClick={() => <span className="b"/>}` dava `a b` antes, porque a varredura ia até o `>`.
+     */
+    const own = ownClassNameExpr(tag);
+    if (own == null)
         return [];
     // Every string literal inside the className expression. Template literals and
     // computed values are skipped on purpose: a class we cannot see in full is a
     // class we would be guessing at.
-    const expr = tag.slice(at);
-    return [...expr.matchAll(/["']([^"']+)["']/g)]
+    return [...own.matchAll(/["']([^"']+)["']/g)]
         .flatMap((m) => m[1].split(/\s+/))
         .filter((c) => c.length > 0 && !c.includes("${"));
 }
+/**
+ * A EXPRESSÃO do `className` que é atributo DIRETO desta tag de abertura, ou `null`.
+ *
+ * Duas travas, e as duas nasceram medidas:
+ *
+ *   PROFUNDIDADE ZERO   um `className` dentro de `{...}`, `(...)` ou `[...]` é de outro elemento -
+ *                       objeto de prop, callback, render prop, JSX passado como prop.
+ *   FRONTEIRA DE PALAVRA `wrapperClassName=` não é `className=`. O regex antigo casava dentro dele,
+ *                       e a classe de um wrapper virava classe da raiz.
+ *
+ * O valor é DELIMITADO: a string entre aspas, ou o bloco `{...}` balanceado. Ler até o fim da tag
+ * misturaria o atributo com tudo que vem depois dele.
+ */
+function ownClassNameExpr(tag) {
+    let depth = 0;
+    for (let i = 0; i < tag.length; i++) {
+        const ch = tag[i];
+        if (ch === "{" || ch === "(" || ch === "[") {
+            depth += 1;
+            continue;
+        }
+        if (ch === "}" || ch === ")" || ch === "]") {
+            depth -= 1;
+            continue;
+        }
+        if (depth !== 0 || !tag.startsWith("className", i))
+            continue;
+        /** Atributo é palavra inteira: o que vem antes tem que ser separador, nunca letra. */
+        const before = i > 0 ? tag[i - 1] : " ";
+        if (/[A-Za-z0-9_$]/.test(before))
+            continue;
+        let j = i + "className".length;
+        while (j < tag.length && /\s/.test(tag[j]))
+            j += 1;
+        if (tag[j] !== "=")
+            continue;
+        j += 1;
+        while (j < tag.length && /\s/.test(tag[j]))
+            j += 1;
+        const quote = tag[j];
+        if (quote === '"' || quote === "'") {
+            const close = tag.indexOf(quote, j + 1);
+            return close === -1 ? tag.slice(j) : tag.slice(j, close + 1);
+        }
+        if (tag[j] !== "{")
+            return "";
+        let d = 0;
+        for (let k = j; k < tag.length; k++) {
+            if (tag[k] === "{")
+                d += 1;
+            else if (tag[k] === "}") {
+                d -= 1;
+                if (d === 0)
+                    return tag.slice(j, k + 1);
+            }
+        }
+        return tag.slice(j);
+    }
+    return null;
+}

package/dist/install-marks.js

@@ -360,8 +360,14 @@ export const CHECKER_SINCE = "0.16.308";
  * estado legado e o deriver volta a deduzir por posição, que é o defeito. Medido no app real: 8
  * componentes que devolvem um Fragment recuperam as classes que hoje caem no vazio, e 386 de 386
  * looks legados leem exatamente como liam.
+ *
+ * 0.16.328 -> 0.16.329 em 28/08: `rootClasses` passou a ler só o `className` do PRÓPRIO elemento.
+ * Antes ele ancorava no primeiro `className=` do texto da tag de abertura, então a classe de um JSX
+ * escrito dentro de uma prop virava classe da raiz - e o `className` da raiz, quando vinha depois,
+ * nunca era alcançado. Medido: 1134 componentes, 77 mudaram, e a receita que o cliente recebe muda
+ * com eles. Uma medição anterior não produz o conserto, então a marca sobe.
  */
-export const READER_SINCE = "0.16.328";
+export const READER_SINCE = "0.16.329";
 /**
  * O QUE ESTÁ INSTALADO AQUI FICOU PARA TRÁS - e as DUAS condições que fazem isso ser verdade.
  *

package/dist/populations.spec-input.js

@@ -51,6 +51,27 @@ export const CODELEVEL_CENSUS = join(POPULATIONS, "codelevel-ui.census.json");
  * `signalui` viraram provas apagadas. Ver `fixtures/populations/README.md`.
  */
 export const CODELEVEL_LEDGER = join(POPULATIONS, "codelevel-ui.ledger.jsonl");
+/**
+ * O MESMO REPOSITÓRIO, MEDIDO DEPOIS - e os dois instantes ficam, porque cada um carrega uma
+ * dimensão que o outro não tem.
+ *
+ * O ledger ao lado é de 26/08, de um CLI que ainda não transportava OCORRÊNCIAS. Este é de 28/08,
+ * medido pelo `doctor` 0.16.327 publicado, e carrega `unrepresentedMatches`.
+ *
+ * POR QUE O ANTIGO NÃO FOI SUBSTITUÍDO. Ele não é evidência velha: ele é a evidência do estado
+ * LEGADO, que é onde todo cliente está até sincronizar. Medido ao trocar um pelo outro - a causa
+ * `cross-family-suggestion` deixa de nascer da fonte `repo` e passa a nascer de `judged`, e a fonte
+ * `repo` some da população inteira. `screen.real` precisa das TRÊS fontes vivas ao mesmo tempo;
+ * sobrescrever apagaria uma dimensão para ganhar outra.
+ *
+ *     26/08  crossFamily 1 · matched 22 · sem o campo      recount 11 · judged 1 · repo 1
+ *     28/08  crossFamily 1 · matched 22 · 4 ocorrências    recount 11 · judged 2 · repo 0
+ *
+ * INSPECIONADO ANTES DE VERSIONAR (28/08): zero caminhos absolutos, zero `/home/`, zero e-mails,
+ * zero credenciais, zero URLs. Ele carrega o que o campo novo promete carregar - caminhos RELATIVOS
+ * de origem, com a linha.
+ */
+export const CODELEVEL_LEDGER_WITH_OCCURRENCES = join(POPULATIONS, "codelevel-ui.ledger.with-occurrences.jsonl");
 /**
  * OS DOIS DOCUMENTOS HISTÓRICOS - a exceção autorizada à regra do derivável (dono, 28/08).
  *

package/package.json

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