synthesisui 0.16.172 → 0.16.174

package/dist/commands/add.js

@@ -137,6 +137,8 @@ export async function add(slug, opts) {
         registry: base,
         fetchedAt: new Date().toISOString(),
         ...(opts.cli ? { cli: opts.cli } : {}),
+        /** Ver `RegistryPayload.compiler`: é o que faz um conserto de CSS chegar a um install. */
+        ...(payload.compiler != null ? { compiler: payload.compiler } : {}),
         ...(scope ? { scope } : {}),
         ...(usage.length > 0 ? { usage } : {}),
     };

package/dist/commands/align.js

@@ -138,16 +138,38 @@ export async function versionBehind(root, opts = {}) {
     const token = await readToken();
     if (!token)
         return null;
-    const res = await fetch(`${lock.registry ?? resolveRegistry()}/api/registry/ds/${lock.slug}`, { headers: { Authorization: `Bearer ${token}` } }).catch(() => null);
+    /**
+     * `?meta=1` - a versão e o compilador, e nada mais.
+     *
+     * Isto baixava o payload INTEIRO para ler um número: o documento, três CSS compilados e o GUIDE,
+     * a cada abertura de sessão e a cada entrada na pasta pelo terminal.
+     */
+    const res = await fetch(`${lock.registry ?? resolveRegistry()}/api/registry/ds/${lock.slug}?meta=1`, { headers: { Authorization: `Bearer ${token}` } }).catch(() => null);
     if (!res?.ok)
         return null;
     const body = (await res.json().catch(() => null));
-    if (!body?.version || body.version <= lock.version)
+    if (!body?.version)
         return null;
-    return {
-        says: `v${body.version} of "${lock.slug}" is published and this repo is on v${lock.version}. The CSS here and the rules your agent reads are both v${lock.version} - they move together, which is why this is worth saying rather than applying.`,
-        run: `npx synthesisui upgrade ${lock.slug}`,
-    };
+    if (body.version > lock.version)
+        return {
+            says: `v${body.version} of "${lock.slug}" is published and this repo is on v${lock.version}. The CSS here and the rules your agent reads are both v${lock.version} - they move together, which is why this is worth saying rather than applying.`,
+            run: `npx synthesisui upgrade ${lock.slug}`,
+        };
+    /**
+     * A MESMA VERSÃO, COMPILADA DIFERENTE - o caso que não tinha como ser dito nem consertado.
+     *
+     * O CSS não é congelado na publicação: ele é compilado do documento a cada busca. Então um conserto
+     * nosso vale para uma versão JÁ publicada, e nenhum comando o buscava - `upgrade` age por versão e
+     * `connect` agia por CLI. Em 07/08 o bloco de esquema alternativo passou a emitir os dois
+     * ancestrais e não havia caminho até o disco de quem já tinha instalado.
+     */
+    if (typeof body.compiler === "number" &&
+        body.compiler !== (lock.compiler ?? null))
+        return {
+            says: `the css for "${lock.slug}" v${lock.version} is compiled differently now - same version, same document, a fix on our side. The files in this repo were written before it.`,
+            run: "npx synthesisui connect",
+        };
+    return null;
 }
 /**
  * A linha que a sessão vê.

package/dist/commands/connect.js

@@ -2,6 +2,7 @@ import { mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { wireAgent } from "../agent-wiring.js";
 import { blockHomes, syncClaudeMd } from "../claude-md.js";
+import { resolveRegistry } from "../config.js";
 import { body, paint, section, snippet } from "../output.js";
 import { hasHook, rcPathFor, shellFrom, shellSnippet, withHook, } from "../shell-hook.js";
 import { IMPORT_SKILL, IMPORT_SKILL_PATH } from "../skill-import.js";
@@ -48,6 +49,14 @@ const LEGACY_SKILLS = ["import-design-system"];
  * SILENCIOSO QUANDO JÁ ESTÁ EM DIA, e sem rede não faz nada - um `connect` que falha por estar num
  * avião seria pior que a defasagem que ele conserta.
  */
+/** O número do compilador que serviria esta versão HOJE - `null` quando não dá para saber. */
+async function fetchCompiler(base, slug, version) {
+    const res = await fetch(`${base}/api/registry/ds/${slug}?version=${version}&meta=1`).catch(() => null);
+    if (!res?.ok)
+        return null;
+    const body = (await res.json().catch(() => null));
+    return typeof body?.compiler === "number" ? body.compiler : null;
+}
 async function refreshInstall(root, cli, registry) {
     const dsDir = join(root, "_synthesisui", "ds");
     const names = await readdir(dsDir, { withFileTypes: true }).catch(() => []);
@@ -67,7 +76,22 @@ async function refreshInstall(root, cli, registry) {
         /** Um DS adotado é descrito aqui e pertencido em outro lugar - não há o que rematerializar. */
         if (!lock.slug || lock.adopted || typeof lock.version !== "number")
             continue;
-        if (lock.cli === cli)
+        /**
+         * O COMPILADOR TAMBÉM DECIDE, e sem ele um conserto de CSS não alcançava ninguém.
+         *
+         * `tokens.css` é compilado no servidor a cada busca, então ele melhora sem que uma linha do CLI
+         * mude e sem que a versão do sistema ande. Aí `upgrade` (que age por versão) e este bloco (que
+         * agia só por CLI) passavam batido, e o conserto ficava disponível para sempre sem caminho até o
+         * disco de quem instalou - foi o que aconteceu em 07/08 com o seletor do esquema alternativo.
+         *
+         * `?meta=1` custa algumas centenas de bytes; falhar nele não pode custar o `connect`, então um
+         * erro de rede simplesmente não aciona a rematerialização.
+         */
+        /** O host que emitiu ESTE install manda - um token pertence ao host que o emitiu. */
+        const base = resolveRegistry(registry ?? lock.registry);
+        const remote = await fetchCompiler(base, lock.slug, lock.version);
+        const compilerMoved = remote != null && remote !== (lock.compiler ?? null);
+        if (lock.cli === cli && !compilerMoved)
             continue;
         const done = await add(lock.slug, {
             ...(registry ? { registry } : {}),

package/dist/doctor/requests.js

@@ -32,7 +32,20 @@ function idOf(kind, name, at) {
 }
 export async function fileRequest(root, req) {
     const at = req.at ?? new Date().toISOString();
-    const full = { ...req, at, id: idOf(req.kind, req.name, at) };
+    /**
+     * O CARIMBO SÓ PODE SER FEITO AGORA: depois que alguém edita o sistema, não há como saber se o nome
+     * existia quando o pedido nasceu - e é essa a diferença entre "apareceu" e "sempre esteve lá".
+     */
+    const name = checkableName({ ...req, at, id: "" });
+    const existed = name
+        ? declaresName(await readInstalledCss(root), name)
+        : false;
+    const full = {
+        ...req,
+        at,
+        id: idOf(req.kind, req.name, at),
+        ...(existed ? { existed: true } : {}),
+    };
     try {
         await appendFile(path(root), `${JSON.stringify(full)}\n`, "utf8");
     }
@@ -94,24 +107,80 @@ export function checkableName(req) {
     const m = /[a-z][a-z0-9]*(?:-[a-z0-9]+)+/.exec(req.name.trim());
     return m ? m[0] : null;
 }
-/** Requests whose ask the installed css now demonstrably delivers. */
+/**
+ * Cada `--custom-property: valor` que o css instalado declara. A ÚLTIMA vence, que é o que a cascata
+ * faz para declarações do mesmo peso - ler a primeira responderia sobre um bloco que o navegador
+ * descarta.
+ */
+function declaredValues(css) {
+    const out = new Map();
+    const re = /(--[a-z0-9-]+)\s*:\s*([^;}]+)/gi;
+    let m = re.exec(css);
+    while (m) {
+        out.set(m[1].toLowerCase(), m[2].trim());
+        m = re.exec(css);
+    }
+    return out;
+}
+/**
+ * O valor final de uma declaração, seguindo `var()` enquanto der. Um design system nomeia um valor
+ * apontando um papel para uma primitiva, então o valor pedido quase nunca está escrito na linha do
+ * papel - parar no primeiro `var()` reprovaria justamente o caso comum.
+ */
+function resolved(map, value, hops = 5) {
+    let v = value.trim();
+    for (let i = 0; i < hops; i += 1) {
+        const m = /^var\(\s*(--[a-z0-9-]+)/i.exec(v);
+        if (!m)
+            break;
+        const next = map.get(m[1].toLowerCase());
+        if (next == null)
+            break;
+        v = next.trim();
+    }
+    return v.toLowerCase().replace(/\s+/g, " ");
+}
+const candidatesFor = (name) => name.startsWith("animate-") ? [`--${name}`] : [`--ds-${name}`, `--${name}`];
+/** Os nomes que o css instalado JÁ declara - ver `GapRequest.existed`. */
+export function declaresName(installedCss, name) {
+    const declared = declaredValues(installedCss);
+    return candidatesFor(name).some((c) => declared.has(c.toLowerCase()));
+}
+/**
+ * Requests whose ask the installed css now demonstrably delivers.
+ *
+ * APARECER É PROVA; EXISTIR NÃO É - e a diferença fechou um bug real como entregue.
+ *
+ * Um pedido é "isto não tem nome". Quando o nome de fato não existia, ele passar a existir é prova
+ * suficiente e é o caso comum - `animate-rise` não tem um valor comparável, o pedido é pelo NOME.
+ *
+ * Mas um pedido feito SOBRE um token que já existe é sobre o VALOR dele, e aí existir responde sim
+ * no instante em que o pedido nasce. Em 07/08 um agente reportou `color-semantic-canvas` apontando
+ * para a mesma primitiva que o `foreground` - 1.00:1, texto invisível - e o `sync` seguinte imprimiu
+ * *"delivered. Nothing for anyone to do"* com o defeito intacto no disco do dono.
+ *
+ * Então `existed` é carimbado quando o pedido é feito, e um pedido assim só fecha quando o css
+ * ENTREGA o valor pedido. Sem valor comparável ele fica aberto e quem decide é a pessoa, no cartão -
+ * um pedido aberto custa uma linha numa tela, um fechamento falso custa o bug.
+ */
 export function satisfiedRequests(requests, installedCss) {
+    const declared = declaredValues(installedCss);
     return requests.filter((r) => {
         const name = checkableName(r);
         if (!name)
             return false;
-        const candidates = name.startsWith("animate-")
-            ? [`--${name}`]
-            : [`--ds-${name}`, `--${name}`];
-        return candidates.some((c) => installedCss.includes(`${c}:`));
+        const present = candidatesFor(name).filter((c) => declared.has(c.toLowerCase()));
+        if (present.length === 0)
+            return false;
+        if (!r.existed)
+            return true;
+        const want = r.value?.trim();
+        if (!want)
+            return false;
+        const asked = resolved(declared, want);
+        return present.some((c) => resolved(declared, declared.get(c.toLowerCase()) ?? "") === asked);
     });
 }
-/**
- * Everything the pinned install actually ships, as one string - tokens.css
- * AND theme.css of the locked version, for every installed system. This is
- * the ground verification stands on: not the doc, not the GUIDE's promises,
- * the css a build would really read.
- */
 export async function readInstalledCss(root) {
     const dsDir = join(root, "_synthesisui", "ds");
     let css = "";

package/package.json

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