synthesisui 0.16.306 → 0.16.308

package/dist/commands/import.js

@@ -19,7 +19,9 @@ import { keyframeOffsets, moduleImports, partialCandidates, readGlobalClasses, r
 import { dataContract } from "../doctor/data-contract.js";
 import { inherit, readDeclaredForms, } from "../doctor/declared-forms.js";
 import { reconcile, scanDefinitions, } from "../doctor/definitions-scan.js";
+import { accountExportsInto, emptyExportAccount, exportInvariantHolds, } from "../doctor/export-census.js";
 import { fragmentsOfSource, fragmentsOfStylesheet, judgeFragments, } from "../doctor/fragments.js";
+import { useFrameworkMajor } from "../doctor/framework-palette.js";
 import { describeConvention, describeRemainder, detectConventions, } from "../doctor/idiom.js";
 import { pageLaws } from "../doctor/page-laws.js";
 import { callSiteNode, placeLayers, } from "../doctor/place-layers.js";
@@ -34,6 +36,7 @@ import { buildLedger, describeLedger, } from "../doctor/style-ledger.js";
 import { MUI_DEFAULT_SPACING, readStyledComponents, spacingOf, } from "../doctor/style-props.js";
 import { buildTable } from "../doctor/tokens.js";
 import { definitionSpan, parseClass, readInlineStyle, rootClasses, rootTag, transcribe, } from "../doctor/transcribe.js";
+import { accountClasses, invariantHolds, sumAccounts, } from "../doctor/value-ledger.js";
 import { transcribeVariants } from "../doctor/variant-read.js";
 import { frontierKind, packageRoot } from "../frontier-kind.js";
 import { keyframesInSheets } from "../global-keyframes.js";
@@ -50,6 +53,7 @@ import { repoStateOf } from "../repo-state.js";
 import { runtimeDeclaredVars, runtimeDeclaredVarsIn } from "../runtime-vars.js";
 import { detectStack, resolveDeps, stackVersions } from "../stack.js";
 import { wiredSlugs, wiringWarning } from "../wired-slugs.js";
+import { harvestWorkspaceCss } from "../workspace-css.js";
 import { placeInWorkspace } from "../workspace-place.js";
 import { add } from "./add.js";
 import { walk, walkAll } from "./doctor.js";
@@ -456,6 +460,16 @@ export async function takeCensus(root, opts) {
     const fragments = [];
     /** Arquivos de estilo que pertencem a componente admitido - o veredito do `css` sai daqui. */
     const admittedStyles = new Set();
+    /** O denominador de exports antes do portão - ver `export-census.ts` (item 13). */
+    const exportAccount = emptyExportAccount();
+    /**
+     * A VERSÃO DO FRAMEWORK, ANTES DA VARREDURA - a paleta publicada muda de língua na maior
+     * (v4 é oklch, v3 é hex), e o resolvedor é chamado fundo demais para receber mais um
+     * parâmetro. Hoisted de depois da varredura, onde só os signals a usavam.
+     */
+    const versions = await resolveDeps(root).catch(() => ({}));
+    useFrameworkMajor(Number.parseInt(/\d+/.exec(versions.tailwindcss ?? "")?.[0] ?? "", 10) ||
+        null);
     /** What the gate turned away, with the reason. Never dropped in silence. */
     const skips = [];
     // Kept for the reference check below, which needs every file at once: a name
@@ -468,6 +482,16 @@ export async function takeCensus(root, opts) {
         if (!declaredValues.has(m[1]))
             declaredValues.set(m[1], m[2].trim());
     }
+    /**
+     * O VOCABULÁRIO DO PACOTE AO LADO (item 19) - ver `workspace-css.ts`. Genérico por decisão do
+     * dono (25/08): qualquer pacote de WORKSPACE que o escopo importa, nunca `node_modules` e nunca
+     * um nome cravado. O escopo dele sempre vence (a trava é o `scopeDeclares`); no repositório
+     * real, 223 valores (37% do não-lido) vestiam variáveis declaradas um pacote ao lado.
+     */
+    const workspace = await harvestWorkspaceCss(root, (name) => declaredValues.has(name)).catch(() => ({ packages: [], declared: new Map() }));
+    for (const [name, value] of workspace.declared) {
+        declaredValues.set(name, value);
+    }
     /**
      * AS REGRAS DE CLASSE DAS FOLHAS GLOBAIS - ver `readGlobalClasses`. Uma regra que um
      * componente admitido veste é a receita dele; `claimed` guarda quais foram vestidas,
@@ -634,7 +658,14 @@ export async function takeCensus(root, opts) {
                 screensOf.set(m[1], at);
             }
             const found = [];
-            for (const d of scanDefinitions(rel, src)) {
+            const defs = scanDefinitions(rel, src);
+            /**
+             * O DENOMINADOR ANTES DO PORTÃO - ver `export-census.ts` (item 13). Todo nome que o scan
+             * produziu TEM destino (admitido ou recusado); o contador mede o que sobra fora do funil.
+             */
+            const openedNames = new Set(defs.map((d) => d.name));
+            accountExportsInto(exportAccount, rel, src, (n) => openedNames.has(n));
+            for (const d of defs) {
                 const verdict = gateComponent({
                     name: d.name,
                     file: rel,
@@ -1952,7 +1983,6 @@ export async function takeCensus(root, opts) {
      * versão (medido 16/08). `resolveDeps` sobe até a raiz do workspace e anda para os irmãos que os
      * `workspaces` declaram, que é onde recharts/chakra/mui realmente moram.
      */
-    const versions = await resolveDeps(root).catch(() => ({}));
     finishSignals(signals, importTally, versions);
     // Every name their CSS defines, from the same harvest the token table came
     // from - so a reference is judged against what actually exists, not against
@@ -1961,6 +1991,9 @@ export async function takeCensus(root, opts) {
     for (const m of css.matchAll(/(--[a-zA-Z0-9_-]+)\s*:/g)) {
         declaredNames.add(m[1]);
     }
+    /** O pacote ao lado também declara (item 19) - sem isto a ref dele viraria "quebrada". */
+    for (const name of workspace.declared.keys())
+        declaredNames.add(name);
     /**
      * E O QUE ELE DECLARA FORA DO CSS - ver `runtimeDeclaredVars`.
      *
@@ -2105,6 +2138,25 @@ export async function takeCensus(root, opts) {
         const target = c?.canonical ?? (c?.bucket === "exclusive" ? c.name : null);
         return target ? safePartName(target) : null;
     }, (pkg) => versions[pkg]);
+    /**
+     * A CONTABILIDADE POR VALOR, contada AQUI porque o material é daqui: os tokens de classe que
+     * vestem cada componente admitido (os nós do sketch e as camadas condicionais cruas), contra
+     * os tokens que o CSS dele declara. Ver `Census.values` e `doctor/value-ledger.ts` - é a
+     * reconciliação do item 11, e a soma fecha com `seen` por construção.
+     */
+    const valueByComponent = {};
+    for (const [lookName, look] of Object.entries(looks)) {
+        const tokens = [];
+        for (const node of look.sketch ?? []) {
+            tokens.push(...(node.classes ?? "").split(/\s+/).filter(Boolean));
+        }
+        for (const layer of look.rawLayers ?? [])
+            tokens.push(...layer.classes);
+        if (tokens.length > 0) {
+            valueByComponent[lookName] = accountClasses(tokens, declaredValues);
+        }
+    }
+    const valuesTotal = sumAccounts(Object.values(valueByComponent));
     return {
         census: 1,
         project: {
@@ -2261,6 +2313,44 @@ export async function takeCensus(root, opts) {
                 },
             }
             : {}),
+        /**
+         * A conta por VALOR - ver o tipo. Ausente quando nenhum componente veste classe, e ausente
+         * quando a soma não fecha: uma conta que viola a própria invariante é bug NOSSO, e um censo
+         * sem o campo é honesto enquanto um campo errado governaria telas. Hoje ela fecha por
+         * construção; o portão existe para o dia em que uma derivação (a engine do D3) não fechar.
+         */
+        ...(valuesTotal.seen > 0 && invariantHolds(valuesTotal)
+            ? {
+                values: {
+                    classes: { ...valuesTotal, byComponent: valueByComponent },
+                },
+            }
+            : {}),
+        /**
+         * O DENOMINADOR ANTES DO PORTÃO - ver `export-census.ts` (item 13). Com ele, "o portão pega
+         * 100%" vira aritmética conferível: candidatos têm destino no gate, formas deliberadas têm
+         * contagem, e o resíduo tem LINHA. Mesmo padrão do `values`: a soma que não fecha não é
+         * emitida - censo sem o campo é mais honesto que campo errado.
+         */
+        ...(exportAccount.seen > 0 && exportInvariantHolds(exportAccount)
+            ? {
+                exports: {
+                    seen: exportAccount.seen,
+                    byForm: exportAccount.byForm,
+                    ...(exportAccount.unopened.length > 0
+                        ? { unopened: exportAccount.unopened.slice(0, 512) }
+                        : {}),
+                },
+            }
+            : {}),
+        /**
+         * DE ONDE VEIO O VOCABULÁRIO EMPRESTADO (item 19) - o pacote workspace e quantas variáveis
+         * ele doou. Viaja para a tela poder dizer "estes nomes moram em `@acme/ui`" em vez de o
+         * cliente procurar no escopo uma declaração que não está lá.
+         */
+        ...(workspace.packages.length > 0
+            ? { workspaceCss: { packages: workspace.packages } }
+            : {}),
         ...(architectures.length > 0
             ? {
                 architectures: architectures.slice(0, 6).map((a) => ({

package/dist/doctor/components-scan.js

@@ -434,6 +434,43 @@ export function tallyToInventory(tally, max = 80) {
         .sort((a, b) => b.files - a.files || b.count - a.count)
         .slice(0, max);
 }
+/**
+ * OS PACOTES DO WORKSPACE, com nome E pasta - a metade que `internalSpecifiers` jogava fora.
+ *
+ * A mesma caminhada (até 4 níveis acima, grupos `packages`/`libs`/`apps`), extraída para UMA
+ * fonte: o item 19 precisa da PASTA de cada pacote para colher o CSS dele, e uma segunda cópia
+ * da regra de descoberta é como duas descobertas começam a discordar.
+ */
+export async function workspacePackages(root) {
+    const out = new Map();
+    for (let up = 0, dir = root; up < 4; up++) {
+        for (const group of ["packages", "libs", "apps"]) {
+            for (const e of await readdir(join(dir, group), {
+                withFileTypes: true,
+            }).catch(() => [])) {
+                if (!e.isDirectory())
+                    continue;
+                const raw = await readFile(join(dir, group, e.name, "package.json"), "utf8").catch(() => null);
+                if (!raw)
+                    continue;
+                try {
+                    const name = JSON.parse(raw).name;
+                    if (typeof name === "string" && name && !out.has(name)) {
+                        out.set(name, join(dir, group, e.name));
+                    }
+                }
+                catch {
+                    // manifesto ilegível custa aquele pacote, nunca a descoberta
+                }
+            }
+        }
+        const parent = join(dir, "..");
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return [...out.entries()].map(([name, dir]) => ({ name, dir }));
+}
 /**
  * Specifier prefixes this workspace owns: the aliases its tsconfig declares and
  * the names of its sibling packages. Everything else that is not relative comes
@@ -459,29 +496,13 @@ export async function internalSpecifiers(root) {
                 // unreadable config costs the aliases, not the run
             }
         }
-        for (const group of ["packages", "libs", "apps"]) {
-            for (const e of await readdir(join(dir, group), {
-                withFileTypes: true,
-            }).catch(() => [])) {
-                if (!e.isDirectory())
-                    continue;
-                const raw = await readFile(join(dir, group, e.name, "package.json"), "utf8").catch(() => null);
-                if (!raw)
-                    continue;
-                try {
-                    const name = JSON.parse(raw).name;
-                    if (typeof name === "string" && name)
-                        out.add(name);
-                }
-                catch {
-                    // same
-                }
-            }
-        }
         const parent = join(dir, "..");
         if (parent === dir)
             break;
         dir = parent;
     }
+    /** Os nomes dos irmãos vêm da MESMA descoberta que o item 19 usa - uma fonte, nunca duas. */
+    for (const pkg of await workspacePackages(root))
+        out.add(pkg.name);
     return [...out];
 }

package/dist/doctor/export-census.js

@@ -0,0 +1,111 @@
+/** `export function X` / `export const x =` / `export default class X` - o nome inline. */
+const NAMED = /export\s+(?:default\s+)?(?:abstract\s+)?(?:async\s+)?(?:function\s*\*?|class|const|let|var|enum)\s+([A-Za-z_$][\w$]*)/g;
+/** `export type X` / `export interface X` - vocabulário, não peça. */
+const TYPE_EXPORT = /export\s+(?:type|interface)\s+[A-Za-z_$]/g;
+/** `export { A, B } from "x"` e `export * from "x"` - repasse. */
+const RE_EXPORT = /export\s*(?:\*|\{[^}]*\})\s*from\s*["']/g;
+/** `export { A, B }` SEM from - nomes declarados neste arquivo, exportados em lista. */
+const LIST_EXPORT = /export\s*\{([^}]*)\}(?!\s*from)/g;
+/** `export default (…)=>` / `export default function (` / objeto/literal - sem nome legível. */
+const ANONYMOUS_DEFAULT = /export\s+default\s+(?:(?:React\.)?(?:memo|forwardRef)\s*\(\s*)*(?:async\s+)?(?:\(|function\s*\(|\{|\[|`|['"\d])/g;
+/** `export default Name;` - com nome; o funil decide se é definição ou repasse. */
+const NAMED_DEFAULT = /export\s+default\s+(?:(?:React\.)?(?:memo|forwardRef)\s*\(\s*)*([A-Za-z_$][\w$]*)\s*[;)\n]/g;
+/** O nome é construído NESTE arquivo? - a mesma pergunta do scanner de definições. */
+function declaresName(source, name) {
+    const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return new RegExp(`(?:^|\\n)\\s*(?:export\\s+)?(?:default\\s+)?(?:async\\s+)?(?:function|class|const|let|var)\\s+${escaped}\\b`).test(source);
+}
+const count = (account, form) => {
+    account.seen += 1;
+    account.byForm[form] = (account.byForm[form] ?? 0) + 1;
+};
+/**
+ * Conta os exports de UM arquivo de componente, contra o que o funil abriu dele.
+ *
+ * `opened` responde se um nome virou candidato (admitido OU recusado - os dois são destino).
+ * Muta `account` em vez de devolver, porque a soma do censo é a soma dos arquivos e um merge de
+ * records a cada arquivo é custo quadrático num monorepo de 966.
+ */
+export function accountExportsInto(account, file, source, opened) {
+    if (!/\.(tsx|jsx|vue|svelte)$/i.test(file))
+        return;
+    const push = (line) => {
+        /** Teto por censo, aplicado por quem monta - aqui só não duplica dentro do arquivo. */
+        if (!account.unopened.some((u) => u.file === line.file && u.name === line.name)) {
+            account.unopened.push(line);
+        }
+    };
+    NAMED.lastIndex = 0;
+    for (const m of source.matchAll(NAMED)) {
+        const name = m[1];
+        if (!/^[A-Z]/.test(name)) {
+            count(account, "helper");
+            continue;
+        }
+        if (opened(name)) {
+            count(account, "candidate");
+            continue;
+        }
+        count(account, "unopened");
+        push({ file, name, form: "unopened" });
+    }
+    TYPE_EXPORT.lastIndex = 0;
+    for (const _ of source.matchAll(TYPE_EXPORT))
+        count(account, "type");
+    RE_EXPORT.lastIndex = 0;
+    for (const _ of source.matchAll(RE_EXPORT))
+        count(account, "re-export");
+    LIST_EXPORT.lastIndex = 0;
+    for (const m of source.matchAll(LIST_EXPORT)) {
+        for (const raw of m[1].split(",")) {
+            /** `Card as default` conta pelo nome local; o scanner de definições já lê essa grafia. */
+            const name = raw
+                .trim()
+                .split(/\s+as\s+/)[0]
+                ?.trim();
+            if (!name || !/^[A-Za-z_$]/.test(name))
+                continue;
+            if (!/^[A-Z]/.test(name)) {
+                count(account, "helper");
+                continue;
+            }
+            if (!declaresName(source, name)) {
+                count(account, "re-export");
+                continue;
+            }
+            if (opened(name)) {
+                count(account, "candidate");
+                continue;
+            }
+            count(account, "export-list");
+            push({ file, name, form: "export-list" });
+        }
+    }
+    ANONYMOUS_DEFAULT.lastIndex = 0;
+    for (const _ of source.matchAll(ANONYMOUS_DEFAULT)) {
+        count(account, "anonymous-default");
+        push({ file, form: "anonymous-default" });
+    }
+    NAMED_DEFAULT.lastIndex = 0;
+    for (const m of source.matchAll(NAMED_DEFAULT)) {
+        const name = m[1];
+        if (!declaresName(source, name)) {
+            count(account, "re-export");
+            continue;
+        }
+        /** Declarado aqui: ou o funil o abriu (candidato), ou é resíduo com linha. */
+        if (opened(name)) {
+            count(account, "candidate");
+            continue;
+        }
+        count(account, "unopened");
+        push({ file, name, form: "unopened" });
+    }
+}
+export function emptyExportAccount() {
+    return { seen: 0, byForm: {}, unopened: [] };
+}
+/** A invariante do denominador: toda contagem por forma soma o total visto. */
+export function exportInvariantHolds(account) {
+    return (Object.values(account.byForm).reduce((a, b) => a + b, 0) === account.seen);
+}

package/dist/doctor/form-identity.js

@@ -0,0 +1,75 @@
+/**
+ * A IDENTIDADE DA FORMA (item 12, 25/08) - a unidade de uma pergunta de self-healing.
+ *
+ * `FragmentShape` tem 7 valores e é grosso demais: o balde `css` lê 42% no frontend-hub e 0% no
+ * codelevel - o MESMO nome com leitores opostos. E texto distinto é fino demais: 10 825 usos do
+ * frontend-hub viram 140 textos, mas cada texto ainda é uma pergunta. A granularidade que decide
+ * é a FORMA - o texto com os valores abstraídos:
+ *
+ *     body { -webkit-font-smoothing: antialiased }   ->  -webkit-font-smoothing: <keyword>
+ *     background: linear-gradient(90deg, #a, #b)     ->  background: <gradient>
+ *     hover:-translate-y-px · -translate-y-px        ->  -translate-y-px        (uma forma)
+ *     text-rose-700 · text-amber-300                 ->  text-<word>-<n>        (uma forma)
+ *
+ * Medido no diagnóstico: 18 473 declarações das 706 folhas do app inteiro comprimem para 194
+ * formas - DEZENAS, não milhares. Uma resposta dele (D2) responde a FORMA, não o texto: quem
+ * ensina a ler `text-<word>-<n>` ensinou as centenas de uma vez.
+ */
+/** O tipo de UM valor de CSS, abstraído - a escada é determinística e a ordem importa. */
+function kindOfValue(raw) {
+    const value = raw.trim();
+    if (/gradient\s*\(/i.test(value))
+        return "<gradient>";
+    if (/^var\(\s*--[\w-]+\s*\)$/i.test(value))
+        return "<var>";
+    if (/^#[0-9a-f]{3,8}$/i.test(value))
+        return "<color>";
+    if (/^(?:rgba?|hsla?|oklch|oklab|lab|lch|color|color-mix)\s*\(/i.test(value))
+        return "<color>";
+    if (/url\s*\(/i.test(value))
+        return "<url>";
+    if (/^calc\s*\(/i.test(value))
+        return "<calc>";
+    if (/^-?[\d.]+(?:px|rem|em|%|s|ms|vh|vw|vmin|vmax|fr|ch|ex|pt)$/i.test(value))
+        return "<length>";
+    if (/^-?[\d.]+$/.test(value))
+        return "<number>";
+    if (/^[a-z][a-z-]*$/i.test(value))
+        return "<keyword>";
+    /** Sombra, transição, pilha de fonte - vários valores numa declaração só. */
+    return "<composite>";
+}
+/**
+ * UM token utilitário, com os valores abstraídos: dígitos viram `<n>`, frações `<n>/<n>`,
+ * hex `<hex>`, valor arbitrário `[…]` - e os MODIFICADORES saem, porque `hover:-translate-y-px`
+ * e `-translate-y-px` são a mesma lacuna de leitura.
+ */
+function classForm(token) {
+    const utility = token.split(":").pop() ?? token;
+    return utility
+        .replace(/\[[^\]]*\]/g, "[…]")
+        .replace(/#[0-9a-f]{3,8}/gi, "<hex>")
+        .replace(/(\d+)\/(\d+)/g, "<n>/<n>")
+        .replace(/\/(\d+)/g, "/<n>")
+        .replace(/\d+(?:\.\d+)?/g, "<n>")
+        .replace(/(?<=-)[a-z]+(?=-<n>(?:\/<n>)?$)/, "<word>");
+}
+/** `sel { prop: value; … }` ou `prop: value` - a primeira declaração nomeia a forma. */
+const DECLARATION = /(-{0,2}[a-zA-Z][\w-]*)\s*:\s*([^;{}]+)/;
+/**
+ * A forma de UM fragmento não lido. Determinística, derivada só do texto - a mesma regra do
+ * backfill do D3: nada aqui é chute, e um texto que não abre vira a forma `<opaque>`, dita.
+ */
+export function formOf(shape, text) {
+    const clean = text.replace(/\s+/g, " ").trim();
+    if (shape === "class" || shape === "template") {
+        const forms = [
+            ...new Set(clean.split(/\s+/).filter(Boolean).map(classForm)),
+        ];
+        return forms.slice(0, 4).join(" ") || "<opaque>";
+    }
+    const declaration = DECLARATION.exec(clean);
+    if (!declaration)
+        return "<opaque>";
+    return `${declaration[1]}: ${kindOfValue(declaration[2])}`;
+}