synthesisui 0.16.254 → 0.16.255

package/dist/commands/add.js

@@ -154,7 +154,20 @@ export async function add(slug, opts) {
      * censo (um `add` puro, sem import antes), o que o lock já dizia é preservado.
      */
     const measured = await censusScope(projectRoot);
-    const scope = measured.system ?? prev?.scope ?? null;
+    /**
+     * OS DOIS CAMPOS: `scopes` com tudo e `scope` com o primeiro.
+     *
+     * O lock é o arquivo que um time COMMITA, e é o que faz um clone fresco saber de
+     * onde o sistema foi medido sem ida à rede. Guardar só o primeiro escopo ali
+     * fazia o `sync` de um clone novo remedir metade de um sistema de dois escopos.
+     * Um CLI anterior lê `scope` e segue funcionando.
+     */
+    const systems = measured.systems.length > 0
+        ? measured.systems
+        : measured.system
+            ? [measured.system]
+            : (prev?.scopes ?? (prev?.scope ? [prev.scope] : []));
+    const scope = systems[0] ?? null;
     const usage = measured.usage.length > 0 ? measured.usage : (prev?.usage ?? []);
     /**
      * `fetchedAt` SÓ ANDA QUANDO ALGO ATERROU - e a alternativa sujava o git de um time inteiro.
@@ -177,6 +190,7 @@ export async function add(slug, opts) {
         ...(payload.compiler != null ? { compiler: payload.compiler } : {}),
         ...(payload.rulesStamp ? { rules: payload.rulesStamp } : {}),
         ...(scope ? { scope } : {}),
+        ...(systems.length > 0 ? { scopes: systems } : {}),
         ...(usage.length > 0 ? { usage } : {}),
     };
     const landed = (() => {

package/dist/commands/doctor.js

@@ -42,7 +42,21 @@ import { resolveDeps } from "../stack.js";
 /** Files that compose components to SHOW them, not to ship them. */
 const IS_ASIDE = /(\.(spec|test|stories)\.[a-z]+$|__tests__\/|(^|\/)\.storybook\/)/;
 const EXTS = [".tsx", ".ts", ".jsx", ".js", ".css", ".scss", ".vue", ".svelte"];
-const SKIP = new Set([
+/**
+ * EXPORTADO porque quem mede o repositório fora deste arquivo tem que pular as
+ * MESMAS pastas.
+ *
+ * `workspace-place.ts` contava as declarações de cada pacote com a sua própria
+ * regra (dotdir + node_modules) e somava `packages/ui/dist/index.css`: 496
+ * declarações de bundle contra 97 de fonte no repo do dono, medido em 19/08. O
+ * número que decidia qual pasta recomendar era cinco sextos build output - e o
+ * censo, que usa este SKIP, nunca leu nada daquilo.
+ *
+ * Duas listas de pastas a ignorar é a mesma classe de divergência que
+ * `loadSystem` existe para matar: nenhuma delas está errada isolada, e juntas
+ * dizem números diferentes sobre o mesmo repositório.
+ */
+export const SKIP = new Set([
     "node_modules",
     ".next",
     ".git",
@@ -551,7 +565,7 @@ export async function doctor(opts) {
      * lista de prioridades tirada de um app consumidor num repo de 2787 arquivos (dono, 06/08).
      */
     const measured = (opts.scopes ?? []).length > 0
-        ? { system: null, usage: [], from: "none" }
+        ? { system: null, systems: [], usage: [], from: "none" }
         : await measuredScope(root);
     const relScopes = (opts.scopes ?? []).length > 0
         ? opts.scopes

package/dist/commands/import.js

@@ -2598,8 +2598,21 @@ async function sayAboutPlace(root, scope) {
     console.log(section("This folder is one package of a workspace"));
     console.log(body(`${paint.strong(place.here)} is one of ${place.packages.length} packages under ${paint.strong(place.workspaceRoot)}.`));
     console.log("");
-    console.log(body(`And the vocabulary is not here: ${paint.strong(vocab.rel)} declares ${vocab.declarations} token${vocab.declarations === 1 ? "" : "s"} across ${vocab.files} file${vocab.files === 1 ? "" : "s"}, while this package declares ${mine?.declarations ?? 0} across ${mine?.files ?? 0}.`));
-    console.log(body(paint.faint("A system built from the app is the average of one consumer; the tokens live where the library declares them.")));
+    console.log(body(
+    /**
+     * A FRASE SEGUE O CRITÉRIO, e o critério é estrutural.
+     *
+     * Enquanto a contagem incluía `dist`, dizer "o vocabulário não está aqui"
+     * fechava com os números: 764 contra 114. Com o build output fora, a
+     * biblioteca declara 97 e o APP declara 114 - a frase antiga passaria a
+     * contradizer os dois números que ela mesma imprime.
+     *
+     * O que faz `packages/ui` ser a fonte de verdade não é volume: é os outros
+     * pacotes o importarem. Dizer isso é dizer a razão verdadeira, e ela
+     * sobrevive ao caso em que o app declara mais.
+     */
+    `${paint.strong(vocab.rel)} is what the other ${vocab.importedBy} package${vocab.importedBy === 1 ? "" : "s"} here import${vocab.importedBy === 1 ? "s" : ""} - that is the shared vocabulary, ${vocab.declarations} token${vocab.declarations === 1 ? "" : "s"} across ${vocab.files} file${vocab.files === 1 ? "" : "s"}. This package declares ${mine?.declarations ?? 0} of its own across ${mine?.files ?? 0}, and those are this app's.`));
+    console.log(body(paint.faint("A system measured from the app is one consumer's set of choices; the shared vocabulary is where the library declares it.")));
     console.log("");
     console.log(body("The system is one place, and the evidence is another:"));
     console.log("");
@@ -3424,8 +3437,30 @@ export async function runImport(opts) {
      * `sayAboutPlace` faz as duas perguntas na ordem: onde este comando está, e
      * onde as declarações estão. Ele só fala quando as respostas divergem.
      */
-    if (!opts.census)
+    /**
+     * OS CANDIDATOS ENTRAM NO CENSO, e é o mesmo `placeInWorkspace` que a mensagem
+     * de lugar já usa - uma medição, dois consumidores.
+     *
+     * Vive aqui e não dentro de `takeCensus` porque a pergunta é sobre o
+     * WORKSPACE, e `takeCensus` mede um escopo: chamá-la de lá faria cada escopo
+     * medido recontar os mesmos cinco pacotes.
+     */
+    if (!opts.census) {
+        const place = await placeInWorkspace(root).catch(() => null);
+        if (place)
+            census.workspace = {
+                root: place.workspaceRoot,
+                here: place.here,
+                packages: place.packages.map((p) => ({
+                    rel: p.rel,
+                    name: p.name,
+                    declarations: p.declarations,
+                    files: p.files,
+                    importedBy: p.importedBy,
+                })),
+            };
         await sayAboutPlace(root, scope);
+    }
     // A census handed to us is written BACK TO ITSELF; one we took lands at the
     // ROOT, whatever it measured. Everything else in `_synthesisui/` is anchored
     // there - config, `ds/<slug>/`, the hook's marker - and the census was the

package/dist/commands/mcp.js

@@ -1042,6 +1042,23 @@ async function describeComponent(root, name) {
     if ((recipe.companions ?? []).length > 0) {
         out.push("", `Goes with: ${(recipe.companions ?? []).join(", ")} - measured pairings; call describe_component on one before composing them together.`);
     }
+    /**
+     * ONDE ELE MORA, E COMO CHEGAR NELE - a linha que decide se o agente importa
+     * ou reescreve.
+     *
+     * `api.from` é o especificador do pacote que o EXPORTA (a lei 13 já o mediu), e
+     * ele só existe para um componente de biblioteca. Quando há um, importar é a
+     * resposta e escrever de novo é duplicar. Quando não há, o caminho é o que
+     * localiza o arquivo - e num sistema de dois escopos ele é a única coisa que
+     * diz de qual dos dois este componente é.
+     */
+    if (recipe.source?.file || recipe.api?.from) {
+        const where = recipe.source?.file;
+        const pkg = recipe.api?.from;
+        out.push("", pkg
+            ? `Lives in: ${where ?? pkg} - exported by ${pkg}. Import it from there; writing it again duplicates a component this system already owns.`
+            : `Lives in: ${where}${recipe.source?.scope ? ` (scope ${recipe.source.scope})` : ""} - local to that folder, and not exported by a package.`);
+    }
     if (recipe.usageStats && recipe.usageStats.count > 0) {
         const u = recipe.usageStats;
         out.push("", `In use: ${u.count} instance${u.count === 1 ? "" : "s"} across ${u.files} file${u.files === 1 ? "" : "s"}${u.projects?.length ? ` in ${u.projects.join(", ")}` : ""}.`);

package/dist/commands/sync.js

@@ -6,10 +6,11 @@ import { markSent, readEvents } from "../doctor/ledger.js";
 import { checkableName, closeRequest, readRequests, verifyAndCloseRequests, } from "../doctor/requests.js";
 import { describeDelta, fingerprintReadings, readSyncMark, writeSyncMark, } from "../last-sync.js";
 import { measuredScope, rememberScope } from "../measured-scope.js";
+import { mergeCensus } from "../merge-census.js";
 import { body, paint, section, snippet } from "../output.js";
 import { repoStateOf } from "../repo-state.js";
 import { reportWhatIsLeft } from "./align.js";
-import { resolveReadParts, siblingProjects, takeCensus } from "./import.js";
+import { resolveReadParts, siblingProjects, takeCensus, } from "./import.js";
 /**
  * What each decision means ON THIS MACHINE - the card decides, the sync
  * enacts. The web never touches the local file; this line is printed right
@@ -247,7 +248,25 @@ export async function remeasure(args) {
      * O servidor continua valendo como segunda fonte: um clone fresco tem o `.lock` e não tem censo.
      */
     const local = await measuredScope(root);
-    let scope = local.system ?? stored.scope ?? null;
+    /**
+     * TODOS os escopos do sistema, não só o primeiro.
+     *
+     * Esta linha lia `local.system` - singular - e um sistema importado de dois
+     * escopos remedia só um deles: 351 componentes nasciam e 36 eram remedidos. Os
+     * outros 315 não eram apagados (`presenceOf` os conta como fora do escopo
+     * medido, de propósito) e também nunca mais eram atualizados - uma feature que
+     * emudece no dia seguinte.
+     *
+     * A queda para `scope` mantém todo sistema anterior lendo como antes.
+     */
+    let scopes = local.systems.length > 0
+        ? local.systems
+        : local.system
+            ? [local.system]
+            : stored.scope
+                ? [stored.scope]
+                : [];
+    let scope = scopes[0] ?? null;
     let usage = local.usage.length > 0 ? local.usage : (stored.usage ?? []);
     /**
      * E QUANDO NINGUÉM SABE, ESTE COMANDO PERGUNTA - uma vez, e grava a resposta.
@@ -263,26 +282,43 @@ export async function remeasure(args) {
         const asked = await askForScope(root);
         if (asked) {
             scope = asked.scope;
+            scopes = [asked.scope];
             if (asked.usage.length > 0)
                 usage = asked.usage;
-            await rememberScope(root, slug, scope, usage);
+            await rememberScope(root, slug, scopes, usage);
         }
     }
     console.log(section("Measuring your repository again"));
-    console.log(body(paint.faint(`${scope ? `reading ${scope}` : "the whole repo"}${local.system && local.system !== stored.scope
+    console.log(body(paint.faint(`${scopes.length > 1 ? `reading ${scopes.join(" + ")}` : scope ? `reading ${scope}` : "the whole repo"}${local.system && local.system !== stored.scope
         ? " · read from _synthesisui/census.json, where the last measurement recorded it"
         : ""} · what you already wrote about your app travels unchanged`)));
-    const census = await takeCensus(scope ? join(root, scope) : root, {
-        ...(scope ? { scopeLabel: scope } : {}),
-        ...(args.cli ? { cli: args.cli } : {}),
-        /** Uma RE-medição conta o que MUDOU; o relatório inteiro fica no `--full` - ver `say`. */
-        ...(args.full ? {} : { quiet: true }),
-        /** O `--usage` é EVIDÊNCIA e leva rótulo: sem ele o censo não sabe de que app o número veio. */
-        usage: usage.map((u) => ({
-            path: join(root, u),
-            label: u,
-        })),
-    }).catch(() => null);
+    /**
+     * UMA MEDIÇÃO POR ESCOPO, FUNDIDAS - o mesmo desenho do `import`.
+     *
+     * `takeCensus` recebe um `root` em cinco pontos que são por PACOTE, então medir
+     * N raízes de dentro dela seria refatorar a função que o corpus dourado guarda.
+     * A evidência (`--usage`) entra UMA vez, com o primeiro escopo: somá-la N vezes
+     * multiplicaria as contagens que decidem o que é hábito.
+     */
+    const measuredList = [];
+    for (const [i, one] of (scopes.length > 0 ? scopes : [""]).entries()) {
+        const c = await takeCensus(one ? join(root, one) : root, {
+            ...(one ? { scopeLabel: one } : {}),
+            ...(args.cli ? { cli: args.cli } : {}),
+            /** Uma RE-medição conta o que MUDOU; o relatório inteiro fica no `--full` - ver `say`. */
+            ...(args.full ? {} : { quiet: true }),
+            /** O `--usage` é EVIDÊNCIA e leva rótulo: sem ele o censo não sabe de que app o número veio. */
+            usage: i === 0 ? usage.map((u) => ({ path: join(root, u), label: u })) : [],
+        }).catch(() => null);
+        if (!c)
+            break;
+        if (one)
+            c.scope = one;
+        measuredList.push(c);
+    }
+    const census = measuredList.length === (scopes.length > 0 ? scopes.length : 1)
+        ? mergeCensus(measuredList)
+        : null;
     if (!census) {
         console.log(body("The measurement failed, so nothing was sent."));
         return;

package/dist/install-marks.js

@@ -100,7 +100,7 @@
  *
  * Quem instalou antes desta versão tem o stub que estanca: o `upgrade`/`connect` é o que alcança.
  */
-export const MATERIALISER_SINCE = "0.16.241";
+export const MATERIALISER_SINCE = "0.16.255";
 /**
  * A ÚLTIMA VERSÃO EM QUE O QUE O HOOK RODA MUDOU.
  *

package/dist/measured-scope.js

@@ -1,6 +1,11 @@
 import { readdir, readFile, stat, writeFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
-const EMPTY = { system: null, usage: [], from: "none" };
+const EMPTY = {
+    system: null,
+    systems: [],
+    usage: [],
+    from: "none",
+};
 /**
  * O ESCOPO NO PONTEIRO DO SISTEMA, que é onde ele não se perde.
  *
@@ -27,22 +32,42 @@ async function scopeInLock(root) {
         catch {
             continue;
         }
-        const scope = typeof lock.scope === "string" && lock.scope.trim()
-            ? lock.scope.trim()
-            : null;
+        /**
+         * `scopes` PRIMEIRO, `scope` como queda - e nunca o contrário.
+         *
+         * Um lock escrito antes desta versão só tem `scope`, e ele continua sendo lido
+         * exatamente como antes. Um lock novo tem os dois, e a lista é a verdade
+         * completa: ler o singular ali daria um sistema de um escopo onde há dois.
+         */
+        const listed = Array.isArray(lock.scopes)
+            ? lock.scopes.filter((x) => typeof x === "string" && !!x.trim())
+            : [];
+        const scope = listed[0] ??
+            (typeof lock.scope === "string" && lock.scope.trim()
+                ? lock.scope.trim()
+                : null);
+        const declared = listed.length > 0 ? listed : scope ? [scope] : [];
         const usage = Array.isArray(lock.usage)
             ? lock.usage.filter((u) => typeof u === "string" && !!u.trim())
             : [];
-        if (!scope && usage.length === 0)
+        if (declared.length === 0 && usage.length === 0)
             continue;
-        const system = scope && (await present(root, scope)) ? scope : null;
+        const systems = [];
+        for (const d of declared)
+            if (await present(root, d))
+                systems.push(d);
         const kept = [];
         for (const u of usage)
             if (await present(root, u))
                 kept.push(u);
-        if (!system && kept.length === 0)
+        if (systems.length === 0 && kept.length === 0)
             continue;
-        return { system, usage: kept, from: "lock" };
+        return {
+            system: systems[0] ?? null,
+            systems,
+            usage: kept,
+            from: "lock",
+        };
     }
     return null;
 }
@@ -81,20 +106,29 @@ export async function censusScope(root) {
     catch {
         return EMPTY;
     }
-    const scope = typeof parsed.scope === "string" && parsed.scope.trim()
-        ? parsed.scope.trim()
-        : null;
+    /** `scopes` primeiro, `scope` como queda - ver `scopeInLock`, mesma regra. */
+    const listed = Array.isArray(parsed.scopes)
+        ? parsed.scopes.filter((x) => typeof x === "string" && !!x.trim())
+        : [];
+    const scope = listed[0] ??
+        (typeof parsed.scope === "string" && parsed.scope.trim()
+            ? parsed.scope.trim()
+            : null);
+    const declared = listed.length > 0 ? listed : scope ? [scope] : [];
     const usage = Array.isArray(parsed.usage)
         ? parsed.usage.filter((u) => typeof u === "string" && !!u.trim())
         : [];
-    const system = scope && (await present(root, scope)) ? scope : null;
+    const systems = [];
+    for (const d of declared)
+        if (await present(root, d))
+            systems.push(d);
     const kept = [];
     for (const u of usage)
         if (await present(root, u))
             kept.push(u);
-    if (!system && kept.length === 0)
+    if (systems.length === 0 && kept.length === 0)
         return EMPTY;
-    return { system, usage: kept, from: "census" };
+    return { system: systems[0] ?? null, systems, usage: kept, from: "census" };
 }
 /**
  * As pastas a LER, na ordem em que importam - o sistema primeiro.
@@ -103,7 +137,12 @@ export async function censusScope(root) {
  * anotações no CI, decide o que chega ao PR.
  */
 export function scopePaths(m) {
-    return [...(m.system ? [m.system] : []), ...m.usage];
+    /**
+     * TODOS os sistemas, não só o primeiro - senão `absorb` e `summary` veem meia
+     * biblioteca num sistema importado de dois escopos.
+     */
+    const systems = m.systems.length > 0 ? m.systems : m.system ? [m.system] : [];
+    return [...systems, ...m.usage];
 }
 /** Como dizer o que foi lido. Uma leitura que não declara o universo é um número sem denominador. */
 export function describeScope(m) {
@@ -131,7 +170,18 @@ export function describeScope(m) {
  *
  * Silencioso quando não há lock: não é erro, é um repo sem sistema instalado.
  */
-export async function rememberScope(root, slug, scope, usage) {
+export async function rememberScope(root, slug, 
+/**
+ * OS ESCOPOS, na ordem em que a pessoa os pediu - o primeiro é a autoridade.
+ *
+ * Aceita a lista e grava OS DOIS campos: `scopes` com tudo e `scope` com o
+ * primeiro. Um CLI anterior lê `scope` e continua funcionando; um lock antigo
+ * lido por este CLI cai no singular. É a compatibilidade nos dois sentidos, e
+ * ela custa uma linha.
+ */
+scopes, usage) {
+    const list = (Array.isArray(scopes) ? scopes : scopes ? [scopes] : []).filter(Boolean);
+    const scope = list[0] ?? null;
     const path = join(root, "_synthesisui", "ds", slug, ".lock");
     const raw = await readFile(path, "utf8").catch(() => null);
     if (!raw)
@@ -146,6 +196,7 @@ export async function rememberScope(root, slug, scope, usage) {
     await writeFile(path, `${JSON.stringify({
         ...lock,
         ...(scope ? { scope } : {}),
+        ...(list.length > 0 ? { scopes: list } : {}),
         ...(usage.length > 0 ? { usage } : {}),
     }, null, 2)}\n`, "utf8");
 }

package/dist/workspace-place.js

@@ -1,5 +1,6 @@
 import { readdir, readFile } from "node:fs/promises";
 import { join, relative } from "node:path";
+import { SKIP } from "./commands/doctor.js";
 const MANIFEST = "package.json";
 const SHEET = /\.(css|scss|sass|less)$/i;
 const DECL = /(^|[\s{;])--[a-zA-Z0-9-]+\s*:/g;
@@ -28,9 +29,11 @@ function workspaceGlobs(p) {
  * Quantas custom properties um pacote declara - o mesmo peso que
  * `siblingProjects` já usa para escolher entre `packages/core` e `packages/ui`.
  *
- * Diretório com ponto e `node_modules` ficam fora pelo mesmo motivo que o `walk`
- * do doctor os ignora: `.next/` guarda CSS COMPILADO, e contá-lo faria o build
- * output votar em onde mora o vocabulário.
+ * A LISTA DE PASTAS IGNORADAS É A DO `walk`, importada e não reescrita. A primeira
+ * versão pulava dotdir e `node_modules` por conta própria e somava
+ * `packages/ui/dist/index.css`: 496 declarações de bundle contra 97 de fonte no
+ * repo do dono (19/08). O número que escolhia a pasta recomendada era cinco
+ * sextos build output, e o censo - que usa o SKIP - nunca leu nada daquilo.
  */
 async function weigh(dir) {
     let declarations = 0;
@@ -39,7 +42,7 @@ async function weigh(dir) {
         if (depth > 8)
             return;
         for (const e of await readdir(at, { withFileTypes: true }).catch(() => [])) {
-            if (e.name.startsWith(".") || e.name === "node_modules")
+            if (e.name.startsWith(".") || SKIP.has(e.name))
                 continue;
             const full = join(at, e.name);
             if (e.isDirectory()) {
@@ -125,16 +128,29 @@ export async function placeInWorkspace(root) {
             declarations,
             files,
             dependsOn: Object.keys(deps).filter((k) => local.has(k)),
+            /** Preenchido no passo seguinte, quando todos os `dependsOn` existem. */
+            importedBy: 0,
         });
     }
+    for (const pkg of packages) {
+        if (!pkg.name)
+            continue;
+        pkg.importedBy = packages.filter((other) => other !== pkg && other.dependsOn.includes(pkg.name)).length;
+    }
     if (packages.length === 0)
         return null;
     const rel = relative(workspaceRoot, root).split("\\").join("/");
-    const ranked = [...packages].sort((a, b) => b.declarations - a.declarations);
+    /**
+     * A ORDEM: quem os outros importam vem primeiro, e a contagem só desempata.
+     * Um pacote que ninguém importa e que declara muito é um consumidor com
+     * vocabulário próprio - é um candidato legítimo, e não é a biblioteca.
+     */
+    const ranked = [...packages].sort((a, b) => b.importedBy - a.importedBy || b.declarations - a.declarations);
+    const lead = ranked[0];
     return {
         workspaceRoot,
         here: rel === "" ? null : rel,
         packages,
-        vocabulary: ranked[0]?.declarations > 0 ? ranked[0] : null,
+        vocabulary: lead && (lead.declarations > 0 || lead.importedBy > 0) ? lead : null,
     };
 }

package/package.json

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