synthesisui 0.16.325 → 0.16.327

package/dist/commands/align.js

@@ -369,9 +369,17 @@ export async function versionBehind(root, opts = {}) {
     const lock = locks[0];
     if (!lock?.slug || lock.version == null)
         return null;
-    if (!(await credentials(opts.home ?? homedir())))
+    /**
+     * UM `home` SÓ PARA AS DUAS LEITURAS, e não um por linha.
+     *
+     * Até 27/08 a primeira respeitava o `home` recebido e a segunda lia o `homedir()` da máquina, o que
+     * fazia os dois testes que esperam resultado passarem só onde havia credencial de produção salva.
+     * Uma variável dividida não deixa a segunda esquecer.
+     */
+    const home = opts.home ?? homedir();
+    if (!(await credentials(home)))
         return null;
-    const token = await readToken();
+    const token = await readToken(home);
     if (!token)
         return null;
     /**

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, } from "../doctor/ledger.js";
+import { appendEvent, COVERAGE_RULE, readEvents, suggestionsFrom, unrepresentedFrom, summarize, } 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";
@@ -938,6 +938,8 @@ export async function doctor(opts) {
                 ...(d.repeats.some((r) => nameToWrite(r))
                     ? { matched: suggestionsFrom(d.repeats) }
                     : {}),
+                /** SEMPRE, inclusive vazio - ver `CheckEvent.unrepresentedMatches`: o vazio é a medição. */
+                unrepresentedMatches: unrepresentedFrom(d.findings, suggestionsFrom(d.repeats)),
             }).catch(() => { });
         console.log("");
         if (opts.fix) {
@@ -1149,6 +1151,15 @@ export async function doctor(opts) {
             ...(d.repeats.some((r) => nameToWrite(r))
                 ? { matched: suggestionsFrom(d.repeats) }
                 : {}),
+            /**
+             * E AS OCORRÊNCIAS QUE OS PARES NÃO CARREGAM - ver `CheckEvent.unrepresentedMatches`.
+             *
+             * ESCRITO SEMPRE, inclusive como lista vazia, e é a única forma de o campo significar alguma
+             * coisa: ausente quer dizer "um CLI que não media isto", e `[]` quer dizer "mediu e não há".
+             * Escrevê-lo condicionalmente faria os dois estados virarem um, e um cliente com ledger antigo
+             * passaria a parecer um cliente medido sem achados.
+             */
+            unrepresentedMatches: unrepresentedFrom(d.findings, suggestionsFrom(d.repeats)),
         });
     }
     if (hasSystem && fullRun) {

package/dist/commands/logout.js

@@ -21,6 +21,6 @@ export async function logout() {
         return;
     }
     console.log(`✓ Signed out${existing?.registry ? ` of ${existing.registry}` : ""} on this machine.`);
-    console.log(`  Removed ${credentialsPath}`);
+    console.log(`  Removed ${credentialsPath()}`);
     console.log("  Run `synthesisui login` to sign in as someone else.");
 }

package/dist/config.js

@@ -11,8 +11,24 @@ export function resolveRegistry(flag) {
     const base = flag || process.env.SYNTHESISUI_REGISTRY_URL || DEFAULT_REGISTRY;
     return base.replace(/\/+$/, ""); // no trailing slash
 }
-/** Where the device-flow token lives - per machine, in the home dir. */
-export const credentialsPath = join(homedir(), ".synthesisui", "credentials.json");
+/**
+ * Where the device-flow token lives - per machine, in the home dir.
+ *
+ * `home` É INJETÁVEL PELO MESMO MOTIVO QUE EM `align`: uma verificação que lê o home da máquina que
+ * roda o teste não é verificável - ela passa ou falha conforme quem está logado ali.
+ *
+ * O QUE ISTO CONSERTA, medido em 27/08: `versionBehind` recebia `home` e o respeitava em
+ * `credentials(...)`, e uma linha depois chamava `readToken()`, que lia uma CONSTANTE de módulo
+ * resolvida com o `homedir()` real. Os dois testes de `decided-waiting` que esperam resultado só
+ * passavam porque encontravam a credencial de produção de quem rodava a suíte; num runner limpo eles
+ * caíam. Era uma porta declarada aberta e fechada pela metade - e o CLAUDE.md pede fechar a porta em
+ * vez de vigiá-la, então ela deixou de ser constante.
+ *
+ * O comportamento do produto é o mesmo: sem argumento, `homedir()`, exatamente como antes.
+ */
+export function credentialsPath(home = homedir()) {
+    return join(home, ".synthesisui", "credentials.json");
+}
 /**
  * Reads the saved token, if any. Optional for now (open gate); the device-flow
  * is what writes it. Sent as a Bearer header when present.
@@ -25,9 +41,9 @@ export const credentialsPath = join(homedir(), ".synthesisui", "credentials.json
  * refused it with a 401 that read as "your session expired" (dono, 31/07). A
  * session cannot expire on a host that never issued it.
  */
-export async function readCredentials() {
+export async function readCredentials(home) {
     try {
-        const raw = await readFile(credentialsPath, "utf8");
+        const raw = await readFile(credentialsPath(home), "utf8");
         const parsed = JSON.parse(raw);
         if (!parsed.token)
             return null;
@@ -44,7 +60,7 @@ export function sameRegistry(a, b) {
     const norm = (u) => u.trim().replace(/\/+$/, "").toLowerCase();
     return norm(a) === norm(b);
 }
-export async function readToken() {
+export async function readToken(home) {
     /**
      * O AMBIENTE GANHA DO ARQUIVO, e é o que permite CI sem navegador.
      *
@@ -60,7 +76,7 @@ export async function readToken() {
     if (fromEnv)
         return fromEnv;
     try {
-        const raw = await readFile(credentialsPath, "utf8");
+        const raw = await readFile(credentialsPath(home), "utf8");
         const parsed = JSON.parse(raw);
         return parsed.token ?? null;
     }
@@ -69,10 +85,11 @@ export async function readToken() {
     }
 }
 /** Persists the device-flow token (chmod 600, user-only dir). */
-export async function writeToken(token, registry) {
-    await mkdir(dirname(credentialsPath), { recursive: true, mode: 0o700 });
+export async function writeToken(token, registry, home) {
+    const path = credentialsPath(home);
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
     const payload = { token, registry, savedAt: new Date().toISOString() };
-    await writeFile(credentialsPath, `${JSON.stringify(payload, null, 2)}\n`, {
+    await writeFile(path, `${JSON.stringify(payload, null, 2)}\n`, {
         mode: 0o600,
     });
 }
@@ -90,10 +107,10 @@ export async function writeToken(token, registry) {
  * Devolve `false` quando não havia nada - a diferença entre "saí" e "você já
  * estava fora" é a única coisa que o comando tem para dizer.
  */
-export async function clearCredentials() {
-    const existing = await readCredentials();
+export async function clearCredentials(home) {
+    const existing = await readCredentials(home);
     try {
-        await rm(credentialsPath, { force: true });
+        await rm(credentialsPath(home), { force: true });
     }
     catch {
         // já não existe, ou o disco recusou - o estado final é o mesmo

package/dist/doctor/ledger.js

@@ -36,6 +36,17 @@ export const LEDGER_FILE = "ledger.jsonl";
  * inteiro o que decide alguma coisa.
  */
 const MATCHED_CAP = 300;
+/**
+ * O MESMO TETO PARA AS OCORRÊNCIAS, e aqui ele corta MAIS, porque cada entrada é uma ocorrência e
+ * não um grupo. Medido antes de escolher o número: 1 no escopo que o repositório real mede, 2 no
+ * repositório inteiro - o teto está três ordens de grandeza acima do caso real, e existe para que
+ * um projeto grande não escreva um evento de centenas de KB no ledger dele.
+ *
+ * O corte é SILENCIOSO neste arquivo, e isso está dito em vez de calado: sem um campo de contagem
+ * não há onde escrever "e mais N". Se algum dia um projeto real encostar no teto, a resposta é um
+ * campo que declare o que ficou de fora - nunca subir o número e seguir.
+ */
+const UNREPRESENTED_CAP = 300;
 /**
  * Os pares a mandar, do agregado que o doctor já monta.
  *
@@ -64,6 +75,49 @@ export function suggestionsFrom(repeats) {
         count: r.count,
     }));
 }
+/**
+ * A IDENTIDADE ESTRUTURAL DE UMA OCORRÊNCIA - a MESMA chave que agrupa os repeats em `scan.ts`.
+ *
+ * Comparar por texto de apresentação (`shown`) seria julgar o nome que a pessoa leu em vez do fato
+ * medido, que é o acoplamento que o #1174 removeu. A família faz parte da identidade: o mesmo
+ * literal em duas famílias são dois fatos diferentes, e só um deles pode ser coincidência.
+ */
+const identityOf = (f) => `${f.kind}:${f.literal.toLowerCase()}`;
+/**
+ * AS OCORRÊNCIAS QUE `matched` NÃO TRANSPORTOU - ver `CheckEvent.unrepresentedMatches`.
+ *
+ * A regra é ESTRUTURAL e nunca semântica: entra a ocorrência que casou com um token nosso e cuja
+ * identidade não está entre as entradas que `matched` de fato carregou. Nada aqui olha
+ * `finding.crossFamily` - filtrar por aquele veredito congelaria a régua do dia da coleta e
+ * impediria uma régua futura de reavaliar o que este CLI decidiu não mandar.
+ *
+ * `matched` entra como ARGUMENTO, e não é detalhe: o que importa é o que foi de fato transportado,
+ * depois do filtro e depois do teto. Um repeat que existiu e foi cortado sai daqui como ocorrência,
+ * porque do ponto de vista de quem lê ele não chegou - e é isso que o campo promete.
+ */
+export function unrepresentedFrom(findings, matched) {
+    const carried = new Set(matched.map(identityOf));
+    const out = [];
+    for (const f of findings) {
+        /** Sem token nosso não houve match nosso, e não há o que a régua de família possa julgar. */
+        if (!f.token)
+            continue;
+        if (carried.has(identityOf(f)))
+            continue;
+        if (out.length >= UNREPRESENTED_CAP)
+            break;
+        out.push({
+            literal: f.literal,
+            kind: f.kind,
+            token: f.token,
+            file: f.file,
+            line: f.line,
+            ...(f.theirToken ? { theirToken: f.theirToken } : {}),
+            ...(f.fontRelative ? { fontRelative: true } : {}),
+        });
+    }
+    return out;
+}
 const ledgerPath = (root) => join(root, "_synthesisui", LEDGER_FILE);
 /** Keep the file from growing forever: past ~1MB, keep the newest half. A
  *  trend needs recent history, not an archive. */

package/dist/populations.spec-input.js

@@ -39,6 +39,60 @@ export const FRONTEND_HUB_CENSUS = join(POPULATIONS, "frontend-hub.census.json")
  * que a jornada é conferida na tela.
  */
 export const CODELEVEL_CENSUS = join(POPULATIONS, "codelevel-ui.census.json");
+/**
+ * O HISTÓRICO DO DOCTOR - a única entrada destas provas que NÃO se deriva de um censo.
+ *
+ * O que ele carrega e o censo não: os PARES que o doctor casou (`matched`) e o placar que ele
+ * fechou (`crossFamily`). O censo é a leitura do CÓDIGO num instante; o ledger é a história das
+ * EXECUÇÕES - nenhum dos dois se produz a partir do outro.
+ *
+ * Congelado em 28/08 porque só existia na máquina do dono, e porque as provas que dependem dele
+ * ficariam órfãs no dia em que aquela pasta sumisse - foi exatamente assim que oito provas do
+ * `signalui` viraram provas apagadas. Ver `fixtures/populations/README.md`.
+ */
+export const CODELEVEL_LEDGER = join(POPULATIONS, "codelevel-ui.ledger.jsonl");
+/**
+ * OS DOIS DOCUMENTOS HISTÓRICOS - a exceção autorizada à regra do derivável (dono, 28/08).
+ *
+ * A regra desta pasta continua valendo para artefato ATUAL: um `design-system.json` de hoje se
+ * deriva do censo, e congelá-lo criaria uma segunda fonte de verdade que envelhece calada.
+ *
+ * Um documento PUBLICADO no passado é outra coisa. A cadeia só sabe produzir o presente: derivar
+ * hoje o que foi publicado em duas versões diferentes devolve o mesmo documento duas vezes, e a
+ * propriedade que o `change-preview` protege - que cada lado do par desenhe com o CSS DA SUA
+ * versão - deixaria de ter o que comparar. O passado não é derivável nem hoje nem nunca.
+ *
+ * PROVENIÊNCIA. `~/personal/codelevel-monorepo/_synthesisui/ds/codelevel/{v2,v3}/design-system.json`,
+ * escritos em 26/08/2026 pelo próprio produto - `v2` por `import`, `v3` por `sync` (`source.by` em
+ * todas as 62 receitas). Copiados byte a byte pelo VALOR: só a formatação foi compactada, e um
+ * spec assere que o objeto lido é idêntico ao original. Nenhum valor foi alterado para caber num
+ * teste, e nenhuma versão foi gerada artificialmente.
+ *
+ * O PAR FOI ESCOLHIDO PELA PROPRIEDADE, e a escolha foi medida nos três pares possíveis:
+ *
+ *     v1 -> v2    0 componentes com declaração movida, 0 que mudaram sem pintar - não serve
+ *     v2 -> v3   20 componentes com declaração movida, 42 que mudaram sem pintar
+ *     v1 -> v3   idêntico ao v2 -> v3
+ *
+ * INSPECIONADOS ANTES DE VERSIONAR, e nada precisou ser mascarado - o que importa, porque mascarar
+ * mudaria o documento:
+ *
+ *     credenciais / bearer / api-key / password    nenhuma
+ *     caminhos absolutos ou de máquina             nenhum
+ *     e-mails ou identificadores pessoais          nenhum
+ *     URLs                                         uma, o namespace de SVG do W3C
+ *
+ * O que eles CARREGAM, e está dito em vez de calado: a narrativa e o tagline do produto (texto de
+ * marketing do próprio dono), os caminhos RELATIVOS dos arquivos de origem dentro do repositório
+ * (`packages/ui/src/...`, os mesmos que o censo congelado ao lado já carrega) e, no `v3`, um
+ * carimbo `meta.repairs` com data.
+ *
+ * E SÃO EVIDÊNCIA HISTÓRICA, NUNCA FONTE NORMATIVA. Nenhuma regra do SynthesisUI pode ler daqui o
+ * que é certo - nem um nome de componente, nem um valor, nem uma convenção. Eles existem para que
+ * uma prova tenha DOIS instantes do mesmo sistema para comparar, e é só isso.
+ */
+export const CODELEVEL_DOCUMENT_OLDER = join(POPULATIONS, "codelevel-ui.v2.document.json");
+export const CODELEVEL_DOCUMENT_NEWER = join(POPULATIONS, "codelevel-ui.v3.document.json");
 /**
  * OS REPOSITÓRIOS VIVOS - e estes NÃO estão congelados, de propósito.
  *

package/dist/repo-state.js

@@ -25,7 +25,7 @@
  */
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
-import { readEvents } from "./doctor/ledger.js";
+import { readEvents, } from "./doctor/ledger.js";
 /**
  * O estado de um slug neste projeto, ou nada quando não há `.lock`.
  *
@@ -83,6 +83,15 @@ export async function repoStateOf(projectRoot, slug, cli) {
         ...(doctor?.matched && doctor.matched.length > 0
             ? { matched: doctor.matched }
             : {}),
+        /**
+         * `Array.isArray` E NUNCA `length > 0` - a linha acima é o contraexemplo, e ela está certa para
+         * `matched`, que não distingue "não mediu" de "mediu zero". Este campo distingue, e é a razão de
+         * ele existir: `[]` é uma medição, e transformá-la em ausência faria um cliente com CLI novo
+         * parecer um cliente com ledger antigo.
+         */
+        ...(Array.isArray(doctor?.unrepresentedMatches)
+            ? { unrepresentedMatches: doctor.unrepresentedMatches }
+            : {}),
         ...(runs.length > 0 ? { runs } : {}),
         ...(typeof lock?.fetchedAt === "string"
             ? { installedAt: lock.fetchedAt }

package/package.json

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