synthesisui 0.16.191 → 0.16.193

package/dist/anatomy-read.js

@@ -31,7 +31,7 @@
  */
 import { readSxProps } from "./doctor/style-props.js";
 import { transcribe, } from "./doctor/transcribe.js";
-import { frontierKind } from "./frontier-kind.js";
+import { frontierKind, packageRoot } from "./frontier-kind.js";
 /** The ten forms, closed. A renderer that accepts any tag draws anything. */
 const FORMS = new Set([
     "image",
@@ -174,6 +174,49 @@ function frontierSx(node, sketch) {
     const trimmed = raw?.trim();
     return trimmed ? { sx: trimmed.slice(0, 400) } : {};
 }
+/**
+ * O QUE O SKETCH MEDIU NAQUELE NÓ - e é UMA função porque três ramos precisam dela.
+ *
+ * A leitura autorada diz a FORMA; o sketch guarda os fatos daquele elemento, alcançáveis pelo índice
+ * `at`. Isto era um bloco solto no meio do caminhamento, e o ramo de FRONTEIRA saía por um `continue`
+ * antes de chegar nele - então `behaviourProps`, `contentFrom`, `passes` e `repeats` nunca chegavam
+ * num nó que nomeia uma biblioteca.
+ *
+ * Medido no repo do dono em 09/08, DEPOIS de o conserto da travessia ter subido: `behaviourProps` em
+ * 15 nós de fronteira e ZERO chegando, `contentFrom` em 23 e zero. O detector de perda apontou; a
+ * causa era este `continue`.
+ *
+ * É a terceira vez que o mesmo formato cobra: um ramo que retorna antes do trabalho comum. O `upgrade`
+ * pulava a medição, o `repointToSteps` enumerava ramos e esquecia um, e agora este. Por isso vira
+ * função - uma lista de campos copiada à mão nasce desatualizada no próximo campo.
+ */
+function measuredAt(node, sketch) {
+    const out = {};
+    if (typeof node.at !== "number") {
+        if (node.when)
+            out.when = node.when;
+        if (node.atRest === false)
+            out.atRest = false;
+        return out;
+    }
+    const measured = sketch?.[node.at];
+    const when = node.when ?? measured?.when;
+    if (when)
+        out.when = when;
+    const atRest = node.atRest ?? measured?.atRest;
+    if (atRest === false)
+        out.atRest = false;
+    if (measured?.contentFrom)
+        out.contentFrom = measured.contentFrom;
+    if (measured?.behaviourProps &&
+        Object.keys(measured.behaviourProps).length > 0)
+        out.behaviourProps = measured.behaviourProps;
+    if (measured?.passes && Object.keys(measured.passes).length > 0)
+        out.passes = measured.passes;
+    if (measured?.repeats)
+        out.repeats = measured.repeats;
+    return out;
+}
 export function resolveAnatomy(read, declared, deps, 
 /** Their name → the slug it reaches in this system. See `RefResolver`. */
 resolve, 
@@ -284,6 +327,8 @@ sxSpacing) {
                         ref: slug || safePartName(name),
                         ...(slug && slug !== safePartName(name) ? { refName: name } : {}),
                         ...frontierClasses(node, sketch),
+                        /** Um componente DELE também é um nó, e o que o sketch mediu nele vale igual. */
+                        ...measuredAt(node, sketch),
                         ...holds,
                     });
                     continue;
@@ -291,7 +336,12 @@ sxSpacing) {
                 const from = String(node.from ?? "").trim();
                 if (!from)
                     continue;
-                const version = deps?.[from];
+                /**
+                 * PELA RAIZ DO PACOTE. O manifesto declara `@base-ui/react` e o código importa
+                 * `@base-ui/react/menu` - o mesmo defeito consertado no `import.ts` em 09/08, e este era o
+                 * segundo site. Uma receita de headless sem versão é um palpite datado.
+                 */
+                const version = deps?.[packageRoot(from)] ?? deps?.[from];
                 if (!external.some((e) => e.from === from))
                     external.push({ from, version });
                 out.push({
@@ -300,6 +350,8 @@ sxSpacing) {
                     ...(version ? { version } : {}),
                     ...frontierClasses(node, sketch),
                     ...frontierSx(node, sketch),
+                    /** O que o sketch mediu naquele nó - o `continue` abaixo o pulava. */
+                    ...measuredAt(node, sketch),
                     ...holds,
                 });
                 continue;
@@ -309,40 +361,7 @@ sxSpacing) {
              * THE GUARD TRAVELS WITH THE NODE, off the sketch it points at - so neither a
              * reading nor the deriver has to carry it, and both get it.
              */
-            if (typeof node.at === "number") {
-                const measured = sketch?.[node.at];
-                const when = node.when ?? measured?.when;
-                if (when)
-                    node_.when = when;
-                const atRest = node.atRest ?? measured?.atRest;
-                if (atRest === false)
-                    node_.atRest = false;
-                /**
-                 * WHAT THE NODE WRITES AND WHICH BEHAVIOUR PROPS IT CARRIES - the two facts that
-                 * turn a styled shell into a component somebody can rebuild. Same lookup as the
-                 * guard, one line up: measured on the sketch, dropped by every seam after it.
-                 */
-                if (measured?.contentFrom)
-                    node_.contentFrom = measured.contentFrom;
-                if (measured?.behaviourProps &&
-                    Object.keys(measured.behaviourProps).length > 0)
-                    node_.behaviourProps = measured.behaviourProps;
-                /**
-                 * O QUE ELE RECEBE E O QUE ELE REPETE, pela mesma consulta. As duas peças que fazem uma
-                 * receita de TELA carregar a fiação de dados, e não só a casca - ver `SketchNode.passes`
-                 * e `SketchNode.repeats`.
-                 */
-                if (measured?.passes && Object.keys(measured.passes).length > 0)
-                    node_.passes = measured.passes;
-                if (measured?.repeats)
-                    node_.repeats = measured.repeats;
-            }
-            else {
-                if (node.when)
-                    node_.when = node.when;
-                if (node.atRest === false)
-                    node_.atRest = false;
-            }
+            Object.assign(node_, measuredAt(node, sketch));
             /**
              * A PART THAT IS A LIBRARY ELEMENT CARRIES BOTH FACTS - see `AnatomyRead.from`.
              * Inert for the renderer, which dispatches on `as`; read by the usage snippet,

package/dist/progress.js

@@ -12,6 +12,9 @@
  * skill runs the CLI with no TTY and pipes the output, so it gets a plain milestone
  * line every so often. Neither has to know about the other, and the non-TTY path never
  * writes a carriage return into a transcript.
+ *
+ * E OS DOIS ESCREVEM EM `stderr`, porque progresso não é resultado: quem redireciona a saída fica com
+ * o relatório limpo, e quem está na tela continua vendo tudo.
  */
 const BAR_WIDTH = 24;
 /**
@@ -22,11 +25,11 @@ const BAR_WIDTH = 24;
  * 08/08 o dono tentou copiar a saída de um `sync` e levou junto 2 172 quadros - um por arquivo de
  * evidência -, o que enterrou o relatório que ele queria mostrar (dono, 08/08).
  *
- * 80ms é o teto do que um olho aproveita: acima de ~12 quadros por segundo a animação já lê como
- * contínua, e o resto é trabalho que só o clipboard vê. No caso dele isso troca 2 172 quadros por
- * algumas dezenas, sem tirar um único frame que alguém fosse perceber.
+ * 250ms, e o número subiu de 80ms em 09/08 por uma razão de LEITURA e não só de clipboard: a linha
+ * mostra o arquivo sendo lido, e a 12 quadros por segundo o nome vira borrão. A quatro por segundo dá
+ * para de fato ler o que está passando - fica melhor na tela E três vezes menor no texto colado.
  */
-const MIN_FRAME_MS = 80;
+const MIN_FRAME_MS = 250;
 /** Every this-many items, the non-TTY path prints one line. Enough to see movement in
  *  a piped log without turning it into the log. */
 const MILESTONE_EVERY = 25;
@@ -60,7 +63,20 @@ function tail(label, width) {
     return `…${label.slice(-(width - 1))}`;
 }
 export function startProgress(title, opts) {
-    const write = opts?.write ?? ((s) => process.stdout.write(s));
+    /**
+     * O PROGRESSO VAI PARA `stderr`, como o banner de fase ao lado - e isto é o que torna a saída
+     * copiável com garantia, e não com esperança.
+     *
+     * Uma barra é PROGRESSO, não resultado. O banner de fase já seguia essa regra desde 01/08 pelo
+     * mesmo motivo; a barra tinha ficado no `stdout` por descuido. Com ela em `stderr`, `sync > arquivo`
+     * e `sync | pbcopy` entregam o relatório limpo sem depender de o terminal honrar `\x1b[2K` - e na
+     * tela nada muda, porque o terminal mostra os dois.
+     *
+     * O dono viu isso duas vezes: na primeira eram 2 172 quadros no clipboard, e na segunda, já com o
+     * limite de tempo, ainda sobravam mais de cem. Depender do comportamento do terminal de cada pessoa
+     * é depender do que a gente não controla.
+     */
+    const write = opts?.write ?? ((s) => process.stderr.write(s));
     const tty = opts?.isTty ?? Boolean(process.stdout.isTTY);
     const now = opts?.now ?? (() => Date.now());
     let total = opts?.total ?? 0;
@@ -68,12 +84,22 @@ export function startProgress(title, opts) {
     let last = "";
     /** `-Infinity` para o PRIMEIRO passo pintar sempre: silêncio no começo lê como travado. */
     let painted = Number.NEGATIVE_INFINITY;
+    /**
+     * APAGAR A LINHA, e não pintar espaços por cima dela.
+     *
+     * A versão anterior voltava o cursor com `\r` e escrevia 80 caracteres, sobrando espaços para cobrir
+     * o quadro mais longo. Na tela funciona; no clipboard não: o terminal do dono guardava cada escrita
+     * como conteúdo NOVO, então colar trazia os quadros um atrás do outro separados por corridas de
+     * espaço - foi exatamente o que ele mostrou depois do primeiro conserto (dono, 09/08).
+     *
+     * `\x1b[2K` é a instrução explícita de LIMPAR A LINHA. Um terminal que a honra substitui a linha no
+     * próprio buffer em vez de acrescentar, e aí a seleção pega uma linha só. E como não há mais nada a
+     * cobrir, o preenchimento some junto: menos 65 bytes por quadro, e nenhuma corrida de espaço no
+     * texto colado.
+     */
     const paint = () => {
         const count = total > 0 ? `${done} of ${total}` : String(done);
-        const line = `  ${bar(done, total)}  ${count}  ${tail(last, 40)}`;
-        // Pad to the previous width so a shorter label cannot leave the tail of a
-        // longer one behind on the line.
-        write(`\r${line.padEnd(80)}`);
+        write(`\x1b[2K\r  ${bar(done, total)}  ${count}  ${tail(last, 40)}`);
     };
     return {
         step(label) {
@@ -103,7 +129,7 @@ export function startProgress(title, opts) {
         },
         done(summary) {
             if (tty)
-                write(`\r${" ".repeat(80)}\r`);
+                write("\x1b[2K\r");
             if (summary)
                 write(`  ${summary}\n`);
         },

package/package.json

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