synthesisui 0.16.344 → 0.16.346

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

@@ -458,7 +458,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 +567,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 +575,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/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.346";
 /**
  * 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.346",
   "description": "Bring SynthesisUI design systems into any project - tokens, typed components, whole pages and an agent-ready CLAUDE.md manifest.",
   "type": "module",
   "bin": {