synthesisui 0.16.127 → 0.16.129

package/dist/anatomy-read.js

@@ -288,6 +288,15 @@ sketch) {
                 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)

package/dist/commands/import.js

@@ -1076,7 +1076,21 @@ export async function takeCensus(root, opts) {
             console.log(body(paint.faint(`  and ${unreadableByComponent.length - 8} more components`)));
         }
     }
-    const coverageLines = describeCoverage(coverage);
+    /**
+     * QUANTOS DECIDEM ARRANJO EM VEZ DE APARÊNCIA - a mesma conta que a plataforma faz para
+     * marcar `composition: true`: uma receita sem uma única declaração nunca prometeu cor.
+     * Dito ANTES de importar, porque "36 de 271 saíram com aparência" faz parecer que 235 se
+     * perderam, e eles não se perderam (04/08).
+     */
+    const composition = Object.values(looks).filter((look) => {
+        const l = look;
+        return (Object.keys(l.base ?? {}).length === 0 &&
+            Object.keys(l.dark ?? {}).length === 0 &&
+            Object.keys(l.states ?? {}).length === 0 &&
+            Object.keys(l.parts ?? {}).length === 0 &&
+            (l.layers ?? []).length === 0);
+    }).length;
+    const coverageLines = describeCoverage(coverage, composition);
     if (coverageLines.length > 0) {
         console.log("");
         console.log(section("What this version reads, on your files"));
@@ -1444,12 +1458,12 @@ function sayBrokenRefs(c) {
     const uses = broken.reduce((n, b) => n + b.count, 0);
     console.log("");
     console.log(section("These resolve to nothing"));
-    console.log(body(`${uses} reference${uses === 1 ? "" : "s"} to ${broken.length} token${broken.length === 1 ? "" : "s"} your CSS never declares. A ${paint.strong("var()")} with no declaration paints no colour - not a different colour.`));
+    console.log(body(`${uses} reference${uses === 1 ? "" : "s"} to ${broken.length} token${broken.length === 1 ? "" : "s"} your CSS never declares. A ${paint.strong("var()")} with no declaration paints no colour - not a different colour. Where exactly one declared token differs by a namespace, the recipe now uses THAT one, so the look survives; the rest travel as the value you typed.`));
     console.log("");
     for (const b of broken.slice(0, 8)) {
         const where = `${b.count}× in ${b.files} file${b.files === 1 ? "" : "s"}`;
         console.log(body(b.meant
-            ? `${paint.strong(`var(${b.name})`)} ${paint.faint(where)} - you declare ${paint.strong(b.meant)}`
+            ? `${paint.strong(`var(${b.name})`)} ${paint.faint(where)} - you declare ${paint.strong(b.meant)}, and that is what the recipe carries. Fix the class and the two agree.`
             : `${paint.strong(`var(${b.name})`)} ${paint.faint(`${where}, and nothing close is declared`)}`));
     }
     if (broken.length > 8) {

package/dist/doctor/coverage.js

@@ -105,12 +105,30 @@ export function summarizeCoverage(counts, components, read, declarations) {
  * then names every shape that is not fully read, with the reason. No percentages without
  * the count behind them: "75%" of an unknown total is a marketing number.
  */
-export function describeCoverage(c) {
+export function describeCoverage(c, 
+/**
+ * QUANTOS SÃO COMPOSIÇÃO, quando quem chama sabe - ver `componentRecipe.composition`.
+ *
+ * Numa biblioteca é zero e a frase não aparece. Num app é a maioria, e dizer só "36 de 271
+ * saíram com aparência" faz parecer que 235 se perderam. Eles não se perderam: decidem
+ * arranjo e fluxo, e é isso que a receita deles carrega. Medido no dashboard dele: 235 de
+ * 271 (04/08).
+ */
+composition) {
     if (c.components === 0)
         return [];
     const lines = [];
     const pct = Math.round((c.read / c.components) * 100);
     lines.push(`${c.read} of ${c.components} components came out with a look - ${pct}%, ${c.declarations} declarations in total. This is measured on your files, not an estimate.`);
+    if (composition && composition > 0) {
+        lines.push(
+        /**
+         * DIZ O QUE FOI MEDIDO, e não o que a plataforma vai concluir. Este número é "não tem
+         * look próprio nos seus arquivos"; a receita final é decidida depois, com a paleta em
+         * mão, e as duas contas não são a mesma. Prometer a segunda aqui seria inventar precisão.
+         */
+        `  and ${composition} have no look of their own in your files - a screen that composes others, in a grid, passing data down. Those arrive as COMPOSITION recipes: the tree, the slots, and what each child receives, with no palette to grade. Nothing was lost; it is a different kind of recipe.`);
+    }
     for (const { shape, files, examples } of c.counts) {
         const share = Math.round((files / c.components) * 100);
         const head = `  ${files} (${share}%) ${shape.label}`;

package/dist/doctor/sketch.js

@@ -351,6 +351,82 @@ export function conditionalPropsOf(body) {
             out[m[1]] = m[2].trim();
     return Object.keys(out).length > 0 ? out : null;
 }
+/**
+ * Toda prop de um elemento, com o valor como eles escreveram - ver `SketchNode.passes`.
+ *
+ * Quatro formas atravessam, porque as quatro são evidência do que a tela liga: a string
+ * literal (a cópia dele), o identificador ou caminho (a fiação), o literal numérico ou
+ * booleano, e a expressão composta curta. Duas não atravessam: função inline e objeto inline.
+ */
+export function passedProps(body, 
+/** O que `behaviourProps` já levou, para cada fato viver num lugar só. */
+taken) {
+    const out = {};
+    const SKIP = /^(className|class|key|ref|style|children)$/;
+    for (const m of body.matchAll(/(\w+)=(?:"([^"]{0,80})"|'([^']{0,80})'|\{([^{}]{1,80})\})/g)) {
+        const prop = m[1];
+        if (SKIP.test(prop) || taken?.[prop] || out[prop])
+            continue;
+        const literal = m[2] ?? m[3];
+        if (literal != null) {
+            out[prop] = literal;
+            continue;
+        }
+        const value = (m[4] ?? "").replace(/\s+/g, " ").trim();
+        // Um corpo de função é código que chama o que a receita não tem; um objeto é estilo.
+        if (!value || /=>|\bfunction\b/.test(value) || value.startsWith("{"))
+            continue;
+        out[prop] = value;
+    }
+    return Object.keys(out).length > 0 ? out : null;
+}
+/**
+ * A expressão que um `map` percorre, quando este elemento está dentro de um - ver `repeats`.
+ *
+ * Mesma forma de `guardAt`: uma varredura para trás até a chamada que envolve este offset, e
+ * o alvo é o que vem antes do `.map(`. Nada é avaliado; a expressão é evidência de que este nó
+ * é uma LISTA.
+ */
+export function repeatOf(source, at) {
+    const MAP = /([A-Za-z_$][\w$.?[\]]{0,60})\s*\.map\s*\(/g;
+    MAP.lastIndex = 0;
+    let found = null;
+    for (const m of source.matchAll(MAP)) {
+        const open = (m.index ?? 0) + m[0].length - 1;
+        if (open > at)
+            break;
+        const end = closeOf(source, open);
+        if (end === -1 || end <= at)
+            continue;
+        found = m[1].replace(/\?$/, "");
+    }
+    return found;
+}
+/** O índice do fecha-parêntese que corresponde ao abre em `open`, ou -1. */
+function closeOf(source, open) {
+    let depth = 0;
+    let quote = "";
+    for (let i = open; i < source.length; i++) {
+        const c = source[i];
+        if (quote) {
+            if (c === "\\")
+                i += 1;
+            else if (c === quote)
+                quote = "";
+            continue;
+        }
+        if (c === '"' || c === "'" || c === "`")
+            quote = c;
+        else if (c === "(")
+            depth += 1;
+        else if (c === ")") {
+            depth -= 1;
+            if (depth === 0)
+                return i;
+        }
+    }
+    return -1;
+}
 export function sketchOf(source, name) {
     /**
      * READ THE IMPORTS BEFORE SLICING - they live at the top of the file, and the
@@ -433,6 +509,16 @@ export function sketchOf(source, name) {
         const conditional = conditionalPropsOf(event.body);
         if (conditional)
             node.behaviourProps = conditional;
+        /**
+         * O QUE ELE RECEBE E O QUE ELE REPETE - ver `passes` e `repeats`. As duas peças que faltavam
+         * para a receita de uma TELA carregar a fiação, e não só a casca.
+         */
+        const given = passedProps(event.body, conditional);
+        if (given)
+            node.passes = given;
+        const list = repeatOf(source, event.at);
+        if (list)
+            node.repeats = list;
         // What has to be true for this element to exist at all - see `guardAt`.
         const guard = guardAt(source, event.at);
         if (guard) {

package/dist/doctor/transcribe.js

@@ -1179,10 +1179,44 @@ function resolveArbitrary(inner, declared) {
         return /[<>{}@;]/.test(raw) ? null : { value: raw };
     }
     const name = v[1];
-    if (!declared.has(name))
-        return { value: raw };
-    return { value: tokenRefFor(name), token: name };
+    if (declared.has(name))
+        return { value: tokenRefFor(name), token: name };
+    /**
+     * A `var()` THEY NEVER DECLARED, WHEN THEY DECLARED IT UNDER ITS NAMESPACE.
+     *
+     * `bg-[var(--ocean-200)]` where the theme declares `--color-ocean-200` is their own
+     * defect - Tailwind v4 namespaces the property and they wrote the bare name - and it is
+     * ALSO unambiguous: exactly one declared token differs from it by a namespace. The census
+     * already computes that answer for the report (`brokenRefs.meant`); carrying the broken
+     * name into the recipe instead meant the declaration reached the document and painted
+     * nothing, because `var(--ocean-200)` exists in their stylesheet and in none of ours.
+     *
+     * Measured on his library (test50, dono, 04/08): 6 declarations across 5 components, all
+     * colours, all dead - and invisible to the ref validator, which only ever looks for `{…}`.
+     *
+     * A name that matches NO namespace stays the literal it was: that one is broken in their
+     * repo too, and inventing a target would be the guess. It travels as the value they typed
+     * and is reported by `brokenRefs`.
+     */
+    const meant = MEANT_NAMESPACES.map((ns) => `--${ns}-${name.slice(2)}`).find((candidate) => declared.has(candidate));
+    if (meant)
+        return { value: tokenRefFor(meant), token: meant };
+    return { value: raw };
 }
+/**
+ * The namespaces a bare name could have been written under, in the order Tailwind v4 uses
+ * them. Mirrors `NAMESPACES` in `broken-refs.ts`, which computes the same answer for the
+ * report - two readers of one fact, and the fact is "exactly one declared token differs
+ * from this by a prefix".
+ */
+const MEANT_NAMESPACES = [
+    "color",
+    "spacing",
+    "radius",
+    "shadow",
+    "font",
+    "text",
+];
 /**
  * A declared custom property, as a token ref in the document's own namespace.
  *

package/package.json

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