synthesisui 0.16.327 → 0.16.328

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/install-marks.js

@@ -352,7 +352,16 @@ 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.
+ */
+export const READER_SINCE = "0.16.328";
 /**
  * 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/package.json

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