synthesisui 0.16.368 → 0.16.370

package/dist/commands/add.js

@@ -554,6 +554,16 @@ export async function add(slug, opts) {
     if (aligned.dropped.length > 0) {
         console.log(line(`  ${aligned.kept} Tailwind utilit${aligned.kept === 1 ? "y" : "ies"} now point at your own decisions; ${aligned.dropped.length} were left alone because the value would be ours (${aligned.dropped.slice(0, 3).join(", ")}${aligned.dropped.length > 3 ? ", …" : ""}) - your classes keep meaning what they mean today.`));
     }
+    /**
+     * O CICLO RECUSADO É DITO, e não engolido - senão o cliente lê um número menor sem saber por quê.
+     *
+     * A folha traz a ponte (`--ease-in-out: var(--ds-motion-easings-in-out)`) para que a utility dele
+     * resolva pelo sistema. Apontar de volta fecharia um ciclo, e um ciclo de custom property não deixa
+     * o valor errado: invalida a propriedade no elemento e em todos os descendentes. Recusar é o certo,
+     * e a linha diz que nada foi perdido - a utility dele continua resolvendo pelo sistema.
+     */
+    if (theirVars.cycles > 0)
+        console.log(`  ${theirVars.cycles} ${theirVars.cycles === 1 ? "value" : "values"} already had the bridge pointing the other way, so ${theirVars.cycles === 1 ? "it was" : "they were"} left alone - your own utility still resolves through this system, and pointing back would have cancelled both.`);
     if (theirVars.pointed > 0)
         console.log(`  ${theirVars.pointed} value${theirVars.pointed === 1 ? "" : "s"} in tokens.css now point at the name YOUR code already gives ${theirVars.pointed === 1 ? "it" : "them"} - change yours and the system follows${theirVars.pruned > 0 ? `; ${theirVars.pruned} matched but your build does not emit ${theirVars.pruned === 1 ? "that name" : "those names"}, so ${theirVars.pruned === 1 ? "it keeps" : "they keep"} the value` : ""}`);
     /**

package/dist/commands/mcp.js

@@ -201,6 +201,24 @@ const TOOLS = [
             required: ["skill"],
         },
     },
+    {
+        name: "apply_upgrade",
+        description: "The optimisation this system can write on its OWN, and the one question to ask before writing it. Call it with { slug } to GET the question - it comes back composed, with their numbers in it, and you deliver it as it is rather than rephrasing it. Only after they say yes, call again with { slug, confirmed: true }. What it writes never adds a word they did not write and never moves a value they chose: a literal only becomes a reference when it resolves to the same value. Everything that would need a NAME from them stays out and comes back counted, so you can say what is still waiting. Do NOT call this with confirmed:true off your own judgement - the whole point of the question is that the answer is theirs. AND THIS RUN ENDS WHEN IT IS APPLIED: report what changed in one short block and stop. If you found something else worth doing - a wiring gap, a defect, a fix waiting - name it in ONE line and offer it as a next step, never as a second investigation in the same breath. A run that answers `optimise my design system` with a nine-row impact table and a second three-option decision has buried the result it was asked for: whatever you measured is worth its own turn, where they can arrive with attention instead of spending what is left of it.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                slug: {
+                    type: "string",
+                    description: "The system's slug, as the import printed it.",
+                },
+                confirmed: {
+                    type: "boolean",
+                    description: "false or omitted: returns the question and the numbers, writes nothing. true: applies it - only after they answered yes in their own words.",
+                },
+            },
+            required: ["slug"],
+        },
+    },
     {
         name: "recipe_vocabulary",
         description: "What a recipe CAN hold: every state that compiles, every preview form, the floor per kind, and the rules a media region needs. Call this BEFORE writing a recipe, not after - the reader that skipped it sent a `dark:` inside a variant and a state the compiler cannot spell, and both were dropped in silence. Served from the catalogue, so it grows as the contract grows.",
@@ -603,6 +621,54 @@ async function listComponents(root) {
  * sumário; com, UM capítulo. O corpo inteiro nunca viaja - a dieta de contexto
  * é servida por construção.
  */
+/**
+ * A OTIMIZAÇÃO QUE UMA RESPOSTA "SIM" ESCREVE - e a pergunta que a precede, composta na plataforma.
+ *
+ * O QUE O CLIENTE GANHA: ele acaba de importar e o agente lhe faz UMA pergunta ali mesmo, em vez de
+ * lhe entregar um link para uma tela com quarenta e seis decisões enfileiradas. Ele responde, e o
+ * sistema é otimizado na mesma conversa.
+ *
+ * A PERGUNTA NÃO É COMPOSTA AQUI NEM PELO AGENTE, e essa é a decisão que faz o texto sobreviver: o
+ * agente escreve bem e escreve DIFERENTE a cada execução, e uma pergunta que muda de forma a cada
+ * vez é uma paráfrase e não uma pergunta do produto. Foi assim que dois fechamentos consecutivos
+ * afirmaram que 198 declarações não chegaram a receita nenhuma quando 22 utilities dele já estavam
+ * no sistema - o resumo dropou exatamente a metade que tinha acabado de entrar. Então o texto vem
+ * pronto de `askToUpgrade`, com os números da medição dentro dele.
+ *
+ * DOIS PASSOS DE PROPÓSITO. Sem `confirmed` nada é escrito: é o que impede a jornada de pular a
+ * pergunta, que é a única coisa nela que pertence à pessoa.
+ */
+async function applyUpgrade(slug, confirmed) {
+    const answer = await askPlatform(`/api/registry/ds/${encodeURIComponent(slug)}/upgrade`, confirmed ? "POST" : "GET");
+    if (!answer.ok)
+        return answer.because;
+    const body = answer.body;
+    if (body.error)
+        return `${body.error}${body.message ? `: ${body.message}` : ""}`;
+    if (!confirmed) {
+        if (!body.ask)
+            return "Nothing here is safe to apply on its own - ask them nothing, and say the system is already on its own names.";
+        return [
+            "ASK THEM THIS, and deliver it as it is - it is composed here so the numbers cannot drift:",
+            "",
+            body.ask,
+            "",
+            `Then, and only then: call apply_upgrade again with { slug: "${slug}", confirmed: true }. If they say no, say what they are choosing - the system stays exactly as their code has it, and the optimisation waits on a button.`,
+        ].join("\n");
+    }
+    if (body.applied === false)
+        return body.message ?? "Nothing was applied.";
+    return [
+        `Done - v${body.version} published.`,
+        `${body.repointed ?? 0} literal${body.repointed === 1 ? "" : "s"} now follow their own tokens, and ${body.named ?? 0} value${body.named === 1 ? "" : "s"} became a named token.`,
+        body.waiting
+            ? `${body.waiting} decision${body.waiting === 1 ? "" : "s"} still need a word only they have - say the number, and that those wait on their own screen.`
+            : "",
+        "The version they had before is published and frozen, so going back is one click.",
+    ]
+        .filter(Boolean)
+        .join(" ");
+}
 async function playbook(skill, section) {
     const answer = await askCatalogue("playbook", undefined, section ? { skill, section } : { skill });
     if (!answer.ok)
@@ -993,6 +1059,45 @@ cli) {
         }
     })();
 }
+/**
+ * UMA ROTA DA PLATAFORMA QUE NÃO É O CATÁLOGO, com a mesma sessão do device-login.
+ *
+ * `askCatalogue` monta `/api/catalogue?want=…` na própria assinatura, o que é certo para o que É
+ * catálogo - e a otimização não é: ela ESCREVE no sistema dele, e uma escrita atrás de um `?want=`
+ * leria como leitura. Então a única coisa compartilhada é o que deve ser: o token e o host.
+ *
+ * O MODO DE FALHA É DITO EM VOZ ALTA, nas três formas em que ele acontece - sem sessão, resposta de
+ * erro, sem rede. Um `catch` que devolve silêncio faria o agente concluir que não havia nada a
+ * fazer, e o cliente perderia a otimização sem nunca saber que ela existia.
+ */
+async function askPlatform(path, method) {
+    const token = await readToken();
+    if (!token)
+        return {
+            ok: false,
+            because: "Not signed in, so the platform could not answer. Run `synthesisui login` in the terminal and call this again.",
+        };
+    try {
+        const res = await fetch(`${resolveRegistry()}${path}`, {
+            method,
+            headers: { Authorization: `Bearer ${token}` },
+        });
+        if (!res.ok)
+            return {
+                ok: false,
+                because: res.status === 404
+                    ? "No system by that slug on this account - check the slug the import printed."
+                    : `The platform answered ${res.status}. ${res.status === 401 ? "Run `synthesisui login` and try again." : "Nothing was written."}`,
+            };
+        return { ok: true, body: await res.json() };
+    }
+    catch {
+        return {
+            ok: false,
+            because: "No network, so the platform could not answer. Nothing was written - say that, and offer to try again rather than describing what would have happened.",
+        };
+    }
+}
 async function askCatalogue(want, post, 
 /** Parâmetros extras do GET (ex.: o playbook e o capítulo pedidos). */
 query) {
@@ -1547,6 +1652,9 @@ cli) {
             const section = args?.section ? String(args.section) : undefined;
             return fromContract(await playbook(skill, section));
         }
+        case "apply_upgrade": {
+            return fromContract(await applyUpgrade(String(args?.slug ?? ""), args?.confirmed === true));
+        }
         case "recipe_vocabulary":
             return fromContract(await recipeVocabulary());
         case "validate_recipe": {

package/dist/install-marks.js

@@ -170,7 +170,7 @@
  * O que o cliente ganha ao rodar `upgrade`: o agente dele no Codex passa a poder PERGUNTAR ao
  * sistema, em vez de só receber as regras e adivinhar o resto.
  */
-export const MATERIALISER_SINCE = "0.16.362";
+export const MATERIALISER_SINCE = "0.16.370";
 /**
  * A ÚLTIMA VERSÃO EM QUE O QUE O HOOK RODA MUDOU.
  *

package/dist/their-vars.js

@@ -101,11 +101,22 @@ export function pointAtTheirNames(css, theirs, resolvable) {
      * buildou não tem como provar o que resolve, e um par afirmado sem prova é pior que par nenhum.
      */
     if (!resolvable || theirs.byName.size === 0)
-        return { css, pointed: 0, pruned: 0, pairs: [] };
+        return { css, pointed: 0, pruned: 0, cycles: 0, pairs: [] };
     const ours = buildTable({ css, source: "installed" });
     const alias = theirNames(ours, theirs);
+    /**
+     * A PONTE QUE JÁ ESTÁ NA FOLHA: o nome DELE -> o nosso token para o qual ele já aponta.
+     *
+     * Lido da própria folha e não de uma lista, porque quem decide o que é bridgeado é o compilador e a
+     * lista dele muda: hoje são famílias, pesos, easings, escala de tipo e gradientes, e amanhã pode ser
+     * outra. Uma cópia da regra aqui divergiria no dia em que uma família entrasse lá.
+     */
+    const bridged = new Map();
+    for (const [, theirName, ourName] of css.matchAll(/^\s*(--[a-zA-Z0-9_-]+)\s*:\s*var\((--ds-[a-zA-Z0-9_-]+)\)\s*;/gm))
+        bridged.set(theirName, ourName);
     let pointed = 0;
     let pruned = 0;
+    let cycles = 0;
     /** Ver `PointedAt.pairs`: o mapa sai do mesmo casamento que reescreve a linha. */
     const pairs = [];
     const out = css.replace(/^(\s*)(--ds-[a-zA-Z0-9_-]+)(\s*:\s*)([^;]+);/gm, (line, indent, name, sep, value) => {
@@ -118,6 +129,15 @@ export function pointAtTheirNames(css, theirs, resolvable) {
         const theirName = alias.get(`${kind}:${normalizeValue(value.trim(), ours.rootPx)}`)?.name;
         if (!theirName || theirName === name)
             return line;
+        /**
+         * A PONTE JÁ APONTA PARA CÁ - então apontar de volta fecha um ciclo, e um ciclo não deixa o
+         * valor errado: deixa a propriedade INVÁLIDA. A utility dele já resolve pelo nosso token, que é
+         * o que a ponte existe para fazer, então esta linha não tem nada a ganhar e tudo a perder.
+         */
+        if (bridged.get(theirName) === name) {
+            cycles += 1;
+            return line;
+        }
         if (!resolvable.has(theirName)) {
             pruned += 1;
             return line;
@@ -126,7 +146,7 @@ export function pointAtTheirNames(css, theirs, resolvable) {
         pairs.push({ ours: name, theirs: theirName, value: value.trim() });
         return `${indent}${name}${sep}var(${theirName});`;
     });
-    return { css: out, pointed, pruned, pairs };
+    return { css: out, pointed, pruned, cycles, pairs };
 }
 /**
  * O PREFIXO DA NOSSA VARIÁVEL -> A FAMÍLIA, e a chave que `theirNames` devolve é `<família>:<valor>`.
@@ -151,7 +171,7 @@ const FAMILY_KIND = {
 export async function pointTokensAtTheirNames(root, payload) {
     const css = payload.artifacts["tokens.css"] ?? "";
     if (!css)
-        return { css, pointed: 0, pruned: 0, pairs: [] };
+        return { css, pointed: 0, pruned: 0, cycles: 0, pairs: [] };
     const [theirs, resolvable] = await Promise.all([
         harvestTheirCss(root),
         resolvableVars(root),

package/package.json

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