synthesisui 0.16.460 → 0.16.462

package/dist/commands/add.js

@@ -199,7 +199,9 @@ export async function add(slug, opts) {
      * Falha calada de propósito: um repositório sem folha de estilo, ou sem build, devolve o que veio
      * do servidor. A folha nunca fica pior do que estava.
      */
-    const theirVars = await pointTokensAtTheirNames(projectRoot, payload);
+    const theirVars = await pointTokensAtTheirNames(projectRoot, payload, 
+    /** O que um build anterior provou - ver `provenBefore`. Sem build aqui, é a melhor prova que há. */
+    (prev?.tokenMap ?? []).map((p) => p.theirs));
     /**
      * O `theme.css` ALINHA ONDE HÁ O QUE ALINHAR - ver `onlyWhatMatched`.
      *
@@ -619,6 +621,12 @@ export async function add(slug, opts) {
      */
     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.`);
+    /**
+     * SEM BUILD, A TELA DIZ DE ONDE VEIO A PROVA - 27/09. Antes, o mapa sumia e a única pista era "0
+     * Tailwind utilities now point at your own decisions"; o dono passou uma tarde sem saber por quê.
+     */
+    if (theirVars.provedBy === "before")
+        console.log(`  No build found here (no CSS in .next, dist, build or out), so the ${theirVars.pairs.length} name${theirVars.pairs.length === 1 ? "" : "s"} an earlier build proved ${theirVars.pairs.length === 1 ? "was" : "were"} kept. Run your build and \`connect\` again to prove them on this machine.`);
     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/connect.js

@@ -262,7 +262,7 @@ async function askWhichAgents(pre) {
                 ? fmt(say("{dir} is here"), { dir: agent.evidence })
                 : fmt(say("no {dir} in this repo"), { dir: agent.evidence }),
         })),
-        picked: pre,
+        picked: preselectedAgents(pre),
     });
     return picked;
 }
@@ -863,11 +863,36 @@ export async function connect(opts) {
             .join("\n"));
     }
 }
+/**
+ * A RESPOSTA DA PERGUNTA DO ENVIO - Enter é SIM desde 27/09.
+ *
+ * O padrão era NÃO (`[y/N]`), com o motivo "enviar é a mudança, e uma mudança de promessa pede um sim
+ * dito". O dono, na rodada 1 do refinamento, olhando a tela: *"a parte do sync estava como default N, acho
+ * que o correto aqui seria default Y"*. Desde a jornada "o sistema só muda com commit" o envio do fim do
+ * turno manda só as checagens - o sistema não muda por ele -, e é isso que a própria pergunta diz. Um não
+ * dito continua sendo não, nas duas línguas.
+ */
+export function sendsAtTurnEnd(answer) {
+    const said = answer.trim();
+    if (said === "")
+        return true;
+    return !/^(n(o)?|n[aã]o)$/i.test(said);
+}
+/**
+ * OS AGENTES QUE COMEÇAM MARCADOS - a evidência do repositório, ou todos quando ele não prova nenhum.
+ *
+ * Num projeto novo, sem `.claude` nem `.codex`, a lista abria sem nada marcado e o Enter confirmava
+ * nenhum. O dono, na rodada 1 do refinamento (27/09): *"por padrão dá para deixar os 2 selecionados"*.
+ * Onde o repositório prova um agente, continua marcado só o que ele prova - ali a evidência é melhor que
+ * um padrão.
+ */
+export function preselectedAgents(proven) {
+    return proven.length > 0 ? [...proven] : AGENTS.map((agent) => agent.id);
+}
 /**
  * Pergunta uma vez, e só num terminal de verdade - o mesmo molde do `askToOverwrite` do `sync`.
  *
- * Sem TTY devolve `null`: não há quem responder, e nada é gravado. O padrão do terminal é NÃO
- * (`[y/N]`), porque enviar é a mudança, e uma mudança de promessa pede um sim dito.
+ * Sem TTY devolve `null`: não há quem responder, e nada é gravado. Ver `sendsAtTurnEnd` para o padrão.
  */
 async function askToSendAtTurnEnd() {
     if (!process.stdin.isTTY || !process.stdout.isTTY)
@@ -875,8 +900,8 @@ async function askToSendAtTurnEnd() {
     const { createInterface } = await import("node:readline/promises");
     const rl = createInterface({ input: process.stdin, output: process.stdout });
     try {
-        const answer = await rl.question(`  ${say("send what the check records to your dashboard at the end of each turn? Your system itself changes only from a commit on a clean main.")} [y/N]: `);
-        return /^(y(es)?|s(im)?)$/i.test(answer.trim());
+        const answer = await rl.question(`  ${say("send what the check records to your dashboard at the end of each turn? Your system itself changes only from a commit on a clean main.")} [Y/n]: `);
+        return sendsAtTurnEnd(answer);
     }
     catch {
         return null;

package/dist/component-codegen.js

@@ -367,12 +367,30 @@ function propsType(axes, tag, base, withAs = false) {
     const extras = axes.map((a) => a.boolean
         ? `  ${a.prop}?: boolean;`
         : `  ${a.prop}?: ${a.options.map((o) => `"${o}"`).join(" | ")};`);
-    if (withAs)
-        extras.push("  /** Render as a different element (th, dt, h2, li…) - the recipe is", "   *  styling only, so the document's semantics stay yours. */", "  as?: ElementType;");
+    /**
+     * COM `as`, AS PROPS SEGUEM O ELEMENTO ESCOLHIDO - rodada 1 do refinamento, 27/09.
+     *
+     * O tipo era `ComponentProps<"button"> & { as?: ElementType }`: aceitava `as={Link}` e recusava o
+     * `href` que o `Link` exige - o `npm run build` do leigo quebrou em "Property 'href' does not exist",
+     * e ele contornou com `{...{ href }}`. Genérico no elemento, com o padrão sendo a tag da receita: sem
+     * `as`, nada muda para quem chama.
+     */
+    if (withAs) {
+        extras.push("  /** Render as a different element (th, dt, h2, li, a Link…) - the recipe is", "   *  styling only, so the document's semantics stay yours, and the props follow it. */", "  as?: T;");
+        /**
+         * SOBREPOSIÇÃO, e não troca: o tipo da tag da receita continua escrito por inteiro, e o elemento
+         * escolhido só ACRESCENTA o que ele tem a mais (o `href` do `Link`). Sem `as`, o `Omit` é vazio e o
+         * tipo é o de antes - e quem lê a raiz no texto (`ComponentProps<"button">`) continua lendo.
+         */
+        const own = ["as", ...axes.map((a) => a.prop)].map((k) => `"${k}"`).join(" | ");
+        return `${base}<"${tag}"> & Omit<${base}<T>, keyof ${base}<"${tag}"> | ${own}> & {\n${extras.join("\n")}\n}`;
+    }
     if (extras.length === 0)
         return `${base}<"${tag}">`;
     return `${base}<"${tag}"> & {\n${extras.join("\n")}\n}`;
 }
+/** O parâmetro de tipo que acompanha `propsType(..., withAs)` - vazio quando não há `as`. */
+const asGeneric = (tag, withAs) => withAs ? `<T extends ElementType = "${tag}">` : "";
 /**
  * THE ELEMENT IS THE CALLER'S DECISION (1kro2o, 29/07).
  *
@@ -385,7 +403,7 @@ function propsType(axes, tag, base, withAs = false) {
  * offered takes the same attributes in practice - the pattern is the exact
  * one the field agent wrote by hand.
  */
-const asTagLine = (tag) => `  const Tag = (as ?? "${tag}") as "${tag}";`;
+const asTagLine = (tag) => `  const Tag = (as ?? "${tag}") as ElementType;`;
 /** The render pieces for an element that offers `as`. `type="button"` must
  *  follow the RENDERED tag - a Button rendered as an <a> with type="button"
  *  is invalid HTML wearing a straight face. Void elements never offer `as`:
@@ -1324,7 +1342,7 @@ localName = name) {
         ].join(", ");
         return `
 /** Part "${partName}" of ${comp}${formOf.get(partName) ? ` (${formOf.get(partName)})` : ""} - compose it inside <${comp}>. */
-export function ${partComp}({ ${partDestructure} }: ${propsType(partAxes, partTag, props, partEl.offersAs)}) {
+export function ${partComp}${asGeneric(partTag, partEl.offersAs)}({ ${partDestructure} }: ${propsType(partAxes, partTag, props, partEl.offersAs)}) {
 ${partEl.setup}  return (
     <${partEl.jsxTag}${partEl.jsxAttrs}
       className={${joinCls([`"${partClassName(name, partName, convention)}"`, "className"])}}
@@ -1339,10 +1357,10 @@ import "./${localName}.css";
 
 import type { ${needsElementType ? `ElementType, ${props}` : props} } from "react";
 
-type ${comp}Props = ${propsType(axes, tag, props, el.offersAs)};
+type ${comp}Props${asGeneric(tag, el.offersAs)} = ${propsType(axes, tag, props, el.offersAs)};
 
 ${compositionHint(comp, name, recipe, voidEl)}
-export function ${comp}({ ${destructure} }: ${comp}Props) {
+export function ${comp}${asGeneric(tag, el.offersAs)}({ ${destructure} }: ${comp}Props${el.offersAs ? "<T>" : ""}) {
 ${el.setup}  return (
 ${rootJsx}
   );
@@ -1454,10 +1472,10 @@ import { cn } from "../cn";
 const BASE = ${JSON.stringify([needsGroup ? "group" : "", tailwindClassList(recipe, resolved, themeVars, excluded)].filter(Boolean).join(" "))};
 ${[...variantConsts, ...booleanConsts].join("\n")}
 
-type ${comp}Props = ${propsType(axes, tag, props, el.offersAs)};
+type ${comp}Props${asGeneric(tag, el.offersAs)} = ${propsType(axes, tag, props, el.offersAs)};
 
 ${compositionHint(comp, name, recipe, voidEl)}
-export function ${comp}({ ${destructure} }: ${comp}Props) {
+export function ${comp}${asGeneric(tag, el.offersAs)}({ ${destructure} }: ${comp}Props${el.offersAs ? "<T>" : ""}) {
 ${el.setup}  return (
 ${hasShape
         ? `${rootOpen}  {...props}
@@ -1525,7 +1543,7 @@ ${orderedParts
         ].join(", ");
         return `
 /** Part "${partName}" of ${comp}${formOf.get(partName) ? ` (${formOf.get(partName)})` : ""} - compose it inside <${comp}>. */
-export function ${partComp}({ ${partDestructure} }: ${propsType(partAxes, partTag, props, partEl.offersAs)}) {
+export function ${partComp}${asGeneric(partTag, partEl.offersAs)}({ ${partDestructure} }: ${propsType(partAxes, partTag, props, partEl.offersAs)}) {
 ${partEl.setup}  return (
     <${partEl.jsxTag}${partEl.jsxAttrs}
       className={${resolveCls([JSON.stringify(partCls), "className"])}}

package/dist/fonts.js

@@ -248,9 +248,15 @@ export function nextFontSnippet(input) {
      * Nenhuma linha aqui menciona o sistema, o slug ou uma variável nossa: é a fonte dele, ligada ao
      * Tailwind dele.
      */
+    /**
+     * `@theme inline`, e não `@theme` - rodada 1 do refinamento, 27/09. O Tailwind escreve um `@theme`
+     * comum no `:root`, e a variável do `next/font` mora na classe do `<body>`: no `:root` ela não existe,
+     * e `font-display` caía na fonte genérica. `inline` faz a utility ler a variável no próprio elemento,
+     * que é o padrão do `create-next-app`.
+     */
     const css = [
         `/* ${appDir}/globals.css - in your own @theme */`,
-        `@theme {`,
+        `@theme inline {`,
         ...emitted.map((role) => `  --font-${role}: var(${roleVar(role)});`),
         `}`,
     ];

package/dist/guide.js

@@ -841,8 +841,9 @@ ${pageBaseSection}${pendingSection}${keyframeLines.length > 0
 ## Motion vocabulary
 
 The base is QUIET: nothing moves until someone asks. When they do, animation is **selection
-from this list**, not improvisation - these are the system's own animations, already compiled
-into ${hasTailwind && hasAnimateKeys ? "`theme.css` as ready utilities" : `\`tokens.css\` as \`@keyframes ds-${slug}-<name>\``}, each on the clock its intent calls for:
+from this list**, not improvisation - these are the system's own animations, each on the clock its
+intent calls for. They are written in ${hasTailwind && hasAnimateKeys ? "`theme.css`" : "`tokens.css`"} next to this guide, which your app does not load -
+nothing of ours is imported. To use one, copy its \`@keyframes\` block${hasTailwind && hasAnimateKeys ? " and its `--animate-<name>` line into your own `@theme`, and the utility below starts to exist" : " into your own stylesheet, and write the `animation` below"}:
 
 ${keyframeLines.join("\n")}
 ${patternLines.length > 0

package/dist/install-marks.js

@@ -258,7 +258,13 @@
  * o nome dele pelo valor quando a receita pede um degrau - rodada 1 do refinamento. Um componente escrito
  * antes carrega o valor cru onde o projeto tem nome.
  */
-export const MATERIALISER_SINCE = "0.16.459";
+/**
+ * 0.16.459 -> 0.16.462 em 27/09, e o passo 1 dá **SIM**: o `GUIDE.md` que cai na pasta passa a entregar
+ * as fontes num `@theme inline` (no `@theme` comum a fonte não carregava) e a dizer de onde vem cada
+ * animação, e os componentes com `as` passam a ter o tipo genérico - rodada 1 do refinamento. Uma pasta
+ * escrita antes ensina o agente a colar uma fonte que não carrega.
+ */
+export const MATERIALISER_SINCE = "0.16.462";
 /**
  * A ÚLTIMA VERSÃO EM QUE O QUE O HOOK RODA MUDOU.
  *

package/dist/their-vars.js

@@ -180,13 +180,14 @@ const FAMILY_KIND = {
     "--ds-motion-durations-": "motion",
     "--ds-motion-easings-": "motion",
 };
+export async function pointTokensAtTheirNames(root, payload, 
 /**
- * A JORNADA INTEIRA, num chamador só - varrer, medir o build, reescrever.
- *
- * Recebe o payload em vez do CSS solto porque um argumento opcional a menos é uma chamada pela
- * metade a menos: quem chama não tem como esquecer de passar a folha certa.
+ * Os nomes DELE que um build anterior provou - `theirs` do `tokenMap` do `.lock`. Usados só quando
+ * esta máquina não tem build: antes de 27/09, sem build o mapa saía vazio e o `connect` apagava 36
+ * pares provados no CodeLevel, sem dizer por quê. O cruzamento é refeito contra o CSS dele de hoje,
+ * então um nome que sumiu do código continua não casando.
  */
-export async function pointTokensAtTheirNames(root, payload) {
+provenBefore = []) {
     const css = payload.artifacts["tokens.css"] ?? "";
     if (!css)
         return {
@@ -196,12 +197,20 @@ export async function pointTokensAtTheirNames(root, payload) {
             compiledAway: 0,
             cycles: 0,
             pairs: [],
+            provedBy: "nothing",
         };
-    const [theirs, resolvable] = await Promise.all([
+    const [theirs, built] = await Promise.all([
         harvestTheirCss(root),
         resolvableVars(root),
     ]);
-    return pointAtTheirNames(css, theirs, resolvable);
+    if (built)
+        return { ...pointAtTheirNames(css, theirs, built), provedBy: "build" };
+    if (provenBefore.length > 0)
+        return {
+            ...pointAtTheirNames(css, theirs, new Set(provenBefore)),
+            provedBy: "before",
+        };
+    return { ...pointAtTheirNames(css, theirs, null), provedBy: "nothing" };
 }
 /** As folhas de estilo DELE, e nenhuma da nossa pasta. Gêmeo de `harvestOwnTokens` no doctor. */
 async function harvestTheirCss(root) {

package/package.json

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