synthesisui 0.16.82 → 0.16.84

package/dist/doctor/variant-read.js

@@ -525,6 +525,116 @@ export function readInlineConditions(source) {
     }
     return layers;
 }
+/**
+ * A LOOKUP RECORD - the shape 16 of 35 components in a real library use, against 2 for
+ * `cva`.
+ *
+ *     const colorStyles: Record<TagColor, string> = {
+ *       primary: "bg-ocean-500 text-white",
+ *       danger:  "bg-danger-400 text-white",
+ *     };
+ *     className={cn("inline-flex px-2.5 rounded-full", colorStyles[color], className)}
+ *
+ * As structured as `cva` and more common by five to one. The first version of this file
+ * read `cva` and the conditional expression - the two shapes I assumed - and covered 6%
+ * of the library. Enumerating first is the rule that produced this function (dono, 01/08).
+ *
+ * THE PROP COMES FROM THE INDEX, not from the record's name. `colorStyles[color]` says
+ * the axis is `color`; the variable could be called anything. When the index is not a
+ * bare identifier - `styles[key]`, `map[a ?? b]` - the axis is unknowable and the record
+ * is skipped rather than attached to a guess.
+ */
+const LOOKUP_RECORD = /(?:const|let)\s+([A-Za-z_$][\w$]*)\s*(?::\s*(?:Record|Partial<Record)<[^>]*>+)?\s*=\s*\{/g;
+/** `colorStyles[color]` - the record, and the prop that indexes it. */
+const RECORD_INDEX = /([A-Za-z_$][\w$]*)\s*\[\s*([A-Za-z_$][\w$]*)\s*\]/g;
+export function readLookupRecords(source, 
+/** Filled with axis → options, because the axis NAMES have to travel too: a first pass
+ *  sent the styles and not the names, so a Tag with eight colours reported no axis at
+ *  all (probe, 01/08). */
+axesOut) {
+    const clean = stripComments(source);
+    // Which prop indexes which record. Read first, because a record nobody indexes is a
+    // constant rather than a variant axis.
+    const axisOf = new Map();
+    RECORD_INDEX.lastIndex = 0;
+    for (const m of clean.matchAll(RECORD_INDEX)) {
+        if (!axisOf.has(m[1]))
+            axisOf.set(m[1], m[2]);
+    }
+    const layers = [];
+    LOOKUP_RECORD.lastIndex = 0;
+    for (const m of clean.matchAll(LOOKUP_RECORD)) {
+        const symbol = m[1];
+        const axis = axisOf.get(symbol);
+        if (!axis)
+            continue;
+        const open = (m.index ?? 0) + m[0].length - 1;
+        const end = endOf(clean, open);
+        if (end === -1)
+            continue;
+        const entries = topLevelEntries(clean.slice(open + 1, end - 1));
+        // Two options is what makes a closed set somebody chose from - the same rule the
+        // contract writer and the doctor already follow.
+        const options = entries.filter((e) => literalClasses(e.value).length > 0);
+        if (options.length < 2)
+            continue;
+        if (axesOut) {
+            const names = options.map((o) => o.key);
+            axesOut[axis] = [...new Set([...(axesOut[axis] ?? []), ...names])];
+        }
+        for (const option of options) {
+            const per = splitByCondition(literalClasses(option.value), {
+                [axis]: option.key,
+            });
+            layers.push(...per.layers);
+        }
+    }
+    return layers;
+}
+/**
+ * A TERNARY BETWEEN TWO CLASS LITERALS - 8 of 35 in the same library.
+ *
+ *     className={cn("base", isActive ? "bg-ocean-500" : "bg-transparent")}
+ *
+ * Both branches are a look, so both are a layer: the truthy one under the prop being
+ * `true` and the falsy one under `false`. Reading only the truthy half would say the
+ * component has one conditional look when it has two.
+ */
+const CLASS_TERNARY = /([!A-Za-z_$][\w$.!]*)\s*(?:===\s*["']([^"']+)["']\s*)?\?\s*["']([^"']*)["']\s*:\s*["']([^"']*)["']/g;
+export function readClassTernaries(source) {
+    const layers = [];
+    CLASS_TERNARY.lastIndex = 0;
+    for (const m of stripComments(source).matchAll(CLASS_TERNARY)) {
+        const negated = m[1].startsWith("!");
+        const prop = m[1].replace(/^!/, "").split(".").pop() ?? "";
+        if (!prop)
+            continue;
+        // `x === "solid" ? a : b` names the option; a bare `x ? a : b` is the boolean, and a
+        // negated condition swaps which branch means true.
+        const whenTrue = m[2] ?? (negated ? "false" : "true");
+        const whenFalse = m[2] ? null : negated ? "true" : "false";
+        for (const [option, raw] of [
+            [whenTrue, m[3]],
+            [whenFalse, m[4]],
+        ]) {
+            if (!option)
+                continue;
+            const classes = raw.split(/\s+/).filter(Boolean);
+            if (classes.length === 0)
+                continue;
+            const per = splitByCondition(classes, { [prop]: option });
+            layers.push(...per.layers);
+        }
+    }
+    return layers;
+}
+/**
+ * A LOOKUP INDEXED BY A TERNARY, which is how the same record serves a boolean.
+ *
+ * Left out on purpose, and said so rather than half-read: `styles[selected ? "on" : "off"]`
+ * would need both the record and the condition resolved together, and the enumeration
+ * found exactly four of them in 530 files. Four is not worth a wrong reading.
+ */
 /**
  * The whole reading of one file's variant styling, transcribed - ready for a recipe.
  *
@@ -533,7 +643,13 @@ export function readInlineConditions(source) {
  */
 export function transcribeVariants(source, declared) {
     const reads = readVariants(source);
-    const inline = readInlineConditions(source);
+    const fromRecords = {};
+    const inline = [
+        ...readInlineConditions(source),
+        // The two shapes the enumeration found to be five times more common than `cva`.
+        ...readLookupRecords(source, fromRecords),
+        ...readClassTernaries(source),
+    ];
     const axes = {};
     const defaults = {};
     const allLayers = [];
@@ -553,6 +669,10 @@ export function transcribeVariants(source, declared) {
         }
     }
     allLayers.push(...inline);
+    for (const [axis, options] of Object.entries(fromRecords)) {
+        if (options.length >= 2)
+            axes[axis] = options;
+    }
     const layers = allLayers
         .map((layer) => {
         /**

package/dist/skill-import.js

@@ -537,6 +537,49 @@ extensions are configured at construction, not toggled later
 of their manifest and attaches it (\`"^2.1.0 in packages/ui"\`), so the rule does not go stale the
 day they upgrade and the information is not lost either.
 
+### Ask what a recipe can hold, BEFORE you write one
+
+\`\`\`
+recipe_vocabulary          what a recipe CAN hold - states, forms, the floor per kind
+validate_recipe(name, r)   would this survive? what would NOT, by name
+\`\`\`
+
+Both are MCP tools on the \`synthesisui\` server. **Call \`recipe_vocabulary\` once, at the
+start**, and work from what it says rather than from what you remember - it is served from
+the live contract, so it is right about a state that was added last week and this file is
+not.
+
+Then **validate every recipe before you send it.** This is not a formality. Nothing checked
+a recipe before these tools existed, and four separate readings were lost in silence: a
+\`dark:\` inside a variant, a state the compiler cannot spell, a part name with a dot in it,
+a layer with an empty style. Each of those was correct work that arrived as nothing.
+
+\`validate_recipe\` never answers yes or no. It answers with what would not survive:
+
+\`\`\`
+REFUSED by the contract        fix it or the WHOLE recipe is dropped
+HELD BY THE SCHEMA AND         the silent half - it validates, it compiles to nothing.
+DROPPED BY THE COMPILER        This is the one worth fixing before sending.
+BELOW THE FLOOR                it would arrive and not be drawable
+\`\`\`
+
+### Write down what we could not hold
+
+Everything \`validate_recipe\` reports goes into \`_synthesisui/not-expressed.md\`, appended
+per component:
+
+\`\`\`
+## MetricCard
+- layers[2].when.scheme … (what the validator said, VERBATIM)
+- below the floor: a fill, so it reads as a surface rather than as bare text
+- the source you read, quoted, so the gap can be checked without opening their repo
+\`\`\`
+
+**Verbatim, and with the source beside it.** This file is how a gap on OUR side gets fixed
+instead of being worked around: said only in chat it evaporates, and paraphrased it becomes
+unfindable. If the file ends up empty, say so - that is the good outcome and it is worth
+one line.
+
 ### The floor: what a preview needs before it can draw anything
 
 The owner asked this directly - "to render the button, what do I need to have?" - and the
@@ -599,6 +642,9 @@ found them wastes a turn and risks contradicting the measurement:
 - **whether a component forwards the rest of its props**, and which it names
 - **which components appear inside which** at their call sites, as pairs
 - **the folder architecture**, and it will ask you which one has priority
+- **which of your components are ours**, matched against the LIVE catalogue rather than a
+  list baked into the CLI. If a run says it fell back to the built-in names, the match is a
+  smaller answer than it should be and the reason is on screen
 
 What is still yours: the anatomy tree, the part names, the frontiers, the roles, the
 concept, and the rules that are not about a class name.

package/package.json

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