synthesisui 0.16.199 → 0.16.200

package/dist/commands/import.js

@@ -172,6 +172,29 @@ async function sheetWithImports(path, seen = new Set(), depth = 0) {
 async function exists(path) {
     return await readFile(path, "utf8").then(() => true, () => false);
 }
+/**
+ * SOB QUE NOME O ESCOPO É IMPORTADO - a única forma de reconhecer a linha da própria biblioteca.
+ *
+ * O app dele importa `@frontend-hub/ui`; o `packages/ui/package.json` declara esse nome. É a mesma
+ * regra que a lei 13 já usa para desempatar `workspace:` contra semver, um passo antes: o MANIFESTO
+ * responde, e não o nome do componente nem o formato do caminho.
+ *
+ * Ausente quando o escopo não é um pacote - e aí a evidência só é somada quando o nome chega de UMA
+ * origem interna, que é a mesma resposta por outro caminho.
+ */
+async function publishedAs(root) {
+    const raw = await readFile(join(root, "package.json"), "utf8").catch(() => null);
+    if (!raw)
+        return null;
+    try {
+        const name = JSON.parse(raw).name;
+        return typeof name === "string" && name ? name : null;
+    }
+    catch {
+        /** Um manifesto ilegível custa a evidência daquele escopo, nunca a medição. */
+        return null;
+    }
+}
 async function harvestOwnCss(root, 
 /**
  * O LEDGER TAMBÉM COME AQUI, e por um motivo de promessa: este é o único laço que vê TODO
@@ -1065,7 +1088,18 @@ export async function takeCensus(root, opts) {
      */
     const turnedAway = new Set(skips.map((s) => s.name));
     const inventory = allComposed.filter((c) => !turnedAway.has(c.name));
-    const composed = new Set(inventory.map((c) => c.name));
+    /**
+     * COMPOSTO POR ELE, e não por qualquer um que use esse nome - a mesma lei, o terceiro sítio.
+     *
+     * Este conjunto responde "preciso criar uma linha a partir da DECLARAÇÃO, ou já existe uma linha
+     * de uso?". Com uma linha por nome, "existe" era inequívoco. Com uma linha por nome+origem, um
+     * `Toggle` do `@base-ui/react` respondia que sim - e o `Toggle` que ele declara em
+     * `packages/ui/atoms` ficava SEM LINHA NENHUMA, que é o mesmo desaparecimento do test50 chegando
+     * por outra porta.
+     *
+     * A linha de terceiro não responde por ele: só conta como composto o que veio de dentro.
+     */
+    const composed = new Set(inventory.filter((c) => !c.from).map((c) => c.name));
     const fromTypes = defined
         .filter((d) => !composed.has(d.name))
         .map((d) => ({
@@ -1160,8 +1194,64 @@ export async function takeCensus(root, opts) {
      * the laws read, and it is the reason this pass exists: three files agreeing is
      * what makes a habit, and a library has one file per component.
      */
-    const own = new Set(scoped.map((c) => c.name));
-    const evidence = new Map(usedThere.filter((c) => !c.from).map((c) => [c.name, c]));
+    /**
+     * A ORIGEM DECIDE, E AUSÊNCIA DE ORIGEM NÃO É UMA ORIGEM - lei 13, no segundo sítio.
+     *
+     * `tallyToInventory` já separa as linhas por nome+origem, e o censo mostra isso funcionando em 8
+     * nomes (`Tooltip`, `Popover.*`, `AnimatePresence`, `Toggle`). Aqui a evidência voltava a casar por
+     * NOME, e o filtro era `!c.from` - que junta três coisas diferentes numa só: o que é dele, o que
+     * tem origem misturada, e o que não tem origem NENHUMA.
+     *
+     * O que isso produziu, medido no repo do dono em 10/08: o `Button` DELE publicava
+     * `variant = ["ocean", "outlined", "contained"]`. `outlined` e `contained` são do MUI, e os
+     * `declaredAxes` dele não têm nenhum dos dois - as opções que ele declara são `ocean`, `royal`,
+     * `ai-outline`, `danger` e mais cinco. Os oito arquivos que importam o Button do MUI já eram
+     * separados pelo `from`; o vazamento veio de um arquivo com 25 usos de `<Button>` e NENHUM import
+     * de `Button` - origem desconhecida, tratada como dele.
+     *
+     * E "DE DENTRO" NÃO ERA UMA ORIGEM, era uma vizinhança: `OWN` valia para todo caminho interno,
+     * então o `Button` da biblioteca dele e o `Button` do Chakra re-exportado atrás do alias `@/` eram
+     * a MESMA linha. Exigir só `own` trocava o vazamento de terceiro por um vazamento de vizinho, e
+     * pior: seis leis - `enlarge`, `on`, `hover`, `click`, `asChild`, `onlyBorder` - escritas sobre um
+     * componente dele que não tem nenhuma dessas props. A origem agora é o especificador inteiro, e a
+     * evidência casa com a linha que veio da PRÓPRIA biblioteca.
+     *
+     * Sem conseguir dizer QUAL linha é a da biblioteca, ninguém soma nada: a direção conservadora é a
+     * mesma dos dois lados - deixar de somar evidência custa uma contagem, somar a errada custa uma
+     * LEI escrita sobre a biblioteca de outra pessoa.
+     */
+    /** Os nomes que a biblioteca declara - a pergunta aqui é de PERTENCIMENTO, não de origem. */
+    const inScope = new Set(scoped.map((c) => c.name));
+    /** `root` aqui já É a pasta do escopo - `runImport` resolve `--scope` antes de chamar. */
+    const published = await publishedAs(root);
+    const evidence = new Map();
+    /** Os nomes que chegam de mais de um lugar de dentro - a lacuna, contada para ser dita. */
+    const ambiguous = [];
+    const byName = new Map();
+    for (const c of usedThere) {
+        if (!c.own)
+            continue;
+        byName.set(c.name, [...(byName.get(c.name) ?? []), c]);
+    }
+    for (const [name, rows] of byName) {
+        /**
+         * A LINHA DA BIBLIOTECA, quando dá para nomeá-la: o app importa o pacote que o escopo publica.
+         * É a resposta exata, e ela não depende de resolver caminho nenhum.
+         */
+        const mine = published
+            ? rows.filter((r) => r.origin === published || r.origin?.startsWith(`${published}/`))
+            : [];
+        if (mine.length === 1) {
+            evidence.set(name, mine[0]);
+            continue;
+        }
+        /** Sem pacote para casar, uma origem interna só também é resposta: não há o que confundir. */
+        if (mine.length === 0 && rows.length === 1) {
+            evidence.set(name, rows[0]);
+            continue;
+        }
+        ambiguous.push(name);
+    }
     const merged = scoped.map((c) => {
         const e = evidence.get(c.name);
         if (!e)
@@ -1198,7 +1288,15 @@ export async function takeCensus(root, opts) {
                 : {}),
         };
     });
-    const theirsOnly = usedThere.filter((c) => !c.from && !own.has(c.name));
+    /**
+     * O QUE O APP TEM E A BIBLIOTECA NÃO - e a mesma lei: só entra o que tem origem DELE.
+     *
+     * A frase que sai daqui diz "estes são componentes seus que vivem só no app". Sem `own`, um nome
+     * de origem desconhecida entrava na lista, e a tela oferecia ao cliente um componente que pode ser
+     * de terceiro - a mesma acusação que o `<Button variant="contained">` sem import produzia do
+     * outro lado.
+     */
+    const theirsOnly = usedThere.filter((c) => c.own && !inScope.has(c.name));
     // The verdict travels WITH the payload: the platform reads one reading rather
     // than computing a second opinion from the same numbers, which is how two
     // implementations of the same judgement start disagreeing.
@@ -1211,8 +1309,19 @@ export async function takeCensus(root, opts) {
      * itself. See `isLibrary`.
      */
     const library = isLibrary(scoped);
+    /**
+     * O VEREDITO É DE UMA LINHA, NÃO DE UM NOME - o quarto sítio da mesma lei.
+     *
+     * `crosswalk` já julga linha a linha e pula quem tem `from`: o `Tooltip` do `recharts` sai dele
+     * SEM veredito, que é o certo. Mas o mapa era por NOME, então o veredito do `Tooltip` DELE -
+     * `exclusive`, um componente que ele escreveu - era colado também na linha do recharts. Medido em
+     * 10/08: `recharts` e `@base-ui/react` chegavam ao censo como componentes exclusivos dele.
+     *
+     * A chave é nome+origem, que é a mesma identidade que o censo passou a carregar.
+     */
+    const idOf = (c) => `${c.name}\u0000${c.origin ?? ""}`;
     const verdicts = new Map(crosswalk(merged, { library }).map((r) => [
-        r.component.name,
+        idOf(r.component),
         { bucket: r.bucket, canonical: r.canonical, because: r.because },
     ]));
     if (usedThere.length > 0) {
@@ -1515,7 +1624,7 @@ export async function takeCensus(root, opts) {
     }
     const components = merged.map((c) => ({
         ...c,
-        ...(verdicts.get(c.name) ?? {}),
+        ...(verdicts.get(idOf(c)) ?? {}),
         ...(laws.has(c.name) ? { laws: laws.get(c.name) } : {}),
         ...(runtimeOf.has(c.name) ? { runtime: runtimeOf.get(c.name) } : {}),
         ...(companionsOf.has(c.name)
@@ -2341,10 +2450,31 @@ function sayReach(c) {
  * shadow one of their own names. `declared` is a DEFINITION of theirs, which is what makes
  * this a tie-break rather than a preference.
  */
+/**
+ * O DESEMPATE QUE DEIXOU DE SER NECESSÁRIO - e que virou uma reivindicação falsa.
+ *
+ * Ele nasceu quando uma linha era um NOME: o `Pill` deles fazia
+ * `import { Toggle } from "@base-ui/react/toggle"`, e esse nome colidia com o `Toggle` que eles
+ * escreveram uma pasta ao lado - a linha saía carregando `from: "@base-ui/react/toggle"`, e `from` é
+ * o que faz o crosswalk pular um componente. O Toggle DELES sumia do sistema inteiro (test50,
+ * 04/08). Apagar o `from` era a única saída, porque não havia duas linhas para escolher.
+ *
+ * Agora há: a origem entra na chave, então o `Toggle` deles e o do `@base-ui/react` são duas linhas.
+ * Continuar apagando o `from` da linha de terceiro faz a esteira reivindicar o componente ALHEIO -
+ * medido em 10/08 no repo do dono: o `Tooltip` do `recharts` e o `Toggle` do `@base-ui/react`
+ * chegavam ao censo como `exclusive`, ou seja, como componentes que ele teria escrito. É exatamente
+ * o caso que a lei 13 nomeia.
+ *
+ * A regra passa a olhar a ORIGEM: um `from` só se apaga quando não há origem para distinguir as
+ * duas - o mundo antigo, e o único em que o desempate ainda é honesto.
+ */
 export function declaredWins(component, declared) {
-    return component.from && declared
-        ? { ...component, from: undefined }
-        : component;
+    if (!component.from || !declared)
+        return component;
+    /** Com origem, a linha dele existe à parte e esta aqui é de quem a exportou. */
+    if (component.origin)
+        return component;
+    return { ...component, from: undefined };
 }
 function rootPackage(tag, sketch) {
     if (!tag || !/^[A-Z]/.test(tag))

package/dist/doctor/components-scan.js

@@ -235,8 +235,19 @@ function importedNames(source, internal = []) {
             if (!part || part === "*")
                 continue;
             const local = (part.split(/\s+as\s+/).pop() ?? "").trim();
+            /**
+             * O ESPECIFICADOR VIAJA MESMO QUANDO É DE DENTRO - e `own` vira uma resposta à parte.
+             *
+             * `OWN` era um balde só para TODO caminho interno, então o `Button` da biblioteca dele e o
+             * `Button` do Chakra re-exportado atrás do alias `@/` eram a mesma linha. Medido no repo do
+             * dono em 10/08: `Button` chega de 10 alvos internos diferentes, 6 deles dentro dos apps, e a
+             * união deles escreveu seis leis - `enlarge`, `on`, `hover`, `click`, `asChild`, `onlyBorder` -
+             * sobre um componente que não tem nenhuma dessas props.
+             *
+             * A lei 13 diz que a origem decide. "De dentro" não é uma origem, é uma vizinhança.
+             */
             if (/^[A-Z]/.test(local))
-                out.set(local, own ? OWN : spec);
+                out.set(local, { spec, own });
         }
     }
     return out;
@@ -333,7 +344,7 @@ internal = []) {
          * causa do `own: true` valer em 7 de 128: uma linha que mistura duas origens nunca tem TODAS
          * as origens de dentro.
          */
-        const key = `${name}\u0000${owner ?? ""}`;
+        const key = `${name}\u0000${owner?.spec ?? ""}`;
         let hit = tally.get(key);
         if (!hit) {
             hit = {
@@ -341,14 +352,18 @@ internal = []) {
                 files: new Set(),
                 props: new Map(),
                 propFiles: new Map(),
-                ...(owner && owner !== OWN ? { from: owner } : {}),
+                ...(owner && !owner.own ? { from: owner.spec } : {}),
                 origins: new Set(),
             };
             tally.set(key, hit);
         }
-        /** TODA origem vista, e não só a primeira - ver `origins` no tipo. */
+        /**
+         * A ORIGEM AGORA ESTÁ INTEIRA NA CHAVE, então esta linha tem uma só. `origins` continua
+         * existindo porque é ele que separa "veio de um lugar que eu sei ler" de "não veio de lugar
+         * nenhum" - e é a segunda que a lei 13 manda não atribuir a ninguém.
+         */
         if (owner)
-            hit.origins.add(owner);
+            hit.origins.add(owner.own ? OWN : owner.spec);
         hit.count += 1;
         hit.files.add(file);
         LITERAL_PROP.lastIndex = 0;
@@ -393,6 +408,14 @@ export function tallyToInventory(tally, max = 80) {
         .map(([key, v]) => ({
         /** A chave carrega a origem para separar as linhas - o nome é a primeira metade dela. */
         name: key.split("\u0000")[0],
+        /**
+         * E A SEGUNDA METADE VIAJA, que é o que permite a quem lê perguntar QUAL. Sem isto o censo
+         * separava as linhas e devolvia só o nome - foi exatamente assim que a evidência de uso voltou
+         * a casar por NOME um passo depois desta função, em `runImport`.
+         */
+        ...(key.slice(key.indexOf("\u0000") + 1)
+            ? { origin: key.slice(key.indexOf("\u0000") + 1) }
+            : {}),
         ...(v.from ? { from: v.from } : {}),
         /** Só dele quando TODA aparição veio de dentro - ver `origins` e `OWN`. */
         ...(v.origins.size > 0 && [...v.origins].every((o) => o === OWN)

package/dist/doctor/contract-check.js

@@ -60,8 +60,36 @@ export function checkContracts(used, documents) {
     }
     if (axes.size === 0)
         return [];
+    /**
+     * E O NOME QUE CHEGA DE MAIS DE UM LUGAR DE DENTRO NÃO SE COBRA DE NINGUÉM.
+     *
+     * A terceira forma da mesma lei, e a que faltava. `own` responde "veio de dentro do projeto", que
+     * é uma VIZINHANÇA e não uma origem: um `Button` do Chakra re-exportado atrás do alias `@/` é tão
+     * "de dentro" quanto o da biblioteca dele.
+     *
+     * Medido no repo do dono em 10/08, no `apps/web-dashboard`: `Button` chega de DEZ lugares, cinco
+     * deles de dentro - `@frontend-hub/ui` (34 arquivos), `@/components/ui/_legacy/_chakra-ui/button`
+     * (25), `@/components/ui/_legacy/_general/Button` (19), `@/components/ui/Button` (3) e
+     * `../Button` (1). A ÚNICA acusação que o doctor fazia contra o sistema dele era
+     * `variant="outline"`, que é do Chakra: as cinco variantes que o Button DELE recebe estão todas
+     * entre as nove que ele declara.
+     *
+     * Uma acusação falsa custa mais que uma acusação perdida: ela ensina a pessoa a não acreditar na
+     * próxima. Enquanto a identidade não se divide de verdade, o mínimo honesto é a esteira SABER que
+     * é ambíguo e calar sobre esse nome.
+     */
+    const insideOrigins = new Map();
+    for (const c of used) {
+        if (!c.own)
+            continue;
+        const seen = insideOrigins.get(c.name) ?? new Set();
+        seen.add(c.origin ?? "");
+        insideOrigins.set(c.name, seen);
+    }
     const out = [];
     for (const c of used) {
+        if ((insideOrigins.get(c.name)?.size ?? 0) > 1)
+            continue;
         // A third party's component answers to its own package, not to this system.
         if (c.from)
             continue;

package/package.json

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