synthesisui 0.16.448 → 0.16.449

package/dist/commands/import.js

@@ -30,6 +30,7 @@ import { componentsPagesReachFor, pageLaws } from "../doctor/page-laws.js";
 import { callSiteNode, placeLayers, } from "../doctor/place-layers.js";
 import { publicApi, requiredProps } from "../doctor/public-api.js";
 import { aliasesOf, describeReachability, edgesIn, reachabilityOf, } from "../doctor/reachability.js";
+import { rootGroundOf } from "../doctor/root-ground.js";
 import { diagnose, scanSource } from "../doctor/scan.js";
 import { parseSchemeBlocks } from "../doctor/scheme-blocks.js";
 import { describeSignals, emptySignals, finishSignals, readSignalsInto, } from "../doctor/signals.js";
@@ -2408,6 +2409,15 @@ export async function takeCensus(root, opts) {
         sheets: globalSheets.map((g) => ({ file: g.file, css: g.body })),
         signals: signals.theme,
     });
+    /**
+     * O CHAO DA FACE PADRAO - a mesma folha, outra pergunta.
+     *
+     * `polarity` responde QUAL face o projeto abre; isto responde O QUE ela veste. Sao
+     * fatos separados de proposito: um projeto pode ter chao sem ter polaridade declarada,
+     * e e' exatamente o caso que fazia o `canvas` ser escolhido por casamento de palavra.
+     * Ver `root-ground.ts` para a medicao do `codelevel` que motivou isto.
+     */
+    const rootGround = rootGroundOf(globalSheets.map((g) => ({ file: g.file, css: g.body })));
     const declaredSchemes = {
         base: Object.fromEntries(schemes.base),
         light: Object.fromEntries(schemes.light),
@@ -2415,6 +2425,9 @@ export async function takeCensus(root, opts) {
         defaultScheme: polarity.scheme,
         defaultSchemeSource: polarity.source,
         ...(polarity.evidence ? { defaultSchemeEvidence: polarity.evidence } : {}),
+        ...(rootGround.background != null || rootGround.color != null
+            ? { rootGround }
+            : {}),
     };
     // 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

package/dist/doctor/root-ground.js

@@ -0,0 +1,86 @@
+/**
+ * O QUE A PÁGINA VESTE, lido da regra em vez de adivinhado pelo nome do token.
+ *
+ * O QUE ISTO RESOLVE PARA O CLIENTE: o `canvas` e o `foreground` da face padrão dele
+ * param de ser escolhidos por casamento de palavra. Medido no `codelevel` em 21/09: o
+ * fundo da página é `--color-paper` (`#fbfaf6`) e o texto é `--color-ink-900`
+ * (`#0c0c11`), escritos numa regra de raiz sem escopo nenhum:
+ *
+ *     html, body { background: var(--color-paper); color: var(--color-ink-900); }
+ *     html.dark  { background: var(--color-ink-950); color: var(--color-ink-50); }
+ *
+ * O vocabulário de `canvas` em `census-import` é `["canvas","background","bg","page",…]`.
+ * `--color-code-bg` casa por causa do `bg` e ganhou o fundo da página; `--color-paper`
+ * não casa com nada e sobrou. A tela dele passou a chamar `CODE-BG` de *"Page
+ * background"*, e a paleta clara nasceu com o fundo de um bloco de código.
+ *
+ * A REGRA NÃO TEM ESSE PROBLEMA porque ela não descreve o token, ela descreve o uso: o
+ * que está depois de `background:` na raiz do documento É o fundo da página, com o nome
+ * que for.
+ *
+ * COMO A FACE É NOMEADA, sem encostar em luminância. A restrição do dono (28/08) proíbe
+ * decidir polaridade por luminância, por nome de token, por nome de repositório ou por
+ * presença ISOLADA de `.dark`. Aqui não é presença isolada: é um PAR. A raiz sem escopo
+ * veste um chão, e um bloco com escopo `dark` veste outro nas mesmas propriedades. O
+ * primeiro é a face padrão por ser o que não tem escopo; o segundo se chama `dark` pelo
+ * próprio seletor. Logo a padrão é `light` — e nenhuma cor foi medida para dizer isso.
+ *
+ * SEM O PAR, A FACE CONTINUA SEM NOME. Um projeto que só tem a raiz sem escopo tem chão,
+ * mas não tem como dizer de que face ele é: `counterpart` sai `null` e quem consome
+ * decide o que fazer com um chão anônimo. Chão sem nome ainda vale — ele diz qual é o
+ * fundo e qual é o texto da face que o projeto abre, que é exatamente o que faltava.
+ */
+import { scopedBlocks } from "./scheme-scope.js";
+/** As propriedades que pintam o chão. `background` abreviado inclui a cor. */
+const GROUND = /^(background|background-color|color)$/i;
+const VAZIO = { background: null, color: null, counterpart: null };
+/**
+ * A PRIMEIRA DECLARAÇÃO VENCE, a mesma regra de `parseSchemeBlocks`.
+ *
+ * Cascata entre folhas é coisa que um scanner não vê, e inventar uma ordem aqui seria
+ * inventar um vencedor. Duas folhas discordando do chão é um fato sobre o projeto, não
+ * uma escolha deste módulo — e a primeira é a que a varredura encontra.
+ */
+export function rootGroundOf(sheets) {
+    let background = null;
+    let color = null;
+    let evidence;
+    /** As faces com escopo que também vestem chão — é o que nomeia a face padrão. */
+    const opostas = new Set();
+    for (const sheet of sheets) {
+        for (const block of scopedBlocks(sheet.css)) {
+            if (block.scope === "other")
+                continue;
+            const vestidas = block.declarations.filter((d) => GROUND.test(d.name));
+            if (vestidas.length === 0)
+                continue;
+            if (block.scope !== "base") {
+                opostas.add(block.scope);
+                continue;
+            }
+            for (const d of vestidas) {
+                const nome = d.name.toLowerCase();
+                if (nome === "color") {
+                    if (color == null) {
+                        color = d.value.trim();
+                        evidence ??= { file: sheet.file, selector: block.stack.join(" ") };
+                    }
+                    continue;
+                }
+                if (background == null) {
+                    background = d.value.trim();
+                    evidence ??= { file: sheet.file, selector: block.stack.join(" ") };
+                }
+            }
+        }
+    }
+    if (background == null && color == null)
+        return VAZIO;
+    /**
+     * UMA CONTRAPARTE SÓ NOMEIA. Se as duas faces com escopo vestem chão, o projeto tem
+     * claro E escuro escritos à mão e a raiz sem escopo é um terceiro estado — aí ela não
+     * é "a outra", e o chão fica anônimo em vez de receber um nome sorteado.
+     */
+    const counterpart = opostas.size === 1 ? (opostas.has("dark") ? "light" : "dark") : null;
+    return { background, color, counterpart, ...(evidence ? { evidence } : {}) };
+}

package/package.json

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