synthesisui 0.16.188 → 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/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/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.188",
+  "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": {