synthesisui 0.16.332 → 0.16.335

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/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/frontier-kind.js

@@ -198,10 +198,35 @@ const NON_RENDERING = new Set([
      */
     "root",
 ]);
-/** `BaseDialog.Portal` → true. `BaseSelect.Positioner` with `z-50 pt-1` → false. */
+/**
+ * `BaseDialog.Portal` → true. `BaseSelect.Positioner` with `z-50 pt-1` → false.
+ *
+ * AND THE ROLE IS READ AT THE END OF THE NAME, not only as the whole of it. React's own
+ * vocabulary composes: a context provider is spelled `ThemeProvider`, `ConfigProvider`,
+ * `LocalizationProvider` - never the bare word - and every one of them renders no element
+ * at all. Reading only the exact word meant the list named the role and missed every
+ * component that carries it.
+ *
+ * Measured on the two populations before widening (29/08), and the class gate is what keeps
+ * it honest - it is still the fact that separates a role from a real box:
+ *
+ *     frontend-hub   14 nodes end in `Provider`, and NONE of them carries a class
+ *                     3 end in `Root` (`DialogRoot`, `RadioCardRoot`), none with classes
+ *     codelevel-ui    none of either
+ *
+ * A styled `Positioner` still survives as a real box, which is exactly what happens in
+ * their Select - the gate above reads the class list first and answers `false`.
+ */
 export function rendersNothing(tag, classes) {
     if (classes?.trim())
         return false;
-    const member = tag.includes(".") ? tag.split(".").pop() : tag;
-    return NON_RENDERING.has((member ?? "").toLowerCase());
+    const member = (tag.includes(".") ? tag.split(".").pop() : tag)?.toLowerCase();
+    if (!member)
+        return false;
+    if (NON_RENDERING.has(member))
+        return true;
+    for (const role of NON_RENDERING)
+        if (member.endsWith(role))
+            return true;
+    return false;
 }

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.332";
+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.332",
+  "version": "0.16.335",
   "description": "Bring SynthesisUI design systems into any project - tokens, typed components, whole pages and an agent-ready CLAUDE.md manifest.",
   "type": "module",
   "bin": {