synthesisui 0.16.53 → 0.16.55

package/dist/commands/import.js

@@ -317,7 +317,25 @@ 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.
+     */
+    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, props: { ...c.props, ...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.
@@ -388,9 +406,13 @@ function summarize(c) {
     // The inventory, phase one: what this project composes. Printed, never
     // mapped - deciding that their `Pill` is our `ds-badge` is a judgement a
     // person approves, and it does not happen in a census.
-    if (c.components && c.components.length > 0) {
-        const withProps = c.components.filter((x) => Object.keys(x.props).length > 0).length;
-        console.log(body(`${c.components.length} components composed here, ${withProps} of them with props written literally`));
+    // COMPOSED means composed. The payload also carries components that are only
+    // DECLARED (a library exports what it never uses), and counting those here
+    // made the line say 108 where 80 things are actually composed (dono, 31/07).
+    const composedOnly = (c.components ?? []).filter((x) => x.count > 0);
+    if (composedOnly.length > 0) {
+        const withProps = composedOnly.filter((x) => Object.keys(x.props).length > 0).length;
+        console.log(body(`${composedOnly.length} components composed here, ${withProps} of them with props written literally`));
     }
     if (c.totals.named > 0) {
         console.log(body(`${paint.strong(String(c.totals.named))} of those values ALREADY have a name in your system - ${c.totals.coverage}% of your design values come from it today`));
@@ -422,7 +444,7 @@ function printComponents(c) {
     if (list.length === 0)
         return;
     console.log("");
-    const mine = list.filter((x) => !x.from);
+    const mine = list.filter((x) => !x.from && x.count > 0);
     const theirs = list.filter((x) => x.from);
     console.log(section("What this project composes"));
     if (theirs.length > 0) {
@@ -439,7 +461,7 @@ function printComponents(c) {
     if (mine.length > 12) {
         console.log(body(paint.faint(`(${mine.length - 12} more of yours)`)));
     }
-    printCrosswalk(mine);
+    printCrosswalk(list.filter((x) => !x.from));
     printObserved(mine);
     printDefined(c, mine);
 }
@@ -468,7 +490,10 @@ function printDefined(census, used) {
     if (withAxes.length > 8) {
         console.log(body(paint.faint(`  (${withAxes.length - 8} more)`)));
     }
-    const crossed = reconcile(defined, used);
+    // Orphans are found by asking what has no USAGE, so this has to see the
+    // composed list alone: handing it the union made every declared component
+    // look used by itself, and 29 orphans became 1.
+    const crossed = reconcile(defined, used.filter((u) => u.count > 0));
     const dead = crossed.filter((r) => r.deadOptions.length > 0);
     const stray = crossed.filter((r) => r.undeclared.length > 0);
     const orphans = crossed.filter((r) => r.orphan);

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