synthesisui 0.16.331 → 0.16.334

package/dist/commands/import.js

@@ -42,6 +42,7 @@ import { variantCallsIn } from "../doctor/variant-calls.js";
 import { transcribeVariants } from "../doctor/variant-read.js";
 import { frontierKind, packageRoot } from "../frontier-kind.js";
 import { keyframesInSheets } from "../global-keyframes.js";
+import { globalClassesWorn } from "../global-wear.js";
 import { withLibraryStructure } from "../library-structure.js";
 import { mergeCensus } from "../merge-census.js";
 import { claimName } from "../name-claim.js";
@@ -1880,7 +1881,20 @@ export async function takeCensus(root, opts) {
      */
     const declaredForms = await readDeclaredForms(root);
     const ledger = buildLedger(opts?.cli ?? "unknown", judgeFragments([...fragments.flat(), ...styleFiles.flatMap((s) => s.fragments)], declaredValues, admittedStyles, {
-        wornGlobal: globalClassesClaimed,
+        /**
+         * QUEM VESTE, REIVINDICA - e a resposta vem da SAÍDA, não do caminho.
+         *
+         * `globalClassesClaimed` é o que os caminhos foram lembrando de registrar, e ele perdia
+         * tudo que chega por tabela de variantes: no sistema do dono, 20 das 23 classes globais
+         * são vestidas SÓ assim, e as 80 declarações delas apareciam na Coverage como não lidas
+         * enquanto chegavam ao componente. `globalClassesWorn` deriva do `looks` já montado, então
+         * um caminho novo não precisa lembrar de nada. A união mantém o que só o island e o
+         * sketch sabem.
+         */
+        wornGlobal: new Set([
+            ...globalClassesClaimed,
+            ...globalClassesWorn(looks, globalClasses),
+        ]),
         islandRead: islandClassesRead,
         refused: new Set(skips.map((s) => s.file)),
     }, 

package/dist/doctor/css-modules.js

@@ -169,6 +169,26 @@ function rules(css, media = null, out = []) {
     }
     return out;
 }
+/**
+ * UMA DECLARAÇÃO DE CUSTOM PROPERTY É UMA DECLARAÇÃO - e descartá-la fazia a receita
+ * apontar para um nome que a nossa saída não declara.
+ *
+ * O padrão anterior era `^-?[a-z][a-z-]*$`: um hífen inicial (o prefixo de fabricante),
+ * nunca dois. Toda `--nome` caía fora, em `base`, em `dark` e em `states`, para toda
+ * classe. Medido no codelevel em 29/08: 0 de 23 classes globais carregavam uma, e a folha
+ * declara duas dentro de `@utility holo-card`.
+ *
+ * O QUE O CLIENTE VIVIA: a receita do `Card variant="holo"` sai com
+ * `background: linear-gradient(var(--holo-inner-bg), …)` e a variável não era declarada em
+ * lugar nenhum da nossa saída - nem o claro `#ffffff`, nem o escuro `#1a1a21`. Um `var()`
+ * sem fallback para propriedade não declarada invalida a declaração em tempo de valor
+ * computado, e o `background` volta ao inicial: o preenchimento E a borda cônica somem.
+ *
+ * Isto NÃO a promove a foundation. Ela continua morando na classe, e é `parseSchemeBlocks`
+ * quem decide o que é vocabulário de documento - lá a régua exige escopo de documento, e
+ * uma variável de componente nunca passa por ela.
+ */
+const PROPERTY = /^(--[a-zA-Z0-9_-]+|-?[a-z][a-z-]*)$/;
 /** `prop: value;` pairs, in the camelCase the contract uses. */
 function declarations(body) {
     const out = {};
@@ -194,12 +214,21 @@ function declarations(body) {
             continue;
         const prop = piece.slice(0, colon).trim();
         const value = piece.slice(colon + 1).trim();
-        if (!/^-?[a-z][a-z-]*$/.test(prop) || !value)
+        if (!PROPERTY.test(prop) || !value)
             continue;
         // A value that could break out of the stylesheet is not a value we carry.
         if (/[<>{}@]/.test(value))
             continue;
-        out[camel(prop)] = value;
+        /**
+         * O NOME DE UMA CUSTOM PROPERTY É A CHAVE DE UMA REFERÊNCIA, e por isso ele não passa
+         * pelo `camel`.
+         *
+         * `--holo-inner-bg` viraria `-HoloInnerBg`, e o `var(--holo-inner-bg)` que a mesma regra
+         * escreve deixaria de encontrá-la. Uma propriedade padrão é um NOME que o contrato
+         * escreve em camelCase e o compilador devolve em kebab; uma custom property é um
+         * IDENTIFICADOR que o autor escolheu, e ela viaja verbatim nas duas pontas.
+         */
+        out[prop.startsWith("--") ? prop : camel(prop)] = value;
     }
     return out;
 }

package/dist/doctor/fragments.js

@@ -284,6 +284,32 @@ const STRUCTURE = new Set([
     "inline",
     "contents",
 ]);
+/**
+ * QUAL CLASSE A REGRA ALVEJA - a última do seletor, que é a que o navegador pinta.
+ *
+ * O QUE O CLIENTE VIVIA: a régua anterior era `^\.classe\s*{`, então só a forma mais simples de
+ * seletor contava. Uma regra de FACE ESCURA se escreve `html.dark .plate { … }` e uma de estado
+ * `.plate:hover { … }` - as duas chegam ao componente pelo leitor de classe global, e as duas
+ * apareciam na Coverage como não lidas. Medido no corpus em 29/08: das 4 declarações do app de
+ * face escura, 2 eram reconhecidas e 2 não, e as 2 perdidas eram exatamente a face escura.
+ *
+ * A ÚLTIMA, e não qualquer uma: em `.plate .interna` quem recebe a declaração é `.interna`, e
+ * dizer que a regra foi lida porque `.plate` é vestida reivindicaria o que não chegou. Em
+ * `html.dark .plate` o alvo é `.plate`, e o `dark` do prefixo é escopo, não alvo.
+ *
+ * Vírgula é uma LISTA de alvos: basta um deles ser vestido para a declaração chegar em algum lugar.
+ */
+function targetClass(text) {
+    const brace = text.indexOf("{");
+    const selector = brace === -1 ? text : text.slice(0, brace);
+    for (const group of selector.split(",")) {
+        const classes = group.match(/\.[A-Za-z][\w-]*/g);
+        /** Sem o ponto: o nome que `globalClasses` indexa. */
+        if (classes?.length)
+            return classes[classes.length - 1].slice(1);
+    }
+    return null;
+}
 /**
  * UMA FORMA DECLARADA POR ELE RESOLVE ISTO? - o portão que transforma `computed` em lido.
  *
@@ -336,7 +362,7 @@ forms = []) {
          * era a última ocorrência de `value-not-read` do repo real (12/08).
          */
         if (f.shape === "css" && f.reason === "shape-not-read") {
-            const cls = /^\.([A-Za-z][\w-]*)\s*\{/.exec(f.text)?.[1];
+            const cls = targetClass(f.text);
             if (cls && wornGlobal.has(cls)) {
                 const { reason: _clear, ...rest } = f;
                 return { ...rest, read: true };

package/dist/doctor/style-ledger.js

@@ -28,7 +28,11 @@
  */
 import { READER } from "../reader-version.js";
 import { formOf } from "./form-identity.js";
-const SHAPES = [
+/**
+ * AS FORMAS QUE O CONTADOR CONHECE, e a lista é exportada para o corpus dourado poder cobrar
+ * uma forma nova sem que ninguém lembre de copiar o nome dela para lá.
+ */
+export const SHAPES = [
     "class",
     "template",
     "inline",

package/dist/global-wear.js

@@ -1,13 +1,10 @@
 import { parseClass } from "./doctor/transcribe.js";
-export function wearGlobal(classes, globals, 
-/** Registra quais classes a folha global reivindicou, para o juiz de duplicidade. */
-claimed) {
+export function wearGlobal(classes, globals) {
     const worn = { base: {}, dark: {}, states: {} };
     for (const cls of classes) {
         const rule = globals.get(cls);
         if (!rule)
             continue;
-        claimed?.add(cls);
         Object.assign(worn.base, rule.base);
         Object.assign(worn.dark, rule.dark);
         for (const [state, block] of Object.entries(rule.states))
@@ -42,3 +39,41 @@ globals) {
         states: Object.fromEntries([...new Set([...Object.keys(worn.states), ...Object.keys(t.states)])].map((k) => [k, { ...worn.states[k], ...t.states[k] }])),
     };
 }
+/**
+ * QUAL CLASSE DA FOLHA GLOBAL ALGUM COMPONENTE VESTE - derivado da SAÍDA, não coletado no caminho.
+ *
+ * O QUE O CLIENTE VIVIA: a plataforma dizia não saber ler o que ela já lia. No sistema do dono, 20
+ * das 23 classes globais são vestidas SÓ por tabela de variantes - `stroke-text`, `text-grad-fire`,
+ * `holo-card`, `megaword` e as outras 16, somando 80 declarações. Todas chegavam ao componente, e
+ * todas apareciam na Coverage como não lidas, com a triagem mandando escrever *"a reader here is a
+ * new module"* para um leitor que já existe. Uma lacuna FALSA custa o mesmo que uma escondida: manda
+ * alguém consertar o que não está quebrado.
+ *
+ * POR QUE DERIVAR, e não registrar no caminho. A reivindicação era um `Set` opcional que `wearGlobal`
+ * aceitava e nenhum dos dois chamadores passava - o mesmo defeito do argumento que dá para esquecer.
+ * Fechar a porta aqui não é passar o argumento nos dois lugares: é parar de perguntar ao CAMINHO e
+ * perguntar à SAÍDA. Uma classe foi vestida quando ela aparece no look - no markup do componente ou
+ * na camada de uma opção de variante -, e um leitor futuro que faça a classe chegar lá reivindica
+ * sozinho, sem lembrar de nada.
+ *
+ * OS DOIS LUGARES onde uma classe existe num look, e são só estes: `sketch[].classes`, que é o
+ * markup dele verbatim, e `layers[].classes`, que é a tabela de variantes.
+ */
+export function globalClassesWorn(looks, globals) {
+    const worn = new Set();
+    if (!globals || globals.size === 0)
+        return worn;
+    const claim = (cls) => {
+        if (cls && globals.has(cls))
+            worn.add(cls);
+    };
+    for (const look of Object.values(looks)) {
+        for (const node of look.sketch ?? [])
+            for (const cls of (node.classes ?? "").split(/\s+/))
+                claim(cls);
+        for (const layer of look.layers ?? [])
+            for (const cls of layer.classes ?? [])
+                claim(cls);
+    }
+    return worn;
+}

package/dist/install-marks.js

@@ -367,7 +367,7 @@ export const CHECKER_SINCE = "0.16.308";
  * nunca era alcançado. Medido: 1134 componentes, 77 mudaram, e a receita que o cliente recebe muda
  * com eles. Uma medição anterior não produz o conserto, então a marca sobe.
  */
-export const READER_SINCE = "0.16.331";
+export const READER_SINCE = "0.16.334";
 /**
  * O QUE ESTÁ INSTALADO AQUI FICOU PARA TRÁS - e as DUAS condições que fazem isso ser verdade.
  *

package/package.json

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