synthesisui 0.16.349 → 0.16.354

package/dist/census-pages.js

@@ -0,0 +1,66 @@
+/**
+ * COMO ELE MONTA UMA PÁGINA - a régua única, num módulo só.
+ *
+ * O que o cliente ganha: o planejador de página oferece o esqueleto que ELE já usa - as peças
+ * dele, na ordem em que ele as escreve - em vez dos três layouts que NÓS escrevemos. Ver
+ * `INV-COLETA-12` em `contracts/camada-1-coleta.md`.
+ *
+ * POR QUE ISTO NÃO MORA EM `import.ts`: três lugares precisam da mesma resposta - a varredura do
+ * escopo, a varredura da evidência (`--usage`, que é onde as páginas moram em todo monorepo) e a
+ * FUSÃO de dois escopos medidos. Duas cópias da transcrição seriam duas réguas no dia em que uma
+ * fosse editada, e o teto declarado num arquivo e furado no outro seria um teto que não existe.
+ */
+import { sketchOf } from "./doctor/sketch.js";
+import { transcribe } from "./doctor/transcribe.js";
+/**
+ * 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;
+/**
+ * UMA PÁGINA DELE, TRANSCRITA - a moldura da raiz e as peças que ela compõe.
+ *
+ * `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.
+ */
+export function pageCompositionOf(rel, src, name, declaredValues) {
+    const sketch = sketchOf(src, name);
+    const at = sketch[0];
+    return {
+        file: rel,
+        root: at?.classes
+            ? transcribe(at.classes.split(/\s+/).filter(Boolean), declaredValues).base
+            : {},
+        composes: sketch
+            .filter((n) => /^[A-Z]/.test(n.tag))
+            .map((n) => ({
+            name: n.tag.split(".")[0],
+            ...(n.from ? { from: n.from } : {}),
+            depth: n.depth,
+        })),
+    };
+}
+/**
+ * AS PÁGINAS DE DOIS ESCOPOS MEDIDOS, SOMADAS - e o teto reaplicado sobre a soma.
+ *
+ * Cada escopo mediu arquivos DIFERENTES, então isto é soma e não desempate: nenhuma regra do
+ * primeiro-escopo-vence se aplica a um conjunto disjunto. O que se preserva é o denominador -
+ * `pagesTotal` conta quantas foram VISTAS em cada medição, inclusive as que aquela medição já
+ * havia cortado, senão a soma de dois cortes leria como o total do projeto.
+ */
+export function mergePages(list) {
+    const all = list.flatMap((c) => c.pages ?? []);
+    if (all.length === 0)
+        return {};
+    const seen = list.reduce((n, c) => n + (c.pagesTotal ?? (c.pages ?? []).length), 0);
+    const pages = all.slice(0, PAGES_MAX);
+    return { pages, ...(seen > pages.length ? { pagesTotal: seen } : {}) };
+}

package/dist/commands/import.js

@@ -3,6 +3,7 @@ import { basename, dirname, join, relative, sep } from "node:path";
 import { anatomyFromSketch } from "../anatomy-from-sketch.js";
 import { applyAnatomyPatch, hasEdits, } from "../anatomy-patch.js";
 import { resolveAnatomy, resolveFlatParts, safePartName, } from "../anatomy-read.js";
+import { PAGES_MAX, pageCompositionOf } from "../census-pages.js";
 import { readCredentials, readToken, resolveRegistry, sameRegistry, } from "../config.js";
 import { declaredElsewhere } from "../declared-elsewhere.js";
 import { architectureGap, architectureRule, componentHome, describeArchitecture, describeChoice, describeGap, detectArchitectures, homeLine, packagingOf, proposeNewHome, resolvesAs, } from "../doctor/architecture.js";
@@ -68,17 +69,12 @@ import { walk, walkAll } from "./doctor.js";
  * 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 DE PÁGINAS, re-exportado de onde a régua inteira mora - ver `census-pages.ts`.
  *
- * 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.
+ * Ele vive lá porque a FUSÃO de dois escopos precisa reaplicá-lo sobre a soma, e um teto
+ * declarado num arquivo e furado no outro é um teto que não existe.
  */
-export const PAGES_MAX = 400;
+export { PAGES_MAX };
 /**
  * How many distinct values travel, PER KIND.
  *
@@ -770,26 +766,7 @@ export async function takeCensus(root, opts) {
                  * que falta para alguém escrever a próxima (04/08).
                  */
                 if (verdict.why === "route" || verdict.why === "screen") {
-                    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) => ({
-                            name: n.tag.split(".")[0],
-                            ...(n.from ? { from: n.from } : {}),
-                            depth: n.depth,
-                        })),
-                    });
+                    pages.push(pageCompositionOf(rel, src, d.name, declaredValues));
                 }
                 skips.push({
                     name: d.name,
@@ -1456,6 +1433,11 @@ export async function takeCensus(root, opts) {
      * not `reports`: an app's classes are choices made from a scale, and folding
      * them into the census would put the average back where the declaration goes.
      *
+     * A ÚNICA COISA QUE ESTE LAÇO ESCREVE ALÉM DA CONTAGEM É `pages`, e a razão é que uma página
+     * não é uma escolha de estilo: é a COMPOSIÇÃO dela - quais peças, em que ordem, sob que
+     * moldura. Ela não entra em `defined`, não declara token e não vota em escala. Ver o bloco
+     * `AS PÁGINAS MORAM AQUI` mais abaixo, com o número das duas populações.
+     *
      * Deliberately its own tally so the LIBRARY QUESTION is asked of the scope
      * alone. Fold the app in first and every export has a count, `isLibrary` reads
      * false, and the crosswalk starts substituting the components it was just
@@ -1548,6 +1530,41 @@ export async function takeCensus(root, opts) {
             // source - so measuring nesting only on the defined loop reported zero
             // companions on a 128-component library (e2e, 01/08).
             readNesting(rel, src, nesting);
+            /**
+             * AS PÁGINAS MORAM AQUI, E ATÉ AGORA O CENSO NÃO GUARDAVA NENHUMA.
+             *
+             * `Census.pages` é como ELE monta uma tela - a moldura da raiz e a ordem das peças -, e é
+             * o único dado a partir do qual alguém escreve a próxima página no vocabulário dele. Ele
+             * só era colhido na varredura do ESCOPO, e o escopo é a biblioteca: uma `packages/ui` não
+             * tem `app/` nem `pages/`, então a resposta era sempre zero. Medido em 01/09 nas duas
+             * populações, com o mesmo `--scope`/`--usage` que o `import` e o `sync` passam:
+             *
+             *     codelevel      0 páginas guardadas · 9 existem  (apps/web 3, apps/landing 6)
+             *     frontend-hub   0 páginas guardadas · 156 existem (apps/web-dashboard)
+             *
+             * Isto NÃO afrouxa a lei da passagem de evidência. Uma página não entra em `defined`, não
+             * doa token e não vota em escala: o que ela doa é COMPOSIÇÃO - quais peças dele seguram
+             * quais telas -, que é exatamente a classe de fato que `--usage` existe para trazer.
+             *
+             * A régua é a mesma do escopo, de propósito: o portão recusa a rota (`route`/`screen`) e
+             * é essa recusa que a identifica como página. Só o que o portão RECUSA por ser tela vira
+             * página, então nada que já é componente é contado duas vezes.
+             */
+            if (/\.(tsx|jsx)$/i.test(rel)) {
+                for (const d of scanDefinitions(rel, src)) {
+                    const verdict = gateComponent({
+                        name: d.name,
+                        file: rel,
+                        source: src,
+                        internal: [...shared, ...uInternal],
+                    });
+                    if (verdict.ok)
+                        continue;
+                    if (verdict.why !== "route" && verdict.why !== "screen")
+                        continue;
+                    pages.push(pageCompositionOf(rel, src, d.name, declaredValues));
+                }
+            }
             // Which PROJECT composes it - the credibility panel's number, per root.
             for (const m of src.matchAll(/<([A-Z][A-Za-z0-9_]*)/g)) {
                 const at = projectsOf.get(m[1]) ?? new Set();
@@ -2000,6 +2017,21 @@ export async function takeCensus(root, opts) {
         ]),
         islandRead: islandClassesRead,
         refused: new Set(skips.map((s) => s.file)),
+        /**
+         * AS ANIMAÇÕES QUE O CENSO CAPTUROU - ver o veredito em `judgeFragments`.
+         *
+         * `keyframes` é o objeto que já viaja no censo e que o compilador emite. Um frame de uma
+         * delas chegou por essa porta, então cobrá-lo como lacuna conta a mesma coisa duas vezes.
+         * A LISTA É A MESMA FUSÃO QUE O CENSO GRAVA, e não a metade de componente.
+         *
+         * `keyframes` sozinho é o que os componentes declaram; `globalKeyframes` é a folha dele, e
+         * é ali que os 35 do codelevel moram - o censo funde os dois na hora de escrever. Ler só o
+         * primeiro aqui declarava capturado um conjunto VAZIO e o conserto não movia nada: a
+         * primeira medição depois de ligar isto deu exatamente os mesmos 130 de antes.
+         *
+         * Se a captura falhar, o frame volta a ser lacuna sozinho, que é a resposta certa.
+         */
+        keyframes: new Set(Object.keys({ ...globalKeyframes, ...keyframes })),
     }, 
     /**
      * AS FORMAS QUE ELE DECLAROU - e é aqui que a declaração dele muda o veredito.

package/dist/doctor/fragments.js

@@ -302,12 +302,24 @@ kind) {
                 continue;
             }
             const selector = selectorOf(open);
+            /**
+             * DE QUAL ANIMAÇÃO ESTE FRAME É - ver `Fragment.inKeyframe`.
+             *
+             * `selectorOf` devolve `0%`, porque o bloco do frame é um seletor comum e o at-rule só
+             * vence quando não há nenhum. O nome fica na pilha e é a única coisa que liga esta
+             * declaração ao keyframe que o censo capturou.
+             */
+            const inKeyframe = open
+                .map((b) => /^@keyframes\s+([^\s{]+)/.exec(b)?.[1])
+                .filter(Boolean)
+                .pop();
             out.push({
                 shape: "css",
                 file,
                 line: i + 1,
                 text: `${selector ? `${selector} ` : ""}{ ${m[1]}: ${m[2].trim()} }`,
                 read: false,
+                ...(inKeyframe ? { inKeyframe } : {}),
                 ...(kind === "global"
                     ? { reason: "shape-not-read" }
                     : kind === "dead"
@@ -440,7 +452,30 @@ forms = []) {
     const wornGlobal = elsewhere?.wornGlobal ?? new Set();
     const islandRead = elsewhere?.islandRead ?? new Map();
     const refused = elsewhere?.refused ?? new Set();
+    const captured = elsewhere?.keyframes ?? new Set();
     return seen.map((f) => {
+        /**
+         * UM FRAME DE UM KEYFRAME CAPTURADO CHEGOU - a mesma família de `wornGlobal` logo abaixo, e a
+         * mesma família de `INV-INTERP-15`: a régua acusava um fato que já estava no censo.
+         *
+         * `0% { opacity: 0 }` não tem leitor de RECEITA e nunca vai ter - um frame não é a decisão de
+         * um componente, é um instante de uma animação. Mas a animação inteira viaja em
+         * `census.keyframes`, com todos os seus frames, e o compilador a emite. Cobrar o frame como
+         * lacuna é contar duas vezes a mesma coisa e chamar a segunda de perda.
+         *
+         * MEDIDO EM 02/09, nas duas populações e com o mesmo `--scope`/`--usage` do produto:
+         *
+         *     codelevel      35 keyframes capturados · 87 de 105 declarações sem leitor eram frames (83%)
+         *     frontend-hub    1 keyframe  capturado ·  0 de   6 eram frames (0%)
+         *
+         * As duas discordam por larga margem, e é isso que decide o desenho: a pergunta não é sobre
+         * volume, é sobre a porta por onde a declaração passou. O nome tem que estar CAPTURADO - um
+         * frame de uma animação que o censo não colheu continua sendo lacuna, porque ali ela é real.
+         */
+        if (f.inKeyframe && captured.has(f.inKeyframe)) {
+            const { reason: _unread, ...rest } = f;
+            return { ...rest, read: true };
+        }
         /**
          * A REGRA DE CLASSE GLOBAL QUE ALGUÉM VESTE FOI LIDA - antes do desvio de
          * `binding`, porque lida é mais forte que ligada. `.root { isolation: isolate }`

package/dist/doctor/transcribe.js

@@ -677,6 +677,24 @@ export function readUtility(raw, declared) {
         if (property)
             return { property, value: `${Number(pct.toFixed(4))}%` };
     }
+    /**
+     * `-translate-x-1/2` TAMBÉM É UMA FRAÇÃO, e ela tem que ser lida AQUI pelo motivo exato que o
+     * comentário acima já dava: depois do split de alpha ela chega como `translate-x-1` e volta
+     * `0.25rem` - *silently wrong, which is worse than unread*.
+     *
+     * E isto não é hipótese: o primeiro rascunho do leitor de `translate` (02/09) tratava a fração
+     * dentro de `readUtilityCore`, depois do split, e produziu `translateX(-0.25rem)` para o
+     * `-translate-x-1/2` com que ele centra elementos. O spec pegou. É a mesma armadilha, uma função
+     * de transform depois.
+     */
+    const shift = /^(-?)translate-([xy])-(\d+)\/(\d+)$/.exec(utility);
+    if (shift) {
+        const pct = (Number(shift[3]) / Number(shift[4])) * 100;
+        return {
+            property: "transform",
+            value: `translate${shift[2] === "x" ? "X" : "Y"}(${shift[1]}${Number(pct.toFixed(4))}%)`,
+        };
+    }
     const read = readUtilityCore(utility, declared);
     return read ? withAlpha(read, utility.split("/")[1]) : read;
 }
@@ -1139,6 +1157,63 @@ function readUtilityCore(utility, declared) {
      * so two on the same element would overwrite - none of their 3 co-occur, and saying
      * one of them is better than saying neither.
      */
+    /**
+     * O EIXO FAZ PARTE DA FUNÇÃO, e não do argumento - `rotate-x-45` é `rotateX(45deg)`.
+     *
+     * O QUE ISTO CONSERTA, e é pior que não-lido: o teste abaixo é `^-?rotate-(.+)$`, que capturava
+     * `x-45` e montava **`rotate(x-45deg)`** - uma declaração que o navegador descarta inteira,
+     * gravada na receita como se fosse a decisão dele. `skew-x-6` e `scale-x-95` caíam fora de
+     * qualquer leitor e viravam lacuna, que é o lado seguro de errar; `rotate-x` era o inseguro.
+     *
+     * MEDIDO EM 02/09 COM A RÉGUA DO PRODUTO - as classes que o censo realmente carrega, e não um
+     * grep: **0 usos nas duas populações** para as seis formas por eixo. E o grep ingênuo mentia
+     * feio: ele dava 114 e 16 para `perspective-` e 60 e 78 para `origin-`, e NENHUM era classe de
+     * componente - era o CSS `perspective:` e `transform-origin:` dentro das `@utility` dele.
+     *
+     * ENTÃO POR QUE LER, com N=0? Pelo mesmo motivo que `peer-<estado>/<nome>:` entrou no
+     * `INV-INTERP-17`: isto não é forma de repositório nenhum, é a GRAMÁTICA que o Tailwind declara,
+     * e nela o eixo é sufixo da função. Derivar da gramática cobre o cliente que a gente nunca viu -
+     * e o que decide o caso é que a alternativa aqui não era silêncio, era CSS inválido.
+     *
+     * O QUE NÃO ENTROU, declarado: `origin-*`, `perspective-*`, `transform-gpu` e `translate-z-*`.
+     * Os três primeiros são propriedades PRÓPRIAS (`transformOrigin`, `perspective`, `willChange`) e
+     * não funções de `transform`, então não são sufixo desta família: entram como leitor novo, com
+     * medição própria, no dia em que uma população as escrever como classe.
+     */
+    const axial = /^(-?)(rotate|skew|scale)-([xyz])-(.+)$/.exec(core);
+    if (axial) {
+        /**
+         * QUANDO ESTE PADRÃO CASA, ELE DECIDE - e nunca deixa cair no leitor genérico abaixo.
+         *
+         * É a metade que fecha a porta de verdade. O primeiro rascunho só ACRESCENTAVA a leitura por
+         * eixo, e `rotate-x-banana` continuava passando para `^-?rotate-(.+)$` e voltando
+         * `rotate(x-bananadeg)` - o mesmo CSS inválido, agora por um caminho a mais. Um `return null`
+         * aqui manda a classe para a lista de não lidas, que é a resposta certa: nunca inventamos, e
+         * uma lacuna dita vale mais que um valor que o navegador descarta.
+         *
+         * E O SINAL SÓ EXISTE ONDE O TAILWIND O DEFINE: `-rotate-y-90` e `-skew-y-3` são válidos;
+         * `-scale-x-95` não é, e aceitá-lo seria ler uma decisão que ele não tem como ter escrito.
+         */
+        const [, sign, kind, ax, arg] = axial;
+        const fn = `${kind}${ax.toUpperCase()}`;
+        const arbitrary = /^\[(.+)\]$/.exec(arg);
+        if (kind === "scale") {
+            if (sign)
+                return null;
+            const factor = arbitrary
+                ? arbitrary[1]
+                : /^\d+$/.test(arg)
+                    ? String(Number(arg) / 100)
+                    : null;
+            return factor
+                ? { property: "transform", value: `${fn}(${factor})` }
+                : null;
+        }
+        if (!arbitrary && !/^\d+(\.\d+)?$/.test(arg))
+            return null;
+        const deg = arbitrary ? arbitrary[1] : `${arg}deg`;
+        return { property: "transform", value: `${fn}(${sign}${deg})` };
+    }
     const rotate = /^-?rotate-(.+)$/.exec(core);
     if (rotate) {
         const arbitrary = /^\[(.+)\]$/.exec(rotate[1]);
@@ -1148,6 +1223,57 @@ function readUtilityCore(utility, declared) {
             value: `rotate(${core.startsWith("-") ? `-${deg}` : deg})`,
         };
     }
+    /**
+     * `-translate-y-px`, `translate-x-1/2`, `translate-y-[140%]` - o deslocamento estático.
+     *
+     * A MESMA FAMÍLIA DE `rotate` E `scale`, e era a única das três sem leitor. Medido em 02/09, por
+     * CAMADA e com a régua do produto:
+     *
+     *     codelevel      22 camadas com classe de transform · 5 chegavam (23%) · 17 perdidas
+     *     frontend-hub    2 camadas · 2 chegavam (100%) · 0 perdidas
+     *
+     * As duas populações discordam porque escrevem coisas diferentes: o `frontend-hub` usa
+     * `scale-95` e `rotate-180`, que já eram lidos; o `codelevel` usa `translate`, e nele as formas
+     * perdidas eram `-translate-y-px` (6), `-translate-x-1/2` (3), `-translate-y-0.5` (2),
+     * `-translate-y-1/2` (2), `translate-y-0`, `translate-y-[140%]` e as duas do grupo nomeado.
+     *
+     * O QUE ELE VÊ SEM ISTO: o card dele sobe 1px no hover no navegador e não sobe no Canvas, e o
+     * elemento que ele centrou com `-translate-x-1/2` aparece deslocado meia largura.
+     *
+     * A ESCALA É A DELE PRIMEIRO, exatamente como em `gap-sm`: `--spacing-<passo>` declarado vence a
+     * fórmula numérica. A FRAÇÃO é percentual por definição do Tailwind (`1/2` = 50%), e não passo de
+     * escala - convertê-la pela escala daria um valor que nada no CSS dele significa.
+     *
+     * DUAS NA MESMA CAMADA AINDA SE SOBRESCREVEM, e isso não é novo nem calado: as três funções
+     * pousam em `transform` inteiro, o comentário de `rotate` já declarava isso, e medido em 02/09 é
+     * **1 de 18** camadas no `codelevel` e 0 no `frontend-hub`. Dizer uma continua sendo melhor que
+     * dizer nenhuma.
+     */
+    const translate = /^-?translate-([xy])-(.+)$/.exec(core);
+    if (translate) {
+        const axis = translate[1] === "x" ? "X" : "Y";
+        const arg = translate[2];
+        const neg = core.startsWith("-");
+        const own = `--spacing-${arg}`;
+        const arbitrary = /^\[(.+)\]$/.exec(arg);
+        /** A FRAÇÃO NÃO CHEGA AQUI - `readUtility` a lê antes do split de alpha, e o comentário lá
+         *  explica por que ela não pode esperar por este ponto. */
+        const size = arbitrary
+            ? arbitrary[1]
+            : arg === "full"
+                ? "100%"
+                : declared.has(own)
+                    ? `{spacing.${arg}}`
+                    : (SPACING[arg] ?? numericSpacing(arg));
+        if (size)
+            return {
+                property: "transform",
+                value: `translate${axis}(${neg ? `-${size}` : size})`,
+                ...(!arbitrary && arg !== "full" && declared.has(own)
+                    ? { token: own }
+                    : {}),
+            };
+    }
     const scale = /^scale-(.+)$/.exec(core);
     if (scale) {
         const arbitrary = /^\[(.+)\]$/.exec(scale[1]);
@@ -1648,8 +1774,12 @@ function slotFor(out, modifiers) {
     let at;
     let unslotted = false;
     for (const mod of rest) {
-        /** `group-hover:`, `group-data-[checked]:` - the PARENT's state. */
-        const group = /^group-(.+)$/.exec(mod);
+        /**
+         * `group-hover:`, `group-data-[checked]:` - the PARENT's state. E o NOME do grupo depois da
+         * barra não é parte do estado: ver a régua gêmea em `variant-read.ts`, com a medição das duas
+         * populações e a prova de que descartar o nome não junta nada.
+         */
+        const group = /^group-(.+?)(?:\/[A-Za-z0-9_-]+)?$/.exec(mod);
         const bare = group ? group[1] : mod;
         const state = STATE_SPELLING[bare] ?? dataState(bare);
         if (state) {

package/dist/doctor/variant-read.js

@@ -73,8 +73,34 @@ const MODIFIER_STATE = {
     "aria-invalid": "invalid",
     "aria-busy": "loading",
 };
-/** `group-hover`, `group-focus`, `peer-checked` - the state of something ELSE. */
-const RELATIONAL = /^(?:group|peer)-(.+)$/;
+/**
+ * O NOME DO GRUPO NÃO É PARTE DO ESTADO - `group-hover/tt:` é "quando o grupo chamado `tt` está em
+ * hover", e o estado ali é `hover`.
+ *
+ * O TAILWIND NOMEIA GRUPOS desde a v3, e é o que se escreve quando dois grupos se aninham: o pai
+ * declara `group/tt` e o filho reage com `group-hover/tt:`. A régua capturava `(.+)` depois do
+ * `group-`, então ela procurava o estado `hover/tt` na tabela e não achava - e o estilo inteiro
+ * daquela condição era declarado perdido.
+ *
+ * MEDIDO EM 02/09, e AS DUAS POPULAÇÕES SÃO OPOSTAS (`INV-GERAL-07`):
+ *
+ *     codelevel      138 usos NOMEADOS em 39 arquivos ·   0 anônimos
+ *     frontend-hub     0 nomeados                     · 192 anônimos
+ *
+ * Uma régua escrita para qualquer uma das duas quebraria na outra por inteiro. O que decide não é
+ * a população: é a gramática que o Tailwind declara, e nela o nome é um IDENTIFICADOR opcional
+ * depois de uma barra. `peer-<estado>/<nome>:` tem a mesma forma e entra pela mesma porta - 0 usos
+ * nas duas populações hoje, e cobrir os dois é derivar da gramática em vez de fixar o que um
+ * repositório escreve.
+ *
+ * DESCARTAR O NOME É SEGURO, e isto foi medido antes de ser decidido: o nome só distinguiria algo
+ * se dois grupos diferentes aparecessem na MESMA lista de classes. No `codelevel` são 2 nomes no
+ * repositório inteiro (`tt` 96, `btn` 42), 7 arquivos usam os dois, e **em 0 dos 10 atributos
+ * `className` medidos eles coexistem**. Cada lista de classes pertence a um elemento, e ali o nome
+ * é derivável do contexto. Se um dia coexistirem, as duas condições produzem o MESMO `within` e
+ * viram duas camadas distinguíveis pelas outras classes - nada é somado em silêncio.
+ */
+const RELATIONAL = /^(?:group|peer)-(.+?)(?:\/[A-Za-z0-9_-]+)?$/;
 /**
  * `data-[state=open]:`, `data-[checked]:`, `data-[side=top]:` - como @base-ui e Radix escrevem uma
  * condição.

package/dist/install-marks.js

@@ -532,7 +532,91 @@ export const CHECKER_SINCE = "0.16.308";
  * 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";
+/**
+ * 0.16.349 -> 0.16.350 em 01/09 (`INV-COLETA-12`, a metade do MONOREPO): as páginas do app dele
+ * passam a chegar ao censo mesmo quando a leitura foi apontada para a biblioteca.
+ *
+ * O QUE ELE GANHA COM O `sync`: a linha *"N of your components hold up M pages"* - quais peças
+ * dele são a espinha das telas dele. Quem roda `--scope packages/ui --usage apps/web` recebia
+ * ZERO página e o relatório calava as duas seções que falam delas.
+ *
+ * A CORREÇÃO DE UMA FRASE QUE ESTAVA AQUI: "ausente continua sendo a resposta certa para quem
+ * apontou a leitura para uma biblioteca" só valia para quem NÃO passou `--usage`. As páginas
+ * moram no app, e a varredura da evidência lia cada um desses arquivos para contagem e lei e
+ * passava direto pela composição. Medido em 01/09, com o mesmo `--scope`/`--usage` que o
+ * `import` e o `sync` passam:
+ *
+ *     codelevel      0 páginas guardadas · 9 existem  (apps/web 3, apps/landing 6)
+ *     frontend-hub   0 páginas guardadas · 156 existem (apps/web-dashboard)
+ *
+ * QUEM NÃO É AFETADO: quem mede um app inteiro sem escopo - esse caminho já carregava as páginas
+ * desde 0.16.348. E quem aponta para uma biblioteca sem `--usage`: ela não compõe telas dentro de
+ * si, o campo segue ausente, e ali a ausência é a resposta certa de verdade.
+ */
+/**
+ * 0.16.350 -> 0.16.351 em 02/09 (`INV-COLETA-16`): um frame de uma animação que o censo CAPTUROU
+ * deixa de ser contado como declaração sem leitor.
+ *
+ * O QUE ELE GANHA COM O `sync`: o número de cobertura para de contar como perdido o que a
+ * plataforma leu inteiro. `0% { opacity: 0 }` nunca vai ter leitor de RECEITA - um frame não é a
+ * decisão de um componente -, mas a animação viaja em `census.keyframes` e o compilador a emite.
+ *
+ *     codelevel      35 keyframes capturados · shape-not-read 130 -> 18 · CSS lido 35% -> 88%
+ *     frontend-hub    1 keyframe  capturado · shape-not-read   6 ->  6 · nada muda
+ *
+ * QUEM NÃO É AFETADO: quem não escreve `@keyframes`. E quem escreve um que a captura NÃO alcançou -
+ * ali o frame continua sendo lacuna, porque ali a perda é real.
+ */
+/**
+ * 0.16.351 -> 0.16.352 em 02/09 (`INV-INTERP-17`): o GRUPO NOMEADO do Tailwind passa a ser lido.
+ *
+ * O QUE ELE GANHA COM O `sync`: a condição que só existe quando o grupo em volta reage. `group/tt`
+ * no pai e `group-hover/tt:` no filho é como se escreve isso desde a v3 do Tailwind, e a régua
+ * procurava o estado `hover/tt` na tabela - não achava, e declarava PERDIDA a condição inteira.
+ *
+ * MEDIDO NO `codelevel`: 4 classes em `unplaced` viram 2 camadas condicionais com `opacity: 1` na
+ * receita do `TooltipContent`. O tooltip dele aparece no hover no navegador e não aparecia na
+ * nossa.
+ *
+ *     codelevel      138 usos NOMEADOS · 0 anônimos · unplaced 4 -> 0
+ *     frontend-hub     0 nomeados · 192 anônimos · unplaced 0 -> 0 (a forma anônima não regride)
+ *
+ * QUEM NÃO É AFETADO: quem escreve só a forma anônima (`group-hover:`), que já era lida. O nome do
+ * grupo é descartado com prova: em 0 dos 10 atributos `className` medidos dois grupos coexistem.
+ */
+/**
+ * 0.16.352 -> 0.16.353 em 02/09 (`INV-INTERP-18`): `translate` passa a ser lido.
+ *
+ * O QUE ELE GANHA COM O `sync`: o deslocamento estático que ele declara. `rotate` e `scale` já
+ * eram lidos; `translate` era a única das três funções de transform sem leitor, e a camada inteira
+ * que dependia dela era descartada.
+ *
+ *     codelevel      5 de 22 camadas chegavam (23%) -> 30 de 30
+ *     frontend-hub   2 de 2 (100%) -> 2 de 2 · ele escreve `scale`/`rotate`, que já eram lidos
+ *
+ * E UM CASO PIOR QUE NÃO-LIDO: `-translate-x-1/2`, com que ele centra elementos, chegava ao leitor
+ * de tamanho como `translate-x-1` e voltava `0.25rem`. Quem já importou tem essa receita gravada -
+ * o elemento aparece deslocado meia largura em vez de centrado.
+ *
+ * QUEM NÃO É AFETADO: quem não escreve `translate-*`.
+ */
+/**
+ * 0.16.353 -> 0.16.354 em 02/09 (`INV-INTERP-19`): o EIXO passa a fazer parte da função, e a régua
+ * para de emitir CSS inválido.
+ *
+ * O QUE ELE GANHA COM O `sync`: `rotate-x-45` virava **`rotate(x-45deg)`**, uma declaração que o
+ * navegador descarta inteira e que ficava GRAVADA na receita como se fosse a decisão dele. Agora é
+ * `rotateX(45deg)`, e o que não é ângulo vira lacuna em vez de valor inventado.
+ *
+ * A MARCA SOBE APESAR DE N=0 nas duas populações, e é uma escolha declarada: quem TEM a forma tem
+ * um valor inválido gravado, e é a marca que faz o `align` chamá-lo a re-medir. Errar para o lado
+ * de subir custa um `sync` que não precisava; errar para o outro deixa o valor inválido para
+ * sempre, e "0 nas duas que eu medi" não é "0 no mundo" (`INV-GERAL-07`).
+ *
+ * QUEM NÃO É AFETADO: quem não escreve `rotate-x`, `skew-x/y` ou `scale-x/y`. As formas SEM eixo -
+ * `rotate-180`, `scale-95` - não se movem, e há asserção disso.
+ */
+export const READER_SINCE = "0.16.354";
 /**
  * O QUE ESTÁ INSTALADO AQUI FICOU PARA TRÁS - e as DUAS condições que fazem isso ser verdade.
  *

package/dist/merge-census.js

@@ -1,3 +1,4 @@
+import { mergePages } from "./census-pages.js";
 import { gapReason } from "./doctor/architecture.js";
 const asRecord = (v) => (v ?? {});
 /** Nome do escopo para as mensagens - `.` quando a medição não escopou nada. */
@@ -296,6 +297,25 @@ export function mergeCensus(list) {
         out.conventions = conventions;
     if (architectures && architectures.length > 0)
         out.architectures = architectures;
+    /**
+     * AS PÁGINAS DOS ESCOPOS SOMAM - ver `mergePages` em `census-pages.ts`.
+     *
+     * `out` nasce de um spread do PRIMEIRO censo e depois é montado campo a campo, então `pages`
+     * do primeiro escopo viajava de carona e a dos SEGUINTES caía inteira, sem uma linha dizendo
+     * isso. Com um escopo só o defeito não aparece (a fusão de uma lista devolve o próprio censo),
+     * e é por isso que ele sobreviveu: o caminho que o expõe é `--scope A --scope B`, que existe
+     * justamente para o sistema que mora em dois pacotes.
+     *
+     * `pagesTotal` também precisava ser recontado: herdado do primeiro, ele descrevia uma medição
+     * e era lido como o total do projeto.
+     */
+    const merged = mergePages(list);
+    delete out.pages;
+    delete out.pagesTotal;
+    if (merged.pages)
+        out.pages = merged.pages;
+    if (merged.pagesTotal)
+        out.pagesTotal = merged.pagesTotal;
     if (gaps.length > 0)
         out.architectureGaps = gaps;
     if (newComponentHome)

package/package.json

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