synthesisui 0.16.407 → 0.16.409

package/dist/commands/doctor.js

@@ -8,7 +8,7 @@ import { emptyTally, internalSpecifiers, scanComponentsInto, tallyToInventory, }
 import { checkContracts } from "../doctor/contract-check.js";
 import { describeMissing, missingDependencies, summarizeMissing, } from "../doctor/dependencies.js";
 import { findFrozenBindings } from "../doctor/frozen.js";
-import { appendEvent, COVERAGE_RULE, readEvents, suggestionsFrom, summarize, unrepresentedFrom, } from "../doctor/ledger.js";
+import { appendEvent, COVERAGE_RULE, COVERAGE_RULE_REASON, readEvents, suggestionsFrom, summarize, unrepresentedFrom, } from "../doctor/ledger.js";
 import { bindingsFromDocument, countComponents, findOverrides, } from "../doctor/overrides.js";
 import { checkableName, readRequests, verifyAndCloseRequests, } from "../doctor/requests.js";
 import { DEFAULT_ROOT_PX, rootSizeOf, saidOfRoot, } from "../doctor/root-size.js";
@@ -16,7 +16,11 @@ import { diagnose, nameToWrite, scanSource, siblingTokens, } from "../doctor/sca
 import { findSelfConflicts, forbiddenProps, isReset, propMatchesLabel, } from "../doctor/self-conflict.js";
 import { withTheirNames } from "../doctor/their-names.js";
 import { buildTable, EMPTY_TABLE, nearestToken, } from "../doctor/tokens.js";
-import { detectAppDirs, globalSheetOf, prefixFrom } from "../global-sheet.js";
+/**
+ * `detectAppDirs` SAIU DESTE IMPORT em 09/09: quem pergunta "quais pastas são app?" agora é
+ * `readWiringPerApp`, que responde a fiação de cada uma. O comando não escolhe mais um app.
+ */
+import { globalSheetOf, prefixFrom } from "../global-sheet.js";
 import { groupRole } from "../group-role.js";
 import { actingSlug, describeScope, measuredScope, scopePaths, } from "../measured-scope.js";
 import { body, paint, section, snippet } from "../output.js";
@@ -25,7 +29,7 @@ import { installedThemeCss, whatOnlyTheSheetResolves, } from "../sheet-needed.js
 import { resolveDeps } from "../stack.js";
 import { projectTongue } from "../their-tongue.js";
 import { danglingTheirVars } from "../their-vars.js";
-import { readWiring } from "../wiring-read.js";
+import { readWiring, readWiringPerApp } from "../wiring-read.js";
 /**
  * `synthesisui doctor` - the check nobody else ships.
  *
@@ -1068,28 +1072,61 @@ export async function doctor(opts) {
          * inventado.
          */
         if (table.slug) {
-            const appDirs = await detectAppDirs(root, config.pagesDir);
-            const sheet = appDirs[0]
-                ? await globalSheetOf(root, `${appDirs[0]}/globals.css`)
-                : null;
+            /**
+             * A INSTRUÇÃO É POR APP, e não do primeiro deles.
+             *
+             * O DEFEITO: esta linha era `appDirs[0]` - num monorepo com três apps servidos, dois recebiam
+             * a instrução do PRIMEIRO, com a folha e o prefixo relativo de outro app. É o mesmo defeito
+             * que `INV-VOLTA-12` fechou uma vez ("ele seguiu a instrução no arquivo CERTO e recebeu de nós
+             * o prefixo do arquivo errado"), voltando pela porta do plural: a invariante fala de "os apps
+             * dele", e o comando respondia por um.
+             *
+             * E A FIAÇÃO TAMBÉM É POR APP (`readWiringPerApp`): `readWiring` varre a raiz e responde
+             * "existe em algum lugar daqui", então o app fiado respondia pelo que não estava - e a pessoa
+             * abria o app sem nada e o comando dizia que estava tudo certo.
+             *
+             * COM UM APP, o texto não muda em byte nenhum - é a maioria dos projetos, e um cabeçalho
+             * por app ali seria cerimônia sobre uma lista de um.
+             */
+            const perApp = await readWiringPerApp(root, table.slug, config.pagesDir);
+            const targets = perApp.length > 0 ? perApp : [{ app: null, wiring }];
             console.log("");
             console.log(body("Paste this into your agent - it does the setup for you:"));
-            console.log("");
-            console.log(snippet(setupPrompt(table.slug, {
-                tokens: !wiring.imported,
-                scope: !wiring.scoped,
-                /** Só é passo quando o projeto TEM o arquivo de fontes - ver `readWiring`. */
-                type: wiring.fontsWritten && !wiring.fontsMapped,
-                ...(sheet
-                    ? { sheet: { path: sheet, prefix: prefixFrom(sheet) } }
-                    : {}),
+            for (const { app, wiring: w } of targets) {
+                const sheet = app
+                    ? await globalSheetOf(root, `${app}/globals.css`)
+                    : null;
                 /**
-                 * DUAS LINHAS COM TAILWIND, UMA SEM - a mesma decisão que o `add` já toma pelo projeto.
-                 * Dizer "as duas linhas" a um projeto que precisa de uma manda o agente procurar o que
-                 * não existe.
+                 * O APP QUE JÁ ESTÁ FIADO SAI DA LISTA, nomeado. Repetir o setup para quem já o fez é o
+                 * defeito de 08/09 outra vez, e num monorepo ele apareceria em escala: dois blocos
+                 * idênticos, um deles cobrando o que já está colado.
                  */
-                imports: config.styles === "css" ? 1 : 2,
-            }).split("\n")));
+                const pending = !w.imported || !w.scoped || (w.fontsWritten && !w.fontsMapped);
+                if (targets.length > 1) {
+                    console.log("");
+                    console.log(body(pending
+                        ? `  ${app} - still needs it`
+                        : `  ${app} - already wired, nothing to paste`));
+                }
+                if (!pending)
+                    continue;
+                console.log("");
+                console.log(snippet(setupPrompt(table.slug, {
+                    tokens: !w.imported,
+                    scope: !w.scoped,
+                    /** Só é passo quando o projeto TEM o arquivo de fontes - ver `readWiring`. */
+                    type: w.fontsWritten && !w.fontsMapped,
+                    ...(sheet
+                        ? { sheet: { path: sheet, prefix: prefixFrom(sheet) } }
+                        : {}),
+                    /**
+                     * DUAS LINHAS COM TAILWIND, UMA SEM - a mesma decisão que o `add` já toma pelo
+                     * projeto. Dizer "as duas linhas" a um projeto que precisa de uma manda o agente
+                     * procurar o que não existe.
+                     */
+                    imports: config.styles === "css" ? 1 : 2,
+                }).split("\n")));
+            }
         }
     }
     /**
@@ -1419,9 +1456,15 @@ export async function doctor(opts) {
              * para 37% sem uma linha de código mudada. Somar as duas fotos anunciaria um progresso
              * inventado; calar a mudança deixaria alguém procurar o que fez o número pular.
              */
-            /** E SEM O NÚMERO DA VERSÃO: o que mudou a conta é a conta, não a nossa release. */
+            /**
+             * E SEM O NÚMERO DA VERSÃO: o que mudou a conta é a conta, não a nossa release.
+             *
+             * A RAZÃO VEM DA RÉGUA, nunca de uma frase cravada aqui: a de 13/08 (*"your own tokens count
+             * now too"*) continuou impressa quando a régua subiu por outro motivo em 09/09, explicando a
+             * causa errada para quem lê. Ver `COVERAGE_RULE_REASON`.
+             */
             if (record.ruleChanged)
-                console.log(body("  the way this is counted changed - your own tokens count now too, so the trend restarts here."));
+                console.log(body(`  the way this is counted changed - ${COVERAGE_RULE_REASON[COVERAGE_RULE] ?? "the ruler moved"}, so the trend restarts here.`));
         }
     }
     /**

package/dist/doctor/apply-fix.js

@@ -96,6 +96,30 @@ function wholeValue(line, at, literal) {
     const after = line[at + literal.length] ?? "";
     return !/[0-9a-z#]/i.test(before) && !/[0-9a-z]/i.test(after);
 }
+/**
+ * A troca nas colunas medidas, da DIREITA para a esquerda: escrever `var(--x)` é mais longo que o
+ * literal, e fazer isso da esquerda para a direita moveria as colunas seguintes.
+ */
+function swapAtCols(line, literal, name, cols) {
+    const guarded = selfRanges(line, name);
+    let out = line;
+    let count = 0;
+    let blocked = 0;
+    for (const at of [...cols].sort((a, b) => b - a)) {
+        /** A linha mudou desde a medição: o comando tem um motivo para isso, e ele não é este. */
+        if (!out.startsWith(literal, at))
+            continue;
+        if (!wholeValue(out, at, literal))
+            continue;
+        if (guarded.some(([start, end]) => at >= start && at + literal.length <= end)) {
+            blocked++;
+            continue;
+        }
+        count++;
+        out = `${out.slice(0, at)}var(${name})${out.slice(at + literal.length)}`;
+    }
+    return { line: out, count, blocked };
+}
 /** Onde este valor está escrito INTEIRO nesta linha - a mesma pergunta que a troca faz. */
 function wholeValuesIn(line, literal) {
     const out = [];
@@ -106,7 +130,21 @@ function wholeValuesIn(line, literal) {
     }
     return out;
 }
-function swapAll(line, literal, name) {
+/**
+ * A TROCA ACONTECE NAS COLUNAS QUE A VARREDURA MEDIU - ver `Finding.cols`.
+ *
+ * Trocar TODA ocorrência do literal na linha era o defeito que o contador de shorthand destapou:
+ * com um achado de `8px` em `padding: 4px 8px`, o comando reescrevia também o `width: 8px`, o
+ * `top: 8px`, o `font-size: 8px` e os dois offsets de `box-shadow` da mesma linha - seis escritas
+ * onde havia um achado. A/B medido em 09/09 com os dois binários sobre o mesmo arquivo.
+ *
+ * SEM COLUNAS, O COMPORTAMENTO É O DE ANTES, e isso é deliberado: um literal DERIVADO (`duration-300`
+ * -> `300ms`) não está escrito na linha, então não há coluna para ele, e a resposta certa continua
+ * sendo a que o comando já dá (nada foi escrito, e ele diz por quê).
+ */
+function swapAll(line, literal, name, cols) {
+    if (cols && cols.length > 0)
+        return swapAtCols(line, literal, name, cols);
     const guarded = selfRanges(line, name);
     let out = "";
     let from = 0;
@@ -168,8 +206,17 @@ export function planFix(d, read) {
      * DE BAIXO PARA CIMA no arquivo não é necessário - a troca não muda a contagem de linhas - mas a
      * ORDEM por arquivo é, para dois achados na mesma linha não se atropelarem: o segundo procura o seu
      * literal no texto que o primeiro já deixou.
+     *
+     * E DA DIREITA PARA A ESQUERDA DENTRO DA LINHA, desde que a troca acontece nas COLUNAS medidas
+     * (ver `Finding.cols`): `var(--ds-spacing-8)` é mais longo que `8px`, então trocar o primeiro
+     * valor de um `padding: 8px 24px` empurra o segundo para a direita e a coluna dele deixa de
+     * casar - o `24px` ficava literal, e o comando dizia que a linha tinha mudado desde a medição.
+     * Medido no próprio caso desta rodada, com o teste ponta a ponta em `apply-fix.spec.ts`.
      */
-    for (const f of d.findings) {
+    const rightToLeft = [...d.findings].sort((a, b) => a.file === b.file && a.line === b.line
+        ? Math.max(...(b.cols ?? [-1])) - Math.max(...(a.cols ?? [-1]))
+        : 0);
+    for (const f of rightToLeft) {
         /**
          * O NOME DELE GANHA - ver `nameToWrite` em `scan.ts`.
          *
@@ -286,7 +333,7 @@ export function planFix(d, read) {
         const already = `${f.file}:${f.line}:${f.literal}`;
         if (done.has(already))
             continue;
-        const swapped = current === undefined ? null : swapAll(current, f.literal, name);
+        const swapped = current === undefined ? null : swapAll(current, f.literal, name, f.cols);
         /**
          * TODA OCORRÊNCIA DA LINHA ERA A PRÓPRIA DECLARAÇÃO - o caso que o guard sempre recusou, dito
          * com a mesma frase de antes. O que mudou é que uma linha que declara E usa deixou de cair aqui.
@@ -469,5 +516,21 @@ export function describeFix(result, dry) {
         lines.push(`${unread} file${unread === 1 ? "" : "s"} could not be read.`);
     if (decisions > 0)
         lines.push(`${decisions} finding${decisions === 1 ? "" : "s"} left: values your system has no name for. Those are decisions - name them, or file a request: npx synthesisui request token`);
+    /**
+     * OS QUE SOBRARAM NA LINHA QUE O COMANDO ACABOU DE REESCREVER - e sem esta linha o recibo não os
+     * liga a nada.
+     *
+     * Desde que cada comprimento de um shorthand tem achado próprio, uma linha volta do `--fix` com
+     * token E literal lado a lado: `padding: 8px var(--ds-spacing-24)`. O número de "sobraram" já
+     * aparecia, mas não dizia que parte dele está em linhas que este mesmo comando tocou - e é
+     * justamente onde ele vai olhar primeiro quando abrir o diff.
+     *
+     * Mesmo formato das outras linhas por motivo (`selfRef`, `notWritten`, `relative`): o número, o
+     * porquê, e o comando para ver.
+     */
+    const rewritten = new Set(applied.map((a) => `${a.file}:${a.line}`));
+    const halfWritten = skipped.filter((s) => rewritten.has(`${s.file}:${s.line}`)).length;
+    if (halfWritten > 0)
+        lines.push(`  ${halfWritten} of those ${halfWritten === 1 ? "sits" : "sit"} on a line this command just rewrote - a shorthand comes back with a token and a literal side by side (\`padding: 8px var(--ds-spacing-24)\`). See them by value: npx synthesisui doctor --migrate`);
     return lines;
 }

package/dist/doctor/ci-format.js

@@ -22,6 +22,8 @@
  * NADA AQUI FALA COM A REDE nem pede login. É a mesma decisão que mantém o hook instalado: uma
  * checagem que telefona para casa é uma checagem que alguém desinstala.
  */
+import { isOlderCli } from "../cli-version.js";
+import { CHECKER_SINCE } from "../install-marks.js";
 const byFileOf = (d) => {
     const out = {};
     for (const f of d.files)
@@ -63,8 +65,23 @@ export function compareToBaseline(d, base, now) {
     const drift = { was: base.totals.drift, now: d.findings.length };
     const phantoms = { was: base.totals.phantoms, now: d.phantomUses };
     const scopeChanged = (base.scope ?? "") !== (now.scope ?? "");
+    /**
+     * O LEITOR MUDOU DESDE O BASELINE, e aí a subida é NOSSA - reprovar o PR dele por isso é o alarme
+     * falso que ensina um time a passar `--no-verify`.
+     *
+     * MEDIDO EM 09/09: um baseline escrito pela 0.16.407 dizia 8799, a rodada de hoje contou 9531 -
+     * cada comprimento de um shorthand conta agora -, e a catraca respondia `worse: true`, *"Fix those
+     * lines"*, saída 1, num repositório onde ninguém tocou uma linha. O tipo deste arquivo já
+     * prometia o contrário desde o primeiro dia (*"um número que sobe porque o leitor melhorou não é
+     * regressão"*), e `incomparable` existia para exatamente isto.
+     *
+     * A RÉGUA É A MARCA QUE JÁ EXISTE: `CHECKER_SINCE` é a última versão em que a leitura que o CI
+     * compara mudou de resposta, e ela sobe no mesmo PR que muda a leitura. Nada de limiar novo.
+     */
+    const readerMoved = base.cli !== undefined && isOlderCli(base.cli, CHECKER_SINCE);
     return {
         worse: !scopeChanged &&
+            !readerMoved &&
             (drift.now > drift.was ||
                 phantoms.now > phantoms.was ||
                 regressed.length > 0),
@@ -76,7 +93,11 @@ export function compareToBaseline(d, base, now) {
             ? {
                 incomparable: `the baseline was measured on ${base.scope ?? "the whole repo"} and this run read ${now.scope ?? "the whole repo"} - different inputs, so nothing is failed on the difference`,
             }
-            : {}),
+            : readerMoved
+                ? {
+                    incomparable: `the baseline was written by CLI ${base.cli}, and this run counts every length in a shorthand - that version counted only the first. The rise is in the reading, not in your code. Rewrite the line before comparing: npx synthesisui doctor --write-baseline`,
+                }
+                : {}),
     };
 }
 /**

package/dist/doctor/ledger.js

@@ -215,8 +215,25 @@ export async function readEvents(root) {
  *
  * A 2 é a camada de token DELE entrando na conta (13/08): `var(--color-ocean-500)`, que ele declara
  * no CSS global, deixou de ser invisível e passou a contar como valor governado.
+ *
+ * A 3 é cada comprimento de um shorthand entrando na conta (09/09): `padding: 8px 24px` contava um
+ * valor e agora conta dois. Sem subir a régua, a tendência anunciava uma QUEDA que ninguém fez -
+ * medido: `coverage 40% -> 0% since the first run` na cópia do `web-subscribe`, e `30% -> 28%` no
+ * `frontend-hub`. O denominador cresceu porque a leitura melhorou, e comparar as duas fotos é
+ * comparar réguas diferentes.
+ */
+export const COVERAGE_RULE = 3;
+/**
+ * POR QUE A TENDÊNCIA RECOMEÇOU - uma frase por régua, e a saída lê ESTA, nunca uma fixa.
+ *
+ * A frase estava cravada no `doctor` desde 13/08 (*"your own tokens count now too"*), então na
+ * primeira vez que a régua subiu por outro motivo ela explicaria a causa ERRADA para quem lê. A
+ * razão viaja com a régua: quem sobe uma escreve a outra ao lado.
  */
-export const COVERAGE_RULE = 2;
+export const COVERAGE_RULE_REASON = {
+    2: "your own tokens count now too",
+    3: "every length in a shorthand counts now - `padding: 8px 24px` was one value and is two",
+};
 export function summarize(events) {
     const hooks = events.filter((e) => e.kind === "hook" && e.file);
     const byFile = new Map();

package/dist/doctor/scan.js

@@ -74,10 +74,43 @@ export const COLOR = /#[0-9a-fA-F]{8}\b|#[0-9a-fA-F]{6}\b|#[0-9a-fA-F]{3}\b|rgba
  * JSX also camelCases, so `borderRadius` has to be as welcome as
  * `border-radius`.
  */
-const OPEN = `["']?`;
-/** `rounded-[14px]`, `border-radius: 14px`, `borderRadius: "14px"`. Zero and
- *  full pills are idiom, not drift - nobody tokenizes `0` or `9999px`. */
-const RADIUS = new RegExp(`(?:border-?[Rr]adius\\s*:\\s*${OPEN}|rounded(?:-[a-z]+)?-\\[)(-?\\d*\\.?\\d+)(px|rem|em)`, "g");
+/**
+ * CADA COMPRIMENTO DA DECLARAÇÃO, e não só o primeiro - a dívida que a `INV-VOC-09` declarou.
+ *
+ * O padrão exigia o número CONTÍGUO à propriedade, então `padding: 8px 24px` rendia `8px` e o
+ * `24px` não existia para a esteira: nem como achado, nem na fila do `absorb`. Medido em 09/09 nas
+ * duas populações:
+ *
+ *     declarações de espaço/raio com comprimento   3694 (web-subscribe)   2970 (frontend-hub)
+ *       com 2+ comprimentos (shorthand)             501 (14%)              482 (16%)
+ *     ocorrências que a lista NÃO via               619                    540
+ *     na PRIMEIRA TELA (as 40 mais repetidas)       5 entram, 5 saem       4 entram, 4 saem
+ *     maior subcontagem de um valor                 16px: 287 -> 398       577 -> 773
+ *
+ * A promessa *"o arquivo tem os 40 mais repetidos"* era falsa, porque a contagem não era a real - e
+ * na MESMA linha impressa havia dois números discordando, o `because` do passe de função (que conta
+ * todos os comprimentos) e a coluna `<spacing, N files>` do scan (parcial).
+ *
+ * A IMUNIDADE À ÂNCORA É PRESERVADA, e é o que separa esta leitura da do passe de função: o valor é
+ * lido DENTRO da declaração (até `;`, `}`, `]`, aspa ou fim de linha), então um `width: 100px` na
+ * mesma linha nunca é lido como padding. Duas réguas, a mesma resposta.
+ */
+const DECL_VALUE = `\\s*:\\s*["'\`]?([^;}\\]"'\`\\n]*)`;
+/**
+ * O comprimento dentro de um valor. O lookbehind impede `4px` dentro de `24px`; o guard de trás
+ * aceita o `_` que o Tailwind usa por espaço (`8px_16px`), como o literal de tempo já faz.
+ */
+const LENGTH_IN_VALUE = /(?<![\d.])(-?\d*\.?\d+)(px|rem|em)(?![a-zA-Z0-9%])/g;
+/** `border-radius: 14px 8px`, `borderRadius: "14px"` - a declaração inteira. */
+const RADIUS_DECL = new RegExp(`border-?[Rr]adius${DECL_VALUE}`, "g");
+/**
+ * `rounded-[14px]`, `rounded-[4px_8px]` - o que está entre os colchetes é um VALOR, e o Tailwind
+ * escreve o espaço como `_`. A primeira versão desta rodada capturava um comprimento por par de
+ * colchetes, então `rounded-[4px_8px]` rendia só o `4px` - o mesmo defeito que o outro lado
+ * consertou, e o comentário de `LENGTH_IN_VALUE` já citava `8px_16px` como a razão de aceitar `_`.
+ * N=0 nas três populações medidas em 09/09: o defeito não estava na amostra, estava na promessa.
+ */
+const RADIUS_UTIL = /rounded(?:-[a-z]+)?-\[([^\]]*)/g;
 /**
  * Arbitrary spacing: `p-[18px]`, `gap-[7px]`, `margin: 18px`, `gap: "18px"`.
  * The JSX side also writes `paddingLeft`, `marginTop` and friends.
@@ -106,7 +139,9 @@ const RADIUS = new RegExp(`(?:border-?[Rr]adius\\s*:\\s*${OPEN}|rounded(?:-[a-z]
  * Duas gramáticas para a mesma propriedade é o tipo de coisa que só aparece quando alguém aponta
  * para um arquivo e conta na mão.
  */
-const SPACING = new RegExp(`(?:\\b[pmg](?:[trblxy])?-\\[|gap-\\[|(?:padding|margin|gap)(?:[A-Z][a-z]+|(?:-[a-z]+)+)?\\s*:\\s*${OPEN})(-?\\d*\\.?\\d+)(px|rem|em)`, "g");
+const SPACING_DECL = new RegExp(`(?:padding|margin|gap)(?:[A-Z][a-z]+|(?:-[a-z]+)+)?${DECL_VALUE}`, "g");
+/** `p-[18px]`, `gap-[7px]`, `p-[8px_16px]` - o valor inteiro entre os colchetes. */
+const SPACING_UTIL = /(?:\b[pmg](?:[trblxy])?-\[|gap-\[)([^\]]*)/g;
 /** A font stack written by hand rather than taken from the type scale. */
 const FONT = /font-family\s*:\s*([^;}\n]+)/g;
 /**
@@ -438,6 +473,16 @@ function scanCore(file, source, table) {
     let svgDepth = 0;
     source.split("\n").forEach((raw, i) => {
         const line = raw.trim();
+        /**
+         * O RECUO DA LINHA, para as COLUNAS do achado serem as do ARQUIVO.
+         *
+         * A varredura trabalha na linha aparada, e todos os guards de posição (fallback, markup,
+         * conteúdo) medem contra ela. `Finding.cols` sai para fora - é o `--fix` que a usa para escrever
+         * no arquivo DELE -, então ela precisa da coluna real: sem somar o recuo, um `border-radius: 4px`
+         * indentado com dois espaços apontava para dois caracteres antes do literal, e a troca não
+         * acontecia (o comando dizia que a linha havia mudado desde a medição).
+         */
+        const indent = line ? raw.indexOf(line) : 0;
         const at = i + 1;
         tokenUses += countTokenUses(line, table);
         /**
@@ -519,8 +564,20 @@ function scanCore(file, source, table) {
                 return;
             }
             const key = `${kind}:${literal}`;
-            if (seen.has(key))
+            /**
+             * A MESMA DECISÃO É UM ACHADO E VÁRIAS ESCRITAS: a segunda ocorrência não vira uma linha nova
+             * no relatório, mas a coluna dela entra no achado que já existe - senão o `--fix` deixaria
+             * metade da linha literal.
+             */
+            const written = col >= 0 && line.startsWith(literal, col) ? col + indent : -1;
+            if (seen.has(key)) {
+                if (written >= 0) {
+                    const first = findings.find((f) => f.kind === kind && f.literal === literal && f.line === at);
+                    if (first && !first.cols?.includes(written))
+                        first.cols = [...(first.cols ?? []), written];
+                }
                 return;
+            }
             seen.add(key);
             // The kind is already known here, and without passing it the lookup
             // answers a `gap` with a radius token.
@@ -536,6 +593,7 @@ function scanCore(file, source, table) {
                 kind,
                 line: at,
                 literal,
+                ...(written >= 0 ? { cols: [written] } : {}),
                 token: match?.token ?? null,
                 ...(/(?<!r)em$/i.test(literal.trim())
                     ? { fontRelative: true }
@@ -576,16 +634,42 @@ function scanCore(file, source, table) {
             }
             push("color", m[0], m.index ?? -1);
         }
-        for (const m of line.matchAll(RADIUS)) {
-            const value = `${m[1]}${m[2]}`;
-            if (!IDIOM.has(value))
-                push("radius", value, m.index ?? -1);
-        }
-        for (const m of line.matchAll(SPACING)) {
-            const value = `${m[1]}${m[2]}`;
-            if (!IDIOM.has(value))
-                push("spacing", value, m.index ?? -1);
-        }
+        /**
+         * CADA COMPRIMENTO DA DECLARAÇÃO, com a COLUNA DELE - e a coluna importa: os três guards de
+         * posição (fallback de `var()`, markup como texto, conteúdo que a página mostra) decidem por
+         * ela. Passar a coluna da propriedade para todos faria o segundo valor de um shorthand ser
+         * julgado pelo lugar do primeiro.
+         */
+        const pushLengths = (kind, m) => {
+            const whole = m[1] ?? "";
+            /**
+             * O VALOR PARA NA PRÓXIMA PROPRIEDADE ESCRITA - e sem isto a leitura vazava por duas formas
+             * que o QA reproduziu em 09/09 (N=0 nas três populações, 1335 arquivos Sass/Less varridos):
+             *
+             *     @supports (padding: 8px) and (width: 100px)     contava o `100px` como padding
+             *     $r: (border-radius: 6px, font-size: 14px)       contava o `14px` como raio
+             *
+             * Os terminadores de `DECL_VALUE` (`;`, `}`, `]`, aspa, fim de linha) não fecham nenhuma das
+             * duas: a declaração de verdade acabou onde a PRÓXIMA começou.
+             */
+            const cut = /(?<![\w-])[a-zA-Z-]{2,}\s*:/.exec(whole);
+            const value = cut ? whole.slice(0, cut.index) : whole;
+            const base = (m.index ?? 0) + m[0].length - whole.length;
+            for (const l of value.matchAll(LENGTH_IN_VALUE)) {
+                const literal = `${l[1]}${l[2]}`;
+                /** `0`, `1px`, `9999px`: idiom em QUALQUER posição, não só na primeira. */
+                if (!IDIOM.has(literal))
+                    push(kind, literal, base + (l.index ?? 0));
+            }
+        };
+        for (const m of line.matchAll(RADIUS_UTIL))
+            pushLengths("radius", m);
+        for (const m of line.matchAll(RADIUS_DECL))
+            pushLengths("radius", m);
+        for (const m of line.matchAll(SPACING_UTIL))
+            pushLengths("spacing", m);
+        for (const m of line.matchAll(SPACING_DECL))
+            pushLengths("spacing", m);
         for (const m of line.matchAll(FONT)) {
             const stack = m[1].trim();
             // A stack already reading from the system is the point, not a problem.

package/dist/global-sheet.js

@@ -65,13 +65,39 @@ async function fromWorkspace(root, spec) {
 }
 /**
  * A folha onde os tokens dele devem entrar, relativa à raiz - `appSheet` quando nada a re-exporta.
+ *
+ * DELEGA, e não caminha: quem caminha é `sheetChainOf`. Dois caminhadores sobre a mesma cadeia é
+ * como um deles para de seguir um salto que o outro segue, e ninguém descobre até um cliente
+ * receber a instrução apontando para a folha errada - que é exatamente o defeito que
+ * `INV-VOLTA-12` fechou.
  */
 export async function globalSheetOf(root, appSheet) {
+    const chain = await sheetChainOf(root, appSheet);
+    return chain[chain.length - 1] ?? appSheet;
+}
+/**
+ * A CADEIA INTEIRA, da folha do app até a última que ninguém re-exporta - e por que ela é pública.
+ *
+ * O QUE O CLIENTE GANHA: a resposta "este app carrega o meu design system?" medida no app DELE, e
+ * não no projeto. `readWiring` varria a raiz e devolvia "existe em algum lugar daqui": num monorepo
+ * com dois apps servidos, um fiado e outro não, o fiado respondia pelo outro - e a pessoa recebia
+ * "está tudo certo" sobre o app que não carrega nada.
+ *
+ * A pergunta dos IMPORTS não se responde varrendo pasta: ela se responde seguindo a cadeia de
+ * `@import` a partir da folha daquele app, porque a folha que carrega os tokens quase nunca é a do
+ * app - num monorepo é a do pacote compartilhado, e os dois apps chegam nela.
+ *
+ * A ordem é do app para fora, e o teto de saltos é o mesmo: um ciclo de imports não pode travar um
+ * comando.
+ */
+export async function sheetChainOf(root, appSheet) {
+    const chain = [];
     let current = appSheet;
     for (let hop = 0; hop < MAX_HOPS; hop += 1) {
+        chain.push(current);
         const raw = await readFile(join(root, current), "utf8").catch(() => null);
         if (!raw)
-            return current;
+            return chain;
         let next = null;
         for (const m of raw.matchAll(IMPORT)) {
             const spec = m[1];
@@ -91,11 +117,12 @@ export async function globalSheetOf(root, appSheet) {
             next = candidate;
             break;
         }
-        if (!next || next === current)
-            return current;
+        /** Uma folha que aponta para si mesma encerra a cadeia em vez de gastar o teto de saltos. */
+        if (!next || next === current || chain.includes(next))
+            return chain;
         current = next;
     }
-    return current;
+    return chain;
 }
 /** O `../` que leva daquela folha até a raiz do repositório - o prefixo do `@import`. */
 export function prefixFrom(sheet) {

package/dist/install-marks.js

@@ -250,7 +250,15 @@ export const MATERIALISER_SINCE = "0.16.403";
  * `#6b6b78 is already --color-ink-500` numa frase da landing e manda tokenizar TEXTO. Um hook
  * pinado antes desta versão aconselha OUTRA coisa, que é a régua desta marca.
  */
-export const CHECKER_SINCE = "0.16.378";
+/**
+ * 0.16.378 -> 0.16.408 em 09/09: o hook passa a ver CADA comprimento de uma declaração. `scanSource`
+ * exigia o número contíguo à propriedade, então num `padding: 8px 24px` ele aconselhava sobre o
+ * `8px` e ficava calado sobre o `24px` - mesmo com um `--spacing-24` do próprio repositório dele
+ * nomeando aquele valor. Medido em 09/09 nas duas populações: 619 e 540 ocorrências que a leitura
+ * não via, 14% e 16% das declarações de espaço/raio. Um hook pinado antes desta versão aconselha
+ * MENOS, que é a régua desta marca.
+ */
+export const CHECKER_SINCE = "0.16.408";
 /**
  * A ÚLTIMA VERSÃO EM QUE OS LEITORES PASSARAM A PRODUZIR UM CENSO DIFERENTE.
  *
@@ -691,7 +699,15 @@ export const CHECKER_SINCE = "0.16.378";
  * muda um byte. Medido em 06/09: `frontend-hub/apps/web-dashboard` tem UM grupo acima (6 393), e
  * `packages/ui` e `apps/web-review` nenhum.
  */
-export const READER_SINCE = "0.16.383";
+/**
+ * 0.16.383 -> 0.16.408 em 09/09: o censo passou a carregar cada comprimento de um shorthand. Um
+ * `padding: 8px 24px` gravava só o `8px`, então o censo de quem já importou afirma menos valores à
+ * mão do que o repositório dele tem - 619 ocorrências no `web-subscribe` e 540 no `frontend-hub`, e
+ * na primeira tela do `absorb` (as 40 mais repetidas) 5 e 4 valores ocupavam o lugar de outros que
+ * deveriam estar lá. Quem tem censo gravado precisa de um `sync` para a fila de trabalho dele ser a
+ * real; ver o livro-razão de `corpus.spec.ts`.
+ */
+export const READER_SINCE = "0.16.408";
 /**
  * O QUE ESTÁ INSTALADO AQUI FICOU PARA TRÁS - e as DUAS condições que fazem isso ser verdade.
  *

package/dist/wiring-read.js

@@ -2,6 +2,7 @@ import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { walk } from "./commands/doctor.js";
 import { FAMILY_SEAM_PREFIX } from "./fonts.js";
+import { detectAppDirs, sheetChainOf } from "./global-sheet.js";
 /**
  * A FIAÇÃO DESTE PROJETO, MEDIDA - e a mesma medição para todos os comandos que a citam.
  *
@@ -111,3 +112,79 @@ export async function readWiring(root, slug) {
     }
     return w;
 }
+/**
+ * A FIAÇÃO DE CADA APP, e num monorepo é ela que decide - `readWiring` acima não decide.
+ *
+ * O QUE O CLIENTE VIA: `readWiring` varre da RAIZ e responde "existe, em algum lugar daqui". Num
+ * monorepo com dois apps servidos, um fiado e outro não, o fiado respondia pelo outro: a pessoa
+ * abria o app que não carrega nada e o comando dizia que estava tudo certo. O contrato já declarava
+ * isso como lacuna (`INV-VOLTA-12`, "a resposta é do PROJETO, e num monorepo ela não decide") e o
+ * comando dizia o que mediu em vez de afirmar - honesto, e ainda a resposta errada.
+ *
+ * COMO A RESPOSTA CERTA É ENCONTRADA, e cada metade vem de onde ela mora:
+ *
+ *     os `@import`   seguindo a CADEIA de folhas a partir da folha daquele app (`sheetChainOf`).
+ *                    A folha que carrega os tokens quase nunca é a do app: num monorepo é a do
+ *                    pacote compartilhado, e os dois apps chegam nela - então varrer pasta daria
+ *                    "não" para os dois, e varrer a raiz dá "sim" para todos
+ *     o `data-ds`    na árvore DAQUELE app, porque o escopo mora no layout dele
+ *     as fontes      idem - `init` escreve o arquivo de fonte por app
+ *
+ * O QUE ESTA FUNÇÃO NÃO GENERALIZA, declarado com o N de hoje (medido em 09/09):
+ *
+ *     `detectAppDirs` só procura em `apps/` e `packages/`   cobre 4 de 4 monorepos medidos;
+ *                                                           `pnpm-workspace.yaml` aparece em 0 de 10
+ *     e só reconhece app pelo `layout` do App Router        cobre 7 de 7 raízes de app medidas;
+ *                                                           `vite` aparece só em PACOTE de
+ *                                                           biblioteca, corretamente ignorado
+ *
+ * As duas são estreitezas REAIS e as duas têm N=0 de evidência contrária hoje. Generalizá-las sem
+ * uma população que as exija seria dimensionar pela imaginação - o erro que `INV-GERAL-07` nomeia
+ * pelo avesso. Quando aparecer um repositório que caia fora, o número dele é que abre a frente.
+ */
+export async function readWiringPerApp(root, slug, pagesDir) {
+    if (!slug)
+        return [];
+    const apps = await detectAppDirs(root, pagesDir);
+    const out = [];
+    const hasShadcn = await readFile(join(root, "components.json"), "utf8").then(() => true, () => false);
+    for (const app of apps) {
+        const w = {
+            imported: false,
+            themed: false,
+            scoped: false,
+            fontsWritten: false,
+            fontsMapped: false,
+            hasShadcn,
+            bridged: false,
+        };
+        /** Os imports: a cadeia daquele app, e não a pasta dele. */
+        for (const sheet of await sheetChainOf(root, `${app}/globals.css`)) {
+            const css = await readFile(join(root, sheet), "utf8").catch(() => "");
+            if (!css)
+                continue;
+            if (css.includes(`_synthesisui/ds/${slug}/tokens.css`))
+                w.imported = true;
+            if (css.includes(`_synthesisui/ds/${slug}/theme.css`))
+                w.themed = true;
+            if (css.includes(`_synthesisui/ds/${slug}/shadcn.css`))
+                w.bridged = true;
+        }
+        /** O escopo e as fontes: a árvore DAQUELE app - é onde o layout dele mora. */
+        for await (const file of walk(join(root, app))) {
+            const src = await readFile(file, "utf8").catch(() => "");
+            if (!src)
+                continue;
+            if (src.includes(`data-ds="${slug}"`))
+                w.scoped = true;
+            if (src.includes("--font-ds-") && /next\/font/.test(src))
+                w.fontsWritten = true;
+            if (new RegExp(`${FAMILY_SEAM_PREFIX}\\w+\\s*:\\s*var\\(\\s*--font-ds-`).test(src))
+                w.fontsMapped = true;
+            if (w.scoped && w.fontsMapped)
+                break;
+        }
+        out.push({ app, wiring: w });
+    }
+    return out;
+}

package/package.json

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