synthesisui 0.16.306 → 0.16.308

package/dist/doctor/transcribe.js

@@ -43,6 +43,7 @@
  *     data-[checked]:bg-ocean-50 → states.checked
  */
 import { tokenRefFor } from "../token-ref.js";
+import { frameworkDeclaration } from "./framework-palette.js";
 /**
  * Utility prefix → the property name THE DOCUMENT USES, which is camelCase.
  *
@@ -291,33 +292,12 @@ const TAILWIND_COLOR = {
      */
     current: "currentColor",
     inherit: "inherit",
-    // zinc and blue, because a real Select is styled entirely in them and every
-    // reference read as nothing (test14, 01/08). Tailwind's own values, verbatim.
-    "zinc-50": "#fafafa",
-    "zinc-100": "#f4f4f5",
-    "zinc-200": "#e4e4e7",
-    "zinc-300": "#d4d4d8",
-    "zinc-400": "#a1a1aa",
-    "zinc-500": "#71717a",
-    "zinc-600": "#52525b",
-    "zinc-700": "#3f3f46",
-    "zinc-800": "#27272a",
-    "zinc-900": "#18181b",
-    "zinc-950": "#09090b",
-    "blue-400": "#60a5fa",
-    "blue-500": "#3b82f6",
-    "blue-600": "#2563eb",
-    "neutral-50": "#fafafa",
-    "neutral-100": "#f5f5f5",
-    "neutral-200": "#e5e5e5",
-    "neutral-300": "#d4d4d4",
-    "neutral-400": "#a3a3a3",
-    "neutral-500": "#737373",
-    "neutral-600": "#525252",
-    "neutral-700": "#404040",
-    "neutral-800": "#262626",
-    "neutral-900": "#171717",
-    "neutral-950": "#0a0a0a",
+    /**
+     * A PALETA saiu daqui em 25/08: zinc, blue e neutral (as entradas do test14) moravam nesta
+     * tabela com os hex da v3, cravados - e um projeto v4 recebia o hex antigo. A paleta inteira
+     * mora em `framework-palette.ts`, por versão maior e com o carimbo `from` que o D1 exige;
+     * aqui ficam só os KEYWORDS de CSS, que não são paleta e não têm versão.
+     */
 };
 /**
  * TYPOGRAPHY, and the reason it is here at all.
@@ -649,8 +629,12 @@ export function parseClass(cls) {
  * `declared` maps a token NAME to its value, so a resolved colour can be
  * reported in their vocabulary rather than as a hex we looked up.
  */
-/** A hex, or a ref into their colour scale - the two shapes an alpha can wrap. */
-const COLOUR_VALUE = /^(#[0-9a-f]{3,8}|\{color\.[^}]+\})$/i;
+/**
+ * A hex, a ref into their colour scale, OR a colour function - the shapes an alpha can wrap.
+ * As funções entraram com a paleta versionada (item 18): a v4 publica oklch, e sem elas
+ * `bg-emerald-500/10` resolvia a cor e PERDIA o alfa em silêncio - o scrim virava parede.
+ */
+const COLOUR_VALUE = /^(#[0-9a-f]{3,8}|\{color\.[^}]+\}|(?:oklch|oklab|rgba?|hsla?|lab|lch)\([^)]*\))$/i;
 /**
  * `#ffffff` + `50` → `color-mix(in srgb, #ffffff 50%, transparent)`.
  *
@@ -922,6 +906,17 @@ function readUtilityCore(utility, declared) {
         if (declared.has(own)) {
             return { property: colorProp, value: refFor(rest), token: own };
         }
+        /**
+         * A PALETA PUBLICADA DO FRAMEWORK, por versão maior e COM carimbo (item 18 + D1).
+         *
+         * Depois do token dele (o vocabulário dele sempre vence) e antes da tabela de keywords:
+         * `text-rose-700` é decisão dele sobre um valor que o Tailwind publica, e morria em silêncio
+         * - 127 valores no diagnóstico de 25/08. O `from: "framework"` é o que separa isto de
+         * inventar: a métrica sabe que não é vocabulário DELE e o self-healing pode perguntar.
+         */
+        const published = frameworkDeclaration(colorProp, rest);
+        if (published)
+            return published;
         const builtin = TAILWIND_COLOR[rest];
         if (builtin)
             return { property: colorProp, value: builtin };

package/dist/doctor/value-ledger.js

@@ -0,0 +1,153 @@
+import { parseClass, readUtility } from "./transcribe.js";
+/**
+ * AS PROPRIEDADES QUE SÃO ARRANJO - a definição de "estrutura", por propriedade resolvida.
+ *
+ * O critério do dono (D4): estrutura é onde "token é impossível por definição" - não existe
+ * decisão de vocabulário em `display: flex`. Espaçamento e tamanho NÃO entram: `gap`, `padding`
+ * e `height` são decisões de escala (a métrica de Spacing & Proportion existe para elas).
+ */
+const STRUCTURAL_PROPERTIES = new Set([
+    "display",
+    "position",
+    "top",
+    "right",
+    "bottom",
+    "left",
+    "inset",
+    "insetInline",
+    "insetBlock",
+    "zIndex",
+    "overflow",
+    "overflowX",
+    "overflowY",
+    "flexDirection",
+    "flexWrap",
+    "alignItems",
+    "alignContent",
+    "alignSelf",
+    "justifyContent",
+    "justifyItems",
+    "justifySelf",
+    "placeItems",
+    "placeContent",
+    "order",
+    "flex",
+    "flexGrow",
+    "flexShrink",
+    "flexBasis",
+    "gridColumn",
+    "gridRow",
+    "gridTemplateColumns",
+    "gridTemplateRows",
+    "pointerEvents",
+    "userSelect",
+    "textAlign",
+    "verticalAlign",
+    "whiteSpace",
+    "objectFit",
+    "objectPosition",
+    "visibility",
+    "isolation",
+    "textOverflow",
+    "borderCollapse",
+]);
+/**
+ * TOKENS DE ARRANJO QUE O RESOLVEDOR NÃO DEVOLVE COMO DECLARAÇÃO - a metade utilitária da mesma
+ * definição. `w-full` e `truncate` não são decisão de vocabulário; `hidden` e `sr-only` são
+ * visibilidade. Lista CONSERVADORA de propósito: o que não estiver aqui e não resolver cai em
+ * `unread`, que é o lado certo de errar - um arranjo cobrado como lacuna custa uma linha; uma
+ * decisão de estilo escondida como "estrutura" custa a confiança na métrica.
+ */
+const STRUCTURAL_TOKENS = new Set([
+    /** Os valores de display crus - a mesma lista que o juiz de fragmento chama de STRUCTURE. */
+    "flex",
+    "inline-flex",
+    "grid",
+    "inline-grid",
+    "block",
+    "inline-block",
+    "inline",
+    "contents",
+    "flow-root",
+    "flex-row",
+    "flex-col",
+    "flex-row-reverse",
+    "flex-col-reverse",
+    "w-full",
+    "h-full",
+    "w-fit",
+    "h-fit",
+    "w-max",
+    "w-min",
+    "min-w-0",
+    "shrink",
+    "shrink-0",
+    "grow",
+    "grow-0",
+    "flex-1",
+    "flex-auto",
+    "flex-none",
+    "hidden",
+    "sr-only",
+    "not-sr-only",
+    "truncate",
+    "group",
+    "peer",
+    "isolate",
+]);
+/**
+ * O destino de UM token de classe. Exportado para o julgamento por valor e a triagem lerem a
+ * MESMA resposta - duas cópias desta decisão é como o item 11 nasceu.
+ */
+export function destinationOf(cls, declared) {
+    const { utility } = parseClass(cls);
+    if (STRUCTURAL_TOKENS.has(utility))
+        return "structure";
+    const read = readUtility(utility, declared);
+    if (read) {
+        return STRUCTURAL_PROPERTIES.has(read.property)
+            ? "structure"
+            : "interpreted";
+    }
+    return "unread";
+}
+/** A conta de uma lista de tokens - a soma SEMPRE fecha com `seen`, por construção. */
+export function accountClasses(tokens, declared) {
+    const account = {
+        seen: 0,
+        interpreted: 0,
+        structure: 0,
+        unread: 0,
+        answered: 0,
+        unknown: 0,
+    };
+    for (const cls of tokens) {
+        account.seen += 1;
+        account[destinationOf(cls, declared)] += 1;
+    }
+    return account;
+}
+/** Soma de contas - o total do censo é a soma das contas por componente, nunca outra medição. */
+export function sumAccounts(accounts) {
+    const out = {
+        seen: 0,
+        interpreted: 0,
+        structure: 0,
+        unread: 0,
+        answered: 0,
+        unknown: 0,
+    };
+    for (const a of accounts) {
+        out.seen += a.seen;
+        out.interpreted += a.interpreted;
+        out.structure += a.structure;
+        out.unread += a.unread;
+        out.answered += a.answered;
+        out.unknown += a.unknown;
+    }
+    return out;
+}
+/** A invariante do item 11, como pergunta - o spec das populações a assere, o portão a exige. */
+export function invariantHolds(a) {
+    return (a.interpreted + a.structure + a.unread + a.answered + a.unknown === a.seen);
+}

package/dist/doctor/variant-read.js

@@ -31,7 +31,7 @@
  * position in `layers`. They agree only if the reader inserts in the order it read.
  */
 import { wearGlobal, withGlobal } from "../global-wear.js";
-import { parseClass, transcribe } from "./transcribe.js";
+import { parseClass, readUtility, transcribe, } from "./transcribe.js";
 /**
  * A Tailwind modifier, mapped to the condition it IS.
  *
@@ -1272,11 +1272,23 @@ globals) {
             ...t.base,
             ...t.dark,
         };
+        /**
+         * O HÍBRIDO DO D1, no nível da camada: `classes` é a grafia DELE, verbatim (a metade de
+         * fidelidade - o codegen devolve o que ele escreveu); `from: "framework"` quando TODA
+         * declaração resolvida veio da paleta publicada - numa camada mista o vocabulário dele
+         * domina e o carimbo fica ausente, que é o caminho de sempre. Ver `framework-palette.ts`.
+         */
+        const reads = bare
+            .map((utility) => readUtility(utility, declared))
+            .filter((d) => d != null);
+        const fromFramework = reads.length > 0 && reads.every((d) => d.from === "framework");
         return {
             ...(layer.when ? { when: layer.when } : {}),
             ...(layer.at ? { at: layer.at } : {}),
             ...(layer.onClasses ? { onClasses: layer.onClasses } : {}),
             style,
+            classes: layer.classes,
+            ...(fromFramework ? { from: "framework" } : {}),
         };
     })
         .filter((layer) => Object.keys(layer.style).length > 0);

package/dist/install-marks.js

@@ -196,7 +196,13 @@ export const MATERIALISER_SINCE = "0.16.306";
  * `var(--text-caption)` - um token de tipo numa posição de raio. Medido no repositório real: 290
  * sugestões com a categoria trocada, 66 delas graváveis por um `--fix --write`.
  */
-export const CHECKER_SINCE = "0.16.250";
+/**
+ * 0.16.250 -> 0.16.308 em 25/08: o julgamento que o hook roda passa pela paleta versionada do
+ * framework (item 18). Um hook pinado antes lê o mesmo arquivo com `text-rose-700` e conta
+ * "não lido" sobre um valor que o de hoje resolve - e o número é o que a pessoa lê para decidir
+ * se adotou. O `!` de important (0.16.306) já tinha mudado a mesma contagem.
+ */
+export const CHECKER_SINCE = "0.16.308";
 /**
  * A ÚLTIMA VERSÃO EM QUE OS LEITORES PASSARAM A PRODUZIR UM CENSO DIFERENTE.
  *
@@ -288,7 +294,31 @@ export const CHECKER_SINCE = "0.16.250";
  *
  * Um censo medido antes carrega a poluição e a perda; quem remede ganha os três de uma vez.
  */
-export const READER_SINCE = "0.16.306";
+/**
+ * 0.16.306 -> 0.16.307 em 25/08: o censo passa a carregar `values` - a CONTABILIDADE POR VALOR
+ * (item 11). Todo token de classe que veste um componente admitido tem um destino, e a soma fecha
+ * por construção: `interpreted + structure + unread + answered + unknown == seen`. É a
+ * reconciliação entre o ledger (que conta lugares) e a produção (que trabalha em valores) - 86%
+ * contra 50% no mesmo repositório, sem uma linha ligando os dois.
+ *
+ * Campo novo: um censo medido antes não o tem, e a tela de cobertura (D4: três colunas, estrutura
+ * visível fora da métrica) só pode ser honesta sobre quem remedir. É o que esta marca avisa.
+ */
+/**
+ * 0.16.307 -> 0.16.308 em 25/08 (mvp-1128), o lote 1 fechado + o começo do lote 2:
+ *
+ *   item 13  o censo carrega `exports` - o denominador antes do portão, com o resíduo em linhas
+ *   item 12  cada grupo não lido carrega `forms` - a unidade da pergunta de self-healing
+ *   item 17  a camada vira o híbrido do D1: `classes` verbatim + `from` de procedência
+ *   item 18  a paleta publicada do framework resolve por versão maior (v4 oklch, v3 hex), com
+ *            carimbo - 127 valores (21%) deixam de morrer em silêncio
+ *   item 19  o vocabulário do pacote workspace IMPORTADO pelo escopo entra na colheita (genérico,
+ *            nunca node_modules; o escopo vence) - medido no repo real: @frontend-hub/ui doa 94
+ *            variáveis, e os 223 valores (37%) que as vestiam passam a resolver como token DELE
+ *
+ * Um censo medido antes não tem nada disso; quem remede ganha os cinco.
+ */
+export const READER_SINCE = "0.16.308";
 /**
  * O QUE ESTÁ INSTALADO AQUI FICOU PARA TRÁS - e as DUAS condições que fazem isso ser verdade.
  *

package/dist/workspace-css.js

@@ -0,0 +1,84 @@
+import { readFile } from "node:fs/promises";
+import { sep } from "node:path";
+import { walkAll } from "./commands/doctor.js";
+import { workspacePackages } from "./doctor/components-scan.js";
+/**
+ * O VOCABULÁRIO QUE MORA NO PACOTE AO LADO (item 19, 25/08).
+ *
+ * A regra do Tailwind v4: só `--color-*` cria utilitário de cor. Num monorepo, essas variáveis
+ * costumam morar no PACOTE de design system - e quando o escopo medido é o app, a colheita de CSS
+ * só via a pasta apontada: o app do repositório real veste `border-lightgray-200` 213 vezes, e o
+ * `--color-lightgray-200` que cria esse utilitário mora em `packages/ui/src/styles.css`, um pacote
+ * ao lado. Resultado medido: 223 valores (37% do não-lido) morriam com o nome declarado a vinte
+ * linhas de distância do alcance do leitor.
+ *
+ * A regra é GENÉRICA por decisão do dono (25/08): qualquer pacote de WORKSPACE que o escopo
+ * importa - nunca um nome cravado, e nunca `node_modules`: o CSS de terceiro de verdade continua
+ * fora e declarado (população zero medida até hoje; quando aparecer, mede-se lá).
+ *
+ * O ESCOPO DELE SEMPRE VENCE: uma variável declarada na pasta medida nunca é sobrescrita por uma
+ * do pacote irmão - quem está mais perto do componente é a decisão mais específica.
+ */
+/**
+ * `from "@acme/ui"` · `import("@acme/ui/x")` · `require("@acme/ui")` · `import "@acme/ui/css"` -
+ * o último é o side-effect import, e é EXATAMENTE como uma folha de tokens entra num app.
+ */
+const SPECIFIER = /(?:from\s*|import\s*\(?\s*|require\s*\(\s*)["']([^"'./][^"']*)["']/g;
+const CUSTOM_PROPERTY = /(--[a-zA-Z0-9_-]+)\s*:\s*([^;}]+)/g;
+const SKIP_DIR = /(^|[/\\])(node_modules|dist|build|\.next|\.git|coverage)([/\\]|$)/;
+/**
+ * Colhe as custom properties dos pacotes workspace que o ESCOPO importa.
+ *
+ * O pré-passe de especificadores relê os fontes do escopo (o laço de componentes só roda DEPOIS,
+ * e é ele que consome o `declared` que esta colheita completa) - custo medido em IO de leitura
+ * pura, centenas de ms num monorepo de mil arquivos, pago uma vez por medição.
+ */
+export async function harvestWorkspaceCss(scopedRoot, 
+/** Nomes já declarados pelo escopo - a trava de "o escopo dele sempre vence". */
+scopeDeclares) {
+    const imported = new Set();
+    for await (const file of walkAll([scopedRoot])) {
+        if (!/\.(tsx|jsx|ts|mjs|cjs|vue|svelte)$/i.test(file))
+            continue;
+        if (SKIP_DIR.test(file))
+            continue;
+        const source = await readFile(file, "utf8").catch(() => "");
+        SPECIFIER.lastIndex = 0;
+        for (const m of source.matchAll(SPECIFIER))
+            imported.add(m[1]);
+    }
+    if (imported.size === 0)
+        return { packages: [], declared: new Map() };
+    const declared = new Map();
+    const packages = [];
+    for (const pkg of await workspacePackages(scopedRoot)) {
+        /**
+         * IMPORTADO PELO ESCOPO - `@acme/ui` cobre `@acme/ui/tokens`. E nunca a própria pasta
+         * medida: o CSS dela já foi colhido pelo laço de sempre, e re-colher criaria a disputa
+         * que a trava abaixo existe para impedir.
+         */
+        const used = [...imported].some((s) => s === pkg.name || s.startsWith(`${pkg.name}/`));
+        if (!used)
+            continue;
+        if (scopedRoot === pkg.dir ||
+            scopedRoot.startsWith(pkg.dir + sep) ||
+            pkg.dir.startsWith(scopedRoot + sep))
+            continue;
+        let vars = 0;
+        for await (const file of walkAll([pkg.dir])) {
+            if (!/\.(css|scss|sass|less)$/i.test(file) || SKIP_DIR.test(file))
+                continue;
+            const body = await readFile(file, "utf8").catch(() => "");
+            CUSTOM_PROPERTY.lastIndex = 0;
+            for (const m of body.matchAll(CUSTOM_PROPERTY)) {
+                if (scopeDeclares(m[1]) || declared.has(m[1]))
+                    continue;
+                declared.set(m[1], m[2].trim());
+                vars += 1;
+            }
+        }
+        if (vars > 0)
+            packages.push({ name: pkg.name, vars });
+    }
+    return { packages, declared };
+}

package/package.json

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