@mmapp/react-compiler 0.1.0-alpha.10 → 0.1.0-alpha.12

package/dist/cli/index.js

@@ -10805,6 +10805,10 @@ async function build(options = {}) {
             definitions: [],
             errorDetails: typeErrors
           };
+        } else if (output.includes("not the tsc command") || output.includes("Cannot find module") || output.includes("ERR_MODULE_NOT_FOUND") || output.includes("command not found")) {
+          console.warn(`[mindmatrix-react] TypeScript not installed \u2014 skipping type check.`);
+          console.warn(`  Run \`npm install\` to enable type checking, or use --skip-type-check.
+`);
         } else {
           console.error(`
 [mindmatrix-react] Type check failed:
@@ -14230,8 +14234,8 @@ function saveCredentials(apiUrl, token) {
   creds[apiUrl] = { token, savedAt: (/* @__PURE__ */ new Date()).toISOString() };
   (0, import_fs5.writeFileSync)(CREDENTIALS_PATH, JSON.stringify(creds, null, 2), "utf-8");
   try {
-    const { chmodSync } = require("fs");
-    chmodSync(CREDENTIALS_PATH, 384);
+    const { chmodSync: chmodSync2 } = require("fs");
+    chmodSync2(CREDENTIALS_PATH, 384);
   } catch {
   }
 }
@@ -14259,7 +14263,7 @@ function resolveToken(apiUrl, explicitToken) {
   return null;
 }
 function prompt(question, hidden = false) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const rl = (0, import_readline.createInterface)({
       input: process.stdin,
       output: process.stdout
@@ -14279,12 +14283,12 @@ function prompt(question, hidden = false) {
         process.stdout.write = origWrite;
         console.log();
         rl.close();
-        resolve6(answer.trim());
+        resolve7(answer.trim());
       });
     } else {
       rl.question(question, (answer) => {
         rl.close();
-        resolve6(answer.trim());
+        resolve7(answer.trim());
       });
     }
   });
@@ -14370,6 +14374,465 @@ var init_auth = __esm({
   }
 });
 
+// src/cli/engine-binary.ts
+var engine_binary_exports = {};
+__export(engine_binary_exports, {
+  GITHUB_RELEASE_BASE: () => GITHUB_RELEASE_BASE,
+  MANAGED_BINARY_PATH: () => MANAGED_BINARY_PATH,
+  METADATA_PATH: () => METADATA_PATH,
+  VERSION_FILE_PATH: () => VERSION_FILE_PATH,
+  askUser: () => askUser,
+  buildDownloadUrl: () => buildDownloadUrl,
+  buildFromSource: () => buildFromSource,
+  detectPlatform: () => detectPlatform,
+  downloadBinary: () => downloadBinary,
+  ensureEngineBinary: () => ensureEngineBinary,
+  findEngineBinary: () => findEngineBinary,
+  getCachedVersion: () => getCachedVersion,
+  getEngineStatus: () => getEngineStatus,
+  hasCargoInstalled: () => hasCargoInstalled,
+  healthCheck: () => healthCheck,
+  installEngine: () => installEngine,
+  printInstallGuide: () => printInstallGuide,
+  readMetadata: () => readMetadata,
+  requireEngineBinary: () => requireEngineBinary,
+  setCachedVersion: () => setCachedVersion,
+  verifyBinary: () => verifyBinary,
+  writeMetadata: () => writeMetadata
+});
+function detectPlatform() {
+  const os = (0, import_os2.platform)();
+  const a = (0, import_os2.arch)();
+  let triple;
+  let releasePlatform = null;
+  if (os === "linux" && a === "x64") {
+    triple = "x86_64-unknown-linux-gnu";
+    releasePlatform = "linux-x64";
+  } else if (os === "linux" && a === "arm64") {
+    triple = "aarch64-unknown-linux-gnu";
+    releasePlatform = "linux-arm64";
+  } else if (os === "darwin" && a === "x64") {
+    triple = "x86_64-apple-darwin";
+    releasePlatform = "darwin-x64";
+  } else if (os === "darwin" && a === "arm64") {
+    triple = "aarch64-apple-darwin";
+    releasePlatform = "darwin-arm64";
+  } else if (os === "win32" && a === "x64") {
+    triple = "x86_64-pc-windows-msvc";
+    releasePlatform = "windows-x64";
+  } else {
+    triple = `${a}-unknown-${os}`;
+  }
+  return { os, arch: a, triple, releasePlatform };
+}
+function getCachedVersion() {
+  try {
+    if ((0, import_fs6.existsSync)(VERSION_FILE_PATH)) {
+      return (0, import_fs6.readFileSync)(VERSION_FILE_PATH, "utf-8").trim();
+    }
+  } catch {
+  }
+  return null;
+}
+function setCachedVersion(version) {
+  (0, import_fs6.mkdirSync)(MMRC_BIN_DIR, { recursive: true });
+  (0, import_fs6.writeFileSync)(VERSION_FILE_PATH, version, "utf-8");
+}
+function readMetadata() {
+  try {
+    if (!(0, import_fs6.existsSync)(METADATA_PATH)) return null;
+    return JSON.parse((0, import_fs6.readFileSync)(METADATA_PATH, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writeMetadata(meta) {
+  (0, import_fs6.mkdirSync)(MMRC_BIN_DIR, { recursive: true });
+  (0, import_fs6.writeFileSync)(METADATA_PATH, JSON.stringify(meta, null, 2), "utf-8");
+}
+async function verifyBinary(binaryPath) {
+  if (!(0, import_fs6.existsSync)(binaryPath)) {
+    return { ok: false, error: `Binary not found at ${binaryPath}` };
+  }
+  return new Promise((resolve7) => {
+    try {
+      const proc = (0, import_child_process2.spawn)(binaryPath, ["--version"], {
+        stdio: ["ignore", "pipe", "pipe"],
+        timeout: 1e4
+      });
+      let stdout = "";
+      let stderr = "";
+      proc.stdout?.on("data", (d) => {
+        stdout += d.toString();
+      });
+      proc.stderr?.on("data", (d) => {
+        stderr += d.toString();
+      });
+      proc.on("error", (err) => {
+        resolve7({ ok: false, error: `Failed to execute: ${err.message}` });
+      });
+      proc.on("close", (code) => {
+        if (code === 0) {
+          const output = stdout.trim() || stderr.trim();
+          const version = output.replace(/^mm[-_](?:server|api)\s*/i, "").trim() || "unknown";
+          resolve7({ ok: true, version });
+        } else {
+          resolve7({ ok: false, error: `Exited with code ${code}. ${stderr.trim()}` });
+        }
+      });
+    } catch (e) {
+      resolve7({ ok: false, error: `Spawn failed: ${e instanceof Error ? e.message : String(e)}` });
+    }
+  });
+}
+async function healthCheck(url, timeoutMs = 5e3) {
+  try {
+    const resp = await fetch(url, { signal: AbortSignal.timeout(timeoutMs) });
+    if (resp.ok) {
+      const data = await resp.json();
+      return { ok: true, version: data.version, db: data.database };
+    }
+    return { ok: resp.status < 500 };
+  } catch {
+    return { ok: false };
+  }
+}
+async function getEngineStatus(explicitPath) {
+  const plat = detectPlatform();
+  const resolution = findEngineBinary(explicitPath);
+  const meta = readMetadata();
+  let version = null;
+  let verified = false;
+  if (resolution.path) {
+    const verify2 = await verifyBinary(resolution.path);
+    if (verify2.ok) {
+      version = verify2.version ?? null;
+      verified = true;
+    }
+  }
+  return {
+    installed: resolution.path !== null,
+    path: resolution.path,
+    source: resolution.source,
+    version,
+    platform: plat,
+    metadata: meta,
+    verified
+  };
+}
+async function installEngine(options) {
+  const { force = false, preferBuild = false, version = "latest", cwd, prompt: prompt2, fetch: fetchFn } = options ?? {};
+  const plat = detectPlatform();
+  if (!force && (0, import_fs6.existsSync)(MANAGED_BINARY_PATH)) {
+    const meta = readMetadata();
+    if (meta?.verified) {
+      console.error(`[mmrc] Found cached binary (${meta.version}, ${meta.platform})`);
+    }
+    const verify2 = await verifyBinary(MANAGED_BINARY_PATH);
+    if (verify2.ok) {
+      console.error(`[mmrc] Cached binary verified: ${verify2.version}`);
+      return { path: MANAGED_BINARY_PATH, source: "managed" };
+    }
+    console.error("[mmrc] Cached binary failed verification \u2014 reinstalling.");
+  }
+  if (preferBuild) {
+    return await installViaBuild(plat, version, cwd, prompt2);
+  }
+  if (plat.releasePlatform) {
+    const dl = await downloadBinary({ version, platform: plat.releasePlatform, fetch: fetchFn });
+    if (dl.success) {
+      console.error("[mmrc] Verifying downloaded binary...");
+      const verify2 = await verifyBinary(dl.path);
+      if (verify2.ok) {
+        console.error(`[mmrc] Verification passed: ${verify2.version}`);
+        writeMetadata({
+          version: verify2.version ?? version,
+          platform: plat.releasePlatform,
+          triple: plat.triple,
+          downloadedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          verified: true,
+          source: "download",
+          path: dl.path
+        });
+        return { path: dl.path, source: "downloaded" };
+      }
+      console.error(`[mmrc] Binary verification FAILED: ${verify2.error}`);
+      console.error("");
+      console.error(`       Platform: ${plat.releasePlatform} (${plat.triple})`);
+      console.error("       This usually means:");
+      console.error("       - Wrong architecture (e.g., ARM binary on x86)");
+      console.error("       - Missing shared libraries (try: ldd " + dl.path + ")");
+      console.error("       - Glibc version mismatch");
+      console.error("");
+      console.error("[mmrc] Falling back to build from source...\n");
+    } else {
+      console.error(`[mmrc] Download failed: ${dl.error}`);
+    }
+  } else {
+    console.error(`[mmrc] No pre-built binary for ${plat.os}/${plat.arch}.`);
+  }
+  return await installViaBuild(plat, version, cwd, prompt2);
+}
+async function installViaBuild(plat, version, cwd, prompt2) {
+  if (!hasCargoInstalled()) {
+    console.error("[mmrc] Rust toolchain not found (cargo not in PATH).");
+    console.error("");
+    if ((0, import_os2.platform)() === "win32") {
+      console.error("  Install Rust from https://rustup.rs");
+    } else {
+      console.error("  Install Rust:");
+      console.error('    curl --proto "=https" --tlsv1.2 -sSf https://sh.rustup.rs | sh');
+    }
+    console.error("");
+    console.error("  Then restart your shell and run: mmrc engine build");
+    return { path: null, source: "not-found" };
+  }
+  const built = await buildFromSource({ cwd, prompt: prompt2 });
+  if (!built) return { path: null, source: "not-found" };
+  console.error("[mmrc] Verifying built binary...");
+  const verify2 = await verifyBinary(built);
+  if (verify2.ok) {
+    console.error(`[mmrc] Build verified: ${verify2.version}`);
+    writeMetadata({
+      version: verify2.version ?? version,
+      platform: plat.releasePlatform ?? `${plat.os}-${plat.arch}`,
+      triple: plat.triple,
+      downloadedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      verified: true,
+      source: "build",
+      path: built
+    });
+    return { path: built, source: "built" };
+  }
+  console.error(`[mmrc] Built binary also failed verification: ${verify2.error}`);
+  return { path: null, source: "not-found" };
+}
+function buildDownloadUrl(version, releasePlatform) {
+  const tag = version.startsWith("v") ? version : `v${version}`;
+  return `${GITHUB_RELEASE_BASE}/${tag}/mm-api-${releasePlatform}`;
+}
+async function downloadBinary(options) {
+  const plat = options.platform ?? detectPlatform().releasePlatform;
+  const dest = options.dest ?? MANAGED_BINARY_PATH;
+  const fetchFn = options.fetch ?? globalThis.fetch;
+  if (!plat) {
+    return { success: false, path: dest, error: "Unsupported platform for pre-built binaries" };
+  }
+  const url = buildDownloadUrl(options.version, plat);
+  console.error(`[mmrc] Downloading mm-api ${options.version} for ${plat}...`);
+  console.error(`[mmrc]   ${url}`);
+  try {
+    const response = await fetchFn(url, { redirect: "follow" });
+    if (!response.ok) {
+      return {
+        success: false,
+        path: dest,
+        error: `HTTP ${response.status}: ${response.statusText} (${url})`
+      };
+    }
+    (0, import_fs6.mkdirSync)(MMRC_BIN_DIR, { recursive: true });
+    const body = response.body;
+    if (!body) {
+      return { success: false, path: dest, error: "Empty response body" };
+    }
+    const fileStream = (0, import_fs6.createWriteStream)(dest);
+    await (0, import_promises.pipeline)(body, fileStream);
+    (0, import_fs6.chmodSync)(dest, 493);
+    setCachedVersion(options.version);
+    console.error(`[mmrc] Downloaded to ${dest}`);
+    return { success: true, path: dest };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { success: false, path: dest, error: message };
+  }
+}
+function hasCargoInstalled() {
+  try {
+    (0, import_child_process2.execSync)("cargo --version", { encoding: "utf-8", timeout: 5e3, stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function askUser(question) {
+  const readline = require("readline");
+  const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve7) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve7(answer.trim().toLowerCase());
+    });
+  });
+}
+async function buildFromSource(options) {
+  const promptFn = options?.prompt ?? askUser;
+  const cwd = options?.cwd ?? process.cwd();
+  if (hasCargoInstalled()) {
+    const answer = await promptFn("[mmrc] No pre-built binary available. Build from source? (y/n) ");
+    if (answer !== "y" && answer !== "yes") return null;
+  } else {
+    const answer = await promptFn(
+      "[mmrc] No pre-built binary available and Rust is not installed.\n       Install Rust and build from source? (y/n) "
+    );
+    if (answer !== "y" && answer !== "yes") return null;
+    console.error("[mmrc] Installing Rust via rustup...");
+    try {
+      (0, import_child_process2.execSync)('curl --proto "=https" --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y', {
+        stdio: "inherit",
+        cwd,
+        timeout: 3e5
+      });
+      const cargoEnv = (0, import_path5.join)((0, import_os2.homedir)(), ".cargo", "env");
+      if ((0, import_fs6.existsSync)(cargoEnv)) {
+        (0, import_child_process2.execSync)(`. ${cargoEnv}`, { stdio: "pipe" });
+      }
+    } catch (err) {
+      console.error("[mmrc] Failed to install Rust:", err instanceof Error ? err.message : err);
+      return null;
+    }
+  }
+  console.error("[mmrc] Building mm-api from source (this may take a few minutes)...");
+  try {
+    (0, import_child_process2.execSync)("cargo build --release -p mm-api", {
+      stdio: "inherit",
+      cwd,
+      timeout: 6e5
+    });
+  } catch (err) {
+    console.error("[mmrc] Build failed:", err instanceof Error ? err.message : err);
+    return null;
+  }
+  const candidates = [
+    (0, import_path5.join)(cwd, "mm-core", "target", "release", "mm-server"),
+    (0, import_path5.join)(cwd, "target", "release", "mm-server")
+  ];
+  for (const p of candidates) {
+    if ((0, import_fs6.existsSync)(p)) {
+      (0, import_fs6.mkdirSync)(MMRC_BIN_DIR, { recursive: true });
+      (0, import_fs6.copyFileSync)(p, MANAGED_BINARY_PATH);
+      (0, import_fs6.chmodSync)(MANAGED_BINARY_PATH, 493);
+      console.error(`[mmrc] Installed to ${MANAGED_BINARY_PATH}`);
+      return MANAGED_BINARY_PATH;
+    }
+  }
+  console.error("[mmrc] Build completed but binary not found in expected locations.");
+  return null;
+}
+function findEngineBinary(explicitPath, cwd) {
+  const workDir = cwd ?? process.cwd();
+  if (explicitPath) {
+    if ((0, import_fs6.existsSync)(explicitPath)) {
+      return { path: explicitPath, source: "explicit" };
+    }
+    return { path: null, source: "not-found" };
+  }
+  if ((0, import_fs6.existsSync)(MANAGED_BINARY_PATH)) {
+    return { path: MANAGED_BINARY_PATH, source: "managed" };
+  }
+  for (const rel of PROJECT_SEARCH_PATHS) {
+    const abs = (0, import_path5.resolve)(workDir, rel);
+    if ((0, import_fs6.existsSync)(abs)) {
+      return { path: abs, source: "project" };
+    }
+  }
+  try {
+    const cmd = (0, import_os2.platform)() === "win32" ? "where mm-server 2>nul || where mm-api 2>nul" : "which mm-server 2>/dev/null || which mm-api 2>/dev/null";
+    const result = (0, import_child_process2.execSync)(cmd, { encoding: "utf-8", timeout: 5e3 }).trim();
+    if (result) {
+      return { path: result.split("\n")[0], source: "path" };
+    }
+  } catch {
+  }
+  return { path: null, source: "not-found" };
+}
+async function ensureEngineBinary(options) {
+  const found = findEngineBinary(options?.explicitPath, options?.cwd);
+  if (found.path) return found;
+  const plat = detectPlatform();
+  const version = options?.version ?? "latest";
+  if (plat.releasePlatform) {
+    const result = await downloadBinary({
+      version,
+      platform: plat.releasePlatform,
+      fetch: options?.fetch
+    });
+    if (result.success) {
+      return { path: result.path, source: "downloaded" };
+    }
+    console.error(`[mmrc] Download failed: ${result.error}`);
+  } else {
+    console.error(`[mmrc] No pre-built binary for ${plat.os}/${plat.arch}`);
+  }
+  if (!options?.nonInteractive) {
+    const built = await buildFromSource({
+      prompt: options?.prompt,
+      cwd: options?.cwd
+    });
+    if (built) {
+      return { path: built, source: "built" };
+    }
+  }
+  return { path: null, source: "not-found" };
+}
+function printInstallGuide() {
+  const plat = detectPlatform();
+  console.error("[mmrc] MindMatrix engine binary not found.\n");
+  console.error("The engine binary (mm-api) is required for local development.");
+  console.error("Choose one of the following options:\n");
+  console.error("  1. Auto-download (recommended):");
+  console.error("     mmrc dev  # auto-downloads the binary");
+  console.error("");
+  console.error("  2. Build from source (requires Rust toolchain):");
+  console.error('     curl --proto "=https" --tlsv1.2 -sSf https://sh.rustup.rs | sh');
+  console.error("     cargo build --release -p mm-api");
+  console.error("");
+  console.error("  3. Download manually:");
+  if (plat.releasePlatform) {
+    console.error(`     curl -L -o ~/.mmrc/bin/mm-api \\`);
+    console.error(`       ${GITHUB_RELEASE_BASE}/v0.1.0/mm-api-${plat.releasePlatform}`);
+    console.error(`     chmod +x ~/.mmrc/bin/mm-api`);
+  } else {
+    console.error(`     # No pre-built binary for ${plat.triple} \u2014 build from source`);
+  }
+  console.error("");
+  console.error("  4. Use a remote backend instead of local:");
+  console.error("     mmrc dev --api-url https://dev.mindmatrix.club/api/v1");
+  console.error("");
+}
+function requireEngineBinary(explicitPath) {
+  const result = findEngineBinary(explicitPath);
+  if (!result.path) {
+    printInstallGuide();
+    process.exit(1);
+  }
+  return result.path;
+}
+var import_fs6, import_path5, import_os2, import_promises, import_child_process2, MMRC_BIN_DIR, BINARY_NAME, MANAGED_BINARY_PATH, VERSION_FILE_PATH, METADATA_PATH, GITHUB_RELEASE_BASE, PROJECT_SEARCH_PATHS;
+var init_engine_binary = __esm({
+  "src/cli/engine-binary.ts"() {
+    "use strict";
+    import_fs6 = require("fs");
+    import_path5 = require("path");
+    import_os2 = require("os");
+    import_promises = require("stream/promises");
+    import_child_process2 = require("child_process");
+    MMRC_BIN_DIR = (0, import_path5.join)((0, import_os2.homedir)(), ".mmrc", "bin");
+    BINARY_NAME = (0, import_os2.platform)() === "win32" ? "mm-api.exe" : "mm-api";
+    MANAGED_BINARY_PATH = (0, import_path5.join)(MMRC_BIN_DIR, BINARY_NAME);
+    VERSION_FILE_PATH = (0, import_path5.join)(MMRC_BIN_DIR, "mm-api.version");
+    METADATA_PATH = (0, import_path5.join)(MMRC_BIN_DIR, "mm-api.json");
+    GITHUB_RELEASE_BASE = "https://github.com/dev-nested/mm-app/releases/download";
+    PROJECT_SEARCH_PATHS = [
+      "engine/target/release/mm-server",
+      "engine/target/debug/mm-server",
+      "mm-core/target/release/mm-server",
+      "mm-core/target/debug/mm-server",
+      "target/release/mm-server",
+      "target/debug/mm-server"
+    ];
+  }
+});
+
 // src/vite/index.ts
 function mindmatrixReact(options) {
   const include = options?.include ?? ["**/*.workflow.tsx"];
@@ -14402,7 +14865,7 @@ function mindmatrixReact(options) {
         experience: ir.experience || {},
         metadata: {
           ...ir.metadata || {},
-          source_file: (0, import_path5.relative)(process.cwd(), filePath),
+          source_file: (0, import_path6.relative)(process.cwd(), filePath),
           compiled_at: (/* @__PURE__ */ new Date()).toISOString()
         }
       };
@@ -14462,7 +14925,7 @@ function mindmatrixReact(options) {
           parserOpts: { plugins: ["jsx", "typescript"] },
           sourceMaps: wantMaps,
           // Embed original source in the source map so debuggers can show .workflow.tsx
-          ...wantMaps ? { sourceFileName: (0, import_path5.basename)(id) } : {}
+          ...wantMaps ? { sourceFileName: (0, import_path6.basename)(id) } : {}
         });
         if (!result?.code) return null;
         const metadata = result.metadata || {};
@@ -14471,25 +14934,25 @@ function mindmatrixReact(options) {
         const errors = metadata.mindmatrixErrors;
         if (warnings?.length) {
           for (const w of warnings) {
-            console.warn(`[mindmatrix-react] ${(0, import_path5.basename)(id)}: ${w.message}`);
+            console.warn(`[mindmatrix-react] ${(0, import_path6.basename)(id)}: ${w.message}`);
           }
         }
         if (errors?.length) {
           for (const e of errors) {
             if (mode === "strict") {
-              this.error(`${(0, import_path5.basename)(id)}: ${e.message}`);
+              this.error(`${(0, import_path6.basename)(id)}: ${e.message}`);
             } else {
-              this.warn(`${(0, import_path5.basename)(id)}: ${e.message}`);
+              this.warn(`${(0, import_path6.basename)(id)}: ${e.message}`);
             }
           }
         }
         if (ir) {
           compiledFiles.set(id, ir);
-          const outputFileName = (0, import_path5.basename)(id).replace(/\.tsx?$/, ".workflow.json");
-          const outputPath = (0, import_path5.join)(process.cwd(), outDir, outputFileName);
-          (0, import_fs6.mkdirSync)((0, import_path5.dirname)(outputPath), { recursive: true });
-          (0, import_fs6.writeFileSync)(outputPath, JSON.stringify(ir, null, 2), "utf-8");
-          console.log(`[mindmatrix-react] Compiled ${(0, import_path5.basename)(id)} \u2192 ${outputFileName}`);
+          const outputFileName = (0, import_path6.basename)(id).replace(/\.tsx?$/, ".workflow.json");
+          const outputPath = (0, import_path6.join)(process.cwd(), outDir, outputFileName);
+          (0, import_fs7.mkdirSync)((0, import_path6.dirname)(outputPath), { recursive: true });
+          (0, import_fs7.writeFileSync)(outputPath, JSON.stringify(ir, null, 2), "utf-8");
+          console.log(`[mindmatrix-react] Compiled ${(0, import_path6.basename)(id)} \u2192 ${outputFileName}`);
           seedToApi(ir, id);
         }
         if (!enableSourceAnnotations && ir) {
@@ -14502,16 +14965,16 @@ function mindmatrixReact(options) {
       } catch (error) {
         const msg = error instanceof Error ? error.message : String(error);
         if (mode === "strict") {
-          this.error(`Failed to compile ${(0, import_path5.basename)(id)}: ${msg}`);
+          this.error(`Failed to compile ${(0, import_path6.basename)(id)}: ${msg}`);
         } else {
-          console.error(`[mindmatrix-react] Error compiling ${(0, import_path5.basename)(id)}:`, msg);
+          console.error(`[mindmatrix-react] Error compiling ${(0, import_path6.basename)(id)}:`, msg);
         }
         return null;
       }
     },
     handleHotUpdate(ctx) {
       if (!shouldTransform(ctx.file)) return;
-      console.log(`[mindmatrix-react] HMR: ${(0, import_path5.basename)(ctx.file)} changed`);
+      console.log(`[mindmatrix-react] HMR: ${(0, import_path6.basename)(ctx.file)} changed`);
       return void 0;
     }
   };
@@ -14534,13 +14997,13 @@ function stripSourceAnnotations(ir) {
   strip(ir.transitions);
   strip(ir.experience);
 }
-var import_core5, import_fs6, import_path5;
+var import_core5, import_fs7, import_path6;
 var init_vite = __esm({
   "src/vite/index.ts"() {
     "use strict";
     import_core5 = require("@babel/core");
-    import_fs6 = require("fs");
-    import_path5 = require("path");
+    import_fs7 = require("fs");
+    import_path6 = require("path");
     init_babel();
   }
 });
@@ -14562,10 +15025,10 @@ async function startLocalServer(options = {}) {
     res.end(data);
   }
   function readBody(req) {
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve7, reject) => {
       const chunks = [];
       req.on("data", (chunk) => chunks.push(chunk));
-      req.on("end", () => resolve6(Buffer.concat(chunks).toString()));
+      req.on("end", () => resolve7(Buffer.concat(chunks).toString()));
       req.on("error", reject);
     });
   }
@@ -14694,7 +15157,7 @@ async function startLocalServer(options = {}) {
       return json(res, 500, { error: message });
     }
   });
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     server.on("error", (err) => {
       if (err.code === "EADDRINUSE") {
         reject(new Error(`Port ${port} is already in use. Is another server running?`));
@@ -14706,7 +15169,7 @@ async function startLocalServer(options = {}) {
       console.log(`[mm-local] Local API server running at http://localhost:${port}`);
       console.log(`[mm-local] Mode: in-memory (data lost on restart)`);
       console.log(`[mm-local] Auth: disabled (all requests accepted)`);
-      resolve6({
+      resolve7({
         server,
         port,
         store,
@@ -15075,7 +15538,7 @@ async function seedInstances(options) {
   for (const file2 of files) {
     let def;
     try {
-      def = JSON.parse((0, import_fs7.readFileSync)(file2, "utf-8"));
+      def = JSON.parse((0, import_fs8.readFileSync)(file2, "utf-8"));
     } catch {
       continue;
     }
@@ -15115,11 +15578,11 @@ async function seedInstances(options) {
   }
   return result;
 }
-var import_fs7, import_glob4, FIRST_NAMES, LAST_NAMES, COMPANIES, LOREM_WORDS, DOMAINS, _counter;
+var import_fs8, import_glob4, FIRST_NAMES, LAST_NAMES, COMPANIES, LOREM_WORDS, DOMAINS, _counter;
 var init_seed = __esm({
   "src/cli/seed.ts"() {
     "use strict";
-    import_fs7 = require("fs");
+    import_fs8 = require("fs");
     import_glob4 = require("glob");
     FIRST_NAMES = ["Alice", "Bob", "Charlie", "Diana", "Eve", "Frank", "Grace", "Henry"];
     LAST_NAMES = ["Smith", "Johnson", "Williams", "Brown", "Jones", "Garcia", "Miller", "Davis"];
@@ -15269,6 +15732,33 @@ function broadcast(clients, data) {
   }
 }
 async function createDevServer(options = {}) {
+  const { existsSync: existsSync9 } = await import("fs");
+  const { resolve: resolve7 } = await import("path");
+  const nodeModulesPath = resolve7(process.cwd(), "node_modules");
+  if (!existsSync9(nodeModulesPath)) {
+    console.error(`
+[mmrc] Error: Dependencies not installed.
+`);
+    console.error(`  Run one of these in your project directory first:
+`);
+    console.error(`    npm install`);
+    console.error(`    pnpm install`);
+    console.error(`    yarn install
+`);
+    process.exit(1);
+  }
+  try {
+    await import("vite");
+  } catch {
+    console.error(`
+[mmrc] Error: 'vite' is not installed.
+`);
+    console.error(`  Install it:
+`);
+    console.error(`    npm install -D vite
+`);
+    process.exit(1);
+  }
   const {
     port = 5199,
     src = "src/workflows",
@@ -15330,6 +15820,45 @@ async function createDevServer(options = {}) {
   }
   const pluginOpts = { mode, include, outDir, seedOnCompile: seed, apiUrl, authToken: token };
   const proxyTarget = apiUrl.replace(/\/api\/v1\/?$/, "") || apiUrl;
+  const devPlayerPlugin = {
+    name: "mindmatrix-dev-player",
+    resolveId(id) {
+      if (id === "virtual:mm-dev-player") return "\0virtual:mm-dev-player";
+      return null;
+    },
+    load(id) {
+      if (id !== "\0virtual:mm-dev-player") return null;
+      return `
+import React from 'react';
+import { createRoot } from 'react-dom/client';
+import { DevPlayer } from '@mmapp/react/player';
+
+const tree = window.__MM_DEV_TREE__ || { type: 'Text', props: { children: 'No tree loaded. Compile a workflow to see the preview.' } };
+const scopes = window.__MM_DEV_SCOPES__ || {};
+
+function App() {
+  const [currentTree, setTree] = React.useState(tree);
+  const [currentScopes, setScopes] = React.useState(scopes);
+
+  React.useEffect(() => {
+    const ws = new WebSocket('ws://' + location.host + '/__mm_dev');
+    ws.onmessage = (ev) => {
+      try {
+        const msg = JSON.parse(ev.data);
+        if (msg.type === 'workflow:compiled' && msg.tree) setTree(msg.tree);
+        if (msg.type === 'workflow:compiled' && msg.scopes) setScopes(msg.scopes);
+      } catch {}
+    };
+    return () => ws.close();
+  }, []);
+
+  return React.createElement(DevPlayer, { tree: currentTree, scopes: currentScopes, title: document.title || 'MindMatrix Dev' });
+}
+
+createRoot(document.getElementById('root')).render(React.createElement(App));
+`;
+    }
+  };
   let deployInFlight = false;
   const compileDeployPlugin = {
     name: "mindmatrix-dev-compile-deploy",
@@ -15374,6 +15903,7 @@ async function createDevServer(options = {}) {
     plugins: [
       mindmatrixReact(pluginOpts),
       compileDeployPlugin,
+      devPlayerPlugin,
       { name: "mindmatrix-error-overlay", configureServer(server) {
         server.middlewares.use(errorOverlayMiddleware());
       } }
@@ -15482,20 +16012,20 @@ function deepMerge(target, source) {
 }
 function findConfigPath(startDir) {
   let dir = startDir ?? process.cwd();
-  const root = (0, import_path6.resolve)("/");
+  const root = (0, import_path7.resolve)("/");
   while (true) {
     for (const name of ["mmrc.config.ts", "mmrc.config.json"]) {
-      const candidate = (0, import_path6.join)(dir, name);
-      if ((0, import_fs8.existsSync)(candidate)) return candidate;
+      const candidate = (0, import_path7.join)(dir, name);
+      if ((0, import_fs9.existsSync)(candidate)) return candidate;
     }
-    const parent = (0, import_path6.resolve)(dir, "..");
+    const parent = (0, import_path7.resolve)(dir, "..");
     if (parent === dir || parent === root) break;
     dir = parent;
   }
   return null;
 }
 function loadConfigFromFile(configPath) {
-  const content = (0, import_fs8.readFileSync)(configPath, "utf-8");
+  const content = (0, import_fs9.readFileSync)(configPath, "utf-8");
   if (configPath.endsWith(".json")) {
     try {
       return JSON.parse(content);
@@ -15576,7 +16106,7 @@ const config = ${json};
 
 export default config;
 `;
-  (0, import_fs8.writeFileSync)(configPath, content, "utf-8");
+  (0, import_fs9.writeFileSync)(configPath, content, "utf-8");
 }
 function resolveTarget(targetName, config, fallbackApiUrl) {
   if (!config || !config.environments) {
@@ -15626,7 +16156,7 @@ const config = {
     dev: { apiUrl: 'https://dev.mindmatrix.club/api/v1' },
   },
 
-  defaultTarget: 'dev',
+  defaultTarget: 'local',
 };
 
 export default config;
@@ -15638,19 +16168,19 @@ function loadMmrcConfig(dir) {
   const partial = loadConfigFromFile(path);
   return deepMerge(DEFAULT_CONFIG, partial);
 }
-var import_fs8, import_path6, DEFAULT_CONFIG;
+var import_fs9, import_path7, DEFAULT_CONFIG;
 var init_config = __esm({
   "src/cli/config.ts"() {
     "use strict";
-    import_fs8 = require("fs");
-    import_path6 = require("path");
+    import_fs9 = require("fs");
+    import_path7 = require("path");
     DEFAULT_CONFIG = {
       dev: {
         port: 5199,
         apiPort: 4200,
         db: "sqlite://mm-dev.db",
         redis: "",
-        api: "http://localhost:4200/api/v1",
+        api: "local",
         seed: false,
         open: false
       },
@@ -15668,7 +16198,7 @@ var init_config = __esm({
         local: { apiUrl: "http://localhost:4200/api/v1" },
         dev: { apiUrl: "https://dev.mindmatrix.club/api/v1" }
       },
-      defaultTarget: "dev"
+      defaultTarget: "local"
     };
   }
 });
@@ -15699,12 +16229,16 @@ function generatePackageJson2(name) {
         deploy: "mmrc deploy --build --src ."
       },
       dependencies: {
-        "@mmapp/react": "^0.1.0-alpha.1"
+        "@mmapp/react": "^0.1.0-alpha.1",
+        "react": "^18.0.0",
+        "react-dom": "^18.0.0"
       },
       devDependencies: {
-        typescript: "^5.5.0",
+        "typescript": "^5.5.0",
         "@types/react": "^18.0.0",
-        react: "^18.0.0"
+        "@types/react-dom": "^18.0.0",
+        "vite": "^6.0.0",
+        "@mmapp/react-compiler": "^0.1.0-alpha.1"
       }
     },
     null,
@@ -16010,7 +16544,7 @@ dev.db
 }
 function isInsideGitRepo(dir) {
   try {
-    (0, import_child_process2.execSync)("git rev-parse --git-dir", { cwd: dir, stdio: "pipe" });
+    (0, import_child_process3.execSync)("git rev-parse --git-dir", { cwd: dir, stdio: "pipe" });
     return true;
   } catch {
     return false;
@@ -16021,9 +16555,9 @@ function scaffoldGit(dir) {
     return "Skipped git init (inside existing repo)";
   }
   try {
-    (0, import_child_process2.execSync)("git init", { cwd: dir, stdio: "pipe" });
-    (0, import_child_process2.execSync)("git add -A", { cwd: dir, stdio: "pipe" });
-    (0, import_child_process2.execSync)('git commit -m "Initial commit from mmrc init"', { cwd: dir, stdio: "pipe" });
+    (0, import_child_process3.execSync)("git init", { cwd: dir, stdio: "pipe" });
+    (0, import_child_process3.execSync)("git add -A", { cwd: dir, stdio: "pipe" });
+    (0, import_child_process3.execSync)('git commit -m "Initial commit from mmrc init"', { cwd: dir, stdio: "pipe" });
     return "Initialized git repository";
   } catch (e) {
     return `Git init failed: ${e.message}`;
@@ -16036,16 +16570,16 @@ async function init(options) {
     process.exit(1);
   }
   const cwd = process.cwd();
-  const packagesDir = (0, import_fs9.existsSync)((0, import_path7.join)(cwd, "packages")) ? (0, import_path7.join)(cwd, "packages") : cwd;
-  const blueprintDir = (0, import_path7.join)(packagesDir, `blueprint-${name}`);
-  if ((0, import_fs9.existsSync)(blueprintDir)) {
+  const packagesDir = (0, import_fs10.existsSync)((0, import_path8.join)(cwd, "packages")) ? (0, import_path8.join)(cwd, "packages") : cwd;
+  const blueprintDir = (0, import_path8.join)(packagesDir, `blueprint-${name}`);
+  if ((0, import_fs10.existsSync)(blueprintDir)) {
     console.error(`[mmrc] Error: Directory already exists: ${blueprintDir}`);
     process.exit(1);
   }
   console.log(`[mmrc] Creating blueprint: ${name}
 `);
-  (0, import_fs9.mkdirSync)((0, import_path7.join)(blueprintDir, "models"), { recursive: true });
-  (0, import_fs9.mkdirSync)((0, import_path7.join)(blueprintDir, "app"), { recursive: true });
+  (0, import_fs10.mkdirSync)((0, import_path8.join)(blueprintDir, "models"), { recursive: true });
+  (0, import_fs10.mkdirSync)((0, import_path8.join)(blueprintDir, "app"), { recursive: true });
   const { generateMmrcConfig: generateMmrcConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
   const files = [
     ["package.json", generatePackageJson2(name)],
@@ -16058,31 +16592,42 @@ async function init(options) {
     ["app/page.tsx", generatePage(name)]
   ];
   for (const [relPath, content] of files) {
-    const fullPath = (0, import_path7.join)(blueprintDir, relPath);
-    (0, import_fs9.writeFileSync)(fullPath, content, "utf-8");
+    const fullPath = (0, import_path8.join)(blueprintDir, relPath);
+    (0, import_fs10.writeFileSync)(fullPath, content, "utf-8");
     console.log(`  + ${relPath}`);
   }
   const gitMessage = scaffoldGit(blueprintDir);
   console.log(`  ${gitMessage}`);
+  console.log(`
+[mmrc] Installing dependencies...`);
+  const { execSync: execSync4 } = require("child_process");
+  try {
+    const usesPnpm = (0, import_fs10.existsSync)((0, import_path8.join)(cwd, "pnpm-lock.yaml")) || (0, import_fs10.existsSync)((0, import_path8.join)(cwd, "pnpm-workspace.yaml"));
+    const usesYarn = (0, import_fs10.existsSync)((0, import_path8.join)(cwd, "yarn.lock"));
+    const pm = usesPnpm ? "pnpm" : usesYarn ? "yarn" : "npm";
+    execSync4(`${pm} install`, { cwd: blueprintDir, stdio: "inherit" });
+    console.log(`[mmrc] Dependencies installed with ${pm}`);
+  } catch (e) {
+    console.warn(`[mmrc] Warning: Could not auto-install dependencies. Run 'npm install' manually in the project directory.`);
+  }
   const title = toTitleCase(name);
+  const relDir = blueprintDir.startsWith(cwd) ? blueprintDir.slice(cwd.length + 1) : blueprintDir;
   console.log(`
 [mmrc] Blueprint "${title}" created at:
   ${blueprintDir}
 
 Next steps:
-  1. cd ${blueprintDir.startsWith(cwd) ? blueprintDir.slice(cwd.length + 1) : blueprintDir}
-  2. mmrc dev                    # Start dev server
-  3. mmrc build                  # Compile to IR
-  4. mmrc deploy --build         # Build + deploy to backend
+  1. cd ${relDir}
+  2. mmrc dev                    # Start dev server with live preview
 `);
 }
-var import_fs9, import_path7, import_child_process2;
+var import_fs10, import_path8, import_child_process3;
 var init_init = __esm({
   "src/cli/init.ts"() {
     "use strict";
-    import_fs9 = require("fs");
-    import_path7 = require("path");
-    import_child_process2 = require("child_process");
+    import_fs10 = require("fs");
+    import_path8 = require("path");
+    import_child_process3 = require("child_process");
   }
 });
 
@@ -17862,7 +18407,7 @@ __export(verify_exports, {
   verifyCommand: () => verifyCommand
 });
 function compileToIR(filePath) {
-  const code = (0, import_fs10.readFileSync)(filePath, "utf-8");
+  const code = (0, import_fs11.readFileSync)(filePath, "utf-8");
   const result = (0, import_core6.transformSync)(code, {
     filename: filePath,
     plugins: [[babelPlugin, { mode: "strict" }]],
@@ -17878,13 +18423,13 @@ function compileToIR(filePath) {
   return irDef;
 }
 async function resolveFiles(target) {
-  const resolved = (0, import_path8.resolve)(target);
-  if (!(0, import_fs10.existsSync)(resolved)) {
+  const resolved = (0, import_path9.resolve)(target);
+  if (!(0, import_fs11.existsSync)(resolved)) {
     throw new Error(`Path not found: ${resolved}`);
   }
-  const stat = (0, import_fs10.statSync)(resolved);
+  const stat = (0, import_fs11.statSync)(resolved);
   if (stat.isFile()) {
-    const ext = (0, import_path8.extname)(resolved);
+    const ext = (0, import_path9.extname)(resolved);
     if (![".ts", ".tsx", ".js", ".jsx"].includes(ext)) {
       throw new Error(`Unsupported file type: ${ext}. Expected .ts, .tsx, .js, or .jsx`);
     }
@@ -17915,12 +18460,12 @@ async function verifyCommand(options) {
   let filesFailed = 0;
   const results = [];
   for (const file2 of files) {
-    const label = (0, import_path8.basename)(file2);
+    const label = (0, import_path9.basename)(file2);
     try {
       const ir = compileToIR(file2);
       if (options.generate) {
         const testCode = generateTestFile(ir);
-        const testFileName = (0, import_path8.basename)(file2).replace(/\.(ts|tsx|js|jsx)$/, ".verify.test.ts");
+        const testFileName = (0, import_path9.basename)(file2).replace(/\.(ts|tsx|js|jsx)$/, ".verify.test.ts");
         console.log(`// --- ${testFileName} ---`);
         console.log(testCode);
         filesProcessed++;
@@ -17966,12 +18511,12 @@ ${"=".repeat(50)}`);
   }
   return { success, filesProcessed, filesFailed, results };
 }
-var import_fs10, import_path8, import_glob5, import_core6;
+var import_fs11, import_path9, import_glob5, import_core6;
 var init_verify = __esm({
   "src/cli/verify.ts"() {
     "use strict";
-    import_fs10 = require("fs");
-    import_path8 = require("path");
+    import_fs11 = require("fs");
+    import_path9 = require("path");
     import_glob5 = require("glob");
     import_core6 = require("@babel/core");
     init_babel();
@@ -17995,12 +18540,12 @@ async function pull(options) {
   console.log(`  Found: ${ir.name || ir.slug} (${ir.category || "workflow"}, v${ir.version || "1.0.0"})`);
   console.log(`  Fields: ${ir.fields?.length ?? 0}, States: ${ir.states?.length ?? 0}, Transitions: ${ir.transitions?.length ?? 0}`);
   const result = decompileProjectEnhanced(ir);
-  (0, import_fs11.mkdirSync)(outDir, { recursive: true });
+  (0, import_fs12.mkdirSync)(outDir, { recursive: true });
   const filesWritten = [];
   for (const file2 of result.files) {
-    const filePath = (0, import_path9.join)(outDir, file2.path);
-    (0, import_fs11.mkdirSync)((0, import_path9.dirname)(filePath), { recursive: true });
-    (0, import_fs11.writeFileSync)(filePath, file2.content, "utf-8");
+    const filePath = (0, import_path10.join)(outDir, file2.path);
+    (0, import_fs12.mkdirSync)((0, import_path10.dirname)(filePath), { recursive: true });
+    (0, import_fs12.writeFileSync)(filePath, file2.content, "utf-8");
     filesWritten.push(file2.path);
     console.log(`  + ${file2.path}`);
   }
@@ -18082,12 +18627,12 @@ function normalizeApiResponse(def) {
   }
   return ir;
 }
-var import_fs11, import_path9;
+var import_fs12, import_path10;
 var init_pull = __esm({
   "src/cli/pull.ts"() {
     "use strict";
-    import_fs11 = require("fs");
-    import_path9 = require("path");
+    import_fs12 = require("fs");
+    import_path10 = require("path");
     init_project_decompiler();
   }
 });
@@ -18105,15 +18650,15 @@ __export(server_exports, {
 });
 function findServerBinary(explicitPath) {
   if (explicitPath) {
-    return (0, import_fs12.existsSync)(explicitPath) ? explicitPath : null;
+    return (0, import_fs13.existsSync)(explicitPath) ? explicitPath : null;
   }
   for (const rel of BINARY_SEARCH_PATHS) {
-    const abs = (0, import_path10.resolve)(process.cwd(), rel);
-    if ((0, import_fs12.existsSync)(abs)) return abs;
+    const abs = (0, import_path11.resolve)(process.cwd(), rel);
+    if ((0, import_fs13.existsSync)(abs)) return abs;
   }
   try {
-    const { execSync: execSync3 } = require("child_process");
-    const result = execSync3("which mm-server 2>/dev/null || which mm-api 2>/dev/null", {
+    const { execSync: execSync4 } = require("child_process");
+    const result = execSync4("which mm-server 2>/dev/null || which mm-api 2>/dev/null", {
       encoding: "utf-8",
       timeout: 5e3
     }).trim();
@@ -18201,12 +18746,12 @@ async function serverMigrate(options) {
     process.exit(1);
   }
   console.log(`[mmrc] Running migrations via ${binary}...`);
-  const { execSync: execSync3 } = require("child_process");
+  const { execSync: execSync4 } = require("child_process");
   try {
     const configPath = options.config ?? findConfigFile();
     const env = { ...process.env, MM_RUN_MIGRATIONS: "true" };
     if (configPath) env.MM_CONFIG_PATH = configPath;
-    execSync3(`${binary} --migrate-only`, { stdio: "inherit", env });
+    execSync4(`${binary} --migrate-only`, { stdio: "inherit", env });
     console.log("[mmrc] Migrations complete.");
   } catch (e) {
     console.error(`[mmrc] Migration failed: ${e.message}`);
@@ -18217,12 +18762,12 @@ function serverInit(options) {
   const output = options.output ?? "mm-server.toml";
   const mode = options.mode ?? "standalone";
   const db = options.db ?? "$env:DATABASE_URL";
-  if ((0, import_fs12.existsSync)(output) && output !== "/dev/stdout") {
+  if ((0, import_fs13.existsSync)(output) && output !== "/dev/stdout") {
     console.error(`[mmrc] Error: ${output} already exists. Use --output to specify a different path.`);
     process.exit(1);
   }
   const content = generateServerToml(mode, db);
-  (0, import_fs12.writeFileSync)(output, content, "utf-8");
+  (0, import_fs13.writeFileSync)(output, content, "utf-8");
   console.log(`[mmrc] Generated ${output} (mode: ${mode})`);
   console.log(`[mmrc] Edit the file, then run: mmrc server start`);
 }
@@ -18337,7 +18882,7 @@ function serverConfig(options) {
   }
   console.log(`[mmrc] Config file: ${configPath}
 `);
-  const raw = (0, import_fs12.readFileSync)(configPath, "utf-8");
+  const raw = (0, import_fs13.readFileSync)(configPath, "utf-8");
   const resolved = raw.replace(/\$env:(\w+)/g, (_match, varName) => {
     const val = process.env[varName];
     return val ? `${val}  # \u2190 $env:${varName}` : `(unset)  # \u2190 $env:${varName}`;
@@ -18351,17 +18896,17 @@ function findConfigFile() {
     "mm-core/mm-server.toml"
   ];
   for (const c of candidates) {
-    const abs = (0, import_path10.resolve)(process.cwd(), c);
-    if ((0, import_fs12.existsSync)(abs)) return abs;
+    const abs = (0, import_path11.resolve)(process.cwd(), c);
+    if ((0, import_fs13.existsSync)(abs)) return abs;
   }
   return null;
 }
-var import_fs12, import_path10, BINARY_SEARCH_PATHS;
+var import_fs13, import_path11, BINARY_SEARCH_PATHS;
 var init_server = __esm({
   "src/cli/server.ts"() {
     "use strict";
-    import_fs12 = require("fs");
-    import_path10 = require("path");
+    import_fs13 = require("fs");
+    import_path11 = require("path");
     BINARY_SEARCH_PATHS = [
       "engine/target/release/mm-server",
       "engine/target/debug/mm-server",
@@ -18671,11 +19216,11 @@ function getPositional() {
 }
 async function loadDevConfig() {
   try {
-    const { existsSync: existsSync8, readFileSync: readFileSync10 } = await import("fs");
-    const { resolve: resolve6 } = await import("path");
-    const configPath = resolve6(process.cwd(), "mm.config.ts");
-    if (!existsSync8(configPath)) return {};
-    const content = readFileSync10(configPath, "utf-8");
+    const { existsSync: existsSync9, readFileSync: readFileSync11 } = await import("fs");
+    const { resolve: resolve7 } = await import("path");
+    const configPath = resolve7(process.cwd(), "mm.config.ts");
+    if (!existsSync9(configPath)) return {};
+    const content = readFileSync11(configPath, "utf-8");
     const devMatch = content.match(/dev\s*:\s*\{([^}]*)\}/s);
     if (!devMatch) return {};
     const block = devMatch[1];
@@ -18703,9 +19248,85 @@ async function main() {
     const src = getFlag("--src") ?? devCfg.src;
     const mode = getFlag("--mode") ?? devCfg.mode;
     const seed = hasFlag("--seed") || devCfg.seed === true;
-    const apiUrl = hasFlag("--local") ? "local" : getFlag("--api-url") ?? devCfg.apiUrl;
+    const explicitApiUrl = getFlag("--api-url") ?? devCfg.apiUrl;
+    const isLocal = hasFlag("--local") || !explicitApiUrl || explicitApiUrl === "local";
     const authToken = getFlag("--token") ?? devCfg.token;
     const open = hasFlag("--open") || devCfg.open === true;
+    const apiPort = getFlag("--api-port") ? parseInt(getFlag("--api-port"), 10) : 4200;
+    let engineProcess = null;
+    if (isLocal) {
+      const { findEngineBinary: findEngineBinary2, installEngine: installEngine2, verifyBinary: verifyBinary2 } = await Promise.resolve().then(() => (init_engine_binary(), engine_binary_exports));
+      let resolution = findEngineBinary2(getFlag("--binary"));
+      if (resolution.path) {
+        const verify2 = await verifyBinary2(resolution.path);
+        if (!verify2.ok) {
+          console.error(`[mmrc] Binary at ${resolution.path} failed verification: ${verify2.error}`);
+          console.error("[mmrc] Attempting reinstall...\n");
+          resolution = { path: null, source: "not-found" };
+        }
+      }
+      if (!resolution.path) {
+        const installed = await installEngine2({
+          force: true,
+          version: getFlag("--engine-version") ?? "latest"
+        });
+        if (!installed.path) {
+          console.error("[mmrc] Could not obtain a working engine binary.");
+          process.exit(1);
+        }
+        resolution = installed;
+      }
+      console.log(`[mmrc] Starting local engine: ${resolution.path} (${resolution.source})`);
+      const { spawn: spawnProcess } = require("child_process");
+      engineProcess = spawnProcess(resolution.path, [], {
+        stdio: ["ignore", "pipe", "pipe"],
+        env: {
+          ...process.env,
+          DATABASE_URL: `sqlite://${process.cwd()}/dev.db`,
+          JWT_SECRET: "dev-secret-mmrc-local",
+          PORT: String(apiPort),
+          RUST_LOG: "mm_api=info,mm_storage=info"
+        }
+      });
+      if (engineProcess.stdout) {
+        engineProcess.stdout.on("data", (data) => {
+          for (const line of data.toString().split("\n").filter(Boolean)) {
+            console.log(`  [engine] ${line}`);
+          }
+        });
+      }
+      if (engineProcess.stderr) {
+        engineProcess.stderr.on("data", (data) => {
+          for (const line of data.toString().split("\n").filter(Boolean)) {
+            console.error(`  [engine] ${line}`);
+          }
+        });
+      }
+      engineProcess.on("error", (err) => {
+        console.error(`[mmrc] Engine failed to start: ${err.message}`);
+        process.exit(1);
+      });
+      const healthUrl = `http://localhost:${apiPort}/health`;
+      let healthy = false;
+      for (let i = 0; i < 30; i++) {
+        try {
+          const res = await fetch(healthUrl, { signal: AbortSignal.timeout(500) });
+          if (res.ok) {
+            healthy = true;
+            break;
+          }
+        } catch {
+        }
+        await new Promise((r) => setTimeout(r, 500));
+      }
+      if (!healthy) {
+        console.error("[mmrc] Engine failed to become healthy within 15s.");
+        engineProcess.kill();
+        process.exit(1);
+      }
+      console.log(`[mmrc] Engine healthy at http://localhost:${apiPort}`);
+    }
+    const apiUrl = isLocal ? `http://localhost:${apiPort}/api/v1` : explicitApiUrl;
     const { createDevServer: createDevServer2 } = await Promise.resolve().then(() => (init_dev_server(), dev_server_exports));
     const server = await createDevServer2({
       port,
@@ -18717,6 +19338,10 @@ async function main() {
       open
     });
     const shutdown = async () => {
+      if (engineProcess) {
+        console.log("[mmrc] Stopping engine...");
+        engineProcess.kill("SIGTERM");
+      }
       await server.close();
       process.exit(0);
     };
@@ -18774,11 +19399,11 @@ async function main() {
       const srcDir = src ?? ".";
       const outDir = dir ?? "dist/workflows";
       console.log("[mmrc] Building before deploy...\n");
-      const { existsSync: existsSync8, readFileSync: readFileSync10, writeFileSync: writeFileSync9, mkdirSync: mkdirSync6 } = await import("fs");
-      const { resolve: resolve6, join: join7 } = await import("path");
+      const { existsSync: existsSync9, readFileSync: readFileSync11, writeFileSync: writeFileSync10, mkdirSync: mkdirSync7 } = await import("fs");
+      const { resolve: resolve7, join: join8 } = await import("path");
       const { glob: glob6 } = await import("glob");
-      const configPath = resolve6(srcDir, "mm.config.ts");
-      if (existsSync8(configPath)) {
+      const configPath = resolve7(srcDir, "mm.config.ts");
+      if (existsSync9(configPath)) {
         const { compileProject: compileProject2 } = await Promise.resolve().then(() => (init_project_compiler(), project_compiler_exports));
         const allFiles = await glob6(`${srcDir}/**/*.{ts,tsx}`, {
           ignore: ["**/node_modules/**", "**/dist/**", "**/__tests__/**", "**/*.test.*"]
@@ -18786,7 +19411,7 @@ async function main() {
         const fileMap = {};
         for (const f of allFiles) {
           const rel = f.startsWith(srcDir + "/") ? f.slice(srcDir.length + 1) : f;
-          fileMap[rel] = readFileSync10(f, "utf-8");
+          fileMap[rel] = readFileSync11(f, "utf-8");
         }
         console.log(`  Compiling project (${Object.keys(fileMap).length} files)...`);
         const result = compileProject2(fileMap);
@@ -18799,16 +19424,16 @@ async function main() {
 [mmrc] Build failed with ${errors.length} errors \u2014 aborting deploy.`);
           process.exit(1);
         }
-        mkdirSync6(outDir, { recursive: true });
-        const irPath = join7(outDir, `${result.ir.slug}.workflow.json`);
-        writeFileSync9(irPath, JSON.stringify(result.ir, null, 2), "utf-8");
+        mkdirSync7(outDir, { recursive: true });
+        const irPath = join8(outDir, `${result.ir.slug}.workflow.json`);
+        writeFileSync10(irPath, JSON.stringify(result.ir, null, 2), "utf-8");
         console.log(`  + ${result.ir.slug}.workflow.json`);
         const seenSlugs = /* @__PURE__ */ new Set([result.ir.slug]);
         for (const child of result.childDefinitions) {
           if (seenSlugs.has(child.slug)) continue;
           seenSlugs.add(child.slug);
-          const childPath = join7(outDir, `${child.slug}.workflow.json`);
-          writeFileSync9(childPath, JSON.stringify(child, null, 2), "utf-8");
+          const childPath = join8(outDir, `${child.slug}.workflow.json`);
+          writeFileSync10(childPath, JSON.stringify(child, null, 2), "utf-8");
           console.log(`  + ${child.slug}.workflow.json`);
         }
         console.log(`  Compiled ${1 + result.childDefinitions.length} definitions.
@@ -18971,17 +19596,132 @@ async function main() {
       console.error("  Usage: mmrc server [start|migrate|init|status|config]");
       process.exit(1);
     }
+  } else if (command === "engine") {
+    const subcommand = args[1];
+    const {
+      detectPlatform: detectPlatform2,
+      findEngineBinary: findEngineBinary2,
+      getEngineStatus: getEngineStatus2,
+      installEngine: installEngine2,
+      buildFromSource: _buildFromSource,
+      verifyBinary: verifyBinary2,
+      healthCheck: healthCheck2,
+      readMetadata: readMetadata2,
+      MANAGED_BINARY_PATH: _MANAGED_BINARY_PATH
+    } = await Promise.resolve().then(() => (init_engine_binary(), engine_binary_exports));
+    if (subcommand === "status") {
+      const status = await getEngineStatus2(getFlag("--binary"));
+      const plat = detectPlatform2();
+      console.log("\n  MindMatrix Engine Status");
+      console.log("  " + "-".repeat(48));
+      console.log(`  Platform:   ${plat.releasePlatform ?? `${plat.os}-${plat.arch}`} (${plat.triple})`);
+      console.log(`  Installed:  ${status.installed ? "yes" : "no"}`);
+      if (status.path) {
+        console.log(`  Path:       ${status.path}`);
+        console.log(`  Source:     ${status.source}`);
+      }
+      console.log(`  Verified:   ${status.verified ? "yes" : "no"}`);
+      if (status.version) {
+        console.log(`  Version:    ${status.version}`);
+      }
+      const meta = readMetadata2();
+      if (meta) {
+        console.log(`  Downloaded: ${meta.downloadedAt}`);
+        console.log(`  Built via:  ${meta.source}`);
+      }
+      console.log("");
+    } else if (subcommand === "install") {
+      const force = hasFlag("--force");
+      const version = getFlag("--version") ?? "latest";
+      const result = await installEngine2({ force, version });
+      if (!result.path) {
+        console.error("[mmrc] Engine installation failed.");
+        process.exit(1);
+      }
+      console.log(`
+[mmrc] Engine installed: ${result.path} (${result.source})`);
+    } else if (subcommand === "build") {
+      const result = await installEngine2({ preferBuild: true, force: true });
+      if (!result.path) {
+        console.error("[mmrc] Engine build failed.");
+        process.exit(1);
+      }
+      console.log(`
+[mmrc] Engine built and cached: ${result.path}`);
+    } else if (subcommand === "update") {
+      const version = getFlag("--version") ?? "latest";
+      console.log("[mmrc] Checking for engine updates...");
+      const result = await installEngine2({ force: true, version });
+      if (!result.path) {
+        console.error("[mmrc] Engine update failed.");
+        process.exit(1);
+      }
+      console.log(`
+[mmrc] Engine updated: ${result.path} (${result.source})`);
+    } else if (subcommand === "verify") {
+      const resolution = findEngineBinary2(getFlag("--binary"));
+      if (!resolution.path) {
+        console.error("[mmrc] No engine binary found. Run `mmrc engine install` first.");
+        process.exit(1);
+      }
+      console.log(`[mmrc] Verifying binary: ${resolution.path}`);
+      const verify2 = await verifyBinary2(resolution.path);
+      if (!verify2.ok) {
+        console.error(`[mmrc] --version check FAILED: ${verify2.error}`);
+        process.exit(1);
+      }
+      console.log(`[mmrc] --version check passed: ${verify2.version}`);
+      const apiPort = getFlag("--port") ? parseInt(getFlag("--port"), 10) : 14200;
+      console.log(`[mmrc] Starting engine on port ${apiPort} for health check...`);
+      const { spawn } = await import("child_process");
+      const proc = spawn(resolution.path, [], {
+        stdio: ["ignore", "pipe", "pipe"],
+        env: {
+          ...process.env,
+          DATABASE_URL: "sqlite://:memory:",
+          JWT_SECRET: "verify-test",
+          PORT: String(apiPort),
+          RUST_LOG: "error"
+        }
+      });
+      let healthy = false;
+      for (let i = 0; i < 20; i++) {
+        const h = await healthCheck2(`http://localhost:${apiPort}/health`, 1e3);
+        if (h.ok) {
+          healthy = true;
+          console.log(`[mmrc] /health check passed${h.version ? ` (v${h.version})` : ""}${h.db ? ` [${h.db}]` : ""}`);
+          break;
+        }
+        await new Promise((r) => setTimeout(r, 500));
+      }
+      proc.kill("SIGTERM");
+      if (!healthy) {
+        console.error("[mmrc] /health check FAILED: engine did not become healthy within 10s.");
+        process.exit(1);
+      }
+      console.log("\n[mmrc] All verification checks passed.");
+    } else {
+      console.error(`[mmrc] Unknown engine subcommand: ${subcommand ?? "(none)"}`);
+      console.error("  Usage: mmrc engine [status|install|build|update|verify]");
+      console.error("");
+      console.error("  status   Show installed binary path, version, platform");
+      console.error("  install  Download or build mm-api binary");
+      console.error("  build    Explicitly build from source (cargo build --release -p mm-api)");
+      console.error("  update   Check for newer version and download/build");
+      console.error("  verify   Run --version and /health check against the binary");
+      process.exit(1);
+    }
   } else if (command === "version" || command === "-v" || command === "--version" || hasFlag("--version") || hasFlag("-v")) {
-    const { readFileSync: readFileSync10 } = await import("fs");
-    const { resolve: resolve6, dirname: dirname4 } = await import("path");
+    const { readFileSync: readFileSync11 } = await import("fs");
+    const { resolve: resolve7, dirname: dirname4 } = await import("path");
     try {
-      const pkgPath = resolve6(dirname4(new URL(import_meta.url).pathname), "../../package.json");
-      const pkg = JSON.parse(readFileSync10(pkgPath, "utf-8"));
+      const pkgPath = resolve7(dirname4(new URL(import_meta.url).pathname), "../../package.json");
+      const pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
       console.log(`mmrc ${pkg.version}`);
     } catch {
       try {
-        const pkgPath = resolve6(__dirname, "../../package.json");
-        const pkg = JSON.parse(readFileSync10(pkgPath, "utf-8"));
+        const pkgPath = resolve7(__dirname, "../../package.json");
+        const pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
         console.log(`mmrc ${pkg.version}`);
       } catch {
         console.log("mmrc (version unknown)");
@@ -18990,10 +19730,10 @@ async function main() {
   } else {
     let version = "";
     try {
-      const { readFileSync: readFileSync10 } = await import("fs");
-      const { resolve: resolve6 } = await import("path");
-      const pkgPath = resolve6(__dirname, "../../package.json");
-      const pkg = JSON.parse(readFileSync10(pkgPath, "utf-8"));
+      const { readFileSync: readFileSync11 } = await import("fs");
+      const { resolve: resolve7 } = await import("path");
+      const pkgPath = resolve7(__dirname, "../../package.json");
+      const pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
       version = ` v${pkg.version}`;
     } catch {
     }
@@ -19012,6 +19752,7 @@ Commands:
   verify  Compile + run verification layers (structural, reachability, safety, liveness, etc.)
   deploy  Compile + upload workflows to backend DB
   pull    Fetch a definition from DB and scaffold local project
+  engine  Manage the mm-api engine binary (install, build, verify, update)
 
 Usage:
   mmrc init <name> [options]
@@ -19074,6 +19815,17 @@ Usage:
     --token     Auth token (or use mmrc login / MMRC_TOKEN env var)
     --out       Output directory (default: <slug>/)
 
+  mmrc engine <subcommand> [options]
+    status      Show installed binary path, version, platform
+    install     Download or build mm-api binary (--force to reinstall, --version VER)
+    build       Explicitly build from source (cargo build --release -p mm-api)
+    update      Check for newer version and download/build (--version VER)
+    verify      Run --version and /health check (--binary PATH, --port PORT)
+
+  Platforms: darwin-arm64, darwin-x64, linux-x64, linux-arm64, windows-x64
+  Binary location: ~/.mmrc/bin/mm-api
+  Metadata: ~/.mmrc/bin/mm-api.json
+
 Token resolution (for deploy/pull):
   1. --token flag (highest priority)
   2. MMRC_TOKEN environment variable
@@ -19097,6 +19849,10 @@ Examples:
   mmrc build --src src/workflows
   mmrc deploy --build --src . --api-url http://localhost:4200/api/v1
   mmrc pull my-blueprint --out ./my-project
+  mmrc engine status
+  mmrc engine install
+  mmrc engine build
+  mmrc engine verify
     `);
   }
 }