synthesisui 0.16.187 → 0.16.189

package/dist/anatomy-from-sketch.js

@@ -237,6 +237,33 @@ const MEMBER_FORM = {
  * already the recipe's `base`, and emitting it again would draw the component
  * inside a copy of itself.
  */
+/**
+ * COMO A PEÇA DA BIBLIOTECA FOI USADA, verbatim - e ela nunca atravessava.
+ *
+ * O sketch já lia `behaviourProps` no ponto de chamada (`open`, `onOpenChange`, `disabled`) e o
+ * contrato já tinha o campo; entre um e outro não havia ninguém carregando. Medido no repo do dono em
+ * 09/08: 15 nós carregavam as props na leitura e ZERO chegavam na receita.
+ *
+ * É a metade que decide se um agente consegue reproduzir o componente sem inventar: `Collapsible.Root`
+ * sozinho não diz se o disclosure é controlado; `Collapsible.Root` com `open` e `onOpenChange` diz.
+ *
+ * Teto de 12 props e 200 caracteres cada: isto viaja no censo e uma expressão de chamada pode ser uma
+ * linha inteira de código. O que passa disso é ruído no lugar onde a receita precisa ser lida.
+ */
+function behaviour(node) {
+    const raw = node.behaviourProps;
+    if (!raw || typeof raw !== "object")
+        return {};
+    const out = {};
+    for (const [key, value] of Object.entries(raw)) {
+        if (Object.keys(out).length >= 12)
+            break;
+        if (typeof value !== "string" || !key)
+            continue;
+        out[key] = value.slice(0, 200);
+    }
+    return Object.keys(out).length > 0 ? { behaviourProps: out } : {};
+}
 export function anatomyFromSketch(sketch, defines, 
 /**
  * Their manifest: a package name → the range they pinned. This is what tells
@@ -335,6 +362,7 @@ versionOf) {
                     as: held.length > 0 ? "stack" : "text",
                     from: String(node.from ?? tag),
                     refName: tag,
+                    ...behaviour(node),
                     /** Its own index, so its guard and its props are still reachable - see `at`. */
                     at: index,
                     ...(held.length > 0 ? { children: held } : {}),
@@ -352,6 +380,8 @@ versionOf) {
                 {
                     as: "component",
                     ref: tag,
+                    /** Como ELE configurou o próprio componente é receita igual - ver `behaviour`. */
+                    ...behaviour(node),
                     /**
                      * THE INDEX IS THE NODE'S IDENTITY ON THE SKETCH, not a pointer to its classes.
                      *
@@ -380,6 +410,16 @@ versionOf) {
                 {
                     as: "external",
                     from: String(node.from ?? tag),
+                    /**
+                     * QUAL PEÇA, e não só de qual pacote - o ramo headless já dizia isto e o opaco não.
+                     *
+                     * `Collapsible.Root` e `Collapsible.Trigger` vêm do mesmo especificador e não são a mesma
+                     * coisa: quem gera código a partir da receita tem de saber qual das duas escrever. Medido
+                     * no repo do dono em 09/08: dos 119 nós de fronteira, 42 diziam a peça e 77 diziam apenas
+                     * o pacote - e os 77 eram exatamente este ramo.
+                     */
+                    refName: tag,
+                    ...behaviour(node),
                     at: index,
                     ...(children.length > 0 ? { children: descend() } : {}),
                 },
@@ -513,8 +553,14 @@ versionOf) {
          * props are copied into the snippet and can never fire, because the element unmounts
          * before anything animates. Headless-only dropped it (dono, 04/08).
          */
+        /**
+         * Uma primitiva headless DESENHADA continua sendo daquela biblioteca, e as props do ponto de
+         * chamada são o que dizem se ela é controlada. Medido em 09/08: `Collapsible.Root`,
+         * `Popover.Root`, `Switch.Root`, `BaseDialog.Root` e `Field.Root` chegavam aqui e perdiam
+         * `open`/`onOpenChange`/`checked` - 11 dos 15 nós que a leitura media.
+         */
         const fromLib = (kind === "headless" || kind === "motion") && node.from
-            ? { from: String(node.from), refName: tag }
+            ? { from: String(node.from), refName: tag, ...behaviour(node) }
             : {};
         const built = {
             as,

package/dist/cli-version.js

@@ -0,0 +1,32 @@
+/**
+ * QUEM ESTÁ ATRÁS DE QUEM, e só isso.
+ *
+ * O aviso "a newer reader is published" disparava por DIFERENÇA, nos dois sentidos. Em 08/08 o dono
+ * rodou `sync` com 0.16.187 recém-publicada, e a plataforma - que ainda não tinha feito deploy -
+ * respondia 0.16.186. A tela dele disse *"You are running 0.16.187 and 0.16.186 is published"* debaixo
+ * de um título que promete o contrário, e mandou rodar `connect` para "atualizar" para uma versão
+ * mais velha que a dele.
+ *
+ * Esse estado não é raro, é a regra: publicar no npm e fazer deploy da plataforma não são o mesmo
+ * instante, então entre um e outro quem instala do npm fica na frente. Um alarme que toca quando está
+ * tudo certo é um alarme que a pessoa aprende a ignorar - e é o mesmo alarme que precisa ser lido no
+ * dia em que ela estiver de verdade para trás.
+ *
+ * Espelha `isOlderCli` de `apps/web/src/lib/ds/reinterpret.ts`. Não é um gêmeo por spec como
+ * `frontier-kind.ts`: aqui não há contrato compartilhado, só a mesma aritmética de três números.
+ */
+export function isOlderCli(mine, published) {
+    const parts = (v) => v.split(".").map((p) => Number.parseInt(p, 10));
+    const a = parts(mine);
+    const b = parts(published);
+    for (let i = 0; i < Math.max(a.length, b.length); i += 1) {
+        const left = a[i];
+        const right = b[i];
+        /** Versão que não é numérica não se compara - e acusar o que não se sabe ler é pior que calar. */
+        if (!Number.isFinite(left) || !Number.isFinite(right))
+            return false;
+        if (left !== right)
+            return left < right;
+    }
+    return false;
+}

package/dist/commands/import.js

@@ -32,7 +32,7 @@ import { MUI_DEFAULT_SPACING, readStyledComponents, spacingOf, } from "../doctor
 import { buildTable } from "../doctor/tokens.js";
 import { definitionSpan, readInlineStyle, rootClasses, rootTag, transcribe, } from "../doctor/transcribe.js";
 import { transcribeVariants } from "../doctor/variant-read.js";
-import { frontierKind } from "../frontier-kind.js";
+import { frontierKind, packageRoot } from "../frontier-kind.js";
 import { withLibraryStructure } from "../library-structure.js";
 import { body, paint, section } from "../output.js";
 import { phase, startProgress } from "../progress.js";
@@ -2478,7 +2478,17 @@ export async function resolveReadParts(census, root) {
                 .filter((lib) => !resolved.external.some((e) => e.from === lib.from))
                 .map((lib) => ({
                 from: lib.from,
-                ...(pinned[lib.from] ? { version: pinned[lib.from] } : {}),
+                /**
+                 * PELA RAIZ DO PACOTE, e não pelo especificador inteiro.
+                 *
+                 * O `package.json` declara `@base-ui/react`; o código importa
+                 * `@base-ui/react/collapsible`. Consultar o manifesto com o segundo acerta só quando os
+                 * dois coincidem - medido no repo do dono em 09/08, 95 de 119 nós de fronteira chegavam
+                 * sem versão, e uma receita de biblioteca headless sem versão é um palpite datado.
+                 */
+                ...(pinned[packageRoot(lib.from)]
+                    ? { version: pinned[packageRoot(lib.from)] }
+                    : {}),
                 /**
                  * EVERY KIND, not the two the rule sentence happened to need.
                  *

package/dist/commands/status.js

@@ -1,5 +1,6 @@
 import { readdir, readFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
+import { isOlderCli } from "../cli-version.js";
 import { readToken, resolveRegistry } from "../config.js";
 import { readEvents } from "../doctor/ledger.js";
 import { readRequests } from "../doctor/requests.js";
@@ -150,7 +151,7 @@ export async function status(opts) {
      * Não vira um item do `align`: o CLI subiu seis vezes num dia e nenhuma delas mudou um leitor, e a
      * verificação de abertura tem que ficar muda nesses casos. Aqui é diferente - a pessoa PERGUNTOU.
      */
-    const behindCli = remote.publishedCli && opts.cli && remote.publishedCli !== opts.cli
+    const behindCli = remote.publishedCli && opts.cli && isOlderCli(opts.cli, remote.publishedCli)
         ? {
             says: `your CLI is ${opts.cli} and ${remote.publishedCli} is published - a newer reader sees styles this one cannot.`,
             run: "npx synthesisui@latest upgrade",

package/dist/commands/sync.js

@@ -1,5 +1,6 @@
 import { readdir, readFile, writeFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
+import { isOlderCli } from "../cli-version.js";
 import { readToken, resolveRegistry } from "../config.js";
 import { markSent, readEvents } from "../doctor/ledger.js";
 import { checkableName, closeRequest, readRequests, verifyAndCloseRequests, } from "../doctor/requests.js";
@@ -201,7 +202,9 @@ export async function remeasure(args) {
      * pode movê-lo é quem roda o comando. Então o número é dito aqui, com o comando ao lado, em vez de
      * viver numa tela que alguém precisa lembrar de abrir.
      */
-    if (stored.publishedCli && args.cli && stored.publishedCli !== args.cli) {
+    if (stored.publishedCli &&
+        args.cli &&
+        isOlderCli(args.cli, stored.publishedCli)) {
         console.log(section("A newer reader is published"));
         console.log(body(`You are running ${args.cli} and ${stored.publishedCli} is published. The measurement below uses ${args.cli}.`));
         console.log(paint.blue(snippet(["npx synthesisui@latest connect"])));

package/dist/frontier-kind.js

@@ -118,7 +118,14 @@ export function frontierKind(pkg) {
     return "opaque";
 }
 /** `@scope/name/sub` → `@scope/name`; `name/sub` → `name`. */
-function packageRoot(pkg) {
+/**
+ * O NOME DO PACOTE, do especificador inteiro: `@base-ui/react/collapsible` -> `@base-ui/react`.
+ *
+ * Exportado em 09/08 porque o carimbo de VERSÃO consultava o manifesto com o especificador cru, e o
+ * `package.json` declara a raiz. Resultado medido no repo do dono: 95 de 119 nós de fronteira
+ * chegavam sem versão, e os 24 que chegavam eram justamente os que importam da raiz.
+ */
+export function packageRoot(pkg) {
     const parts = pkg.split("/");
     return pkg.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
 }

package/package.json

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