synthesisui 0.16.306 → 0.16.307

package/dist/commands/import.js

@@ -34,6 +34,7 @@ import { buildLedger, describeLedger, } from "../doctor/style-ledger.js";
 import { MUI_DEFAULT_SPACING, readStyledComponents, spacingOf, } from "../doctor/style-props.js";
 import { buildTable } from "../doctor/tokens.js";
 import { definitionSpan, parseClass, readInlineStyle, rootClasses, rootTag, transcribe, } from "../doctor/transcribe.js";
+import { accountClasses, invariantHolds, sumAccounts, } from "../doctor/value-ledger.js";
 import { transcribeVariants } from "../doctor/variant-read.js";
 import { frontierKind, packageRoot } from "../frontier-kind.js";
 import { keyframesInSheets } from "../global-keyframes.js";
@@ -2105,6 +2106,25 @@ export async function takeCensus(root, opts) {
         const target = c?.canonical ?? (c?.bucket === "exclusive" ? c.name : null);
         return target ? safePartName(target) : null;
     }, (pkg) => versions[pkg]);
+    /**
+     * A CONTABILIDADE POR VALOR, contada AQUI porque o material é daqui: os tokens de classe que
+     * vestem cada componente admitido (os nós do sketch e as camadas condicionais cruas), contra
+     * os tokens que o CSS dele declara. Ver `Census.values` e `doctor/value-ledger.ts` - é a
+     * reconciliação do item 11, e a soma fecha com `seen` por construção.
+     */
+    const valueByComponent = {};
+    for (const [lookName, look] of Object.entries(looks)) {
+        const tokens = [];
+        for (const node of look.sketch ?? []) {
+            tokens.push(...(node.classes ?? "").split(/\s+/).filter(Boolean));
+        }
+        for (const layer of look.rawLayers ?? [])
+            tokens.push(...layer.classes);
+        if (tokens.length > 0) {
+            valueByComponent[lookName] = accountClasses(tokens, declaredValues);
+        }
+    }
+    const valuesTotal = sumAccounts(Object.values(valueByComponent));
     return {
         census: 1,
         project: {
@@ -2261,6 +2281,19 @@ export async function takeCensus(root, opts) {
                 },
             }
             : {}),
+        /**
+         * A conta por VALOR - ver o tipo. Ausente quando nenhum componente veste classe, e ausente
+         * quando a soma não fecha: uma conta que viola a própria invariante é bug NOSSO, e um censo
+         * sem o campo é honesto enquanto um campo errado governaria telas. Hoje ela fecha por
+         * construção; o portão existe para o dia em que uma derivação (a engine do D3) não fechar.
+         */
+        ...(valuesTotal.seen > 0 && invariantHolds(valuesTotal)
+            ? {
+                values: {
+                    classes: { ...valuesTotal, byComponent: valueByComponent },
+                },
+            }
+            : {}),
         ...(architectures.length > 0
             ? {
                 architectures: architectures.slice(0, 6).map((a) => ({

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/install-marks.js

@@ -288,7 +288,17 @@ 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.
+ */
+export const READER_SINCE = "0.16.307";
 /**
  * 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.306",
+  "version": "0.16.307",
   "description": "Bring SynthesisUI design systems into any project - tokens, typed components, whole pages and an agent-ready CLAUDE.md manifest.",
   "type": "module",
   "bin": {