synthesisui 0.16.54 → 0.16.56

package/dist/commands/import.js

@@ -317,7 +317,31 @@ export async function takeCensus(root) {
         },
         propFiles: {},
     }));
-    const merged = [...inventory, ...fromTypes];
+    /**
+     * A composed component that is ALSO defined keeps its usage and gains the
+     * axes its type declares - the declaration wins per axis, because it is the
+     * closed set the author designed.
+     *
+     * Without this the usage silently truncated the contract: `MetricCard` is
+     * composed once with `size="xsm"`, so its axis had ONE option and was dropped
+     * by the two-option rule, while its type declares four sizes and three
+     * variants (dono, 31/07). The component would have reached the platform with
+     * no contract at all, which is the exact thing reading definitions was for.
+     *
+     * Carried BESIDE the usage rather than written into it. The first attempt
+     * merged the declaration into `props` and broke the two readings that need
+     * `props` to mean "what the code passed": the composition list started
+     * showing declared options as composed, and the dead-option check went quiet
+     * because every declared option now looked used.
+     */
+    const declaredBy = new Map(defined.map((d) => [d.name, d]));
+    const enriched = inventory.map((c) => {
+        const d = declaredBy.get(c.name);
+        if (!d || Object.keys(d.axes).length === 0)
+            return c;
+        return { ...c, declaredAxes: d.axes };
+    });
+    const merged = [...enriched, ...fromTypes];
     // The verdict travels WITH the payload: the platform reads one reading rather
     // than computing a second opinion from the same numbers, which is how two
     // implementations of the same judgement start disagreeing.

package/dist/doctor/crosswalk.js

@@ -238,6 +238,28 @@ export const TWIN_OVERLAP = 0.5;
  * the colour work learned twice: a ratio over a tiny set says nothing.
  */
 export const TWIN_MIN_SHARED = 2;
+/**
+ * Axes that measure rather than mean.
+ *
+ * Every component has a size, and `sm|md|lg` is the same three words in all of
+ * them - so a shared size scale is a shared SCALE, never a shared purpose. It
+ * paired a metric card with a text input at 50% (dono, 31/07), which is the
+ * kind of finding that teaches a person to stop reading the list.
+ *
+ * `intent`, `tone`, `status` and their kin are what say what a thing IS, and a
+ * pair needs at least one of those in common before its sizes count for
+ * anything.
+ */
+const DIMENSIONAL = new Set(["size", "density"]);
+/**
+ * Values that are the absence of a choice.
+ *
+ * `default` and `neutral` appear on almost every axis and mean "nothing in
+ * particular", so sharing them is not agreement. With sizes excluded, a metric
+ * card and a text input still paired because both offer a `default` variant
+ * (dono, 31/07) - the same false positive one level down.
+ */
+const UNCHOSEN = new Set(["neutral", "default", "none", "normal", "base"]);
 function sharedCount(a, b) {
     const va = new Set();
     const vb = new Set();
@@ -259,6 +281,29 @@ function sharedCount(a, b) {
             n += 1;
     return n;
 }
+/** Shared values on an axis that MEANS something, not one that measures. */
+function sharedMeaning(a, b) {
+    const pick = (x) => {
+        const out = new Set();
+        for (const [p, values] of Object.entries(x)) {
+            const axis = AXIS_SYNONYM[p.toLowerCase()];
+            if (!axis || DIMENSIONAL.has(axis))
+                continue;
+            for (const v of canonicalValues(values)) {
+                if (!UNCHOSEN.has(v))
+                    out.add(v);
+            }
+        }
+        return out;
+    };
+    const va = pick(a);
+    const vb = pick(b);
+    let n = 0;
+    for (const v of va)
+        if (vb.has(v))
+            n += 1;
+    return n;
+}
 export function crosswalk(components) {
     const mine = components.filter((c) => !c.from);
     // Two of THEIR components reading as the same catalogue entry is the
@@ -294,7 +339,8 @@ export function crosswalk(components) {
             overlap: axisOverlap(component.props, o.props),
         }))
             .filter((t) => t.overlap >= TWIN_OVERLAP &&
-            sharedCount(component.props, mine.find((m) => m.name === t.name)?.props ?? {}) >= TWIN_MIN_SHARED)
+            sharedCount(component.props, mine.find((m) => m.name === t.name)?.props ?? {}) >= TWIN_MIN_SHARED &&
+            sharedMeaning(component.props, mine.find((m) => m.name === t.name)?.props ?? {}) >= 1)
             .sort((a, b) => b.overlap - a.overlap);
         if (canonical && CATALOGUE[canonical]) {
             const alsoClaiming = (claims.get(canonical) ?? []).filter((n) => n !== component.name);

package/package.json

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