synthesisui 0.16.447 → 0.16.449

package/dist/agent-wiring.js

@@ -359,7 +359,22 @@ home = homedir()) {
     const settings = await readJson(path);
     const current = settings.statusLine;
     const command = typeof current?.command === "string" ? current.command : "";
-    if (command.includes(rel))
+    /**
+     * "JÁ ESTÁ LÁ" SÃO DUAS COISAS: o ponteiro é nosso E o arquivo existe - 21/09, com o repositório
+     * dele na mão.
+     *
+     * Ele apagou o `_synthesisui/statusline.mjs` para recuperar a barra e rodou o `connect` de novo.
+     * A checagem olhava só o `statusLine` do settings, que continuava apontando para o nosso caminho:
+     * o comando respondeu "já está lá" e não escreveu nada. Sobrou uma configuração apontando para um
+     * arquivo ausente, e o Claude Code tenta rodá-lo a cada respiração da barra.
+     *
+     * Um ponteiro sem o arquivo é pior que nenhum dos dois - por isso ele é reescrito em vez de
+     * aceito como pronto.
+     */
+    const jaEscrito = await access(join(root, rel))
+        .then(() => true)
+        .catch(() => false);
+    if (command.includes(rel) && jaEscrito)
         return { status: "already there", command: ours };
     /**
      * A BARRA DELE PODE MORAR NO SETTINGS GLOBAL, E QUASE SEMPRE MORA - achado em 21/09, com o print
@@ -377,7 +392,13 @@ home = homedir()) {
     const globalSettings = await readJson(globalPath);
     const globalLine = globalSettings.statusLine;
     const fallback = typeof globalLine?.command === "string" ? globalLine.command : "";
-    const was = command.trim() ? command : fallback.trim() ? fallback : null;
+    /**
+     * E O NOSSO PRÓPRIO COMANDO NUNCA VIRA "O ANTERIOR": se o `statusLine` aponta para o invólucro e
+     * o arquivo sumiu, guardar aquilo faria o script novo chamar a si mesmo. A barra dele, nesse
+     * caso, é a do global - que é onde ela estava antes de tudo isto.
+     */
+    const dele = command.includes(rel) ? "" : command;
+    const was = dele.trim() ? dele : fallback.trim() ? fallback : null;
     await mkdir(join(root, "_synthesisui"), { recursive: true });
     await writeFile(join(root, rel), wrapperSource(was), "utf8");
     await mkdir(dir, { recursive: true });

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.447",
+  "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": {