synthesisui 0.16.327 → 0.16.329

package/dist/anatomy-from-sketch.js

@@ -318,7 +318,24 @@ export function anatomyFromSketch(sketch, defines,
  * from `recharts: ^2.12.0`, since both are spelled the same way. See
  * `frontierOf`.
  */
-versionOf) {
+versionOf, 
+/**
+ * QUAL NÓ JÁ FOI ABSORVIDO EM `base` - ver `CensusLook.consumedAt`, onde o fato nasce.
+ *
+ *     number     consuma EXATAMENTE esse nó
+ *     "none"     a coleta mediu e não absorveu nenhum - não consuma nenhum
+ *     undefined  censo LEGADO - a regra antiga, byte a byte
+ *
+ * `undefined` NUNCA é `"none"`: um censo gravado antes desta medição existir não disse que não
+ * absorveu nada; ele não disse nada. Tratá-lo como `"none"` mudaria retroativamente a leitura de
+ * 386 componentes num app real, dos quais 26 mudariam de fato - e mudar dado antigo sem uma nova
+ * medição é a definição de reinterpretar o passado.
+ *
+ * Opcional porque 37 dos 39 chamadores são specs que montam um sketch à mão e testam a regra
+ * legada de propósito. Os chamadores de PRODUÇÃO são dois, e `anatomy-consumed.guard.spec.ts`
+ * nomeia os dois: um parâmetro opcional que se pode esquecer é o defeito que este item desfaz.
+ */
+consumedAt) {
     const notes = [];
     const libraries = [];
     if (!Array.isArray(sketch) || sketch.length === 0)
@@ -662,10 +679,33 @@ versionOf) {
      * root arriving as a sibling (dono, 03/08). The reader stamps which node the
      * component returns - see `SketchNode.root`.
      */
-    const stamped = sketch.findIndex((node) => node?.root);
-    const top = stamped >= 0 ? stamped : roots.length > 0 ? roots[0] : 0;
+    /**
+     * ═══ DADO NOVO NÃO DEDUZ NADA (28/08, T43-b) ═══
+     *
+     * A linha abaixo era uma dedução por POSIÇÃO - "o nó carimbado, senão o primeiro de d0, senão o
+     * zero" - e ela discordava do coletor exatamente onde a âncora falha. Num componente que devolve
+     * um Fragment o coletor não absorve nada em `base`, e esta linha consumia um nó mesmo assim: as
+     * classes daquele nó caíam no vazio. Medido no `frontend-hub`: 8 componentes.
+     *
+     * Com o fato, não há o que deduzir. Sem o fato - censo legado - a dedução antiga fica INTEIRA,
+     * porque um censo velho não disse "não absorvi nada": ele não disse nada.
+     */
+    const top = consumedAt === "none"
+        ? -1
+        : typeof consumedAt === "number"
+            ? consumedAt
+            : /** LEGADO, e esta é a regra antiga sem uma vírgula mudada. */
+                (() => {
+                    const stamped = sketch.findIndex((node) => node?.root);
+                    return stamped >= 0 ? stamped : roots.length > 0 ? roots[0] : 0;
+                })();
+    /**
+     * `top === -1` é "nenhum nó foi consumido", e então TODO nó de d0 é emitido com as classes dele -
+     * que é o conserto: nada se perde e nada é inventado. `roots.filter(at => at !== top)` já devolve
+     * todos quando `top` não é um índice, então a mesma linha serve aos dois casos.
+     */
     const read = [
-        ...(kids[top] ?? []).flatMap((child) => build(child, 0)),
+        ...(top >= 0 ? (kids[top] ?? []).flatMap((child) => build(child, 0)) : []),
         ...roots.filter((at) => at !== top).flatMap((sibling) => build(sibling, 0)),
     ];
     /**
@@ -678,7 +718,7 @@ versionOf) {
      * as empty boxes: a Chat that says nothing about messages reads as a component
      * we failed to extract (dono, 01/08).
      */
-    const rootNode = sketch[top];
+    const rootNode = top >= 0 ? sketch[top] : undefined;
     if (rootNode?.slot) {
         const only = EXPECTS[String(rootNode.tag ?? "").toLowerCase()];
         /**

package/dist/commands/import.js

@@ -829,6 +829,22 @@ export async function takeCensus(root, opts) {
                     if (esize > 0 || etag || esketch.length > 0) {
                         looks[extra.name] = {
                             ...(esketch.length > 0 ? { sketch: esketch } : {}),
+                            /**
+                             * O MESMO FATO NO SEGUNDO COMPONENTE DO ARQUIVO - ver `CensusLook.consumedAt`.
+                             *
+                             * Escrever só no caminho primário deixaria metade dos looks de um arquivo com dois
+                             * componentes no estado LEGADO para sempre, e o deriver voltaria a deduzir por posição
+                             * exatamente neles. Um campo que só metade dos caminhos escreve é um campo que mente
+                             * sobre o que a medição cobriu.
+                             */
+                            ...(esketch.length > 0
+                                ? {
+                                    consumedAt: (() => {
+                                        const at = esketch.findIndex((n) => n.root);
+                                        return at >= 0 ? at : "none";
+                                    })(),
+                                }
+                                : {}),
                             /**
                              * Ver `CensusLook.aside` - o segundo componente do arquivo também.
                              *
@@ -1030,6 +1046,23 @@ export async function takeCensus(root, opts) {
                  * the owner's rule, adopted verbatim (dono, 01/08).
                  */
                 const sketch = sketchOf(src, found[0].name);
+                /**
+                 * QUAL NÓ FOI ABSORVIDO EM `base` - o fato, medido onde ele acontece. Ver
+                 * `CensusLook.consumedAt`.
+                 *
+                 * `rootClasses` acha o elemento pela âncora `returnAt` → primeiro `<`, e `sketchOf` carimba
+                 * `root` com a MESMA âncora. Quando ela acha um elemento, é o className DELE que entra em
+                 * `base` - com classes ou sem, e sem é o caso comum. Quando ela não acha (retorno em
+                 * Fragment, ou `returnAt` = -1), nada é absorvido e nenhum nó pode ser consumido.
+                 *
+                 * Provado nos dois repositórios reais, 139 arquivos: NUNCA existe um caso sem carimbo em que
+                 * `rootClasses` tenha lido alguma classe. As duas leituras falham juntas, sempre.
+                 *
+                 * E o carimbo `root` continua sendo outra coisa - a raiz ESTRUTURAL. Este campo é derivado
+                 * dele hoje porque hoje eles coincidem; ele não passa a ser ele.
+                 */
+                const consumedIndex = sketch.findIndex((n) => n.root);
+                const consumed = consumedIndex >= 0 ? consumedIndex : "none";
                 /**
                  * THE CSS THE COMPONENT CARRIES INSIDE ITSELF.
                  *
@@ -1192,6 +1225,8 @@ export async function takeCensus(root, opts) {
                             }
                             : {}),
                         ...withoutDark,
+                        /** SEMPRE, inclusive `"none"` - ver `CensusLook.consumedAt`: o vazio é a medição. */
+                        consumedAt: consumed,
                         base,
                         states,
                         /**
@@ -3545,7 +3580,9 @@ quiet = false) {
          */
         const derived = Array.isArray(anatomy) && anatomy.length > 0
             ? null
-            : anatomyFromSketch(looks[component]?.sketch, resolveRef, (pkg) => deps[pkg]);
+            : anatomyFromSketch(looks[component]?.sketch, resolveRef, (pkg) => deps[pkg], 
+            /** O fato medido na coleta, ou `undefined` num look legado - ver `CensusLook.consumedAt`. */
+            looks[component]?.consumedAt);
         if (derived?.read.length) {
             for (const note of derived.notes)
                 notes.add(note);

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

@@ -352,7 +352,22 @@ export const CHECKER_SINCE = "0.16.308";
  * nenhum dos 22 apps dourados tem componente com nome de tag de SVG. Quem tem só vê a correção
  * depois de remedir.
  */
-export const READER_SINCE = "0.16.324";
+/**
+ * 0.16.324 -> 0.16.328 em 28/08 (T43-b): o censo passou a carregar `consumedAt` - qual nó do sketch
+ * teve as classes absorvidas em `base`, ou `"none"` quando nenhum teve.
+ *
+ * A marca sobe porque a medição ANTERIOR não tem como produzir o conserto: sem o campo o look cai no
+ * 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.329";
 /**
  * O QUE ESTÁ INSTALADO AQUI FICOU PARA TRÁS - e as DUAS condições que fazem isso ser verdade.
  *

package/dist/naming-queue.js

@@ -59,7 +59,10 @@ export function namingQueue(looks, defines, versionOf) {
         const sketch = looks[component]?.sketch;
         if (!Array.isArray(sketch) || sketch.length === 0)
             continue;
-        const derived = anatomyFromSketch(sketch, defines, versionOf);
+        const derived = anatomyFromSketch(sketch, defines, versionOf, 
+        /** O fato medido na coleta, ou `undefined` num look legado - ver `CensusLook.consumedAt`. */
+        looks[component]
+            ?.consumedAt);
         if (derived.read.length === 0)
             continue;
         components += 1;

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.327",
+  "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": {