synthesisui 0.16.22 → 0.16.25

package/dist/cn-codegen.js

@@ -104,9 +104,26 @@ const PREFIXES = [
   "gap-x", "gap-y", "gap",
   "w", "h", "min-w", "min-h", "max-w", "max-h",
   "leading", "tracking",
-  "flex", "grid", "justify", "items", "self", "order", "z",
+  "justify-items", "justify-self", "justify",
+  "items", "self", "order", "z",
 ];
 
+/**
+ * Utilities that set \`display\`. One group, so \`hidden\` can evict \`flex\` -
+ * and kept OUT of the prefix walk, because \`flex\` also heads whole families
+ * that set OTHER properties. Read as a prefix, \`flex-row\` evicted the \`flex\`
+ * that makes the box a flex container, and every Row and Stack in the project
+ * stacked its children in silence. Found by an agent in the field (test03,
+ * 29/07), diagnosed against computed output, fixed locally, and FILED - this
+ * is its fix, ported to the source so it stops evaporating on regeneration.
+ */
+const DISPLAYS = new Set([
+  "flex", "grid", "block", "inline", "inline-flex", "inline-grid",
+  "inline-block", "hidden", "contents", "flow-root", "table", "list-item",
+]);
+const FLEX_DIRECTIONS = new Set(["row", "col", "row-reverse", "col-reverse"]);
+const FLEX_WRAPS = new Set(["wrap", "nowrap", "wrap-reverse"]);
+
 /**
  * The property this class sets, or the class itself when we cannot tell.
  *
@@ -124,10 +141,23 @@ function groupOf(cls: string): string {
   const negative = base.startsWith("-");
   if (negative) base = base.slice(1);
 
+  if (DISPLAYS.has(base)) return \`\${variants}display\`;
+
   const dash = base.indexOf("-");
   const head = dash === -1 ? base : base.slice(0, dash);
   const rest = dash === -1 ? "" : base.slice(dash + 1);
 
+  if (head === "flex") {
+    if (FLEX_DIRECTIONS.has(rest)) return \`\${variants}flex-direction\`;
+    if (FLEX_WRAPS.has(rest)) return \`\${variants}flex-wrap\`;
+    return \`\${variants}flex\`; // flex-1 / flex-auto / flex-none / flex-initial
+  }
+  if (head === "grid") {
+    // grid-cols-* / grid-rows-* / grid-flow-* each own their property.
+    const sub = rest.indexOf("-") === -1 ? rest : rest.slice(0, rest.indexOf("-"));
+    return \`\${variants}grid-\${sub}\`;
+  }
+
   // The two families a prefix cannot settle, answered by this system's names.
   if (head === "text") {
     if (TEXT_SIZES.has(rest)) return \`\${variants}font-size\`;

package/dist/commands/sync.js

@@ -0,0 +1,98 @@
+import { readdir, readFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { readToken, resolveRegistry } from "../config.js";
+import { readEvents } from "../doctor/ledger.js";
+import { readRequests } from "../doctor/requests.js";
+import { body, section } from "../output.js";
+/**
+ * `synthesisui sync` - the ledger travels, because a person said so.
+ *
+ * The hook writes the ledger and NEVER touches the network; the doctor reads
+ * it and never sends it. This command is the one place the record leaves the
+ * machine, and it only runs by hand. That split is load-bearing: a check that
+ * phones home is a check that gets uninstalled, and the entire governance
+ * stack stands on the check staying installed.
+ *
+ * What it buys: the dashboard answer to the question a design-system lead
+ * asks before paying for anything - is my team's drift going up or down? Run
+ * it after a session, from CI after a merge, or never; the local record is
+ * complete either way.
+ *
+ * Re-running is free and safe. The server dedupes events on their identity
+ * and treats the request queue as a snapshot, so the local files remain the
+ * single source of truth.
+ */
+export async function sync(opts) {
+    const root = resolve(opts.dir ?? process.cwd());
+    const base = resolveRegistry(opts.registry);
+    const token = await readToken();
+    if (!token) {
+        console.log(section("Sync"));
+        console.log(body("Not logged in. The record stays local until you say so:"));
+        console.log(body("    synthesisui login"));
+        return;
+    }
+    // Which system does this project's record belong to? The .lock says.
+    const dsDir = join(root, "_synthesisui", "ds");
+    let slug = null;
+    try {
+        const slugs = (await readdir(dsDir, { withFileTypes: true }))
+            .filter((e) => e.isDirectory())
+            .map((e) => e.name);
+        for (const s of slugs) {
+            const raw = await readFile(join(dsDir, s, ".lock"), "utf8").catch(() => "");
+            try {
+                const lock = JSON.parse(raw);
+                // An adopted system is described, not owned on the platform - there is
+                // no dashboard row to sync into (yet).
+                if (lock.slug && !lock.adopted) {
+                    slug = lock.slug;
+                    break;
+                }
+            }
+            catch {
+                // unreadable lock - try the next
+            }
+        }
+    }
+    catch {
+        // no _synthesisui at all
+    }
+    if (!slug) {
+        console.log(section("Sync"));
+        console.log(body("No installed system here, so there is nowhere to sync to."));
+        return;
+    }
+    const events = await readEvents(root);
+    const requests = await readRequests(root);
+    if (events.length === 0 && requests.length === 0) {
+        console.log(section("Sync"));
+        console.log(body("Nothing recorded yet. The record fills as the hook checks writes and doctor runs."));
+        return;
+    }
+    const res = await fetch(`${base}/api/ledger`, {
+        method: "POST",
+        headers: {
+            "content-type": "application/json",
+            Authorization: `Bearer ${token}`,
+        },
+        body: JSON.stringify({ slug, events, requests }),
+    }).catch(() => null);
+    if (!res) {
+        console.log(section("Sync"));
+        console.log(body("Could not reach the registry. The record is safe locally."));
+        return;
+    }
+    if (!res.ok) {
+        const err = (await res.json().catch(() => ({})));
+        console.log(section("Sync"));
+        console.log(body(err.message ?? `The registry answered ${res.status}.`));
+        return;
+    }
+    const out = (await res.json());
+    console.log(section("Sync"));
+    console.log(body(`${out.eventsReceived} checks sent, ${out.eventsNew} new. ${out.requestsNow} open request${out.requestsNow === 1 ? "" : "s"}.`));
+    console.log("");
+    console.log(body(`The record lives on your system's overview:`));
+    console.log(body(`    ${base}/dashboard/mine/${slug}`));
+}

package/dist/fonts.js

@@ -62,7 +62,17 @@ export function nextFontSnippet(families, slug, appDir = "app") {
         if (!seen.has(name)) {
             seen.set(name, role);
             importNames.push(importName(name));
-            consts.push(`export const ${seen.get(name)} = ${importName(name)}({`, `  subsets: ["latin"],`, `  variable: "--font-ds-${seen.get(name)}",`, `});`);
+            consts.push(`export const ${seen.get(name)} = ${importName(name)}({`, `  subsets: ["latin"],`, 
+            // WEIGHTS ARE ALWAYS SPELLED OUT, because next/font only allows
+            // omitting them for VARIABLE fonts - and plenty of Google families
+            // ship as static cuts (IBM Plex Mono, for one). The generated file
+            // assumed variable and broke the consumer's first `next build`; an
+            // agent caught it in the field (test03, 29/07) and had to repair our
+            // output by hand. Explicit weights are valid for BOTH kinds, so
+            // emitting them always can never break - and these three are the
+            // steps every generated system actually uses (regular/medium/
+            // semibold), so no static cut is downloaded for nothing.
+            `  weight: ["400", "500", "600"],`, `  variable: "--font-ds-${seen.get(name)}",`, `});`);
         }
     }
     const fontsFile = [

package/dist/index.js

@@ -15,6 +15,7 @@ import { login } from "./commands/login.js";
 import { mcp } from "./commands/mcp.js";
 import { refit } from "./commands/refit.js";
 import { request } from "./commands/request.js";
+import { sync } from "./commands/sync.js";
 import { template } from "./commands/template.js";
 import { upgrade } from "./commands/upgrade.js";
 import { use } from "./commands/use.js";
@@ -331,6 +332,9 @@ async function main() {
         case "clean":
             await clean({ dir, force: flags.force === true });
             break;
+        case "sync":
+            await sync({ dir, registry });
+            break;
         case "request": {
             // `synthesisui request` lists; `request component --name x --for "..."`
             // files; `request --done <id>` closes. The agent's front door is the MCP

package/package.json

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