synthesisui 0.16.421 → 0.16.423

package/dist/their-tongue.js

@@ -7,7 +7,7 @@ const OUR_VAR = /var\(\s*(--ds-[a-zA-Z0-9_-]+)\s*(?:,([^()]*))?\)/g;
  * verdade quando nenhum dos três aponta. Somar aqui, e não em cada comando, é o que impede duas
  * contas diferentes para a mesma pergunta.
  *
- * `null` quando nada foi traduzido (projeto sem mapa) - e aí quem chama DIZ isso.
+ * `null` quando nada foi traduzido - e aí quem chama DIZ isso.
  */
 export function sumSpoken(reports) {
     const real = reports.filter((r) => r !== null);
@@ -20,13 +20,16 @@ export function sumSpoken(reports) {
     return {
         named: real.reduce((n, r) => n + r.named, 0),
         inlined: real.reduce((n, r) => n + r.inlined, 0),
+        froze: real.reduce((n, r) => n + r.froze, 0),
         left: [...left].sort(),
     };
 }
 export function inTheirTongue(css, tongue, destination = "stylesheet") {
     let named = 0;
     let inlined = 0;
+    let froze = 0;
     const left = new Set();
+    const write = (value) => destination === "tailwind-class" ? value.replace(/\s+/g, "_") : value;
     const out = css.replace(OUR_VAR, (whole, name, fallback) => {
         const theirName = tongue.names.get(name);
         if (theirName) {
@@ -41,14 +44,28 @@ export function inTheirTongue(css, tongue, destination = "stylesheet") {
         const value = tongue.values.get(name);
         if (value) {
             inlined += 1;
-            return destination === "tailwind-class"
-                ? value.replace(/\s+/g, "_")
-                : value;
+            if (tongue.frozen.has(name))
+                froze += 1;
+            return write(value);
+        }
+        /**
+         * O FALLBACK ESCRITO NA PRÓPRIA REFERÊNCIA É A ÚLTIMA RESPOSTA, e ela é do autor do texto.
+         *
+         * Quem escreve `var(--ds-motion-durations-base, 200ms)` já disse o que aquilo vale quando a
+         * folha não responde - é o idioma de `motion.ts` e de `interactive-templates.ts`, os dois
+         * módulos que montam animação sem ter o documento em mão. Antes disto a referência inteira
+         * sobrevivia no arquivo dele, levando junto a nossa grafia e uma dependência da nossa folha
+         * que o fallback existia justamente para dispensar.
+         */
+        const declared = fallback?.trim();
+        if (declared) {
+            inlined += 1;
+            return write(declared);
         }
         left.add(name);
-        return fallback ? whole : whole;
+        return whole;
     });
-    return { css: out, named, inlined, left: [...left].sort() };
+    return { css: out, named, inlined, froze, left: [...left].sort() };
 }
 /**
  * O VOCABULARIO DESTE REPOSITORIO **SEM O `add` TER RODADO** - a folha deixa de ser pre-requisito.
@@ -63,39 +80,137 @@ export function inTheirTongue(css, tongue, destination = "stylesheet") {
  * DELE e o build dele, e responde quais das nossas variaveis tem nome dele. A diferenca e' que
  * nada disso vai para o disco - nem o mapa, nem a folha.
  *
- * `null` quando o repositorio dele nao nomeia nada do que este sistema declara. Ai' a folha
- * continua sendo o caminho, e quem chama DIZ isso - em vez de escrever `var(--ds-*)` cru e
- * deixar a pessoa descobrir por que a cor nao apareceu.
+ * E UM REPOSITORIO QUE NAO NOMEIA NADA CONTINUA TENDO RESPOSTA: os pares podem ser zero e a folha
+ * ainda carrega o valor compilado de cada variavel, que e' o destino 2. Enquanto este caminho
+ * respondia `null` nesse caso, o arquivo saia com `var(--ds-*)` cru - a grafia que `INV-GERAL-13`
+ * proibe, escrita justamente no projeto que tem menos chance de ter a folha carregada.
+ *
+ * `null` so' quando nem o `tokens.css` veio - e ai' nao ha' o que responder.
+ */
+export async function tongueFromArtifacts(root, 
+/**
+ * Os artefatos do payload - e `undefined` é um estado real, não um descuido do chamador.
+ *
+ * Uma leitura que chegou sem eles é indistinguível de uma que não chegou: a resposta é `null`
+ * nos dois casos, e quem chama DIZ isso. Sem esta tolerância o comando estoura em vez de
+ * relatar, que é a pior forma de uma lacuna aparecer.
  */
-export async function tongueFromArtifacts(root, artifacts) {
-    const tokens = artifacts["tokens.css"] ?? "";
+artifacts) {
+    const tokens = artifacts?.["tokens.css"] ?? "";
     if (!tokens)
         return null;
     const { pointTokensAtTheirNames } = await import("./their-vars.js");
-    const { pairs } = await pointTokensAtTheirNames(root, { artifacts });
-    if (pairs.length === 0)
-        return null;
+    const { pairs } = await pointTokensAtTheirNames(root, {
+        artifacts: artifacts ?? {},
+    }).catch(() => ({ pairs: [] }));
     return tongueOf(pairs, tokens);
 }
 /**
- * O VOCABULÁRIO DESTE REPOSITÓRIO, montado do que o `add` já deixou na pasta.
+ * O VOCABULÁRIO DESTE REPOSITÓRIO, LIDO DA FOLHA - e o mapa é confirmação, nunca pré-requisito.
+ *
+ * `installedCss` é a folha compilada deste install, e ela responde as duas perguntas sozinha porque
+ * `their-vars.ts` já a reescreveu nesta máquina:
  *
- * `map` vem do `.lock` (`tokenMap`) e é o que a máquina dele descobriu; `declared` vem do
- * `tokens.css` instalado, que é onde cada variável nossa tem o valor compilado. Nenhuma medição
- * nova: as duas coisas já estão no disco.
+ * ```
+ * --ds-color-ink-50: var(--color-ink-50);   -> ele nomeia: o nome DELE
+ * --ds-motion-durations-base: 180ms;        -> ele não nomeia: o VALOR
+ * --ds-color-semantic-primary: var(--ds-color-brand-500);  -> cadeia nossa: segue até uma das duas
+ * ```
+ *
+ * A CADEIA É SEGUIDA, e antes ela era descartada. A linha que aponta para outra variável nossa é a
+ * forma como o compilador escreve um papel semântico - `primary` é `brand-500` -, e pular essas
+ * linhas deixava sem resposta justamente os nomes que um componente mais usa. Medido na folha do
+ * `codelevel`: 53 das 119 variáveis eram puladas por essa razão, e todas elas tinham resposta uma
+ * indireção adiante.
+ *
+ * `map` vem do `.lock` (`tokenMap`) quando existe, e tem PRECEDÊNCIA: ele é o que a máquina dele
+ * mediu contra as folhas e o build, enquanto a folha reescrita é o efeito daquela medição. Onde os
+ * dois concordam a resposta é a mesma; onde só um tem resposta, ela vale.
  */
 export function tongueOf(map, installedCss) {
     const names = new Map(map.map((p) => [p.ours, p.theirs]));
     const values = new Map();
-    for (const m of installedCss.matchAll(/^\s*(--ds-[a-zA-Z0-9_-]+)\s*:\s*([^;]+);/gm)) {
-        const value = m[2].trim();
-        /** Uma linha que aponta para outra variável não é um valor - seguir a cadeia é do navegador. */
-        if (value.includes("var("))
+    /**
+     * O que cada variável nossa declara na folha, antes de qualquer indireção ser seguida.
+     *
+     * SEM ÂNCORA NO INÍCIO DA LINHA, e a âncora era um buraco de verdade - a mesma lição que
+     * `apply-fix.ts` já pagou uma vez. A regra antiga era `^\s*--nome:`, que só enxerga CSS formatado
+     * com uma declaração por linha. Numa folha minificada - e um `tokens.css` compilado pode chegar
+     * assim - a linha inteira é `[data-ds="x"]{--ds-a:#111;--ds-b:1rem}`: nenhuma declaração começa a
+     * linha, o mapa sai VAZIO, e o componente materializado leva a nossa grafia inteira para o
+     * repositório dele sem nada acusar.
+     *
+     * Encontrado pelo spec ponta a ponta de A3 em 11/09, rodando `add` e `component` de verdade: o
+     * `button.css` saiu com as duas referências cruas.
+     *
+     * O que delimita uma declaração é o que vem ANTES dela: o começo do texto, uma `{` que abre a
+     * regra, ou o `;` da declaração anterior. É a mesma pontuação em qualquer formatação.
+     *
+     * E O FECHO É UM LOOKAHEAD, não um consumo - senão o `;` que TERMINA uma declaração some do texto
+     * disponível e deixa de poder ABRIR a próxima. Numa folha minificada isso faz o laço ler uma
+     * declaração sim, outra não: `--ds-a` entra, `--ds-b` desaparece, e o resultado é pior que não ler
+     * nada, porque metade do mapa parece um mapa.
+     */
+    const declared = new Map();
+    /** Quantas vezes a folha declara cada variável nossa - ver `Tongue.frozen`. */
+    const times = new Map();
+    for (const m of installedCss.matchAll(/(?:^|[{;])\s*(--ds-[a-zA-Z0-9_-]+)\s*:\s*([^;}]+)(?=[;}])/g)) {
+        times.set(m[1], (times.get(m[1]) ?? 0) + 1);
+        if (!declared.has(m[1]))
+            declared.set(m[1], m[2].trim());
+    }
+    /** `var(--alvo)` ou `var(--alvo, fallback)` como VALOR INTEIRO de uma declaração. */
+    const INDIRECTION = /^var\(\s*(--[a-zA-Z0-9_-]+)\s*(?:,([\s\S]*))?\)$/;
+    /**
+     * O DESTINO DE UMA VARIÁVEL NOSSA, seguindo a cadeia até uma das duas metades.
+     *
+     * `seen` corta o ciclo: uma folha que se referencia em volta é um defeito do compilador, e o
+     * preço dele não pode ser um `component` que nunca termina.
+     */
+    const destinationOf = (ours, seen) => {
+        if (seen.has(ours))
+            return null;
+        seen.add(ours);
+        const value = declared.get(ours);
+        if (value === undefined)
+            return null;
+        const indirect = INDIRECTION.exec(value);
+        if (!indirect)
+            return { value };
+        const target = indirect[1];
+        /** Outra variável NOSSA: a resposta está mais adiante, nunca aqui. */
+        if (target.startsWith("--ds-")) {
+            const next = destinationOf(target, seen);
+            if (next)
+                return next;
+            /** A cadeia morreu sem resposta - o fallback escrito na indireção é a última palavra. */
+            const written = indirect[2]?.trim();
+            return written ? { value: written } : null;
+        }
+        return { name: target };
+    };
+    for (const ours of declared.keys()) {
+        if (names.has(ours))
+            continue;
+        const destination = destinationOf(ours, new Set());
+        if (!destination)
             continue;
-        if (!values.has(m[1]))
-            values.set(m[1], value);
+        if ("name" in destination)
+            names.set(ours, destination.name);
+        else
+            values.set(ours, destination.value);
     }
-    return { names, values };
+    /**
+     * AS QUE MUDAM ENTRE ESQUEMAS E VIRAM LITERAL - o subconjunto que congela.
+     *
+     * Só entra aqui o que caiu em `values`: onde há nome dele, o mecanismo de esquema DELE vira o
+     * valor junto e não há nada a dizer.
+     */
+    const frozen = new Set();
+    for (const [ours, n] of times)
+        if (n > 1 && values.has(ours))
+            frozen.add(ours);
+    return { names, values, frozen };
 }
 /**
  * NENHUMA MATERIALIZAÇÃO VAZA VOCABULÁRIO INTERNO - a regra da camada, num lugar só (dono, 26/08).
@@ -106,34 +221,56 @@ export function tongueOf(map, installedCss) {
  * ausente. Um mecanismo novo de materialização que chamar esta função já nasce coberto; um que não
  * chamar é reprovado pelo gate (ver contracts/camada-6-volta.md, INV-VOLTA-02).
  *
- * `null` quando não há mapa: projeto de destino, repositório que nunca buildou, ou install anterior
- * a 0.16.290. Nos três casos nada é traduzido e a folha instalada continua sendo o caminho - e quem
- * chama DIZ qual dos dois aconteceu.
+ * A FOLHA RESPONDE MESMO SEM MAPA - o conserto de 11/09, e ele tem três estados reais por trás.
+ *
+ * Esta função exigia um `.lock` com `tokenMap` não vazio e respondia `null` fora disso. Os três
+ * casos que caíam ali - install anterior a 0.16.290, repositório que nunca buildou, e projeto de
+ * destino que não nomeia nada nosso - recebiam o arquivo com `var(--ds-*)` cru, e o comando dizia
+ * que a folha continuava sendo o caminho. Era a única porta do produto que ainda PEDIA o import, e
+ * ela pedia exatamente a quem menos podia atender.
+ *
+ * Agora o `.lock` decide só a VERSÃO da folha a ler. Sem ele, a folha da raiz é o re-export que o
+ * `add` escreve e serve igual - e um projeto sem pasta nenhuma continua respondendo `null`, porque
+ * ali não há folha para ler.
  */
 export async function projectTongue(root, slug) {
     const { readFile } = await import("node:fs/promises");
     const { join } = await import("node:path");
     const dir = join(root, "_synthesisui", "ds", slug);
     const lock = await readFile(join(dir, ".lock"), "utf8").catch(() => null);
-    if (!lock)
-        return null;
     let map = [];
-    let version = 0;
-    try {
-        const parsed = JSON.parse(lock);
-        map = parsed.tokenMap ?? [];
-        version = parsed.version ?? 0;
-    }
-    catch {
-        return null;
+    let version = null;
+    if (lock) {
+        try {
+            const parsed = JSON.parse(lock);
+            map = parsed.tokenMap ?? [];
+            version = parsed.version ?? 0;
+        }
+        catch {
+            /** Um `.lock` ilegível não apaga a folha ao lado dele - ver a leitura logo abaixo. */
+            map = [];
+            version = null;
+        }
     }
-    if (map.length === 0)
-        return null;
     /**
      * O VALOR COMPILADO MORA NA PASTA DA VERSÃO - a folha da raiz é um re-export de uma linha, escrito
-     * assim de propósito para que o `@import` dele nunca mude entre updates (ver `add.ts`). É de lá
-     * que sai o literal para as variáveis que não têm nome dele.
+     * assim de propósito para que o caminho nunca mude entre updates (ver `add.ts`). Sem `.lock` legível
+     * não há versão para abrir, e aí a folha da raiz é o que existe: ela pode ser o re-export (e não
+     * declara nada) ou a folha inteira de um install antigo, e ler as duas custa uma chamada.
      */
-    const installed = await readFile(join(dir, `v${version}`, "tokens.css"), "utf8").catch(() => "");
+    const sheets = [
+        version === null ? null : join(dir, `v${version}`, "tokens.css"),
+        join(dir, "tokens.css"),
+    ].filter((p) => p !== null);
+    let installed = "";
+    for (const path of sheets) {
+        const css = await readFile(path, "utf8").catch(() => "");
+        if (css.includes("--ds-")) {
+            installed = css;
+            break;
+        }
+    }
+    if (map.length === 0 && !installed)
+        return null;
     return tongueOf(map, installed);
 }

package/dist/wired-slugs.js

@@ -47,21 +47,27 @@ export function wiredSlugs(css) {
     return out;
 }
 /**
- * O QUE DIZER A ELE QUANDO O SISTEMA JÁ NASCEU COM OUTRO NOME.
+ * O QUE DIZER A ELE QUANDO O CSS DELE AINDA IMPORTA UMA FOLHA NOSSA.
  *
  * Roda DEPOIS do envio, com o slug que o servidor devolveu - então não é previsão, é fato: a pasta
  * vai ser escrita com este nome e os `@import` dele apontam para outro.
  *
- * `null` quando o CSS não cabeia nada (todo primeiro import limpo) e quando o slug que nasceu já é
- * um dos cabeados. Um aviso que aparece sempre é um aviso que ninguém lê.
+ * A SAÍDA MUDOU EM 11/09, e ela é o oposto do que era. Este aviso terminava com as duas linhas de
+ * `@import` para ele colar apontando para o slug novo - ou seja, consertava o import mantendo-o.
+ * Nenhum projeto precisa mais daquele import (`INV-GERAL-13`): o que a plataforma escreve no
+ * repositório dele não depende de folha nossa nenhuma. Então a saída é REMOVER as linhas, e o aviso
+ * diz isso com a consequência que ele precisa para decidir - o build já está quebrado hoje.
  *
- * A frase carrega as três coisas que a decisão precisa: o que o CSS espera, o que existe agora, e o
- * que acontece se ele não fizer nada. Sem a terceira isto é trivia - e foi a terceira que faltou na
- * corrida que parou o build dele.
+ * E ELE PODE TER ESCRITO CÓDIGO SOBRE AQUELA FOLHA. Um `var(--ds-*)` à mão num arquivo dele, de uma
+ * versão anterior do produto, para de resolver quando o import sai - e a linha diz o que o `doctor`
+ * REALMENTE responde: ele CONTA essas referências na linha de cobertura (`N from <sistema>`), e não
+ * as lista uma a uma. Prometer a lista seria a família de defeito que o `ARCHITECTURE.md` abre
+ * citando - afirmar que um comando conserta o que ele não conserta.
+ *
+ * `null` quando o CSS não cabeia nada, que é todo projeto novo.
  *
  * DIZER, E NÃO CONSERTAR. O CSS é dele; reescrevê-lo por conta própria seria a plataforma editando
- * o repositório de alguém sem pedir. É o mesmo padrão do `add`, que imprime o `@import` e não o
- * cola.
+ * o repositório de alguém sem pedir.
  */
 export function wiringWarning(
 /**
@@ -71,16 +77,24 @@ export function wiringWarning(
 wired, slugThatWasBorn) {
     if (wired.length === 0)
         return null;
-    if (wired.includes(slugThatWasBorn.toLowerCase()))
-        return null;
+    const stale = wired.filter((w) => w !== slugThatWasBorn.toLowerCase());
     return [
-        `Your CSS imports _synthesisui/ds/${wired[0]}/, and this system is "${slugThatWasBorn}".`,
-        `Those @import lines point at a folder that does not exist, and the build fails on them -`,
-        `not a missing colour, a build that stops. Point them at ${slugThatWasBorn} to fix it:`,
-        "",
-        `    @import ".../_synthesisui/ds/${slugThatWasBorn}/tokens.css";`,
-        `    @import ".../_synthesisui/ds/${slugThatWasBorn}/theme.css";`,
-        "",
+        `Your CSS imports _synthesisui/ds/${wired[0]}/ - nothing needs that any more.`,
+        ...(stale.length > 0
+            ? [
+                `It points at a folder this install does not write (the system is "${slugThatWasBorn}"),`,
+                `so \`next build\` fails on it today - not a missing colour, a build that stops.`,
+            ]
+            : []),
+        ``,
+        `Delete those @import lines. Everything we write into this repository speaks the names your`,
+        `own code declares, or carries the value itself - there is no stylesheet of ours to load.`,
+        ``,
+        `If you wrote --ds-* by hand against an older version, \`npx synthesisui doctor\` COUNTS them -`,
+        `the "from <system>" number on the coverage line is how many references still point at us. Those`,
+        `stop resolving when the import goes; re-run \`component\` on whatever wrote them and they come`,
+        `back in your own names.`,
+        ``,
         "Yours to change - we do not edit your CSS.",
     ].join("\n");
 }

package/package.json

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

package/dist/setup-prompt.js

@@ -1,95 +0,0 @@
-/**
- * O TEXTO QUE TIRA AS EDIÇÕES DE SETUP DA MÃO DA PESSOA - e que agora USA a medição.
- *
- * O QUE O CLIENTE GANHA: um design system instalado não muda um pixel até que alguma folha que o app
- * carrega importe os tokens e algum elemento carregue o escopo. Em 27/07 isso foi medido em 0% - a
- * lista numerada de três passos existia e ninguém a executava. A pessoa que roda o comando tem um
- * agente aberto ao lado, então o fecho deixou de ser tarefa e passou a ser um texto para colar.
- *
- * O DEFEITO QUE ISTO CORRIGE (dono, 07/09): o texto era FIXO. O `doctor` acabava de imprimir
- * `✗ ✓ ✓` - só o import faltava, o escopo e a tipografia já estavam lá - e o parágrafo seguinte
- * mandava *"Do the ONE-TIME SETUP it names, all of it"*, listando as três. Um agente obediente
- * reescreve o que já estava correto, e o próprio texto termina com "não mexa nos meus estilos": ele
- * se contradizia dentro de si mesmo.
- *
- * Então o que falta é ARGUMENTO. Sem ele o texto pede tudo, que é a verdade nos dois lugares onde
- * ninguém mediu nada: o fecho do `init` (o projeto acabou de receber o sistema) e a tela do
- * onboarding (a plataforma não vê o disco de ninguém). Com ele, o texto pede o que falta e NOMEIA o
- * que já está pronto para o agente deixar em paz.
- *
- * GÊMEO POR SPEC com `apps/web/src/lib/ds/install-mission.ts`, que serve o mesmo texto na tela -
- * `setup-prompt.spec.ts` reprova o drift. O CLI é publicado standalone e não pode importar de
- * `apps/web`, então a cópia é inevitável; o que não é inevitável é ela divergir em silêncio, e dois
- * textos diferentes para o mesmo setup ensinam dois setups.
- */
-export function initCommand(slug) {
-    return `npx synthesisui@latest init --styles tailwind --ds ${slug}`;
-}
-/**
- * A LINHA QUE DÁ SAÍDA QUANDO UMA VERSÃO ESTÁ PROPAGANDO (dono, 07/09).
- *
- * Ele rodou `npx synthesisui@latest doctor` e recebeu `ETARGET / No matching version found`: o
- * `dist-tag` do npm já apontava para a versão nova e o tarball ainda não estava na réplica que a
- * máquina dele consultou. O erro é do npm e acontece ANTES do nosso código rodar, então não há como
- * interceptá-lo - o que está na nossa mão é a instrução não deixar quem lê sem saída, porque
- * `ETARGET` não diz que é transitório nem o que fazer.
- */
-const PROPAGATING = "If npm answers `ETARGET` or `No matching version found`, a release is still propagating - wait a minute and run it again, or pin the version the registry does have (`npm view synthesisui version`).";
-const CONNECT_STEP = `Run: npx synthesisui@latest connect
-   ${PROPAGATING}
-   If it answers "already had it" on both lines, everything is live and you are done.
-   If it WROTE either of them, then they are not live in this session, because hooks and tools are only read at startup. Stop there and tell me, in bold, on its own line: **RESTART THIS SESSION - the check is installed but not running yet.** Do not keep writing files after that; a session that cannot be checked is the state this whole setup exists to avoid.`;
-/** As linhas exatas quando a folha é conhecida; a descrição do arquivo quando não é. */
-function importStep(slug, gap) {
-    const lines = [
-        `@import "${gap.sheet ? gap.sheet.prefix : "<path to the repo root>/"}_synthesisui/ds/${slug}/tokens.css";`,
-        ...(gap.imports === 2
-            ? [
-                `@import "${gap.sheet ? gap.sheet.prefix : "<path to the repo root>/"}_synthesisui/ds/${slug}/theme.css";`,
-            ]
-            : []),
-    ];
-    const where = gap.sheet
-        ? `\`${gap.sheet.path}\``
-        : "the global stylesheet this project's apps actually load (in a monorepo that is usually the shared package's, not the app's)";
-    return `Add ${gap.imports === 2 ? "these two lines" : "this line"} to ${where}, RIGHT AFTER its \`@import "tailwindcss"\` line:
-
-${lines.map((l) => `      ${l}`).join("\n")}
-
-   The position is not cosmetic. Read there, this sheet comes BEFORE any \`@theme\` this project declares, so wherever both name the same variable the project's own value wins. Moved to the end of the file, ours would win instead - silently.`;
-}
-export function setupPrompt(slug, gap) {
-    const g = gap ?? {
-        tokens: true,
-        scope: true,
-        type: true,
-        imports: 2,
-    };
-    const done = [
-        g.tokens ? null : "a stylesheet already imports the system's tokens",
-        g.scope ? null : `\`data-ds="${slug}"\` is already on a root element`,
-        g.type
-            ? null
-            : "this project's type is already mapped onto the system's family tokens",
-    ].filter(Boolean);
-    const steps = [];
-    if (g.tokens)
-        steps.push(importStep(slug, g));
-    if (g.scope)
-        steps.push(`Put \`data-ds="${slug}"\` on a root element of each app - the element every page renders inside. Keep any classes it already has; a background they chose is a decision they made.`);
-    if (g.type)
-        steps.push(`Map this project's type onto the system's family tokens: import from the fonts file the install wrote and point the family variables at it, in the same stylesheet. This is the step people skip, and without it the pages render in the framework's default face.`);
-    steps.push(`Run: npx synthesisui@latest doctor
-   ${PROPAGATING}
-   If it says "no system installed", the install never happened - run \`${initCommand(slug)}\` and then start over from step 1.
-   It must NOT say "this project does not load it yet". If it does, it names exactly which piece is still missing - fix that one and run it again.`);
-    steps.push(CONNECT_STEP);
-    const alreadyDone = done.length > 0
-        ? `\nAlready in place - LEAVE THESE ALONE:\n${done.map((d) => `- ${d}`).join("\n")}\n`
-        : "";
-    return `Set up the "${slug}" design system in this project, so its tokens reach the browser. I already ran the install in my terminal.
-${alreadyDone}
-${steps.map((s, i) => `${i + 1}. ${s}`).join("\n")}
-
-Do not change any of my existing styles.`;
-}