synthesisui 0.16.198 → 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

@@ -2,14 +2,146 @@ import { readdir, readFile } from "node:fs/promises";
 import { join } from "node:path";
 /**
  * Opens a JSX element whose name is capitalised - which is React's own rule for
- * "this is a component, not an html tag".
+ * "this is a component, not an html tag". The name allows dots (`Card.Header`).
  *
- * The name allows dots (`Card.Header`) and the body is captured lazily up to
- * the first `>` that is not inside a quoted value.
+ * SÓ A ABERTURA. O corpo NÃO vem daqui - ver `bodyOf`.
  */
-const ELEMENT = /<([A-Z][A-Za-z0-9_]*(?:\.[A-Z][A-Za-z0-9_]*)*)(\s[^>]*?)?\/?>/gs;
-/** `variant="primary"` or `variant={"primary"}` - a literal a person typed. */
-const LITERAL_PROP = /([a-zA-Z][a-zA-Z0-9_-]*)\s*=\s*\{?\s*["']([^"']*)["']\s*\}?/g;
+const OPENS = /<([A-Z][A-Za-z0-9_]*(?:\.[A-Z][A-Za-z0-9_]*)*)/g;
+/**
+ * ONDE A TAG TERMINA DE VERDADE - e isto era uma varredura de caractere.
+ *
+ * O corpo era `(\s[^>]*?)?`: para no primeiro `>` que aparecer, sem saber o que é aspa e
+ * sem saber o que é aninhamento. Medido no repositório do dono em 10/08, isso produzia
+ * DOIS defeitos que pareciam não ter relação:
+ *
+ *   <WidgetCard rightTitleSlot={ <Button variant="neutral" onClick={() => …
+ *     os atributos do FILHO caem no corpo do PAI - o censo registrou `variant: neutral`
+ *     no WidgetCard, que declara `default | left-border | full-border`. A tela reportou
+ *     "uso fora do contrato" sobre um uso que nunca existiu.
+ *
+ *   value="… Domain 'sg.futurescope.com' … the 'Sending' tab …"
+ *     a aspa simples dentro da dupla fechava o valor cedo, o resto da frase ficava no
+ *     corpo, e o passe de booleano nu colhia palavra por palavra: `the`, `following`,
+ *     `registrar`, `domains`. Dezenove palavras viraram props do Textarea.
+ *
+ * Um defeito INVENTADO é pior que um não achado: o não achado custa uma lacuna, o
+ * inventado custa a confiança na tela inteira. Por isso a resposta não é acrescentar
+ * casos à regex - é um scanner que sabe o que está lendo, e que fecha por construção.
+ *
+ * Devolve o corpo e onde continuar a varredura. Uma tag sem fechamento (arquivo cortado,
+ * TypeScript genérico que não era elemento) devolve `null` e não vira uso.
+ */
+function bodyOf(source, from) {
+    let quote = null;
+    let depth = 0;
+    for (let i = from; i < source.length; i++) {
+        const ch = source[i];
+        if (quote) {
+            /** Escape dentro de string: `\"` não fecha nada. */
+            if (ch === "\\")
+                i += 1;
+            else if (ch === quote)
+                quote = null;
+            continue;
+        }
+        if (ch === '"' || ch === "'" || ch === "`") {
+            quote = ch;
+            continue;
+        }
+        if (ch === "{")
+            depth += 1;
+        else if (ch === "}")
+            depth -= 1;
+        /** Em profundidade zero e fora de aspas: aqui a tag realmente fecha. */ else if (ch === ">" &&
+            depth <= 0)
+            return {
+                body: withoutExpressions(source.slice(from, i)).replace(/\/$/, ""),
+                end: i + 1,
+            };
+    }
+    return null;
+}
+/**
+ * O QUE ESTÁ DENTRO DE CHAVES NÃO É PROP DESTA TAG - e sem isto o corpo termina no lugar certo
+ * e ainda entrega o filho errado.
+ *
+ * `<WidgetCard rightTitleSlot={<Button variant="neutral" />} />` fecha corretamente no `/>` do
+ * WidgetCard: o `>` do Button está em profundidade 1. Mas o corpo continua carregando
+ * `variant="neutral"`, porque a atribuição do filho mora dentro da expressão do slot.
+ *
+ * Então a expressão vira espaço - e o que ela contém não se perde: o `<Button` dentro dela é
+ * encontrado pela própria varredura, no lugar dele, com as props dele.
+ *
+ * COM UMA EXCEÇÃO, E ELA É MEDIDA: `variant={"info"}` é o MESMO literal que `variant="info"`, e um
+ * spec já dizia isso. A primeira versão deste passe apagava os dois e a suíte reprovou - eu tinha
+ * escrito no comentário que o `LITERAL_PROP` via o corpo cru antes, o que o código não fazia. Uma
+ * chave contendo só um literal volta como valor; qualquer outra coisa dentro é expressão.
+ */
+function withoutExpressions(body) {
+    let out = "";
+    let inner = "";
+    let depth = 0;
+    let quote = null;
+    /** Fecha uma expressão: um literal puro é VALOR e volta; o resto é do que estiver dentro. */
+    const close = () => {
+        out += /^\s*(["'`])(?:\\.|(?!\1)[^\\])*\1\s*$/.test(inner)
+            ? `{${inner}}`
+            : " ";
+        inner = "";
+    };
+    for (let i = 0; i < body.length; i++) {
+        const ch = body[i];
+        const keep = (text) => {
+            if (depth === 0)
+                out += text;
+            else
+                inner += text;
+        };
+        if (quote) {
+            if (ch === "\\") {
+                keep(body.slice(i, i + 2));
+                i += 1;
+            }
+            else {
+                keep(ch);
+                if (ch === quote)
+                    quote = null;
+            }
+            continue;
+        }
+        if (ch === '"' || ch === "'" || ch === "`") {
+            quote = ch;
+            keep(ch);
+            continue;
+        }
+        if (ch === "{") {
+            depth += 1;
+            if (depth > 1)
+                inner += ch;
+            continue;
+        }
+        if (ch === "}") {
+            depth -= 1;
+            if (depth === 0)
+                close();
+            else if (depth > 0)
+                inner += ch;
+            else
+                depth = 0;
+            continue;
+        }
+        keep(ch);
+    }
+    return out;
+}
+/**
+ * `variant="primary"` ou `variant={'primary'}` - um literal que alguém digitou.
+ *
+ * A ASPA CASA COM ELA MESMA (`(["'])…\2`), e não com qualquer uma. `["']([^"']*)["']`
+ * tratava as duas como intercambiáveis, então um valor com apóstrofo dentro truncava - e o
+ * que sobrava virava prop. Ver `bodyOf`.
+ */
+const LITERAL_PROP = /([a-zA-Z][a-zA-Z0-9_-]*)\s*=\s*\{?\s*(["'])((?:\\.|(?!\2)[^\\])*)\2\s*\}?/g;
 /** `dense` with no value is a boolean prop set to true, and that IS a literal
  *  decision worth counting. */
 const BARE_PROP = /(^|\s)([a-z][a-zA-Z0-9_]*)(?=\s|$)/g;
@@ -103,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;
@@ -171,8 +314,12 @@ internal = []) {
         return;
     const owners = importedNames(source, internal);
     const private_ = localOnlyNames(source);
-    ELEMENT.lastIndex = 0;
-    for (const m of source.matchAll(ELEMENT)) {
+    /**
+     * Abertura por regex, corpo por SCANNER - ver `bodyOf`. A regex só encontra `<Nome`; onde a
+     * tag termina é uma pergunta que só um scanner com estado responde.
+     */
+    OPENS.lastIndex = 0;
+    for (const m of source.matchAll(OPENS)) {
         if (m.index != null && looksLikeType(source, m.index))
             continue;
         const name = m[1];
@@ -180,31 +327,50 @@ internal = []) {
         // shadow nothing and still bind a name it also imports.
         if (!owners.has(name) && private_.has(name.split(".")[0]))
             continue;
-        const body = m[2] ?? "";
+        const read = bodyOf(source, (m.index ?? 0) + m[0].length);
+        /** Tag sem fechamento não é uso: arquivo cortado, ou um genérico que não era elemento. */
+        if (!read)
+            continue;
+        const body = read.body;
         // A dotted name belongs to whoever exported its root (`Popover.Root`).
         const owner = owners.get(name) ?? owners.get(name.split(".")[0]);
-        /** Ver `ComponentTally`: dois `Button` de pacotes diferentes são duas linhas, não uma. */
-        let hit = tally.get(name);
+        /**
+         * A ORIGEM ENTRA NA CHAVE - a lei 13 do CLAUDE.md, que este comentário já afirmava e o código
+         * não cumpria: a chave era só o nome.
+         *
+         * Medido no repositório do dono em 10/08: os apps usam o `Button` DELE e o do MUI, e as
+         * variantes do MUI (`contained`, `outlined`, `text`) caíam na conta do Button dele, que declara
+         * `ocean`, `royal`, `neutral`. O mesmo com `CircularProgress` e `determinate`. E era a mesma
+         * 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?.spec ?? ""}`;
+        let hit = tally.get(key);
         if (!hit) {
             hit = {
                 count: 0,
                 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(name, hit);
+            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;
         const named = new Set();
         for (const p of body.matchAll(LITERAL_PROP)) {
-            const [, prop, value] = p;
+            /** O grupo 2 é a ASPA (a backreference); o valor é o 3 - ver `LITERAL_PROP`. */
+            const [, prop, , value] = p;
             named.add(prop);
             if (NOT_A_DECISION.test(prop))
                 continue;
@@ -239,8 +405,17 @@ internal = []) {
 /** The inventory, commonest first. */
 export function tallyToInventory(tally, max = 80) {
     return [...tally.entries()]
-        .map(([name, v]) => ({
-        name,
+        .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.198",
+  "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": {