synthesisui 0.16.344 → 0.16.348

package/dist/commands/import.js

@@ -24,7 +24,7 @@ import { accountExportsInto, emptyExportAccount, exportInvariantHolds, } from ".
 import { fragmentsOfSource, fragmentsOfStylesheet, judgeFragments, } from "../doctor/fragments.js";
 import { useFrameworkMajor } from "../doctor/framework-palette.js";
 import { describeConvention, describeRemainder, detectConventions, } from "../doctor/idiom.js";
-import { pageLaws } from "../doctor/page-laws.js";
+import { componentsPagesReachFor, pageLaws } from "../doctor/page-laws.js";
 import { callSiteNode, placeLayers, } from "../doctor/place-layers.js";
 import { publicApi, requiredProps } from "../doctor/public-api.js";
 import { aliasesOf, describeReachability, edgesIn, reachabilityOf, } from "../doctor/reachability.js";
@@ -60,6 +60,25 @@ import { harvestWorkspaceCss } from "../workspace-css.js";
 import { placeInWorkspace } from "../workspace-place.js";
 import { add } from "./add.js";
 import { walk, walkAll } from "./doctor.js";
+/**
+ * UMA PÁGINA DELE, como ele a montou - ver `Census.pages`.
+ *
+ * Não é "uma rota do Next": é qualquer arquivo que o portão de componente recusou por ser tela e
+ * não peça (`route` ou `screen`), em qualquer stack. O que a identifica é o veredito do portão,
+ * nunca o nome do arquivo - e é isso que a faz valer no projeto de alguém que a gente nunca viu.
+ */
+/**
+ * QUANTAS PÁGINAS VIAJAM NO CENSO.
+ *
+ * O teto existe pela mesma razão que o de `skipped`: num monorepo o número estoura e o censo
+ * viraria um dump do repositório. Medido em 01/09, o `frontend-hub` tem 145 arquivos de página e
+ * o nosso app 65, então 400 cabe as duas populações inteiras e o corte só aparece em repositório
+ * bem maior que os que a gente mede.
+ *
+ * E QUANDO ELE CORTAR, `pagesTotal` diz quantas eram. Uma tela que contasse `pages.length` diria
+ * 400 e pareceria completa, que é a forma mais barata de um corte silencioso mentir.
+ */
+export const PAGES_MAX = 400;
 /**
  * How many distinct values travel, PER KIND.
  *
@@ -472,7 +491,8 @@ export async function takeCensus(root, opts) {
     const sourceOf = new Map();
     /** Nome → o que a peça é, quando o portão soube dizer. Ver `CensusLook.kind`. */
     const kindOf = new Map();
-    /** A raiz e a composição de cada página, para as leis - ver `pageLaws`. */
+    /** Como ele monta cada página - as leis saem daqui, e o censo carrega o dado. Ver `pageLaws`
+     *  e `Census.pages`. */
     const pages = [];
     /** Todo fragmento de estilo visto, para o ledger - ver `buildLedger`. */
     const fragments = [];
@@ -753,12 +773,22 @@ export async function takeCensus(root, opts) {
                     const sketch = sketchOf(src, d.name);
                     const root = sketch[0];
                     pages.push({
+                        file: rel,
                         root: root?.classes
                             ? transcribe(root.classes.split(/\s+/).filter(Boolean), declaredValues).base
                             : {},
+                        /**
+                         * `from` VEM DO SKETCH e não de uma segunda leitura do arquivo: o nó já carrega o
+                         * especificador que o import dele declara, e reabrir o arquivo para descobrir o
+                         * mesmo fato é a falha de esteira que o dono nomeou em 01/08.
+                         */
                         composes: sketch
                             .filter((n) => /^[A-Z]/.test(n.tag))
-                            .map((n) => n.tag.split(".")[0]),
+                            .map((n) => ({
+                            name: n.tag.split(".")[0],
+                            ...(n.from ? { from: n.from } : {}),
+                            depth: n.depth,
+                        })),
                     });
                 }
                 skips.push({
@@ -2061,7 +2091,15 @@ export async function takeCensus(root, opts) {
         for (const line of ledgerLines.slice(0, 24))
             say(body(line));
     }
-    const pageRules = pageLaws(pages);
+    /**
+     * As leis contam NOMES, e o censo carrega a peça inteira. O `map` fica aqui e não em
+     * `page-laws.ts` para o módulo das leis continuar sem saber o que é um censo - ele responde
+     * "no que estas páginas concordam" e nada mais.
+     */
+    const pageRules = pageLaws(pages.map((page) => ({
+        root: page.root ?? {},
+        composes: page.composes.map((c) => c.name),
+    })));
     if (pageRules.length > 0) {
         say("");
         say(section("What your pages agree on"));
@@ -2070,6 +2108,32 @@ export async function takeCensus(root, opts) {
             say(body(paint.faint(`  ${law.evidence}`)));
         }
     }
+    /**
+     * AS PEÇAS QUE AS PÁGINAS DELE ALCANÇAM, ditas em voz alta - ver `componentsPagesReachFor`.
+     *
+     * Isto existe porque o campo `pages` do censo nasceria SEM LEITOR: a plataforma vai consumi-lo
+     * num planejador que ainda não existe, e um dado guardado que ninguém mostra é a mesma coisa
+     * que não medir. Aqui ele vira uma frase que já vale sozinha - o desenvolvedor descobre quais
+     * das peças dele são a espinha das telas dele, que é uma pergunta que ninguém respondia.
+     *
+     * O NÚMERO VEM JUNTO SEMPRE, e ele é páginas e não usos - sem o denominador em palavras a lista
+     * lê como ranking de importância em vez de contagem de espalhamento.
+     */
+    const spread = componentsPagesReachFor(pages, (from) => {
+        if (!from)
+            return true;
+        if (internal.some((prefix) => from.startsWith(prefix)))
+            return true;
+        return frontierKind(from) === "own";
+    });
+    if (spread.length > 0) {
+        say("");
+        say(section("The components your pages are built from"));
+        say(body(`${spread.length} of your components hold up ${pages.length} ${pages.length === 1 ? "page" : "pages"} - a new page starts from these.`));
+        for (const piece of spread.slice(0, 8)) {
+            say(body(paint.faint(`  ${piece.name} - on ${piece.pages} of your ${pages.length} pages`)));
+        }
+    }
     if (architectures.length > 0) {
         say("");
         say(section("How this project is organised"));
@@ -2397,6 +2461,17 @@ export async function takeCensus(root, opts) {
          * Omitido quando não há nenhuma, que é o caso de todo primeiro import.
          */
         ...(declaredForms.length > 0 ? { declaredForms } : {}),
+        /**
+         * COMO ELE MONTA UMA PÁGINA - ver `Census.pages`. Omitido quando não há página nenhuma, que é
+         * o caso de toda biblioteca: ela não compõe telas dentro de si, e um array vazio aqui leria
+         * como "medimos e ele não monta nada".
+         */
+        ...(pages.length > 0
+            ? {
+                pages: pages.slice(0, PAGES_MAX),
+                ...(pages.length > PAGES_MAX ? { pagesTotal: pages.length } : {}),
+            }
+            : {}),
         /**
          * A FOLHA DELE ENTRA POR ÚLTIMO, e a ordem é a resposta a quem manda.
          *

package/dist/doctor/css-modules.js

@@ -202,7 +202,17 @@ function declarations(body) {
      */
     let flat = body;
     for (let guard = 0; guard < 12; guard++) {
-        const next = flat.replace(/\{[^{}]*\}/g, "");
+        /**
+         * O CABEÇALHO SAI JUNTO COM O BLOCO, e não depois - senão ele fica grudado na declaração
+         * seguinte e come a declaração inteira. Tirando só `{ … }`, o corpo de
+         *
+         *     .panel { color: red; &:hover { color: blue; } padding: 24px; }
+         *
+         * virava `color: red; &:hover  padding: 24px;`, e o pedaço do meio tem `:` no `:hover`:
+         * a propriedade lida era `&` e o `padding` do cartão dele MORRIA - a decisão estava no
+         * código, contada como interpretada, e não chegava à receita.
+         */
+        const next = flat.replace(/[^;{}]*\{[^{}]*\}/g, "");
         if (next === flat)
             break;
         flat = next;
@@ -458,7 +468,76 @@ function looksLikeTypeArg(source, at) {
 }
 export function scanTags(source) {
     const out = [];
+    /**
+     * QUANTAS TAGS ESTÃO ABERTAS - o que diz se estamos em CÓDIGO ou em CONTEÚDO.
+     *
+     * A distinção existe por causa das aspas, e ela é o que separa duas coisas escritas igual:
+     * `.replaceAll("<task_complete/>", …)` é código, e a tag ali é texto; `Don't` é conteúdo, e
+     * o apóstrofo ali é prosa. Parear aspas nos dois lugares custou marcação REAL na primeira
+     * tentativa - o `KeapCRMDialog` deles perdeu quatro `<Skeleton>` legítimos porque
+     * `height="70px"` desalinhou o par (medido, 01/09).
+     */
+    let open = 0;
     for (let i = 0; i < source.length; i++) {
+        /**
+         * COMENTÁRIO NÃO É MARCAÇÃO, e vale nos dois lados: `{/* … *\/}` mora no conteúdo e
+         * `//<AddIcon />` mora no código.
+         *
+         * O QUE O CLIENTE PERDE SEM ISTO: uma linha que ele comentou vira um nó da anatomia. No
+         * `frontend-hub`, `icon, //<AddIcon iconColor={…} />` faz o `SidebarButton` nascer com um
+         * ícone que a marcação não tem - e como o nó fantasma cai em `depth` 0, ele vira a RAIZ e
+         * desloca todo `at` abaixo dele, que é o índice pelo qual a anatomia acha o nó medido.
+         * Um `{/* … <StudioButtonNextStep …/> … *\/}` entrega um COMPONENTE inteiro que ele apagou.
+         *
+         * Medido em 01/09: 19 de 378 componentes e 2 de 95 páginas do app dele, 15 de 170
+         * componentes e 3 de 56 páginas do nosso. A biblioteca dele dá 0 de 36 - o defeito
+         * atravessou porque não aparece onde a esteira é mais olhada.
+         */
+        if (source[i] === "/" && source[i + 1] === "*") {
+            const close = source.indexOf("*/", i + 2);
+            i = close === -1 ? source.length : close + 1;
+            continue;
+        }
+        /** `https://…` não abre comentário, e o `://` é o que diz isso sem saber o contexto. */
+        if (source[i] === "/" && source[i + 1] === "/" && source[i - 1] !== ":") {
+            const nl = source.indexOf("\n", i + 2);
+            i = nl === -1 ? source.length : nl;
+            continue;
+        }
+        /**
+         * LITERAL DE TEXTO, só em código - com nenhuma tag aberta. Dentro de uma tag as aspas são
+         * atributo e o laço abaixo já as consome inteiras; dentro do conteúdo elas são prosa.
+         */
+        if (open === 0 &&
+            (source[i] === '"' || source[i] === "'" || source[i] === "`")) {
+            const quote = source[i];
+            /**
+             * ASPAS NÃO ATRAVESSAM LINHA - é regra da linguagem, e é ela que separa um literal de
+             * uma aspa solta dentro de outra coisa.
+             *
+             * Sem esse limite, o `["']` de uma EXPRESSÃO REGULAR abria uma string que só fechava
+             * páginas adiante: `cleanContent.replace(/^["']|["']$/g, "")` apagou os 19 nós do
+             * `ToolResultView` deles - o componente inteiro (medido, 01/09). Crase é a exceção,
+             * porque template literal atravessa linha de propósito.
+             */
+            const limit = quote === "`"
+                ? source.length
+                : source.indexOf("\n", i + 1) + 1 || source.length;
+            let j = i + 1;
+            while (j < limit) {
+                if (source[j] === "\\")
+                    j += 2;
+                else if (source[j] === quote)
+                    break;
+                else
+                    j += 1;
+            }
+            /** Sem par até o limite não é literal - é aspa solta, e engoli-la custaria marcação. */
+            if (j < limit && source[j] === quote) {
+                i = j;
+                continue;
+            }
+        }
         if (source[i] !== "<")
             continue;
         const closing = source[i + 1] === "/";
@@ -498,6 +577,7 @@ export function scanTags(source) {
         const body = source.slice(nameAt + name.length, end);
         if (closing) {
             out.push({ at: i, kind: "close", tag: name, body: "" });
+            open = Math.max(0, open - 1);
         }
         else {
             out.push({ at: i, kind: "open", tag: name, body });
@@ -505,6 +585,9 @@ export function scanTags(source) {
             if (body.trimEnd().endsWith("/")) {
                 out.push({ at: i + 1, kind: "close", tag: name, body: "" });
             }
+            else {
+                open += 1;
+            }
         }
         i = end;
     }

package/dist/doctor/fragments.js

@@ -197,6 +197,48 @@ function backtick(source, from) {
  * contagem: um global com regra de CLASSE é forma que nenhum leitor cobre hoje - 399 declarações
  * no repo dele, e a única lacuna que estava calada em vez de declarada (04/08).
  */
+/**
+ * O SELETOR DE UMA DECLARAÇÃO, resolvido contra os blocos que a contêm.
+ *
+ * O QUE O CLIENTE GANHA: uma declaração que ele escreveu dentro de `&:hover` chega aqui como
+ * `.card:hover` - o nome inteiro, o mesmo que o navegador aplica. Sem isto ela chegava como
+ * `&:hover`, e um `&` sem pai não tem a quem se ligar: nenhum leitor deste lado ou do outro
+ * consegue dizer de que elemento aquela decisão é.
+ *
+ * UMA AT-RULE É CONTEXTO, NUNCA PAI. `@media (…) { .card { padding } }` é uma decisão do `.card`
+ * sob uma condição, e não de um elemento chamado `@media`. A at-rule só responde pelo seletor
+ * quando não há nenhum dentro dela - que é como `@utility text-grad { … }` do Tailwind 4 e o
+ * `0%` de um `@keyframes` seguem chegando exatamente como chegavam.
+ */
+function selectorOf(open) {
+    let selector = "";
+    let atRule = "";
+    for (const block of open) {
+        if (!block)
+            continue;
+        if (block.startsWith("@")) {
+            if (!selector)
+                atRule = block;
+            continue;
+        }
+        selector = selector ? resolveNesting(block, selector) : block;
+    }
+    return selector || atRule;
+}
+/**
+ * O `&` DO FILHO TROCADO PELO PAI, e o filho sem `&` pendurado como descendente - as duas
+ * regras do CSS aninhado. Uma lista de pais vira `:is(a, b)`, que é o que o próprio CSS faz:
+ * escrever `a, b:hover` diria outra coisa, e diria errado.
+ */
+function resolveNesting(child, parent) {
+    const base = parent.includes(",") ? `:is(${parent})` : parent;
+    return child
+        .split(",")
+        .map((part) => part.trim())
+        .filter(Boolean)
+        .map((part) => part.includes("&") ? part.replaceAll("&", base) : `${base} ${part}`)
+        .join(", ");
+}
 export function fragmentsOfStylesheet(file, css, 
 /**
  * COMO ESTA FOLHA CHEGA NO BUILD DELES, e isso vem do GRAFO DE IMPORTS e nunca do nome do
@@ -212,31 +254,54 @@ export function fragmentsOfStylesheet(file, css,
  */
 kind) {
     const out = [];
-    let selector = "";
+    /**
+     * OS BLOCOS ABERTOS, E NÃO O ÚLTIMO SELETOR VISTO.
+     *
+     * O QUE O CLIENTE VIVIA COM UMA VARIÁVEL SÓ: depois de um bloco aninhado, TODA declaração que
+     * vinha a seguir ficava com o seletor do bloco que já tinha fechado. No `.card { color: red;
+     * &:hover { color: blue } padding: 8px }`, o `padding` dele era registrado como sendo do
+     * `:hover` - uma decisão de repouso lida como decisão de estado. Medido no repositório vivo em
+     * 01/09, sobre 724 folhas e 19 374 declarações: **440 (2,3%) ficavam com o seletor de um bloco
+     * já fechado, e 942 (4,9%) saíam com um `&` que não tinha pai a que se referir**.
+     */
+    const open = [];
     for (const [i, raw] of css.split("\n").entries()) {
         const line = raw.replace(/\/\*.*?\*\//g, "");
         for (const piece of line.matchAll(PIECES)) {
             const text = (piece[1] ?? "").trim();
             if (piece[2] === "{") {
-                selector = text;
+                open.push(text);
                 continue;
             }
+            /**
+             * O BLOCO SÓ FECHA DEPOIS QUE A DECLARAÇÃO DELE FOI LIDA. `.a { color: red }` numa linha
+             * só termina a declaração no `}`, sem `;` - desempilhar antes de ler perdia a última
+             * declaração de todo bloco escrito assim. Medido no repositório vivo quando aconteceu:
+             * 19 declarações a menos no censo do `frontend-hub`, num conserto que só devia mexer em
+             * QUAL seletor cada uma tem.
+             */
+            const closes = piece[2] === "}";
             /**
              * Sem terminador não há declaração: `padding: 8px` no fim de uma linha pode ser a primeira
              * metade de um valor que continua na próxima.
              */
-            if (!piece[2] || !text)
+            if (!piece[2] || !text) {
+                if (closes)
+                    open.pop();
                 continue;
+            }
             const m = DECLARATION.exec(text);
-            if (!m)
-                continue;
             /**
              * UM TOKEN NÃO É UM FRAGMENTO DE COMPONENTE. `--color-ocean-500: #…` é a paleta, e ela tem
              * o seu próprio caminho e o seu próprio relatório; contá-la aqui inflaria o total com o que
              * já está coberto em outro lugar.
              */
-            if (m[1].startsWith("--"))
+            if (!m || m[1].startsWith("--")) {
+                if (closes)
+                    open.pop();
                 continue;
+            }
+            const selector = selectorOf(open);
             out.push({
                 shape: "css",
                 file,
@@ -249,6 +314,8 @@ kind) {
                         ? { reason: "sheet-not-imported" }
                         : {}),
             });
+            if (closes)
+                open.pop();
         }
     }
     return out;
@@ -302,6 +369,24 @@ const STRUCTURE = new Set([
 function targetClass(text) {
     const brace = text.indexOf("{");
     const selector = brace === -1 ? text : text.slice(0, brace);
+    /**
+     * `@utility x` É A CLASSE `.x` - ela é a forma do Tailwind 4 de declarar um utilitário, e não
+     * traz o ponto que este casamento procura.
+     *
+     * O QUE ELE VIA SEM ISTO: a declaração CHEGAVA ao componente e o relatório dizia que não. O
+     * `readGlobalClasses` lê `@utility` desde 24/08 e a entrega no look de quem veste a classe -
+     * medido em 01/09 pela cadeia real, o `Scene` recebe `perspective: 900px` da `@utility
+     * scene-3d`. Mas o julgamento procurava um ponto no seletor, não achava, e mandava as mesmas
+     * declarações para o ledger como forma sem leitor. No censo do `codelevel`: **68 declarações
+     * em 22 utilities anunciadas como não interpretadas**, com as duas que um componente veste
+     * (`scene-3d` no `Scene`, `stage-3d` no `Stage`) já dentro da receita dele.
+     *
+     * Um número que acusa lacuna onde não há custa o mesmo que um que a esconde: manda alguém
+     * consertar o que não está quebrado. Quase custou um leitor inteiro escrito duas vezes.
+     */
+    const utility = /^@utility\s+([a-z][\w-]*)/i.exec(selector.trim())?.[1];
+    if (utility)
+        return utility;
     for (const group of selector.split(",")) {
         const classes = group.match(/\.[A-Za-z][\w-]*/g);
         /** Sem o ponto: o nome que `globalClasses` indexa. */

package/dist/doctor/page-laws.js

@@ -104,3 +104,41 @@ export function pageLaws(pages) {
 function topOf(composed) {
     return [...composed.entries()].sort((a, b) => b[1] - a[1])[0]?.[0] ?? "";
 }
+/**
+ * OS COMPONENTES QUE AS PÁGINAS DELE MAIS ALCANÇAM - fato contado, e nunca inferência de papel.
+ *
+ * O QUE ISTO DESTRAVA: a paleta de um planejador de página que abre com os componentes que ELE usa, na ordem
+ * em que ele usa, em vez de uma lista que a gente escreveu. Medido em 01/09, uma página do
+ * `frontend-hub` monta `ContentWrapper` em 20 delas, `PageHeader` em 14 e `HorizontalMenu` em 8 -
+ * e essas três são a gramática de layout daquele projeto, escrita em componentes.
+ *
+ * O QUE ELA NÃO DIZ, de propósito: que esses componentes SÃO layout. Isso é leitura de papel e ela
+ * exigiria provar que o componente envolve os outros; o que está medido aqui é quantas páginas a
+ * alcançam, e é só isso que o texto pode afirmar. Chamar frequência de papel seria a plataforma
+ * batizando o vocabulário dele, que a decisão 3 proíbe.
+ *
+ * CONTA PÁGINAS E NÃO USOS: uma página que repete o mesmo `Card` oito vezes não faz dele o
+ * esqueleto do projeto - faz dele o conteúdo daquela página. O sinal é ESPALHAMENTO.
+ *
+ * SÓ OS COMPONENTES DELE. Sem o filtro a lista abriria com `motion.div` e `LucideSearch`, que são de
+ * terceiros e não estão no sistema dele para serem oferecidas. Quem chama decide o que é dele,
+ * porque a régua que desempata `workspace:` contra semver mora no manifesto - ver `frontierKind`.
+ */
+export function componentsPagesReachFor(pages, theirs) {
+    const spread = new Map();
+    for (const page of pages) {
+        const seen = new Set();
+        for (const piece of page.composes) {
+            if (!theirs(piece.from))
+                continue;
+            if (seen.has(piece.name))
+                continue;
+            seen.add(piece.name);
+            spread.set(piece.name, (spread.get(piece.name) ?? 0) + 1);
+        }
+    }
+    return [...spread.entries()]
+        .filter(([, n]) => n >= AGREE)
+        .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+        .map(([name, n]) => ({ name, pages: n }));
+}

package/dist/install-marks.js

@@ -144,7 +144,15 @@
  * terminal dizendo qual arquivo e como tomar a versão nova por escolha. Antes desta versão a
  * reescrita era incondicional e o único aviso era prosa depois do fato.
  */
-export const MATERIALISER_SINCE = "0.16.319";
+/**
+ * 0.16.319 -> 0.16.345 em 01/09 (`markup-only.spec`): o scanner de tags parou de ler comentário e
+ * literal de texto como marcação, e isso chega ao ARQUIVO que o `materialize` escreve.
+ *
+ * O sketch alimenta a anatomia e a anatomia alimenta o codegen, então um bloco JSX que ele
+ * comentou vinha sendo escrito na pasta dele como componente de verdade. Medido em 14 arquivos
+ * das duas populações o nó fantasma era a RAIZ - o elemento cujas classes viram a `base`.
+ */
+export const MATERIALISER_SINCE = "0.16.345";
 /**
  * A ÚLTIMA VERSÃO EM QUE O QUE O HOOK RODA MUDOU.
  *
@@ -484,7 +492,47 @@ export const CHECKER_SINCE = "0.16.308";
  * parte do repositório. O corpus dourado NÃO se moveu por isso: nenhum dos 29 apps é medido com
  * escopo, e o hash parado aqui é ausência de cobertura, nunca ausência de efeito.
  */
-export const READER_SINCE = "0.16.341";
+/**
+ * 0.16.341 -> 0.16.345 em 01/09 (`markup-only.spec`): o leitor deixou de tratar COMENTÁRIO e
+ * LITERAL DE TEXTO como marcação.
+ *
+ * O QUE O CLIENTE VIVIA: uma linha que ele comentou virava um elemento da anatomia dele. No
+ * `frontend-hub`, `icon, //<AddIcon iconColor={…} />` faz o `SidebarButton` nascer com um ícone
+ * que a marcação não tem; um `{/* … <StudioButtonNextStep …/> … *\/}` entrega um COMPONENTE
+ * inteiro que ele apagou; e `.replaceAll("<task_complete/>", …)` entrega uma tag que só existe
+ * dentro de uma string.
+ *
+ * A marca sobe porque o SKETCH é medido na máquina dele e viaja gravado no censo: o `sync`
+ * remede com `takeCensus`, então quem rodar recebe a anatomia sem os nós fantasma. Sem a marca,
+ * o `align` não chamaria ninguém.
+ *
+ * QUANTOS: 735 arquivos das duas populações, 47 mudaram, 111 nós saíram - os 111 verificados
+ * contra o AST do compilador como comentário ou literal, e zero marcação real perdida. Em 14
+ * arquivos o nó fantasma era a RAIZ, que é o que vira a `base` da receita.
+ *
+ * QUEM NÃO É AFETADO: quem não deixa código comentado na marcação. A biblioteca dele
+ * (`packages/ui`) dá 0 de 36 - e foi por isso que o defeito atravessou, porque ele não aparece
+ * onde a esteira é mais olhada. O corpus dourado não se movia por isso: nenhum dos 29 apps
+ * tinha a forma, e a fixture `markup-with-commented-out-code` entra no mesmo PR para o portão
+ * deixar de ser cego.
+ */
+/**
+ * 0.16.345 -> 0.16.346 em 01/09 (`INV-COLETA-12`): o censo passou a carregar COMO ELE MONTA UMA
+ * PÁGINA - a sequência de peças de cada uma, com a origem de cada peça.
+ *
+ * O QUE ELE GANHA COM O `sync`: a plataforma passa a saber quais das peças DELE sustentam as telas
+ * dele. Sem isso, qualquer coisa que precise partir de uma página só tem o esqueleto que NÓS
+ * escrevemos - três layouts padrão contra os componentes que ele de fato usa.
+ *
+ * O campo é NOVO, então todo censo já guardado está sem ele: a marca sobe porque a ausência aqui
+ * não se distingue de "este projeto não tem páginas", e só o remedir separa os dois. O `sync`
+ * refaz com `takeCensus`.
+ *
+ * QUEM NÃO É AFETADO: quem apontou a leitura para uma biblioteca. Ela não compõe telas dentro de
+ * si, o campo fica ausente, e ausente ali continua sendo a resposta certa - o `codelevel-ui` dá
+ * 0 de 0 contra 145 arquivos de página do `frontend-hub`.
+ */
+export const READER_SINCE = "0.16.348";
 /**
  * O QUE ESTÁ INSTALADO AQUI FICOU PARA TRÁS - e as DUAS condições que fazem isso ser verdade.
  *

package/package.json

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