synthesisui 0.16.135 → 0.16.136

package/dist/commands/import.js

@@ -13,7 +13,7 @@ import { describeGate, gateComponent, groupSkips, SCREENS_FOR_SYSTEM, } from "..
 import { emptyTally, internalSpecifiers, scanComponentsInto, tallyToInventory, } from "../doctor/components-scan.js";
 import { countShape, describeCoverage, summarizeCoverage, } from "../doctor/coverage.js";
 import { crosswalk, floorSize, isLibrary, observedRules, useLiveCatalogue, } from "../doctor/crosswalk.js";
-import { keyframeOffsets, moduleImports, readModuleCss, readModuleUsage, transcribeModule, } from "../doctor/css-modules.js";
+import { keyframeOffsets, moduleImports, partialCandidates, readModuleCss, readModuleUsage, sheetImports, transcribeModule, } from "../doctor/css-modules.js";
 import { dataContract } from "../doctor/data-contract.js";
 import { reconcile, scanDefinitions, } from "../doctor/definitions-scan.js";
 import { fragmentsOfSource, fragmentsOfStylesheet, judgeFragments, } from "../doctor/fragments.js";
@@ -128,6 +128,48 @@ async function siblingProjects(root) {
  * this" - could not be said, and we ended up rediscovering by colour distance
  * what their stylesheet had spelled out all along.
  */
+/**
+ * UMA FOLHA E TUDO O QUE ELA TRAZ PARA DENTRO DE SI, na ordem em que o sass compila.
+ *
+ * Uma partial (`_darkMode.scss`) nunca é compilada sozinha: ela entra em quem a importa, e portanto
+ * herda o escopo de quem a importa. Ler o `.module.scss` sem seguir os `@import` dele deixava de
+ * fora 1 400 declarações (91% de tudo o que a esteira chamava de "CSS global sem leitor") - e elas
+ * são, no build dele, as faces light e dark de classes que o componente JÁ veste (medido, 05/08).
+ *
+ * Devolve o CSS concatenado e os arquivos que entraram, porque o ledger precisa saber que a partial
+ * pertence a um componente admitido - senão ela continua contabilizada como forma sem leitor, e o
+ * relatório passa a discordar da receita.
+ */
+async function sheetWithImports(path, seen = new Set(), depth = 0) {
+    if (depth > 6 || seen.has(path))
+        return { css: "", files: [] };
+    seen.add(path);
+    const body = await readFile(path, "utf8").catch(() => "");
+    if (!body)
+        return { css: "", files: [] };
+    let css = "";
+    const files = [path];
+    /**
+     * O IMPORTADO VEM ANTES, que é a ordem do sass: quem importa sobrescreve o que importou. Inverter
+     * isto faria a face dark de uma partial vencer a base do próprio module.
+     */
+    for (const spec of sheetImports(body)) {
+        for (const candidate of partialCandidates(spec)) {
+            const child = join(dirname(path), candidate);
+            const nested = await sheetWithImports(child, seen, depth + 1);
+            if (nested.css || nested.files.length > 1 || (await exists(child))) {
+                css += nested.css;
+                files.push(...nested.files);
+                break;
+            }
+        }
+    }
+    return { css: `${css}\n${body}`, files };
+}
+/** Existe no disco - o candidato de partial que o sass acharia primeiro. */
+async function exists(path) {
+    return await readFile(path, "utf8").then(() => true, () => false);
+}
 async function harvestOwnCss(root, 
 /**
  * O LEDGER TAMBÉM COME AQUI, e por um motivo de promessa: este é o único laço que vê TODO
@@ -139,17 +181,40 @@ async function harvestOwnCss(root,
  * não admitido é um motivo, não um desaparecimento.
  */
 into) {
-    let css = "";
+    /**
+     * DOIS PASSES, porque o escopo de uma folha está no GRAFO e não no nome dela.
+     *
+     * O primeiro junta tudo; o segundo julga cada folha sabendo quem importa quem. Um pass só
+     * decidia por `/\.module\./` e chamava de "CSS global sem leitor" 1 400 declarações que o build
+     * deles compila dentro de um module (medido, 05/08).
+     */
+    const sheets = [];
     for await (const file of walkAll([root])) {
         if (!/\.(css|scss|sass|less)$/i.test(file))
             continue;
         const body = await readFile(file, "utf8").catch(() => "");
+        sheets.push({ file, body });
+    }
+    /** Todo caminho que alguma folha importa, resolvido como o sass resolveria. */
+    const imported = new Set();
+    for (const sheet of sheets)
+        for (const spec of sheetImports(sheet.body))
+            for (const candidate of partialCandidates(spec))
+                imported.add(join(dirname(sheet.file), candidate));
+    let css = "";
+    for (const { file, body } of sheets) {
         css += `\n${body}`;
-        if (into && body)
-            into.push({
-                file: relative(root, file),
-                fragments: fragmentsOfStylesheet(relative(root, file), body, /\.module\./.test(file)),
-            });
+        if (!into || !body)
+            continue;
+        const partial = basename(file).startsWith("_");
+        into.push({
+            file: relative(root, file),
+            fragments: fragmentsOfStylesheet(relative(root, file), body, /\.module\./.test(file) || (partial && imported.has(file))
+                ? "scoped"
+                : partial
+                    ? "dead"
+                    : "global"),
+        });
     }
     return css;
 }
@@ -564,7 +629,13 @@ export async function takeCensus(root, opts) {
                 let fromModule = null;
                 for (const mod of modules) {
                     const cssPath = join(dirname(file), mod.specifier);
-                    const moduleCss = await readFile(cssPath, "utf8").catch(() => "");
+                    /**
+                     * O MODULE E AS PARTIALS QUE ELE IMPORTA, que no build dele são um arquivo só. Ler apenas
+                     * o `.module.scss` deixava 1 400 declarações fora - as faces light e dark de classes que
+                     * o componente já veste, escritas em `_lightMode.scss`/`_darkMode.scss` ao lado.
+                     */
+                    const sheet = await sheetWithImports(cssPath);
+                    const moduleCss = sheet.css.trim();
                     if (!moduleCss)
                         continue;
                     const usage = readModuleUsage(src, mod.local);
@@ -574,8 +645,14 @@ export async function takeCensus(root, opts) {
                      * ESTE MODULE PERTENCE A UM COMPONENTE ADMITIDO - o único fato que este laço tem e o
                      * ledger precisa. Os fragmentos dele vêm do `harvestOwnCss`, que vê todos os arquivos
                      * de estilo e não só os de componente aceito.
+                     *
+                     * A PARTIAL ENTRA JUNTO: ela é parte deste module, então o veredito dela é o mesmo. Sem
+                     * isto o relatório continuaria chamando de "forma sem leitor" exatamente o que a receita
+                     * acabou de ler - relatório e receita discordando, que é o defeito que o ledger existe
+                     * para não ter.
                      */
-                    admittedStyles.add(relative(root, cssPath));
+                    for (const part of sheet.files)
+                        admittedStyles.add(relative(root, part));
                     const readModule = transcribeModule(readModuleCss(moduleCss), usage, declaredValues);
                     if (readModule.read === 0)
                         continue;

package/dist/doctor/css-modules.js

@@ -335,6 +335,50 @@ export function moduleImports(source) {
         specifier: m[2],
     }));
 }
+/**
+ * `@import "./_darkMode"`, `@use "./_lightMode.scss"` - o que uma folha traz para dentro de si.
+ *
+ * UMA PARTIAL NÃO É UMA FOLHA. Um arquivo `_nome.scss` nunca é compilado sozinho - o sass o
+ * compila DENTRO de quem o importa, e por isso o escopo dele é o de quem importa. No app do dono,
+ * 122 das 138 folhas "globais" são partials e 120 delas são importadas por um `.module.scss` do
+ * mesmo diretório: 1 400 declarações (91%) que a esteira classificava como CSS global sem leitor
+ * são, no build dele, regras de module - hasheadas e escopadas ao componente (medido, 05/08).
+ *
+ * Decidir escopo por NOME DE ARQUIVO (`/\.module\./`) é a lei 14 um nível abaixo: a resposta está
+ * no grafo de imports, não na string do caminho.
+ */
+const SHEET_IMPORT = /@(?:import|use|forward)\s+["']([^"']+)["']/g;
+export function sheetImports(css) {
+    SHEET_IMPORT.lastIndex = 0;
+    return ([...stripCssComments(css).matchAll(SHEET_IMPORT)]
+        .map((m) => m[1].trim())
+        /**
+         * Só o que é relativo. `@use "sass:math"` e um pacote do node_modules não carregam decisão de
+         * aparência deles, e seguir esses caminhos é como um leitor de CSS vira um resolvedor de
+         * módulos pela metade.
+         */
+        .filter((spec) => spec.startsWith(".") || !spec.includes(":"))
+        .filter((spec) => !spec.startsWith("~") && !spec.startsWith("url(")));
+}
+/** `./_darkMode` → os nomes de arquivo que o sass tentaria, na ordem em que ele tenta. */
+export function partialCandidates(specifier) {
+    const clean = specifier.replace(/^\.\//, "");
+    const slash = clean.lastIndexOf("/");
+    const dir = slash === -1 ? "" : `${clean.slice(0, slash)}/`;
+    const base = slash === -1 ? clean : clean.slice(slash + 1);
+    if (/\.(css|scss|sass|less)$/.test(base))
+        return base.startsWith("_")
+            ? [`${dir}${base}`]
+            : [`${dir}${base}`, `${dir}_${base}`];
+    const stem = base.startsWith("_") ? base : `_${base}`;
+    return [
+        `${dir}${base}.scss`,
+        `${dir}${stem}.scss`,
+        `${dir}${base}.sass`,
+        `${dir}${stem}.sass`,
+        `${dir}${base}.css`,
+    ];
+}
 /**
  * A generic in type position, not an element.
  *

package/dist/doctor/fragments.js

@@ -110,7 +110,20 @@ export function fragmentsOfSource(file, source) {
  * contagem: um global com regra de CLASSE é forma que nenhum leitor cobre hoje - 399 declarações
  * no repo dele, e a única lacuna que estava calada em vez de declarada (04/08).
  */
-export function fragmentsOfStylesheet(file, css, scoped) {
+export function fragmentsOfStylesheet(file, css, 
+/**
+ * COMO ESTA FOLHA CHEGA NO BUILD DELES, e isso vem do GRAFO DE IMPORTS e nunca do nome do
+ * arquivo. Uma partial (`_darkMode.scss`) é compilada dentro de quem a importa e herda o escopo
+ * dele: 122 das 138 folhas "globais" do app dele são partials, e 120 entram num `.module.scss`
+ * ao lado (medido, 05/08).
+ *
+ *     scoped   module, ou partial de um module: o veredito é do componente dono, e
+ *              `judgeFragments` o dá olhando se o escopo o admitiu
+ *     global   uma folha que o código importa: forma que nenhum leitor cobre hoje
+ *     dead     partial que ninguém importa: o build deles não a compila, e ela não
+ *              pinta nada - aqui, nem lá
+ */
+kind) {
     const out = [];
     let selector = "";
     for (const [i, raw] of css.split("\n").entries()) {
@@ -143,7 +156,11 @@ export function fragmentsOfStylesheet(file, css, scoped) {
                 line: i + 1,
                 text: `${selector ? `${selector} ` : ""}{ ${m[1]}: ${m[2].trim()} }`,
                 read: false,
-                ...(scoped ? {} : { reason: "shape-not-read" }),
+                ...(kind === "global"
+                    ? { reason: "shape-not-read" }
+                    : kind === "dead"
+                        ? { reason: "sheet-not-imported" }
+                        : {}),
             });
         }
     }

package/dist/doctor/gap-triage.js

@@ -84,7 +84,14 @@ function whereOf(shape, reason) {
                 module: null,
                 work: reason === "component-not-admitted"
                     ? "the gate refused the component: these styles exist and no recipe claims them. Changing that means moving the GATE - a decision about the vitrine, not a reader to write"
-                    : "the value is assembled at render time and is not in the source at any level - there is nothing to read",
+                    : reason === "sheet-not-imported"
+                        ? /**
+                           * NÃO É LACUNA NOSSA NEM DELES-QUE-A-GENTE-CONSERTA: é um arquivo que o build deles
+                           * não compila. Cair na frase de runtime dizia que o valor é montado em tempo de
+                           * execução, o que é falso e mandaria alguém procurar o que não existe.
+                           */
+                            "a sass partial no stylesheet imports: their own build never compiles it, so it paints nothing today - here or in their app. Deleting it is their call, not a reader to write"
+                        : "the value is assembled at render time and is not in the source at any level - there is nothing to read",
             };
     }
 }

package/dist/doctor/style-ledger.js

@@ -54,6 +54,7 @@ const BECAUSE = {
     "value-not-read": "the shape is read and this value is not - a utility or property outside the scales this project declares",
     computed: "the value is assembled at render time, so it is not in the source at any level and there is nothing to read",
     "component-not-admitted": "read, and it belongs to a component this scope does not admit into the system - the styles exist and no recipe claims them",
+    "sheet-not-imported": "this is a sass partial and no stylesheet imports it, so your own build never compiles it - it paints nothing today, here or anywhere",
 };
 /**
  * O ledger de uma varredura, a partir dos fragmentos vistos.

package/package.json

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