synthesisui 0.16.272 → 0.16.274

package/dist/anatomy-from-sketch.js

@@ -608,8 +608,12 @@ versionOf) {
          * one is a hole somebody has to explain.
          */
         const expects = EXPECTS[lower];
+        /**
+         * E O MESMO ÍNDICE NO SLOT DE UM NÓ INTERNO, pela mesma razão: `measuredAt` só alcança um nó que
+         * saiba de onde veio. Aqui o `at` é o do PRÓPRIO nó, porque é o conteúdo dele que o slot ocupa.
+         */
         const withSlot = node.slot
-            ? [...inside, { as: "slot", ...(expects ? { expects } : {}) }]
+            ? [...inside, { as: "slot", at: index, ...(expects ? { expects } : {}) }]
             : inside;
         if (withSlot.length > 0) {
             built.children = withSlot;
@@ -655,7 +659,31 @@ versionOf) {
     const rootNode = sketch[top];
     if (rootNode?.slot) {
         const only = EXPECTS[String(rootNode.tag ?? "").toLowerCase()];
-        read.push({ as: "slot", ...(only ? { expects: only } : {}) });
+        /**
+         * O ÍNDICE DA RAIZ VIAJA COM O SLOT - e sem ele TODO fato de call-site da raiz sumia.
+         *
+         * `measuredAt` (anatomy-read.ts) começa com `if (typeof node.at !== "number") return out` e só
+         * depois lê `passes`, `contentFrom`, `behaviourProps`, `repeats` e `text`. Um nó sintetizado sem
+         * `at` não tem como recuperar nada disso.
+         *
+         * Medido em 21/08 no repositório do dono, e o que se perdia era ACESSIBILIDADE QUE ELE ESCREVEU:
+         *
+         *     Toast           <div role="status" aria-live="polite">
+         *     TooltipContent  <span role="tooltip">
+         *     ThemeToggle     <button type="button" role="switch" aria-label=…>
+         *     Card            <Tag onMouseMove=… onMouseLeave=…>   (o tilt inteiro)
+         *
+         * A lei 10 diz que acessibilidade SUPOSTA é pior que nenhuma. Isto era o inverso e é pior ainda:
+         * ele escreveu, o censo colheu, e a receita entregava uma div muda ao agente dele.
+         *
+         * A raiz continua consumida - ela É o componente. O que muda é que o fato dela deixa de morrer com
+         * ela: viaja no slot que representa o conteúdo dela, que é o nó que sobra da raiz.
+         */
+        read.push({
+            as: "slot",
+            at: top,
+            ...(only ? { expects: only } : {}),
+        });
     }
     return { read, notes, libraries };
 }

package/dist/commands/import.js

@@ -42,7 +42,9 @@ import { mergeCensus } from "../merge-census.js";
 import { claimName } from "../name-claim.js";
 import { namingQueue } from "../naming-queue.js";
 import { body, paint, section } from "../output.js";
+import { outsideScope } from "../outside-scope.js";
 import { phase, startProgress } from "../progress.js";
+import { repoStateOf } from "../repo-state.js";
 import { detectStack, resolveDeps, stackVersions } from "../stack.js";
 import { placeInWorkspace } from "../workspace-place.js";
 import { walk, walkAll } from "./doctor.js";
@@ -380,6 +382,17 @@ export async function takeCensus(root, opts) {
      */
     const say = opts?.quiet ? () => { } : (line) => console.log(line);
     const scopeLabel = opts?.scopeLabel;
+    /**
+     * O QUE O ESCOPO DEIXOU DE FORA, medido no sistema de arquivos - ver `outside-scope.ts`.
+     *
+     * Os caminhos que o leitor REALMENTE olhou são o escopo mais os de uso: `--scope packages/ui
+     * --usage apps/web` lê os dois, então nenhum dos dois é "fora". Sem `scopeLabel` a função devolve
+     * `null` por conta, porque aí ele apontou para a raiz.
+     */
+    const outside = await outsideScope(root, [
+        ...(scopeLabel ? [scopeLabel] : []),
+        ...(opts?.usage ?? []).map((u) => u.label),
+    ]).catch(() => null);
     /**
      * THE LIVE CATALOGUE, once, before anything is matched.
      *
@@ -2150,6 +2163,15 @@ export async function takeCensus(root, opts) {
          * acima o tempo todo, gravado por este mesmo objeto - os dois chegam juntos e só um sobrevivia.
          */
         ...(scopeLabel ? { scope: scopeLabel } : {}),
+        /**
+         * O DENOMINADOR DO FORA - ver `outside-scope.ts`.
+         *
+         * `reachability` e `coverage` contam o dentro. Esta é a única linha que diz o que o escopo
+         * EXCLUIU, e ela existe porque a garantia honesta sobre o que ninguém abriu não é "leu tudo" - é
+         * "sabe exatamente o que não abriu". `null` quando não há escopo: aí o leitor olhou a raiz e a
+         * categoria não existe.
+         */
+        ...(outside ? { outsideScope: outside } : {}),
         ...((opts?.usage ?? []).length > 0
             ? { usage: (opts?.usage ?? []).map((u) => u.label) }
             : {}),
@@ -3667,6 +3689,10 @@ export async function runImport(opts) {
         console.log("");
         return;
     }
+    /** O que a máquina dele fez até agora - ver o corpo do POST abaixo. */
+    const repoAtImport = opts.cli
+        ? await repoStateOf(root, "", opts.cli).catch(() => null)
+        : null;
     phase(3, 3, "Sending v1 and the v2 proposal");
     const res = await fetch(`${base}/api/onboarding/import`, {
         method: "POST",
@@ -3674,10 +3700,26 @@ export async function runImport(opts) {
             "content-type": "application/json",
             Authorization: `Bearer ${token}`,
         },
+        /**
+         * O ESTADO DO REPO VAI NO IMPORT TAMBÉM - e não só no `sync`.
+         *
+         * Medido em 21/08: `repo_state` era NULL no sistema que acabou de nascer, porque este corpo tinha
+         * três campos e o do `sync` tem seis. A consequência é que TRÊS classes de causa ficam cegas num
+         * import - `command-failed`, `command-flooded` e `command-skipped-check` leem `repo.runs`, e sem
+         * ele o cliente roda, algo quebra no comando, e a plataforma não sabe.
+         *
+         * O import É a primeira sincronização: quando ele roda, o `ledger.jsonl` já tem as execuções
+         * anteriores no disco - 16 delas, no caso medido, e zero enviadas.
+         *
+         * O SLUG AINDA NÃO EXISTE aqui, e é por isso que ele vai vazio: `repoStateOf` usa o slug só para
+         * ler `_synthesisui/ds/<slug>/.lock`, que num import não existe de qualquer forma. Todo campo do
+         * payload é opcional, então o que falta simplesmente não viaja - em vez de o conjunto todo faltar.
+         */
         body: JSON.stringify({
             census,
             name: chosen,
             ...(opts.group ? { group: opts.group } : {}),
+            ...(repoAtImport ? { repo: repoAtImport } : {}),
         }),
     }).catch(() => null);
     if (!res || !res.ok) {

package/dist/index.js

@@ -640,7 +640,15 @@ function scrub(message) {
         .replace(/(?:\.{0,2}\/)[^\s'"`)]{2,}/g, "<path>")
         .trim();
 }
-async function recordRun(command, started, ok, error, bytes) {
+async function recordRun(command, started, ok, error, 
+/**
+ * O QUE A SAÍDA MEDIU: quantos bytes, e a LINHA MAIS LARGA.
+ *
+ * A largura é o eixo novo. Em 21/08 a tabela do import saiu ilegível na tela do dono com 27 947
+ * bytes - abaixo de qualquer teto de inundação - porque o problema nunca foi tamanho, foi uma linha
+ * que não cabe.
+ */
+written) {
     try {
         const root = resolve(typeof parseFlags(process.argv.slice(2)).flags.dir === "string"
             ? parseFlags(process.argv.slice(2)).flags.dir
@@ -681,7 +689,22 @@ async function recordRun(command, started, ok, error, bytes) {
             ms: Date.now() - started,
             /** Só a primeira linha, cortada: uma stack carrega caminhos do projeto de alguém. */
             ...(message ? { error: message.split("\n")[0].slice(0, 200) } : {}),
-            ...(typeof bytes === "number" && bytes > 0 ? { bytes } : {}),
+            ...(written && written.bytes > 0 ? { bytes: written.bytes } : {}),
+            /**
+             * A LARGURA VIAJA COM A DO TERMINAL, e não sozinha.
+             *
+             * `widest: 180` não diz nada; `widest: 180` num terminal de 120 diz que sessenta colunas foram
+             * redesenhadas em cima de si mesmas. Sem `columns` a plataforma teria que supor uma largura, e
+             * supor aqui é o que faz um alarme falso em toda máquina com janela grande.
+             */
+            ...(written && written.widest > 0
+                ? {
+                    widest: written.widest,
+                    ...(process.stdout.columns
+                        ? { columns: process.stdout.columns }
+                        : {}),
+                }
+                : {}),
             ...(frame ? { where: frame } : {}),
         });
     }
@@ -706,23 +729,44 @@ async function recordRun(command, started, ok, error, bytes) {
 function countingStdout() {
     const original = process.stdout.write.bind(process.stdout);
     let bytes = 0;
+    let widest = 0;
+    /**
+     * E A LINHA MAIS LARGA, medida junto - o eixo que nunca foi medido.
+     *
+     * Em 21/08 a tabela de fechamento do import saiu ILEGÍVEL na tela do dono: uma célula sobrescrevendo
+     * a outra, palavras cortadas no meio (`"19 com os eixos declaas partes aninhadas"`). A saída tinha
+     * 27 947 bytes - bem abaixo do teto de inundação de 64 KB -, então nenhuma medição nossa viu nada.
+     *
+     * Bytes não é a pergunta. A pergunta é se a linha CABE. Comparar a mais larga com
+     * `process.stdout.columns` transforma "a tabela quebrou" num número que a plataforma recebe, e é a
+     * primeira coisa que a esteira mede sobre a PRÓPRIA saída em vez de sobre o repositório dele.
+     *
+     * Códigos ANSI são retirados antes de contar: cor não ocupa coluna, e contá-la acusaria toda linha
+     * pintada.
+     */
     process.stdout.write = ((chunk, ...rest) => {
-        bytes +=
-            typeof chunk === "string"
-                ? Buffer.byteLength(chunk)
-                : Buffer.isBuffer(chunk)
-                    ? chunk.length
-                    : 0;
+        const text = typeof chunk === "string"
+            ? chunk
+            : Buffer.isBuffer(chunk)
+                ? chunk.toString("utf8")
+                : "";
+        bytes += Buffer.byteLength(text);
+        for (const line of text.split("\n")) {
+            // biome-ignore lint/suspicious/noControlCharactersInRegex: ANSI é exatamente o que se retira
+            const visible = line.replace(/\u001b\[[0-9;]*m/g, "");
+            if (visible.length > widest)
+                widest = visible.length;
+        }
         return original(chunk, ...rest);
     });
-    return () => bytes;
+    return () => ({ bytes, widest });
 }
 async function guarded() {
     const started = Date.now();
     const command = parseFlags(process.argv.slice(2)).positionals[0] ?? "";
     /** `help` e a invocação vazia não são trabalho sobre um projeto, e registrá-las seria só ruído. */
     const worth = command && command !== "help";
-    const written = worth ? countingStdout() : () => 0;
+    const written = worth ? countingStdout() : () => ({ bytes: 0, widest: 0 });
     try {
         await main();
         if (worth)

package/dist/install-marks.js

@@ -253,7 +253,7 @@ export const CHECKER_SINCE = "0.16.250";
  * publicado antes deste código existir, e uma marca nele calaria o aviso para quem o instalou. Mesma
  * lição de algumas horas antes, na mesma sessão.
  */
-export const READER_SINCE = "0.16.271";
+export const READER_SINCE = "0.16.274";
 /**
  * O QUE ESTÁ INSTALADO AQUI FICOU PARA TRÁS - e as DUAS condições que fazem isso ser verdade.
  *

package/dist/outside-scope.js

@@ -0,0 +1,103 @@
+import { readdir } from "node:fs/promises";
+import { join, relative, sep } from "node:path";
+/**
+ * O QUE O ESCOPO EXCLUIU - o único denominador que a esteira não tinha.
+ *
+ * O QUÊ. `census.reachability` diz *"22 de 22 arquivos alcançados"* e `census.coverage` diz *"60
+ * componentes, 59 lidos"*. As duas contas são honestas e as duas são sobre o DENTRO: quando alguém
+ * roda `--scope packages/ui`, tudo fora dali é invisível por construção, e nada conta o que ficou
+ * fora.
+ *
+ * POR QUÊ. O dono perguntou, com razão, se a gente consegue garantir que nenhuma informação dele se
+ * perde. Para tudo o que o leitor TOCA a resposta agora é sim, com portão. Para o que ele nunca abriu,
+ * a resposta honesta não é "sim" - é *"a gente sabe exatamente o que não abriu, e diz"*. É a única
+ * garantia que a física permite: não se conta o que não se olhou, mas se conta o que se deixou de
+ * olhar.
+ *
+ * COMO. Contagem de sistema de arquivos, determinística e barata. Nenhum parse: só quantos arquivos
+ * com a extensão do leitor existem fora do escopo, e em que diretórios de topo.
+ *
+ * O QUE ISTO NÃO PROMETE: dizer o que existe DENTRO daqueles arquivos. Isso exigiria lê-los, que é
+ * exatamente o que o escopo pediu para não fazer. A linha diz o tamanho da porta fechada, não o que
+ * há atrás dela - e é por isso que ela é uma oferta ("aponte para cá também"), nunca um alarme.
+ */
+/** As extensões que os leitores da esteira realmente abrem. */
+const READ = new Set([".tsx", ".jsx", ".ts", ".js", ".css", ".vue", ".svelte"]);
+/** Pastas que nenhum cliente quer contadas - e a lista é sobre RUÍDO, não sobre leitura. */
+const SKIP = new Set([
+    "node_modules",
+    "dist",
+    "build",
+    "out",
+    ".next",
+    ".turbo",
+    ".git",
+    "coverage",
+    "_synthesisui",
+    "storybook-static",
+]);
+async function countIn(dir, root, inside, tally, depth = 0) {
+    /** Um monorepo fundo não vale um passeio infinito; oito níveis cobrem qualquer layout real. */
+    if (depth > 8)
+        return;
+    /**
+     * O TIPO ESCRITO À MÃO, e não inferido de `readdir`: a sobrecarga que o TS escolhe sem argumento
+     * devolve `Dirent<Buffer>`, e aí `entry.name` deixa de ser string. Inferir de uma sobrecarga é
+     * pedir que o compilador adivinhe qual das cinco eu quis.
+     */
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (entry.name.startsWith(".") || SKIP.has(entry.name))
+            continue;
+        const path = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            await countIn(path, root, inside, tally, depth + 1);
+            continue;
+        }
+        const dot = entry.name.lastIndexOf(".");
+        if (dot < 0 || !READ.has(entry.name.slice(dot)))
+            continue;
+        const rel = relative(root, path);
+        if (inside(rel))
+            continue;
+        /** O diretório de topo é a unidade que uma pessoa reconhece: `apps/web`, não a pasta folha. */
+        const top = rel.split(sep).slice(0, 2).join("/");
+        tally.set(top, (tally.get(top) ?? 0) + 1);
+    }
+}
+/**
+ * MEDE O FORA. `scopes` são os caminhos que o import realmente leu, relativos à raiz.
+ *
+ * Devolve `null` quando não há escopo declarado: sem `--scope` o leitor olhou a raiz, então "fora do
+ * escopo" não é uma categoria que existe - e emitir uma linha de zero ensinaria o cliente a ignorar a
+ * seção quando ela tiver algo.
+ */
+export async function outsideScope(root, scopes) {
+    const declared = scopes.map((s) => s.replace(/^\.\//, "").replace(/\/$/, ""));
+    if (declared.length === 0)
+        return null;
+    const inside = (rel) => declared.some((s) => rel === s || rel.startsWith(`${s}/`));
+    const tally = new Map();
+    await countIn(root, root, inside, tally);
+    const places = [...tally]
+        .map(([path, files]) => ({ path, files }))
+        .sort((a, b) => b.files - a.files);
+    const files = places.reduce((n, p) => n + p.files, 0);
+    if (files === 0)
+        return null;
+    const named = places
+        .slice(0, 3)
+        .map((p) => `${p.path} (${p.files})`)
+        .join(", ");
+    return {
+        files,
+        places,
+        said: `${files} more readable file${files === 1 ? "" : "s"} live outside what you pointed at - ${named}${places.length > 3 ? `, and ${places.length - 3} more place${places.length - 3 === 1 ? "" : "s"}` : ""}. Nothing was read there, so nothing about them is in this measurement: point at them too if their design belongs in this system.`,
+    };
+}

package/package.json

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