@1agh/maude 0.17.1 → 0.18.0

package/plugins/design/dev-server/build.ts

@@ -15,8 +15,8 @@
 //
 // Per DDR-009 (Bun runtime authoritative) + DDR-012 (React 19 unified) + DDR-014 (Lightning CSS).
 
-import { existsSync, mkdirSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { dirname, join, relative, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 import { browserslistToTargets, bundle as lcssBundle } from 'lightningcss';
@@ -65,13 +65,29 @@ function ensureDist() {
   if (!existsSync(DIST)) mkdirSync(DIST, { recursive: true });
 }
 
+async function readPluginVersion(): Promise<{ version: string }> {
+  // plugins/design/dev-server/ → plugins/design/.claude-plugin/plugin.json
+  const manifest = join(ROOT, '..', '.claude-plugin', 'plugin.json');
+  try {
+    const parsed = JSON.parse(await Bun.file(manifest).text()) as { version?: unknown };
+    if (typeof parsed.version === 'string') return { version: parsed.version };
+  } catch {
+    /* fall through to dev default */
+  }
+  return { version: 'dev' };
+}
+
 // ---------- (a) Client JSX bundle ----------
 
 async function buildClient(): Promise<{ outBytes: number; outPath: string }> {
   ensureDist();
   const outPath = join(DIST, 'client.bundle.js');
-  // Read package.json version at build time for the wordmark sub-line.
-  const pkg = JSON.parse(await Bun.file(join(ROOT, '..', '..', '..', 'package.json')).text());
+  // Wordmark sub-line version. Read from plugins/design/.claude-plugin/plugin.json —
+  // that file ships in both npm installs AND marketplace-cache clones (it's the
+  // plugin manifest, always present). The old `../../../package.json` hop
+  // resolved to the repo root in dev but ENOENT'd in marketplace caches where
+  // the maude bundle isn't installed as a package. DDR-044, Phase 19.
+  const pkg = await readPluginVersion();
   const result = await Bun.build({
     entrypoints: [join(ROOT, 'client/app.jsx')],
     outdir: DIST,
@@ -122,14 +138,117 @@ async function buildCss(): Promise<{ outBytes: number; outPath: string }> {
 
 // ---------- (c) Server binary (bun build --compile, per-platform) ----------
 
+// Per-target oxc-parser binding embed. Bun 1.3.4+ regressed `--compile` NAPI
+// native-binding embedding (see DDR-042-oxc-parser-bun-compile-workaround.md).
+// `with { type: 'file' }` requires a literal string path, so we generate one
+// thin entry file per --target whose only purpose is to (1) embed the matching
+// platform binding as an asset, (2) set NAPI_RS_NATIVE_LIBRARY_PATH from the
+// runtime virtual path, then (3) hand off to the real server.ts. ESM
+// evaluation order guarantees the env var is set before any downstream module
+// touches oxc-parser.
+
+// oxc-parser's NAPI-RS binding packages use a richer slug than our build
+// target slug — Linux needs the libc kind suffix, Windows needs the toolchain
+// suffix. Mirrored from oxc-parser/src-js/bindings.js loader cases.
+function oxcBindingSlug(slug: string): string {
+  if (slug === 'linux-x64') return 'linux-x64-gnu';
+  if (slug === 'linux-arm64') return 'linux-arm64-gnu';
+  if (slug === 'win32-x64') return 'win32-x64-msvc';
+  // darwin-arm64 / darwin-x64 / linux-x64-musl / linux-arm64-musl already match.
+  return slug;
+}
+
+// npm/bun's installer respects each package's `os`/`cpu` fields and skips
+// platform sub-packages whose filter doesn't match the host (the bindings
+// declare e.g. `"cpu": ["x64"]`). For cross-compile targets — most notably
+// darwin-x64 built on a darwin-arm64 CI runner — this means the matching
+// `@oxc-parser/binding-<oxcSlug>` is NOT in node_modules even though it's
+// listed as a direct devDependency. Fetch + extract the tarball manually so
+// `with { type: 'file' }` resolution succeeds during `bun build --compile`.
+async function ensureBindingForTarget(oxcSlug: string): Promise<void> {
+  const bindingDir = join(ROOT, 'node_modules', '@oxc-parser', `binding-${oxcSlug}`);
+  const bindingFile = join(bindingDir, `parser.${oxcSlug}.node`);
+  if (existsSync(bindingFile)) return; // host install already placed it
+
+  // Read the installed oxc-parser version so the tarball URL stays in sync.
+  // Walk up from build.ts to find the workspace-visible oxc-parser package.json
+  // (pnpm hoists it under node_modules/.pnpm, then symlinks at workspace level).
+  let oxcVersion = '0.131.0';
+  const candidates = [
+    join(ROOT, 'node_modules', 'oxc-parser', 'package.json'),
+    join(ROOT, '..', '..', '..', 'node_modules', 'oxc-parser', 'package.json'),
+  ];
+  for (const c of candidates) {
+    if (existsSync(c)) {
+      oxcVersion = JSON.parse(readFileSync(c, 'utf8')).version;
+      break;
+    }
+  }
+
+  console.log(`[build] cross-compile: fetching @oxc-parser/binding-${oxcSlug}@${oxcVersion}`);
+  const tarballUrl = `https://registry.npmjs.org/@oxc-parser/binding-${oxcSlug}/-/binding-${oxcSlug}-${oxcVersion}.tgz`;
+  const response = await fetch(tarballUrl);
+  if (!response.ok) {
+    throw new Error(`failed to fetch ${tarballUrl}: HTTP ${response.status}`);
+  }
+  const tmpTgz = join(ROOT, `.binding-${oxcSlug}.tgz`);
+  await Bun.write(tmpTgz, await response.arrayBuffer());
+  mkdirSync(bindingDir, { recursive: true });
+  // npm pack output: `package/parser.<oxcSlug>.node` + `package/package.json`.
+  // --strip-components=1 drops the leading `package/` so files land in bindingDir.
+  const tarProc = Bun.spawn(['tar', 'xf', tmpTgz, '-C', bindingDir, '--strip-components=1'], {
+    stdout: 'inherit',
+    stderr: 'inherit',
+  });
+  const tarCode = await tarProc.exited;
+  if (tarCode !== 0)
+    throw new Error(`tar extraction failed for binding-${oxcSlug} (exit ${tarCode})`);
+  unlinkSync(tmpTgz);
+}
+
+export function writeCompileEntry(target: PlatformTarget): string {
+  const slug = platformSlug(target);
+  const oxcSlug = oxcBindingSlug(slug);
+  const entryDir = join(DIST, '.compile-entries');
+  mkdirSync(entryDir, { recursive: true });
+
+  // ESM hoists `import` statements above top-level code, so the env-var
+  // assignment MUST live in a separate leaf module that's imported BEFORE
+  // server.ts — otherwise server.ts (and transitively oxc-parser) evaluates
+  // first and reads NAPI_RS_NATIVE_LIBRARY_PATH before we set it.
+  const initPath = join(entryDir, `init-oxc-${slug}.ts`);
+  const entryPath = join(entryDir, `server-${slug}.ts`);
+  const bindingSpec = `@oxc-parser/binding-${oxcSlug}/parser.${oxcSlug}.node`;
+  const initContent = `// AUTO-GENERATED by build.ts — do not edit by hand.
+// Per-target oxc-parser binding embed (Bun 1.3.4+ --compile NAPI regression
+// workaround — see .ai/decisions/DDR-042-oxc-parser-bun-compile-workaround.md).
+// Side-effect module: must be imported BEFORE any oxc-parser usage.
+import bindingPath from ${JSON.stringify(bindingSpec)} with { type: 'file' };
+process.env.NAPI_RS_NATIVE_LIBRARY_PATH = bindingPath;
+`;
+  writeFileSync(initPath, initContent);
+
+  // Forward slashes for the import specifier even on Windows hosts — ESM uses
+  // POSIX-style paths, not the host's filesystem separator.
+  const realServerRel = relative(entryDir, join(ROOT, 'server.ts')).split('\\').join('/');
+  const entryContent = `// AUTO-GENERATED by build.ts — do not edit by hand.
+// Per-target compile entry — see DDR-042-oxc-parser-bun-compile-workaround.md.
+import './init-oxc-${slug}.ts';
+import ${JSON.stringify(realServerRel)};
+`;
+  writeFileSync(entryPath, entryContent);
+  return entryPath;
+}
+
 async function buildServerBinary(target: PlatformTarget): Promise<{ outPath: string }> {
   ensureDist();
   const slug = platformSlug(target);
   const ext = slug.startsWith('win32') ? '.exe' : '';
   const outPath = join(DIST, `maude-${slug}${ext}`);
-  const entry = join(ROOT, 'server.ts');
-  if (!existsSync(entry)) {
-    // T7 not landed yet — fall back to the .mjs entry so this script remains runnable mid-migration.
+  const realEntry = join(ROOT, 'server.ts');
+  if (!existsSync(realEntry)) {
+    // Legacy fallback — pre-DDR-009 .mjs path. Doesn't use oxc-parser, so the
+    // 1.3.4+ regression doesn't apply; entry stub generator is skipped.
     const legacy = join(ROOT, 'server.mjs');
     if (!existsSync(legacy)) throw new Error(`Neither server.ts nor server.mjs exists in ${ROOT}`);
     const proc = Bun.spawn(
@@ -150,6 +269,10 @@ async function buildServerBinary(target: PlatformTarget): Promise<{ outPath: str
       throw new Error(`bun build --compile (legacy) failed for ${target} (exit ${code})`);
     return { outPath };
   }
+  // Make sure the target's NAPI binding is on disk even if bun/npm's os/cpu
+  // filter skipped it (cross-compile case — see ensureBindingForTarget docs).
+  await ensureBindingForTarget(oxcBindingSlug(slug));
+  const entry = writeCompileEntry(target);
   const proc = Bun.spawn(
     [
       'bun',
@@ -262,6 +385,11 @@ async function main() {
   }
 }
 
-await main();
+// Only run the build when invoked directly — importers (e.g. the test suite,
+// which calls `writeCompileEntry` from build.ts) should not trigger a dev
+// build as a side effect.
+if (import.meta.main) {
+  await main();
+}
 
 export { buildClient, buildCss, buildServerBinary, PLATFORM_MATRIX, type PlatformTarget };

package/plugins/design/dev-server/canvas-pipeline.ts

@@ -16,6 +16,11 @@
 // Toolchain matches scripts/migrate-canvases.ts (codemod) and canvas-edit.ts
 // (AST-aware /design:edit element edits) — same oxc-parser + magic-string pair
 // in three call sites, one mental model.
+//
+// `bun build --compile` requires a per-target entry stub that sets
+// NAPI_RS_NATIVE_LIBRARY_PATH before this file's transitive imports load
+// oxc-parser. The pipeline itself is unaware of the workaround — it's a
+// build-layer concern. See DDR-042-oxc-parser-bun-compile-workaround.md.
 
 import MagicString from 'magic-string';
 import { parseSync } from 'oxc-parser';

package/plugins/design/dev-server/config.schema.json

@@ -116,6 +116,18 @@
       },
       "default": ["accent"]
     },
+    "accentStrategy": {
+      "type": "string",
+      "description": "How many --accent* families exist. The completeness-critic C7 gates the actual family count against this declaration. Default: 'single' (backwards-compatible). 'chromatic-N' is parameterized — write the literal N (e.g. 'chromatic-5'). Per DDR-043.",
+      "pattern": "^(single|paired|chromatic-[1-9][0-9]?)$",
+      "default": "single"
+    },
+    "colorSpace": {
+      "type": "string",
+      "enum": ["oklch", "hsl", "hex", "lab"],
+      "description": "Color space the project uses in tokens CSS. The completeness-critic V2 gates the actual token format against this declaration. Default: 'oklch' (backwards-compatible). Per DDR-043.",
+      "default": "oklch"
+    },
     "designSystems": {
       "type": "array",
       "description": "Design systems available in this project. Single-DS projects have one entry; multi-DS projects (marketing vs. admin vs. mobile) list each here. Each canvas's .meta.json declares which DS it uses via the 'designSystem' field.",