@mmapp/react-compiler 0.1.0-alpha.7 → 0.1.0-alpha.9

package/dist/index.js

@@ -1874,18 +1874,6 @@ var init_component_extractor = __esm({
   }
 });
 
-// ../player-core/dist/index.mjs
-function normalizeCategory(primary, ...tags) {
-  const uniqueTags = [...new Set(tags.filter((t27) => t27 !== primary))];
-  uniqueTags.sort();
-  return [primary, ...uniqueTags];
-}
-var init_dist = __esm({
-  "../player-core/dist/index.mjs"() {
-    "use strict";
-  }
-});
-
 // src/babel/emitters/experience-transform.ts
 function transformToFrontend(node) {
   const result = {
@@ -2262,7 +2250,7 @@ function liftAction(action) {
   }
   return {
     slug: action.id,
-    category: normalizeCategory("expression", "mutation", action.type),
+    category: (0, import_player_core.normalizeCategory)("expression", "mutation", action.type),
     parts: parts.length > 0 ? parts : void 0
   };
 }
@@ -2292,7 +2280,7 @@ function liftSchedule(during) {
   for (const action of during.actions) {
     parts.push({
       slug: "do",
-      category: normalizeCategory("expression", "mutation", action.type),
+      category: (0, import_player_core.normalizeCategory)("expression", "mutation", action.type),
       parts: Object.entries(action.config || {}).map(([key, value]) => ({
         slug: key,
         category: ["atom"],
@@ -2302,7 +2290,7 @@ function liftSchedule(during) {
   }
   return {
     slug: during.id,
-    category: normalizeCategory("schedule", during.type),
+    category: (0, import_player_core.normalizeCategory)("schedule", during.type),
     parts
   };
 }
@@ -2315,14 +2303,14 @@ function liftState(state) {
   if (state.on_enter && state.on_enter.length > 0) {
     parts.push({
       slug: "on_enter",
-      category: normalizeCategory("expression", "sequence"),
+      category: (0, import_player_core.normalizeCategory)("expression", "sequence"),
       parts: state.on_enter.map(liftAction)
     });
   }
   if (state.on_exit && state.on_exit.length > 0) {
     parts.push({
       slug: "on_exit",
-      category: normalizeCategory("expression", "sequence"),
+      category: (0, import_player_core.normalizeCategory)("expression", "sequence"),
       parts: state.on_exit.map(liftAction)
     });
   }
@@ -2333,7 +2321,7 @@ function liftState(state) {
   }
   return {
     slug: state.name,
-    category: normalizeCategory("state", ...tags),
+    category: (0, import_player_core.normalizeCategory)("state", ...tags),
     parts: parts.length > 0 ? parts : void 0
   };
 }
@@ -2356,17 +2344,17 @@ function liftTransition(transition) {
   if (transition.actions && transition.actions.length > 0) {
     parts.push({
       slug: "actions",
-      category: normalizeCategory("expression", "sequence"),
+      category: (0, import_player_core.normalizeCategory)("expression", "sequence"),
       parts: transition.actions.map(liftAction)
     });
   }
   if (transition.conditions && transition.conditions.length > 0) {
     parts.push({
       slug: "conditions",
-      category: normalizeCategory("expression", "guard"),
+      category: (0, import_player_core.normalizeCategory)("expression", "guard"),
       parts: transition.conditions.map((c, i) => ({
         slug: `condition_${i}`,
-        category: normalizeCategory("expression", c.type || "condition"),
+        category: (0, import_player_core.normalizeCategory)("expression", c.type || "condition"),
         parts: c.expression ? [{ slug: c.expression, category: ["binding"] }] : void 0
       }))
     });
@@ -2405,7 +2393,7 @@ function liftField(field) {
   }
   return {
     slug: field.name,
-    category: normalizeCategory("field", field.type),
+    category: (0, import_player_core.normalizeCategory)("field", field.type),
     parts: parts.length > 0 ? parts : void 0
   };
 }
@@ -2428,20 +2416,20 @@ function liftView(node) {
         if (match) {
           parts.push({
             slug: key,
-            category: normalizeCategory("expression", "effect", "transition"),
+            category: (0, import_player_core.normalizeCategory)("expression", "effect", "transition"),
             parts: [{ slug: match[1], category: ["ref"] }]
           });
         } else {
           parts.push({
             slug: key,
-            category: normalizeCategory("expression", "binding"),
+            category: (0, import_player_core.normalizeCategory)("expression", "binding"),
             parts: [{ slug: String(expr), category: ["binding"] }]
           });
         }
       } else {
         parts.push({
           slug: key,
-          category: normalizeCategory("expression", "binding"),
+          category: (0, import_player_core.normalizeCategory)("expression", "binding"),
           parts: [{ slug: String(expr), category: ["binding"] }]
         });
       }
@@ -2452,20 +2440,20 @@ function liftView(node) {
     if (eqMatch) {
       parts.push({
         slug: "visible_when",
-        category: normalizeCategory("expression", "guard"),
+        category: (0, import_player_core.normalizeCategory)("expression", "guard"),
         parts: [{
           slug: "body",
-          category: normalizeCategory("expression", "eq"),
+          category: (0, import_player_core.normalizeCategory)("expression", "eq"),
           parts: [
-            { slug: "lhs", category: normalizeCategory("expression", "path"), parts: [{ slug: eqMatch[1], category: ["binding"] }] },
-            { slug: "rhs", category: normalizeCategory("expression", "literal"), parts: [{ slug: eqMatch[2], category: ["literal"] }] }
+            { slug: "lhs", category: (0, import_player_core.normalizeCategory)("expression", "path"), parts: [{ slug: eqMatch[1], category: ["binding"] }] },
+            { slug: "rhs", category: (0, import_player_core.normalizeCategory)("expression", "literal"), parts: [{ slug: eqMatch[2], category: ["literal"] }] }
           ]
         }]
       });
     } else {
       parts.push({
         slug: "visible_when",
-        category: normalizeCategory("expression", "guard"),
+        category: (0, import_player_core.normalizeCategory)("expression", "guard"),
         parts: [{ slug: node.visible_when, category: ["binding"] }]
       });
     }
@@ -2477,7 +2465,7 @@ function liftView(node) {
   }
   return {
     slug: node.id,
-    category: normalizeCategory("view", componentTag),
+    category: (0, import_player_core.normalizeCategory)("view", componentTag),
     parts: parts.length > 0 ? parts : void 0
   };
 }
@@ -2498,7 +2486,7 @@ function emitCanonical(extracted, sourceFilename) {
   }
   parts.push({
     slug: "manifest",
-    category: normalizeCategory("meta", "manifest"),
+    category: (0, import_player_core.normalizeCategory)("meta", "manifest"),
     parts: [
       {
         slug: "workflows",
@@ -2519,7 +2507,7 @@ function emitCanonical(extracted, sourceFilename) {
   let categoryArray;
   if (category.includes("/")) {
     const [primary, ...tags] = category.split("/");
-    categoryArray = normalizeCategory(primary, ...tags);
+    categoryArray = (0, import_player_core.normalizeCategory)(primary, ...tags);
   } else {
     categoryArray = [category];
   }
@@ -2688,11 +2676,11 @@ function compilerStateToWorkflow(state, metadata) {
     extraMetadata: Object.keys(extraMetadata).length > 0 ? extraMetadata : void 0
   };
 }
-var PROP_RULES, COMPONENT_RENAMES, RENAME_EXTRA_CONFIG, emitPureForm;
+var import_player_core, PROP_RULES, COMPONENT_RENAMES, RENAME_EXTRA_CONFIG, emitPureForm;
 var init_pure_form_emitter = __esm({
   "src/babel/emitters/pure-form-emitter.ts"() {
     "use strict";
-    init_dist();
+    import_player_core = require("@mmapp/player-core");
     init_transition_extractor();
     init_experience_transform();
     PROP_RULES = {
@@ -5232,7 +5220,7 @@ function extractImperativeWorkflow(path, state) {
       const source = node.source.value;
       for (const spec of node.specifiers) {
         const localName = spec.local.name;
-        if (source.includes("@mmapp/react") || source.includes("@mindmatrix/react")) {
+        if (source.includes("@mmapp/react") || source.includes("@mmapp/react")) {
           stdLibImports.add(localName);
         } else {
           importedFns.set(localName, source);
@@ -7425,7 +7413,7 @@ function createVisitor(options = {}) {
       if (mode === "strict" && STRICT_BANNED_HOOKS[hookName]) {
         const error = {
           code: STRICT_BANNED_HOOKS[hookName],
-          message: `${hookName}() is not allowed in strict mode. Use @mindmatrix/react effect hooks instead.`,
+          message: `${hookName}() is not allowed in strict mode. Use @mmapp/react effect hooks instead.`,
           line: path.node.loc?.start.line,
           column: path.node.loc?.start.column,
           severity: "error"
@@ -7517,12 +7505,12 @@ function createVisitor(options = {}) {
         }
       }
       if (mode !== "strict") return;
-      if (source.startsWith("@mindmatrix/") || source.startsWith("@mmapp/") || source === "react" || source.startsWith("react/") || source.startsWith(".") || source.startsWith("/")) {
+      if (source.startsWith("@mmapp/") || source.startsWith("@mmapp/") || source === "react" || source.startsWith("react/") || source.startsWith(".") || source.startsWith("/")) {
         return;
       }
       const error = {
         code: "STRICT_FORBIDDEN_IMPORT",
-        message: `Import from '${source}' is not allowed in strict mode. Only @mindmatrix/* and relative imports are permitted.`,
+        message: `Import from '${source}' is not allowed in strict mode. Only @mmapp/* and relative imports are permitted.`,
         line: path.node.loc?.start.line,
         column: path.node.loc?.start.column,
         severity: "error"
@@ -10628,249 +10616,795 @@ var init_project_compiler = __esm({
   }
 });
 
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  DIAGNOSTIC_CODES: () => DIAGNOSTIC_CODES,
-  DiagnosticCollector: () => DiagnosticCollector,
-  IncrementalCache: () => IncrementalCache,
-  IncrementalProjectCompiler: () => IncrementalProjectCompiler,
-  babelPlugin: () => babelPlugin,
-  build: () => build,
-  buildDependencyGraph: () => buildDependencyGraph,
-  buildEnvelope: () => buildEnvelope,
-  compileActions: () => compileActions,
-  compileModel: () => compileModel,
-  compileModels: () => compileModels,
-  compileProject: () => compileProject,
-  compileSource: () => compileSource,
-  compilerStateToWorkflow: () => compilerStateToWorkflow,
-  computeEnvelopeId: () => computeEnvelopeId,
-  computeTransitiveDirtySet: () => computeTransitiveDirtySet,
-  createDevServer: () => createDevServer,
-  createDiagnosticCollector: () => createDiagnosticCollector,
-  createSourceEnvelope: () => createSourceEnvelope,
-  createVisitor: () => createVisitor,
-  decompile: () => decompile,
-  decompileProject: () => decompileProject,
-  decompileToTSX: () => decompileToTSX,
-  deploy: () => deploy,
-  detectFileRole: () => detectFileRole,
-  diffEnvelopes: () => diffEnvelopes,
-  diffFsTrees: () => diffFsTrees,
-  emitCanonical: () => emitCanonical,
-  emitCompiledOutput: () => emitCompiledOutput,
-  emitIR: () => emitIR,
-  emitPureForm: () => emitPureForm,
-  envelopesEqual: () => envelopesEqual,
-  extractComponents: () => extractComponents,
-  extractComputed: () => extractComputed,
-  extractEffects: () => extractEffects,
-  extractEvents: () => extractEvents,
-  extractImports: () => extractImports,
-  extractRoutes: () => extractRoutes,
-  extractStates: () => extractStates,
-  extractTransitions: () => extractTransitions,
-  filterByRole: () => filterByRole,
-  generateFsTree: () => generateFsTree,
-  hashContent: () => hashContent,
-  normalizeDecompilerInput: () => normalizeDecompilerInput,
-  resolveActionReferences: () => resolveActionReferences,
-  resolveImport: () => resolveImport,
-  shouldDecompileAsProject: () => shouldDecompileAsProject,
-  topologicalSort: () => topologicalSort,
-  transformToFrontend: () => transformToFrontend,
-  validateRoundTrip: () => validateRoundTrip,
-  validateSourceRoundTrip: () => validateSourceRoundTrip
+// src/cli/auth.ts
+var auth_exports = {};
+__export(auth_exports, {
+  loadCredentials: () => loadCredentials,
+  login: () => login,
+  logout: () => logout,
+  resolveToken: () => resolveToken,
+  saveCredentials: () => saveCredentials,
+  whoami: () => whoami
 });
-module.exports = __toCommonJS(index_exports);
-init_state_extractor();
-init_effect_extractor();
-init_transition_extractor();
-init_event_extractor();
-init_component_extractor();
-init_pure_form_emitter();
-init_experience_transform();
-
-// src/decompiler/index.ts
-var t10 = __toESM(require("@babel/types"));
-var import_generator = __toESM(require("@babel/generator"));
-
-// src/decompiler/ast-builder.ts
-var t8 = __toESM(require("@babel/types"));
-var import_parser = require("@babel/parser");
-
-// src/decompiler/sx-emitter.ts
-var t7 = __toESM(require("@babel/types"));
-function isTRBL(v) {
-  if (typeof v !== "object" || v === null) return false;
-  const obj = v;
-  return typeof obj.top === "number" && typeof obj.right === "number" && typeof obj.bottom === "number" && typeof obj.left === "number";
-}
-function isFourCorners(v) {
-  if (typeof v !== "object" || v === null) return false;
-  const obj = v;
-  return typeof obj.topLeft === "number" && typeof obj.topRight === "number" && typeof obj.bottomRight === "number" && typeof obj.bottomLeft === "number";
-}
-function isTokenRef(v) {
-  if (typeof v !== "object" || v === null) return false;
-  return v.kind === "token-ref";
-}
-function emitSpacingShorthand(prefix, trbl) {
-  const { top, right, bottom, left } = trbl;
-  if (top === right && right === bottom && bottom === left) {
-    return [prop(prefix, top)];
-  }
-  if (top === bottom && left === right) {
-    return [
-      prop(`${prefix}y`, top),
-      prop(`${prefix}x`, left)
-    ];
+function loadCredentials() {
+  if (!(0, import_fs4.existsSync)(CREDENTIALS_PATH)) return {};
+  try {
+    return JSON.parse((0, import_fs4.readFileSync)(CREDENTIALS_PATH, "utf-8"));
+  } catch {
+    return {};
   }
-  return [
-    prop(`${prefix}t`, top),
-    prop(`${prefix}r`, right),
-    prop(`${prefix}b`, bottom),
-    prop(`${prefix}l`, left)
-  ];
 }
-function emitRadiusShorthand(corners) {
-  const { topLeft, topRight, bottomRight, bottomLeft } = corners;
-  if (topLeft === topRight && topRight === bottomRight && bottomRight === bottomLeft) {
-    return [prop("rounded", topLeft)];
+function saveCredentials(apiUrl, token) {
+  (0, import_fs4.mkdirSync)(MMRC_DIR, { recursive: true, mode: 448 });
+  const creds = loadCredentials();
+  creds[apiUrl] = { token, savedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  (0, import_fs4.writeFileSync)(CREDENTIALS_PATH, JSON.stringify(creds, null, 2), "utf-8");
+  try {
+    const { chmodSync } = require("fs");
+    chmodSync(CREDENTIALS_PATH, 384);
+  } catch {
   }
-  return [
-    prop("roundedTL", topLeft),
-    prop("roundedTR", topRight),
-    prop("roundedBR", bottomRight),
-    prop("roundedBL", bottomLeft)
-  ];
 }
-function emitColorValue(color) {
-  if (isTokenRef(color)) {
-    return t7.stringLiteral(`token:${color.name}`);
-  }
-  if (typeof color === "string") {
-    return t7.stringLiteral(color);
+function removeCredentials(apiUrl) {
+  if (!(0, import_fs4.existsSync)(CREDENTIALS_PATH)) return;
+  if (!apiUrl) {
+    (0, import_fs4.unlinkSync)(CREDENTIALS_PATH);
+    return;
   }
-  if (typeof color === "object" && color !== null) {
-    const c = color;
-    if (typeof c.r === "number" && typeof c.g === "number" && typeof c.b === "number") {
-      const a = typeof c.a === "number" ? c.a : 1;
-      if (a === 1) {
-        const hex = `#${hexByte(c.r)}${hexByte(c.g)}${hexByte(c.b)}`;
-        return t7.stringLiteral(hex);
-      }
-      return t7.stringLiteral(`rgba(${c.r}, ${c.g}, ${c.b}, ${a})`);
-    }
+  const creds = loadCredentials();
+  delete creds[apiUrl];
+  if (Object.keys(creds).length === 0) {
+    (0, import_fs4.unlinkSync)(CREDENTIALS_PATH);
+  } else {
+    (0, import_fs4.writeFileSync)(CREDENTIALS_PATH, JSON.stringify(creds, null, 2), "utf-8");
   }
-  return t7.stringLiteral("inherit");
 }
-function hexByte(n) {
-  return Math.round(n).toString(16).padStart(2, "0");
-}
-function prop(key, value) {
-  return t7.objectProperty(t7.identifier(key), valueToExpression(value));
+function resolveToken(apiUrl, explicitToken) {
+  if (explicitToken) return explicitToken;
+  const envToken = process.env.MMRC_TOKEN;
+  if (envToken) return envToken;
+  const creds = loadCredentials();
+  const entry = creds[apiUrl];
+  if (entry?.token) return entry.token;
+  return null;
 }
-function valueToExpression(value) {
-  if (typeof value === "string") return t7.stringLiteral(value);
-  if (typeof value === "number") return t7.numericLiteral(value);
-  if (typeof value === "boolean") return t7.booleanLiteral(value);
-  if (value === null) return t7.nullLiteral();
-  if (value === void 0) return t7.identifier("undefined");
-  if (Array.isArray(value)) {
-    return t7.arrayExpression(value.map((v) => valueToExpression(v)));
-  }
-  if (typeof value === "object") {
-    const entries = Object.entries(value);
-    return t7.objectExpression(
-      entries.map(
-        ([k, v]) => t7.objectProperty(t7.identifier(k), valueToExpression(v))
-      )
-    );
-  }
-  return t7.identifier("undefined");
+function prompt(question, hidden = false) {
+  return new Promise((resolve3) => {
+    const rl = (0, import_readline.createInterface)({
+      input: process.stdin,
+      output: process.stdout
+    });
+    if (hidden && process.stdin.isTTY) {
+      const origWrite = process.stdout.write.bind(process.stdout);
+      process.stdout.write = ((chunk, encodingOrCb, cb) => {
+        if (typeof chunk === "string" && chunk.includes(question)) {
+          return origWrite(chunk, encodingOrCb, cb);
+        }
+        if (typeof chunk === "string" && !chunk.includes("\n")) {
+          return true;
+        }
+        return origWrite(chunk, encodingOrCb, cb);
+      });
+      rl.question(question, (answer) => {
+        process.stdout.write = origWrite;
+        console.log();
+        rl.close();
+        resolve3(answer.trim());
+      });
+    } else {
+      rl.question(question, (answer) => {
+        rl.close();
+        resolve3(answer.trim());
+      });
+    }
+  });
 }
-var STATE_TO_SX_KEY = {
-  hovered: "hover",
-  pressed: "pressed",
-  focused: "focus",
-  selected: "selected",
-  disabled: "disabled"
-};
-function emitSxProp(style) {
-  if (!style || typeof style !== "object") return null;
-  const props = [];
-  if (style.padding && isTRBL(style.padding)) {
-    props.push(...emitSpacingShorthand("p", style.padding));
-  }
-  if (style.margin && isTRBL(style.margin)) {
-    props.push(...emitSpacingShorthand("m", style.margin));
-  }
-  if (style.backgroundColor) {
-    props.push(t7.objectProperty(
-      t7.identifier("bg"),
-      emitColorValue(style.backgroundColor)
-    ));
-  }
-  if (style.borderRadius && isFourCorners(style.borderRadius)) {
-    props.push(...emitRadiusShorthand(style.borderRadius));
-  }
-  if (typeof style.gap === "number") {
-    props.push(prop("gap", style.gap));
-  }
-  if (typeof style.flexDirection === "string") {
-    props.push(prop("direction", style.flexDirection));
-  }
-  if (typeof style.justifyContent === "string") {
-    props.push(prop("justify", style.justifyContent));
-  }
-  if (typeof style.alignItems === "string") {
-    props.push(prop("align", style.alignItems));
+async function login(apiUrl, email, password) {
+  if (!email) {
+    email = await prompt("Email: ");
   }
-  if (style.width !== void 0) props.push(prop("w", style.width));
-  if (style.height !== void 0) props.push(prop("h", style.height));
-  if (style.minWidth !== void 0) props.push(prop("minW", style.minWidth));
-  if (style.minHeight !== void 0) props.push(prop("minH", style.minHeight));
-  if (style.maxWidth !== void 0) props.push(prop("maxW", style.maxWidth));
-  if (style.maxHeight !== void 0) props.push(prop("maxH", style.maxHeight));
-  if (typeof style.opacity === "number") {
-    props.push(prop("opacity", style.opacity));
+  if (!password) {
+    password = await prompt("Password: ", true);
   }
-  if (style.color) {
-    props.push(t7.objectProperty(
-      t7.identifier("color"),
-      emitColorValue(style.color)
-    ));
+  if (!email || !password) {
+    throw new Error("Email and password are required");
   }
-  if (typeof style.overflow === "string") {
-    props.push(prop("overflow", style.overflow));
+  console.log(`[mmrc] Logging in to ${apiUrl}...`);
+  const res = await fetch(`${apiUrl}/auth/login`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ email, password })
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Login failed: ${res.status} ${text}`);
+  }
+  const data = await res.json();
+  const token = data.token ?? data.access_token ?? data.accessToken;
+  if (!token) {
+    throw new Error("Login succeeded but no token in response");
+  }
+  saveCredentials(apiUrl, token);
+  const userName = data.name ?? data.user?.name ?? data.user?.email ?? email;
+  console.log(`[mmrc] Logged in as ${userName}`);
+  console.log(`[mmrc] Token saved to ${CREDENTIALS_PATH}`);
+  return token;
+}
+function logout(apiUrl) {
+  if (apiUrl) {
+    removeCredentials(apiUrl);
+    console.log(`[mmrc] Credentials removed for ${apiUrl}`);
+  } else {
+    removeCredentials();
+    console.log("[mmrc] All saved credentials removed");
   }
-  if (typeof style.position === "string") {
-    props.push(prop("position", style.position));
+}
+async function whoami(apiUrl) {
+  const token = resolveToken(apiUrl);
+  if (!token) {
+    console.log("[mmrc] Not logged in. Run `mmrc login` to authenticate.");
+    return;
   }
-  if (typeof style.states === "object" && style.states !== null) {
-    for (const [state, override] of Object.entries(style.states)) {
-      const sxKey = STATE_TO_SX_KEY[state] || state;
-      if (typeof override === "object" && override !== null) {
-        const subProp = emitSxProp(override);
-        if (subProp && t7.isJSXExpressionContainer(subProp.value) && t7.isObjectExpression(subProp.value.expression)) {
-          props.push(t7.objectProperty(
-            t7.identifier(sxKey),
-            subProp.value.expression
-          ));
-        }
+  try {
+    const res = await fetch(`${apiUrl}/auth/me`, {
+      headers: { Authorization: `Bearer ${token}` }
+    });
+    if (!res.ok) {
+      if (res.status === 401) {
+        console.log("[mmrc] Token is expired or invalid. Run `mmrc login` to re-authenticate.");
+        return;
       }
+      console.log(`[mmrc] Failed to fetch user info: ${res.status}`);
+      return;
     }
+    const user = await res.json();
+    console.log(`[mmrc] Logged in to ${apiUrl}`);
+    console.log(`  Name:  ${user.name ?? "(unknown)"}`);
+    console.log(`  Email: ${user.email ?? "(unknown)"}`);
+    if (user.id) console.log(`  ID:    ${user.id}`);
+    if (user.role) console.log(`  Role:  ${user.role}`);
+  } catch (error) {
+    console.log(`[mmrc] Could not connect to ${apiUrl}: ${error.message}`);
   }
-  if (props.length === 0) return null;
-  return t7.jsxAttribute(
-    t7.jsxIdentifier("sx"),
-    t7.jsxExpressionContainer(t7.objectExpression(props))
-  );
 }
-
-// src/decompiler/ast-builder.ts
+var import_fs4, import_path3, import_os, import_readline, MMRC_DIR, CREDENTIALS_PATH;
+var init_auth = __esm({
+  "src/cli/auth.ts"() {
+    "use strict";
+    import_fs4 = require("fs");
+    import_path3 = require("path");
+    import_os = require("os");
+    import_readline = require("readline");
+    MMRC_DIR = (0, import_path3.join)((0, import_os.homedir)(), ".mmrc");
+    CREDENTIALS_PATH = (0, import_path3.join)(MMRC_DIR, "credentials.json");
+  }
+});
+
+// src/cli/deploy.ts
+var deploy_exports = {};
+__export(deploy_exports, {
+  deploy: () => deploy,
+  syncServices: () => syncServices
+});
+async function deploy(options) {
+  const dir = options.dir ?? "dist/workflows";
+  const targetLabel = options.targetName ? ` (target: ${options.targetName})` : "";
+  console.log(`[mindmatrix-react] Deploying workflows from ${dir} to ${options.apiUrl}${targetLabel}...`);
+  const files = await (0, import_glob2.glob)(`${dir}/**/*.workflow.json`);
+  if (files.length === 0) {
+    console.log(`[mindmatrix-react] No workflow files found in ${dir}`);
+    return { created: [], updated: [], versioned: [], skipped: [], failed: [] };
+  }
+  const result = {
+    created: [],
+    updated: [],
+    versioned: [],
+    skipped: [],
+    failed: []
+  };
+  const deployedIRs = [];
+  for (const file2 of files) {
+    try {
+      const ir = JSON.parse((0, import_fs5.readFileSync)(file2, "utf-8"));
+      const slug = ir.slug;
+      if (options.dryRun) {
+        console.log(`  [dry-run] Would deploy ${slug} (${(0, import_path4.basename)(file2)})`);
+        continue;
+      }
+      const existing = await fetchExistingDefinition(options.apiUrl, options.token, slug);
+      if (!existing) {
+        await createDefinition(options.apiUrl, options.token, ir);
+        console.log(`  \u2713 ${slug} (created)`);
+        result.created.push(slug);
+      } else if (existing.instanceCount === 0 || options.force) {
+        await updateDefinition(options.apiUrl, options.token, existing.id, ir);
+        console.log(`  \u2713 ${slug} (updated)`);
+        result.updated.push(slug);
+      } else {
+        const newVersion = bumpVersion(existing.version);
+        ir.version = newVersion;
+        await createDefinition(options.apiUrl, options.token, ir);
+        console.log(`  \u2713 ${slug} v${newVersion} (new version, ${existing.instanceCount} instances on v${existing.version})`);
+        result.versioned.push(slug);
+      }
+      deployedIRs.push(ir);
+    } catch (error) {
+      const slug = (0, import_path4.basename)(file2).replace(".workflow.json", "");
+      const msg = error.message;
+      console.error(`  \u2717 ${slug}: ${msg}`);
+      result.failed.push({ slug, error: msg });
+    }
+  }
+  if (!options.dryRun) {
+    for (const ir of deployedIRs) {
+      const serviceResult = await syncServices(options.apiUrl, options.token, ir);
+      if (serviceResult) {
+        if (!result.services) {
+          result.services = { registered: [], updated: [], failed: [] };
+        }
+        result.services.registered.push(...serviceResult.registered);
+        result.services.updated.push(...serviceResult.updated);
+        result.services.failed.push(...serviceResult.failed);
+      }
+    }
+  }
+  if (options.reportFile) {
+    (0, import_fs5.writeFileSync)(options.reportFile, JSON.stringify(result, null, 2), "utf-8");
+    console.log(`
+  Report written to ${options.reportFile}`);
+  }
+  const total = result.created.length + result.updated.length + result.versioned.length;
+  console.log(
+    `
+[mindmatrix-react] Deployed ${total} workflows (${result.created.length} created, ${result.updated.length} updated, ${result.versioned.length} versioned, ${result.failed.length} failed)`
+  );
+  if (result.services) {
+    const svcTotal = result.services.registered.length + result.services.updated.length;
+    if (svcTotal > 0 || result.services.failed.length > 0) {
+      console.log(
+        `[mindmatrix-react] Synced ${svcTotal} services (${result.services.registered.length} registered, ${result.services.updated.length} updated, ${result.services.failed.length} failed)`
+      );
+    }
+  }
+  return result;
+}
+async function fetchExistingDefinition(apiUrl, token, slug) {
+  try {
+    const res = await fetch(`${apiUrl}/workflow/definitions?slug=${encodeURIComponent(slug)}`, {
+      headers: { Authorization: `Bearer ${token}` }
+    });
+    if (!res.ok) return null;
+    const data = await res.json();
+    const definitions = Array.isArray(data) ? data : data.items ?? data.data;
+    if (!definitions || definitions.length === 0) return null;
+    const def = definitions[0];
+    return {
+      id: def.id,
+      slug: def.slug,
+      version: def.version || "0.1.0",
+      instanceCount: def.instanceCount ?? def.instance_count ?? 0
+    };
+  } catch {
+    return null;
+  }
+}
+async function createDefinition(apiUrl, token, ir) {
+  const res = await fetch(`${apiUrl}/workflow/definitions`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    },
+    body: JSON.stringify(ir)
+  });
+  if (!res.ok) {
+    const errorText = await res.text();
+    throw new Error(`Create failed: ${res.status} ${errorText}`);
+  }
+}
+async function updateDefinition(apiUrl, token, id, ir) {
+  const { slug: _slug, ...updatePayload } = ir;
+  const res = await fetch(`${apiUrl}/workflow/definitions/${id}`, {
+    method: "PATCH",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    },
+    body: JSON.stringify(updatePayload)
+  });
+  if (!res.ok) {
+    const errorText = await res.text();
+    throw new Error(`Update failed: ${res.status} ${errorText}`);
+  }
+}
+function bumpVersion(version) {
+  const parts = version.split(".");
+  if (parts.length !== 3) return `${version}.1`;
+  const patch = parseInt(parts[2], 10) || 0;
+  return `${parts[0]}.${parts[1]}.${patch + 1}`;
+}
+async function syncServices(apiUrl, token, ir) {
+  const metadata = ir.metadata;
+  const orchestration = metadata?.orchestration;
+  const services = orchestration?.services;
+  if (!services || Object.keys(services).length === 0) return null;
+  const result = { registered: [], updated: [], failed: [] };
+  for (const [name, config] of Object.entries(services)) {
+    try {
+      const registration = {
+        name,
+        connection: {
+          type: config.type || "webhook",
+          url: config.url,
+          queue: config.queue
+        },
+        actions: config.actions || [],
+        labels: config.labels || {}
+      };
+      const existing = await fetchExistingService(apiUrl, token, name);
+      if (existing) {
+        await fetch(`${apiUrl}/services/${existing.id}`, {
+          method: "PATCH",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${token}`
+          },
+          body: JSON.stringify(registration)
+        });
+        console.log(`  \u2713 service: ${name} (updated)`);
+        result.updated.push(name);
+      } else {
+        const res = await fetch(`${apiUrl}/services`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${token}`
+          },
+          body: JSON.stringify(registration)
+        });
+        if (!res.ok) {
+          const errorText = await res.text();
+          throw new Error(`Register failed: ${res.status} ${errorText}`);
+        }
+        console.log(`  \u2713 service: ${name} (registered)`);
+        result.registered.push(name);
+      }
+    } catch (error) {
+      const msg = error.message;
+      console.error(`  \u2717 service: ${name}: ${msg}`);
+      result.failed.push(name);
+    }
+  }
+  return result;
+}
+async function fetchExistingService(apiUrl, token, name) {
+  try {
+    const res = await fetch(`${apiUrl}/services?name=${encodeURIComponent(name)}`, {
+      headers: { Authorization: `Bearer ${token}` }
+    });
+    if (!res.ok) return null;
+    const data = await res.json();
+    const servicesList = Array.isArray(data) ? data : data.services ?? data.items ?? data.data;
+    if (!servicesList || servicesList.length === 0) return null;
+    const found = servicesList.find((s) => s.name === name);
+    return found ? { id: found.id, name: found.name } : null;
+  } catch {
+    return null;
+  }
+}
+var import_glob2, import_fs5, import_path4;
+var init_deploy = __esm({
+  "src/cli/deploy.ts"() {
+    "use strict";
+    import_glob2 = require("glob");
+    import_fs5 = require("fs");
+    import_path4 = require("path");
+  }
+});
+
+// src/cli/seed.ts
+var seed_exports = {};
+__export(seed_exports, {
+  generateFieldValue: () => generateFieldValue,
+  generateInstanceData: () => generateInstanceData,
+  seedInstances: () => seedInstances
+});
+function randomInt(min, max) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+function randomPick(arr) {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+function loremSentence(words = 5) {
+  const result = [];
+  for (let i = 0; i < words; i++) result.push(randomPick(LOREM_WORDS));
+  const s = result.join(" ");
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function generateFieldValue(field, index) {
+  if (field.default_value !== void 0 && field.default_value !== null) {
+    return field.default_value;
+  }
+  if (field.options && field.options.length > 0) {
+    return field.options[index % field.options.length].value;
+  }
+  const ft = (field.field_type ?? field.type ?? "text").toLowerCase();
+  switch (ft) {
+    case "text":
+    case "string":
+    case "textarea":
+    case "rich_text": {
+      const name = field.name.toLowerCase();
+      if (name.includes("email")) return `${randomPick(FIRST_NAMES).toLowerCase()}${++_counter}@${randomPick(DOMAINS)}`;
+      if (name.includes("name") && name.includes("first")) return randomPick(FIRST_NAMES);
+      if (name.includes("name") && name.includes("last")) return randomPick(LAST_NAMES);
+      if (name.includes("name") || name === "title") return `${randomPick(FIRST_NAMES)} ${randomPick(LAST_NAMES)}`;
+      if (name.includes("company") || name.includes("org")) return randomPick(COMPANIES);
+      if (name.includes("phone")) return `+1-555-${randomInt(100, 999)}-${randomInt(1e3, 9999)}`;
+      if (name.includes("url") || name.includes("website")) return `https://${randomPick(DOMAINS)}/${field.name}`;
+      if (name.includes("description") || name.includes("note") || name.includes("comment")) return loremSentence(randomInt(8, 15));
+      if (name.includes("address")) return `${randomInt(100, 9999)} ${loremSentence(2)} St`;
+      return loremSentence(randomInt(2, 5));
+    }
+    case "number":
+    case "numeric":
+    case "integer":
+    case "int": {
+      const name = field.name.toLowerCase();
+      if (name.includes("price") || name.includes("amount") || name.includes("cost") || name.includes("salary"))
+        return randomInt(1e3, 99999) / 100;
+      if (name.includes("age")) return randomInt(18, 65);
+      if (name.includes("quantity") || name.includes("count") || name.includes("qty")) return randomInt(1, 100);
+      if (name.includes("percent") || name.includes("rate")) return randomInt(1, 100);
+      return randomInt(1, 1e3);
+    }
+    case "currency":
+    case "decimal":
+      return randomInt(100, 999999) / 100;
+    case "boolean":
+    case "bool":
+    case "checkbox":
+    case "toggle":
+      return index % 2 === 0;
+    case "date":
+    case "datetime":
+    case "timestamptz": {
+      const d = /* @__PURE__ */ new Date();
+      d.setDate(d.getDate() - randomInt(0, 365));
+      return d.toISOString().split("T")[0];
+    }
+    case "select":
+    case "enum":
+    case "multi_select":
+      return field.options?.[index % (field.options?.length || 1)]?.value ?? "option_1";
+    case "email":
+      return `${randomPick(FIRST_NAMES).toLowerCase()}${++_counter}@${randomPick(DOMAINS)}`;
+    case "url":
+      return `https://${randomPick(DOMAINS)}/${field.name}`;
+    case "json":
+    case "object":
+      return {};
+    case "array":
+      return [];
+    default:
+      return loremSentence(3);
+  }
+}
+function generateInstanceData(fields, index) {
+  const data = {};
+  for (const field of fields) {
+    if (field.name === "id" || field.name === "created_at" || field.name === "updated_at") continue;
+    data[field.name] = generateFieldValue(field, index);
+  }
+  return data;
+}
+async function seedInstances(options) {
+  const dir = options.dir ?? "dist/workflows";
+  const count = options.count ?? 7;
+  const result = { created: 0, definitions: 0, errors: [] };
+  const files = await (0, import_glob3.glob)(`${dir}/**/*.workflow.json`);
+  if (files.length === 0) return result;
+  for (const file2 of files) {
+    let def;
+    try {
+      def = JSON.parse((0, import_fs6.readFileSync)(file2, "utf-8"));
+    } catch {
+      continue;
+    }
+    if (!def.slug || !def.fields || def.fields.length === 0) continue;
+    const startState = def.states?.find((s) => s.state_type === "START")?.name ?? def.states?.[0]?.name ?? "initial";
+    let defCreated = 0;
+    for (let i = 0; i < count; i++) {
+      const stateData = generateInstanceData(def.fields, i);
+      try {
+        const resp = await fetch(`${options.apiUrl}/workflow/instances`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${options.token}`
+          },
+          body: JSON.stringify({
+            definition_slug: def.slug,
+            initial_state: startState,
+            state_data: stateData
+          })
+        });
+        if (resp.ok) {
+          defCreated++;
+        } else {
+          const errText = await resp.text().catch(() => resp.statusText);
+          result.errors.push(`${def.slug}[${i}]: ${resp.status} ${errText}`);
+        }
+      } catch (e) {
+        result.errors.push(`${def.slug}[${i}]: ${e instanceof Error ? e.message : String(e)}`);
+      }
+    }
+    if (defCreated > 0) {
+      result.definitions++;
+      result.created += defCreated;
+      console.log(`  [seed] ${def.slug}: ${defCreated} instances created`);
+    }
+  }
+  return result;
+}
+var import_fs6, import_glob3, FIRST_NAMES, LAST_NAMES, COMPANIES, LOREM_WORDS, DOMAINS, _counter;
+var init_seed = __esm({
+  "src/cli/seed.ts"() {
+    "use strict";
+    import_fs6 = require("fs");
+    import_glob3 = require("glob");
+    FIRST_NAMES = ["Alice", "Bob", "Charlie", "Diana", "Eve", "Frank", "Grace", "Henry"];
+    LAST_NAMES = ["Smith", "Johnson", "Williams", "Brown", "Jones", "Garcia", "Miller", "Davis"];
+    COMPANIES = ["Acme Corp", "TechStart Inc", "GlobalTrade Ltd", "DataFlow Systems", "CloudPeak"];
+    LOREM_WORDS = ["lorem", "ipsum", "dolor", "sit", "amet", "consectetur", "adipiscing", "elit", "sed", "do", "eiusmod", "tempor"];
+    DOMAINS = ["example.com", "test.org", "demo.io", "sample.net"];
+    _counter = 0;
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DIAGNOSTIC_CODES: () => DIAGNOSTIC_CODES,
+  DiagnosticCollector: () => DiagnosticCollector,
+  IncrementalCache: () => IncrementalCache,
+  IncrementalProjectCompiler: () => IncrementalProjectCompiler,
+  babelPlugin: () => babelPlugin,
+  build: () => build,
+  buildDependencyGraph: () => buildDependencyGraph,
+  buildEnvelope: () => buildEnvelope,
+  compileActions: () => compileActions,
+  compileModel: () => compileModel,
+  compileModels: () => compileModels,
+  compileProject: () => compileProject,
+  compileSource: () => compileSource,
+  compilerStateToWorkflow: () => compilerStateToWorkflow,
+  computeEnvelopeId: () => computeEnvelopeId,
+  computeTransitiveDirtySet: () => computeTransitiveDirtySet,
+  createDevServer: () => createDevServer,
+  createDiagnosticCollector: () => createDiagnosticCollector,
+  createSourceEnvelope: () => createSourceEnvelope,
+  createVisitor: () => createVisitor,
+  decompile: () => decompile,
+  decompileProject: () => decompileProject,
+  decompileToTSX: () => decompileToTSX,
+  deploy: () => deploy,
+  detectFileRole: () => detectFileRole,
+  diffEnvelopes: () => diffEnvelopes,
+  diffFsTrees: () => diffFsTrees,
+  emitCanonical: () => emitCanonical,
+  emitCompiledOutput: () => emitCompiledOutput,
+  emitIR: () => emitIR,
+  emitPureForm: () => emitPureForm,
+  envelopesEqual: () => envelopesEqual,
+  extractComponents: () => extractComponents,
+  extractComputed: () => extractComputed,
+  extractEffects: () => extractEffects,
+  extractEvents: () => extractEvents,
+  extractImports: () => extractImports,
+  extractRoutes: () => extractRoutes,
+  extractStates: () => extractStates,
+  extractTransitions: () => extractTransitions,
+  filterByRole: () => filterByRole,
+  generateFsTree: () => generateFsTree,
+  hashContent: () => hashContent,
+  normalizeDecompilerInput: () => normalizeDecompilerInput,
+  resolveActionReferences: () => resolveActionReferences,
+  resolveImport: () => resolveImport,
+  shouldDecompileAsProject: () => shouldDecompileAsProject,
+  topologicalSort: () => topologicalSort,
+  transformToFrontend: () => transformToFrontend,
+  validateRoundTrip: () => validateRoundTrip,
+  validateSourceRoundTrip: () => validateSourceRoundTrip
+});
+module.exports = __toCommonJS(index_exports);
+init_state_extractor();
+init_effect_extractor();
+init_transition_extractor();
+init_event_extractor();
+init_component_extractor();
+init_pure_form_emitter();
+init_experience_transform();
+
+// src/decompiler/index.ts
+var t10 = __toESM(require("@babel/types"));
+var import_generator = __toESM(require("@babel/generator"));
+
+// src/decompiler/ast-builder.ts
+var t8 = __toESM(require("@babel/types"));
+var import_parser = require("@babel/parser");
+
+// src/decompiler/sx-emitter.ts
+var t7 = __toESM(require("@babel/types"));
+function isTRBL(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const obj = v;
+  return typeof obj.top === "number" && typeof obj.right === "number" && typeof obj.bottom === "number" && typeof obj.left === "number";
+}
+function isFourCorners(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const obj = v;
+  return typeof obj.topLeft === "number" && typeof obj.topRight === "number" && typeof obj.bottomRight === "number" && typeof obj.bottomLeft === "number";
+}
+function isTokenRef(v) {
+  if (typeof v !== "object" || v === null) return false;
+  return v.kind === "token-ref";
+}
+function emitSpacingShorthand(prefix, trbl) {
+  const { top, right, bottom, left } = trbl;
+  if (top === right && right === bottom && bottom === left) {
+    return [prop(prefix, top)];
+  }
+  if (top === bottom && left === right) {
+    return [
+      prop(`${prefix}y`, top),
+      prop(`${prefix}x`, left)
+    ];
+  }
+  return [
+    prop(`${prefix}t`, top),
+    prop(`${prefix}r`, right),
+    prop(`${prefix}b`, bottom),
+    prop(`${prefix}l`, left)
+  ];
+}
+function emitRadiusShorthand(corners) {
+  const { topLeft, topRight, bottomRight, bottomLeft } = corners;
+  if (topLeft === topRight && topRight === bottomRight && bottomRight === bottomLeft) {
+    return [prop("rounded", topLeft)];
+  }
+  return [
+    prop("roundedTL", topLeft),
+    prop("roundedTR", topRight),
+    prop("roundedBR", bottomRight),
+    prop("roundedBL", bottomLeft)
+  ];
+}
+function emitColorValue(color) {
+  if (isTokenRef(color)) {
+    return t7.stringLiteral(`token:${color.name}`);
+  }
+  if (typeof color === "string") {
+    return t7.stringLiteral(color);
+  }
+  if (typeof color === "object" && color !== null) {
+    const c = color;
+    if (typeof c.r === "number" && typeof c.g === "number" && typeof c.b === "number") {
+      const a = typeof c.a === "number" ? c.a : 1;
+      if (a === 1) {
+        const hex = `#${hexByte(c.r)}${hexByte(c.g)}${hexByte(c.b)}`;
+        return t7.stringLiteral(hex);
+      }
+      return t7.stringLiteral(`rgba(${c.r}, ${c.g}, ${c.b}, ${a})`);
+    }
+  }
+  return t7.stringLiteral("inherit");
+}
+function hexByte(n) {
+  return Math.round(n).toString(16).padStart(2, "0");
+}
+function prop(key, value) {
+  return t7.objectProperty(t7.identifier(key), valueToExpression(value));
+}
+function valueToExpression(value) {
+  if (typeof value === "string") return t7.stringLiteral(value);
+  if (typeof value === "number") return t7.numericLiteral(value);
+  if (typeof value === "boolean") return t7.booleanLiteral(value);
+  if (value === null) return t7.nullLiteral();
+  if (value === void 0) return t7.identifier("undefined");
+  if (Array.isArray(value)) {
+    return t7.arrayExpression(value.map((v) => valueToExpression(v)));
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value);
+    return t7.objectExpression(
+      entries.map(
+        ([k, v]) => t7.objectProperty(t7.identifier(k), valueToExpression(v))
+      )
+    );
+  }
+  return t7.identifier("undefined");
+}
+var STATE_TO_SX_KEY = {
+  hovered: "hover",
+  pressed: "pressed",
+  focused: "focus",
+  selected: "selected",
+  disabled: "disabled"
+};
+function emitSxProp(style) {
+  if (!style || typeof style !== "object") return null;
+  const props = [];
+  if (style.padding && isTRBL(style.padding)) {
+    props.push(...emitSpacingShorthand("p", style.padding));
+  }
+  if (style.margin && isTRBL(style.margin)) {
+    props.push(...emitSpacingShorthand("m", style.margin));
+  }
+  if (style.backgroundColor) {
+    props.push(t7.objectProperty(
+      t7.identifier("bg"),
+      emitColorValue(style.backgroundColor)
+    ));
+  }
+  if (style.borderRadius && isFourCorners(style.borderRadius)) {
+    props.push(...emitRadiusShorthand(style.borderRadius));
+  }
+  if (typeof style.gap === "number") {
+    props.push(prop("gap", style.gap));
+  }
+  if (typeof style.flexDirection === "string") {
+    props.push(prop("direction", style.flexDirection));
+  }
+  if (typeof style.justifyContent === "string") {
+    props.push(prop("justify", style.justifyContent));
+  }
+  if (typeof style.alignItems === "string") {
+    props.push(prop("align", style.alignItems));
+  }
+  if (style.width !== void 0) props.push(prop("w", style.width));
+  if (style.height !== void 0) props.push(prop("h", style.height));
+  if (style.minWidth !== void 0) props.push(prop("minW", style.minWidth));
+  if (style.minHeight !== void 0) props.push(prop("minH", style.minHeight));
+  if (style.maxWidth !== void 0) props.push(prop("maxW", style.maxWidth));
+  if (style.maxHeight !== void 0) props.push(prop("maxH", style.maxHeight));
+  if (typeof style.opacity === "number") {
+    props.push(prop("opacity", style.opacity));
+  }
+  if (style.color) {
+    props.push(t7.objectProperty(
+      t7.identifier("color"),
+      emitColorValue(style.color)
+    ));
+  }
+  if (typeof style.overflow === "string") {
+    props.push(prop("overflow", style.overflow));
+  }
+  if (typeof style.position === "string") {
+    props.push(prop("position", style.position));
+  }
+  if (typeof style.states === "object" && style.states !== null) {
+    for (const [state, override] of Object.entries(style.states)) {
+      const sxKey = STATE_TO_SX_KEY[state] || state;
+      if (typeof override === "object" && override !== null) {
+        const subProp = emitSxProp(override);
+        if (subProp && t7.isJSXExpressionContainer(subProp.value) && t7.isObjectExpression(subProp.value.expression)) {
+          props.push(t7.objectProperty(
+            t7.identifier(sxKey),
+            subProp.value.expression
+          ));
+        }
+      }
+    }
+  }
+  if (props.length === 0) return null;
+  return t7.jsxAttribute(
+    t7.jsxIdentifier("sx"),
+    t7.jsxExpressionContainer(t7.objectExpression(props))
+  );
+}
+
+// src/decompiler/ast-builder.ts
 function buildSymbolTable(fields, metadata, transitions, experience) {
   const locals = /* @__PURE__ */ new Map();
   const setters = /* @__PURE__ */ new Map();
@@ -11128,7 +11662,7 @@ function buildJSXTree(node, imports, symbols) {
   }
   const componentName = node.component;
   if (REACT_ATOMS.has(componentName)) {
-    addImport(imports, "@mindmatrix/react", componentName);
+    addImport(imports, "@mmapp/react", componentName);
   }
   const attributes = [];
   if (node.config) {
@@ -11173,7 +11707,7 @@ function buildJSXTree(node, imports, symbols) {
     isSelfClosing
   );
   if (node.visible_when) {
-    addImport(imports, "@mindmatrix/react", "Show");
+    addImport(imports, "@mmapp/react", "Show");
     return t8.jsxElement(
       t8.jsxOpeningElement(
         t8.jsxIdentifier("Show"),
@@ -11254,7 +11788,7 @@ function fieldTypeAnnotation(field) {
 }
 function emitFieldDeclarations(fields, imports) {
   if (fields.length === 0) return [];
-  addImport2(imports, "@mindmatrix/react", "useState");
+  addImport2(imports, "@mmapp/react", "useState");
   const statements = [];
   for (const field of fields) {
     if (field.computed) continue;
@@ -11318,7 +11852,7 @@ function emitStateEffects(states, imports) {
   const statements = [];
   for (const state of states) {
     if (state.on_enter.length > 0) {
-      addImport2(imports, "@mindmatrix/react", "useOnEnter");
+      addImport2(imports, "@mmapp/react", "useOnEnter");
       statements.push(
         t9.expressionStatement(
           t9.callExpression(t9.identifier("useOnEnter"), [
@@ -11329,7 +11863,7 @@ function emitStateEffects(states, imports) {
       );
     }
     if (state.on_exit.length > 0) {
-      addImport2(imports, "@mindmatrix/react", "useOnExit");
+      addImport2(imports, "@mmapp/react", "useOnExit");
       statements.push(
         t9.expressionStatement(
           t9.callExpression(t9.identifier("useOnExit"), [
@@ -11340,7 +11874,7 @@ function emitStateEffects(states, imports) {
       );
     }
     if (state.during.length > 0) {
-      addImport2(imports, "@mindmatrix/react", "useWhileIn");
+      addImport2(imports, "@mmapp/react", "useWhileIn");
       for (const during of state.during) {
         const args = [
           t9.stringLiteral(state.name)
@@ -11361,7 +11895,7 @@ function emitStateEffects(states, imports) {
 }
 function emitTransitionDeclarations(transitions, imports) {
   if (transitions.length === 0) return [];
-  addImport2(imports, "@mindmatrix/react", "useTransition");
+  addImport2(imports, "@mmapp/react", "useTransition");
   const correctedTransitions = correctFromFields(transitions);
   const statements = [];
   for (const transition of correctedTransitions) {
@@ -11596,7 +12130,7 @@ function emitSingleCondition(cond) {
 function emitRoleDeclarations(metadata, imports) {
   const roleDeps = metadata?.roleDependencies;
   if (!roleDeps || roleDeps.length === 0) return [];
-  addImport2(imports, "@mindmatrix/react", "useRole");
+  addImport2(imports, "@mmapp/react", "useRole");
   const statements = [];
   for (const role of roleDeps) {
     const varName = `is${toPascalCase(role)}`;
@@ -11617,7 +12151,7 @@ function emitQueryDeclarations(metadata, imports) {
   const modelImports = metadata?.modelImports;
   const addedModelImports = /* @__PURE__ */ new Set();
   if (dataSources && dataSources.length > 0) {
-    addImport2(imports, "@mindmatrix/react", "useQuery");
+    addImport2(imports, "@mmapp/react", "useQuery");
     const usedVarNames = /* @__PURE__ */ new Set();
     for (const ds of dataSources) {
       if (ds.type !== "workflow") continue;
@@ -11684,7 +12218,7 @@ function emitQueryDeclarations(metadata, imports) {
   }
   const mutationTargets = metadata?.mutationTargets;
   if (mutationTargets && mutationTargets.length > 0) {
-    addImport2(imports, "@mindmatrix/react", "useMutation");
+    addImport2(imports, "@mmapp/react", "useMutation");
     for (const slug of mutationTargets) {
       const modelPath = modelImports?.[slug];
       const modelVarName2 = modelPath ? `${toCamelCase2(slug.replace(/-/g, "_"))}Model` : void 0;
@@ -11709,7 +12243,7 @@ function emitQueryDeclarations(metadata, imports) {
 function emitChangeWatchers(metadata, imports) {
   const watchers = metadata?.fieldWatchers;
   if (!watchers || watchers.length === 0) return [];
-  addImport2(imports, "@mindmatrix/react", "useOnChange");
+  addImport2(imports, "@mmapp/react", "useOnChange");
   const statements = [];
   for (const watcher of watchers) {
     statements.push(
@@ -11725,7 +12259,7 @@ function emitChangeWatchers(metadata, imports) {
 }
 function emitEventSubscriptions(onEvent, imports) {
   if (!onEvent || onEvent.length === 0) return [];
-  addImport2(imports, "@mindmatrix/react", "useOnEvent");
+  addImport2(imports, "@mmapp/react", "useOnEvent");
   const statements = [];
   for (const sub of onEvent) {
     const actions = sub.actions.map((a, i) => ({
@@ -11752,7 +12286,7 @@ function emitEventSubscriptions(onEvent, imports) {
 function emitTransitionEffects(metadata, imports) {
   const effects = metadata?.transitionEffects;
   if (!effects || effects.length === 0) return [];
-  addImport2(imports, "@mindmatrix/react", "useOnTransition");
+  addImport2(imports, "@mmapp/react", "useOnTransition");
   const statements = [];
   for (const effect of effects) {
     statements.push(
@@ -11783,7 +12317,7 @@ function emitLocalDefaultDeclarations(experience, existingFields, imports) {
     const camelName = toCamelCase2(key);
     if (emittedCamelNames.has(camelName)) continue;
     emittedCamelNames.add(camelName);
-    addImport2(imports, "@mindmatrix/react", "useState");
+    addImport2(imports, "@mmapp/react", "useState");
     const setter = `set${toPascalCase(key)}`;
     let defaultExpr;
     if (value === void 0 || value === null) {
@@ -11996,7 +12530,7 @@ function generateServerActionFile(actions) {
     ` * Each receives a TransitionContext with instance data and utilities.`,
     ` */`,
     ``,
-    `import type { TransitionContext } from '@mindmatrix/react';`,
+    `import type { TransitionContext } from '@mmapp/react';`,
     ``
   ];
   for (const action of actions) {
@@ -12069,7 +12603,7 @@ function generateConfigFile(def) {
     ` * Blueprint configuration for "${def.name || pascalCase(def.slug)}".`,
     ` */`,
     ``,
-    `import { defineBlueprint } from '@mindmatrix/react';`,
+    `import { defineBlueprint } from '@mmapp/react';`,
     ``,
     `export default defineBlueprint({`,
     `  slug: '${def.slug}',`,
@@ -12164,7 +12698,7 @@ function generateMainFile(def, pages, hasModel, serverActionNames, options) {
   reactImports.add("Stack");
   if (reactImports.size > 0) {
     const sorted = [...reactImports].sort();
-    importLines.push(`import { ${sorted.join(", ")} } from '@mindmatrix/react';`);
+    importLines.push(`import { ${sorted.join(", ")} } from '@mmapp/react';`);
   }
   if (hasModel) {
     const typeName = pascalCase(slug);
@@ -13361,27 +13895,580 @@ async function startWatchMode(options) {
   console.log(`
 [mindmatrix-react] Watching ${srcDir} for changes... (Ctrl+C to stop)
 `);
-  fsWatch(srcDir, { recursive: true }, (_event, filename) => {
-    if (!filename) return;
-    if (!filename.match(/\.(tsx?|jsx?)$/)) return;
-    if (filename.includes("node_modules") || filename.includes("dist")) return;
-    if (debounce) clearTimeout(debounce);
-    debounce = setTimeout(async () => {
-      const ts = (/* @__PURE__ */ new Date()).toLocaleTimeString();
-      console.log(`
-[${ts}] Change detected: ${filename} \u2014 recompiling...`);
-      try {
-        await build({ ...options, watch: false, skipTypeCheck: true });
-      } catch (e) {
-        console.error(`[mindmatrix-react] Rebuild failed:`, e.message);
-      }
-    }, 300);
-  });
-  return new Promise(() => {
-  });
+  fsWatch(srcDir, { recursive: true }, (_event, filename) => {
+    if (!filename) return;
+    if (!filename.match(/\.(tsx?|jsx?)$/)) return;
+    if (filename.includes("node_modules") || filename.includes("dist")) return;
+    if (debounce) clearTimeout(debounce);
+    debounce = setTimeout(async () => {
+      const ts = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+      console.log(`
+[${ts}] Change detected: ${filename} \u2014 recompiling...`);
+      try {
+        await build({ ...options, watch: false, skipTypeCheck: true });
+      } catch (e) {
+        console.error(`[mindmatrix-react] Rebuild failed:`, e.message);
+      }
+    }, 300);
+  });
+  return new Promise(() => {
+  });
+}
+
+// src/cli/local-server.ts
+var http = __toESM(require("http"));
+var import_node_crypto = require("crypto");
+var MemoryStore = class {
+  constructor() {
+    this.definitions = /* @__PURE__ */ new Map();
+    this.instances = /* @__PURE__ */ new Map();
+    this.slugIndex = /* @__PURE__ */ new Map();
+  }
+  // slug → id
+  // ── Definitions ──────────────────────────────────────────────────────
+  createDefinition(input) {
+    if (this.slugIndex.has(input.slug)) {
+      const existing = this.definitions.get(this.slugIndex.get(input.slug));
+      if (existing) return existing;
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const def = {
+      id: input.id ?? (0, import_node_crypto.randomUUID)(),
+      slug: input.slug,
+      name: input.name,
+      version: input.version ?? "1.0.0",
+      description: input.description ?? null,
+      category: input.category ?? "workflow",
+      fields: input.fields ?? [],
+      states: input.states ?? [],
+      transitions: input.transitions ?? [],
+      roles: input.roles ?? [],
+      experience: input.experience ?? null,
+      metadata: input.metadata ?? {},
+      child_definitions: input.child_definitions ?? [],
+      is_immutable: input.is_immutable ?? false,
+      tags: input.tags ?? [],
+      inline_tags: input.inline_tags ?? [],
+      created_at: now,
+      updated_at: now
+    };
+    this.definitions.set(def.id, def);
+    this.slugIndex.set(def.slug, def.id);
+    return def;
+  }
+  getDefinition(idOrSlug) {
+    const byId = this.definitions.get(idOrSlug);
+    if (byId) return byId;
+    const id = this.slugIndex.get(idOrSlug);
+    if (id) return this.definitions.get(id);
+    return void 0;
+  }
+  listDefinitions(opts) {
+    let items = Array.from(this.definitions.values());
+    if (opts?.category) {
+      items = items.filter((d) => d.category === opts.category);
+    }
+    const total = items.length;
+    const offset = opts?.offset ?? 0;
+    const limit = opts?.limit ?? 50;
+    items = items.slice(offset, offset + limit);
+    return { items, total };
+  }
+  patchDefinition(id, patch) {
+    const def = this.definitions.get(id);
+    if (!def) return void 0;
+    Object.assign(def, patch, { updated_at: (/* @__PURE__ */ new Date()).toISOString() });
+    return def;
+  }
+  deleteDefinition(id) {
+    const def = this.definitions.get(id);
+    if (!def) return false;
+    this.slugIndex.delete(def.slug);
+    this.definitions.delete(id);
+    return true;
+  }
+  // ── Instances ────────────────────────────────────────────────────────
+  createInstance(input) {
+    const def = this.getDefinition(input.definition_id) ?? this.getDefinition(input.definition_slug);
+    if (!def) return null;
+    const initialState = def.states.find((s) => s.type === "START" || s.type === "initial");
+    const stateName = initialState?.name ?? "initial";
+    const stateData = {};
+    for (const field of def.fields) {
+      if (field.default_value !== void 0) {
+        stateData[field.name] = field.default_value;
+      }
+    }
+    Object.assign(stateData, input.state_data ?? {});
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const inst = {
+      id: (0, import_node_crypto.randomUUID)(),
+      definition_id: def.id,
+      definition_slug: def.slug,
+      current_state: stateName,
+      state_data: stateData,
+      execution_lock_version: 0,
+      event_log: [{
+        event_type: "transition",
+        message: `Instance created in state '${stateName}'`,
+        timestamp: now
+      }],
+      created_at: now,
+      updated_at: now
+    };
+    this.instances.set(inst.id, inst);
+    return inst;
+  }
+  getInstance(id) {
+    return this.instances.get(id);
+  }
+  listInstances(opts) {
+    let items = Array.from(this.instances.values());
+    if (opts?.definition_id) {
+      items = items.filter((i) => i.definition_id === opts.definition_id);
+    }
+    const total = items.length;
+    const offset = opts?.offset ?? 0;
+    const limit = opts?.limit ?? 50;
+    items = items.slice(offset, offset + limit);
+    return { items, total };
+  }
+  // ── Execute Action (Transition) ──────────────────────────────────────
+  executeAction(input) {
+    const def = this.getDefinition(input.definition_id);
+    if (!def) return { success: false, error: "Definition not found" };
+    let inst;
+    if (input.instance_id) {
+      const existing = this.instances.get(input.instance_id);
+      if (!existing) return { success: false, error: "Instance not found" };
+      inst = existing;
+    } else {
+      const created = this.createInstance({
+        definition_id: def.id,
+        definition_slug: def.slug,
+        state_data: input.payload
+      });
+      if (!created) return { success: false, error: "Failed to create instance" };
+      inst = created;
+    }
+    if (input.payload && input.instance_id) {
+      Object.assign(inst.state_data, input.payload);
+    }
+    const transition = def.transitions.find((t27) => t27.name === input.action_name && t27.from.includes(inst.current_state));
+    if (!transition) {
+      return {
+        success: false,
+        instance_id: inst.id,
+        from_state: inst.current_state,
+        to_state: null,
+        state_data: inst.state_data,
+        error: `No transition '${input.action_name}' from state '${inst.current_state}'`
+      };
+    }
+    const fromState = inst.current_state;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const events = [];
+    let lastEvalResult = null;
+    events.push({ event_type: "transition", message: `Transition '${transition.name}' started: ${fromState} \u2192 ${transition.to}`, timestamp: now });
+    for (const action of transition.actions ?? []) {
+      try {
+        if (action.type === "set_field") {
+          const field = action.config?.field;
+          if (action.config?.expression) {
+            const expr = action.config.expression;
+            const result = this.evaluateSimpleExpression(expr, inst.state_data);
+            inst.state_data[field] = result;
+          } else if (action.config?.value !== void 0) {
+            inst.state_data[field] = action.config.value;
+          }
+          events.push({ event_type: "action_executed", message: `transition action 'set_field' succeeded`, timestamp: now });
+        } else if (action.type === "eval") {
+          const expr = action.config?.expression;
+          lastEvalResult = this.evaluateSimpleExpression(expr, inst.state_data);
+          events.push({ event_type: "action_executed", message: `transition action 'eval' succeeded`, timestamp: now });
+        } else {
+          events.push({ event_type: "action_executed", message: `transition action '${action.type}' succeeded (no-op in local mode)`, timestamp: now });
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        events.push({ event_type: "action_failed", message: `transition action '${action.type}' failed: ${msg}`, timestamp: now });
+        return {
+          success: false,
+          instance_id: inst.id,
+          from_state: fromState,
+          to_state: null,
+          state_data: inst.state_data,
+          event_log: events,
+          error: `transition action failed: ${msg}`
+        };
+      }
+    }
+    inst.current_state = transition.to;
+    inst.execution_lock_version++;
+    inst.updated_at = now;
+    events.push({ event_type: "transition", message: `State changed: ${fromState} \u2192 ${transition.to}`, timestamp: now });
+    inst.event_log.push(...events);
+    return {
+      success: true,
+      instance_id: inst.id,
+      from_state: fromState,
+      to_state: transition.to,
+      state_data: inst.state_data,
+      result: lastEvalResult,
+      event_log: events
+    };
+  }
+  /**
+   * Minimal expression evaluator for local dev mode.
+   * Handles: field references, arithmetic, string literals, simple comparisons.
+   * Does NOT handle: while loops, if/else, function calls, multi-statement blocks.
+   * For full evaluation, use mm-napi when available.
+   */
+  evaluateSimpleExpression(expr, context) {
+    if (context[expr] !== void 0) return context[expr];
+    const arithMatch = expr.match(/^(\w+)\s*([+\-*/])\s*(\d+(?:\.\d+)?)$/);
+    if (arithMatch) {
+      const [, field, op, numStr] = arithMatch;
+      const left = Number(context[field] ?? 0);
+      const right = Number(numStr);
+      switch (op) {
+        case "+":
+          return left + right;
+        case "-":
+          return left - right;
+        case "*":
+          return left * right;
+        case "/":
+          return right !== 0 ? left / right : 0;
+      }
+    }
+    if (/^\d+(\.\d+)?$/.test(expr.trim())) {
+      return Number(expr.trim());
+    }
+    const strMatch = expr.match(/^["'](.*)["']$/);
+    if (strMatch) return strMatch[1];
+    try {
+      const keys = Object.keys(context);
+      const values = Object.values(context);
+      const fn = new Function(...keys, `"use strict"; return (${expr});`);
+      return fn(...values);
+    } catch {
+      return null;
+    }
+  }
+};
+async function startLocalServer(options = {}) {
+  const { port = 4200, noAuth = true } = options;
+  const store = new MemoryStore();
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  function json(res, status, body) {
+    const data = JSON.stringify(body);
+    res.writeHead(status, {
+      "Content-Type": "application/json",
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Methods": "GET, POST, PATCH, PUT, DELETE, OPTIONS",
+      "Access-Control-Allow-Headers": "Content-Type, Authorization",
+      "Content-Length": Buffer.byteLength(data)
+    });
+    res.end(data);
+  }
+  function readBody(req) {
+    return new Promise((resolve3, reject) => {
+      const chunks = [];
+      req.on("data", (chunk) => chunks.push(chunk));
+      req.on("end", () => resolve3(Buffer.concat(chunks).toString()));
+      req.on("error", reject);
+    });
+  }
+  function parseQuery(url) {
+    const idx = url.indexOf("?");
+    if (idx === -1) return {};
+    const params = {};
+    const qs = url.slice(idx + 1);
+    for (const pair of qs.split("&")) {
+      const [k, v] = pair.split("=");
+      if (k) params[decodeURIComponent(k)] = decodeURIComponent(v ?? "");
+    }
+    return params;
+  }
+  const server = http.createServer(async (req, res) => {
+    const method = req.method?.toUpperCase() ?? "GET";
+    const rawUrl = req.url ?? "/";
+    const queryStart = rawUrl.indexOf("?");
+    const path = queryStart >= 0 ? rawUrl.slice(0, queryStart) : rawUrl;
+    const query = parseQuery(rawUrl);
+    if (method === "OPTIONS") {
+      res.writeHead(204, {
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Methods": "GET, POST, PATCH, PUT, DELETE, OPTIONS",
+        "Access-Control-Allow-Headers": "Content-Type, Authorization",
+        "Access-Control-Max-Age": "86400"
+      });
+      res.end();
+      return;
+    }
+    try {
+      if (path === "/health" && method === "GET") {
+        return json(res, 200, {
+          status: "ok",
+          service: "mm-local-dev",
+          mode: "in-memory",
+          started_at: startedAt,
+          definitions: store.definitions.size,
+          instances: store.instances.size
+        });
+      }
+      if (path === "/api/v1/auth/login" && (method === "POST" || method === "GET")) {
+        return json(res, 200, {
+          token: "dev-token-local",
+          user: {
+            id: "dev-user-001",
+            email: "dev@localhost",
+            role: "admin",
+            name: "Local Developer"
+          }
+        });
+      }
+      if (path === "/api/v1/workflow/definitions" && method === "GET") {
+        const result = store.listDefinitions({
+          category: query.category,
+          limit: query.limit ? parseInt(query.limit, 10) : void 0,
+          offset: query.offset ? parseInt(query.offset, 10) : void 0
+        });
+        if (query.slug) {
+          const def = store.getDefinition(query.slug);
+          return json(res, 200, { items: def ? [def] : [], total: def ? 1 : 0 });
+        }
+        return json(res, 200, result);
+      }
+      const defMatch = path.match(/^\/api\/v1\/workflow\/definitions\/([^/]+)$/);
+      if (defMatch && method === "GET") {
+        const def = store.getDefinition(defMatch[1]);
+        if (!def) return json(res, 404, { error: "Not found" });
+        return json(res, 200, def);
+      }
+      if (path === "/api/v1/workflow/definitions" && method === "POST") {
+        const body = JSON.parse(await readBody(req));
+        const def = store.createDefinition(body);
+        return json(res, 201, def);
+      }
+      if (defMatch && method === "PATCH") {
+        const body = JSON.parse(await readBody(req));
+        const updated = store.patchDefinition(defMatch[1], body);
+        if (!updated) return json(res, 404, { error: "Not found" });
+        return json(res, 200, updated);
+      }
+      if (defMatch && method === "DELETE") {
+        const deleted = store.deleteDefinition(defMatch[1]);
+        if (!deleted) return json(res, 404, { error: "Not found" });
+        return json(res, 204, null);
+      }
+      if (path === "/api/v1/workflow/instances" && method === "GET") {
+        const result = store.listInstances({
+          definition_id: query.definition_id,
+          limit: query.limit ? parseInt(query.limit, 10) : void 0,
+          offset: query.offset ? parseInt(query.offset, 10) : void 0
+        });
+        return json(res, 200, result);
+      }
+      if (path === "/api/v1/workflow/instances" && method === "POST") {
+        const body = JSON.parse(await readBody(req));
+        const inst = store.createInstance(body);
+        if (!inst) return json(res, 404, { error: "Definition not found" });
+        return json(res, 201, inst);
+      }
+      const instMatch = path.match(/^\/api\/v1\/workflow\/instances\/([^/]+)$/);
+      if (instMatch && method === "GET") {
+        const inst = store.getInstance(instMatch[1]);
+        if (!inst) return json(res, 404, { error: "Not found" });
+        return json(res, 200, inst);
+      }
+      if (path === "/api/v1/workflow/execute-action" && method === "POST") {
+        const body = JSON.parse(await readBody(req));
+        const result = store.executeAction(body);
+        return json(res, 200, result);
+      }
+      const dataMatch = path.match(/^\/api\/v1\/data\/([^/]+)$/);
+      if (dataMatch && method === "GET") {
+        const def = store.getDefinition(dataMatch[1]);
+        if (!def) return json(res, 404, { error: "Not found" });
+        const instances = store.listInstances({ definition_id: def.id });
+        return json(res, 200, instances);
+      }
+      if (path.startsWith("/api/v1/")) {
+        return json(res, 501, { error: "Not implemented in local dev mode", path, method });
+      }
+      return json(res, 404, { error: "Not found", path });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(`[mm-local] ${method} ${path} \u2014 Error: ${message}`);
+      return json(res, 500, { error: message });
+    }
+  });
+  return new Promise((resolve3, reject) => {
+    server.on("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        reject(new Error(`Port ${port} is already in use. Is another server running?`));
+      } else {
+        reject(err);
+      }
+    });
+    server.listen(port, () => {
+      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)`);
+      resolve3({
+        server,
+        port,
+        store,
+        async close() {
+          return new Promise((res) => {
+            server.close(() => {
+              console.log("[mm-local] Local API server stopped");
+              res();
+            });
+          });
+        }
+      });
+    });
+  });
+}
+
+// src/dev-server.ts
+var currentErrors = null;
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function renderErrorOverlay(errors) {
+  const cards = errors.map((err) => {
+    const loc = err.line ? `${err.file}:${err.line}${err.column ? ":" + err.column : ""}` : err.file;
+    const snippet = err.snippet ? `<pre style="background:#1a1a2e;color:#e0e0e0;padding:12px 16px;border-radius:6px;overflow-x:auto;margin-top:8px;font-size:13px;line-height:1.5">${escapeHtml(err.snippet)}</pre>` : "";
+    return `<div style="background:#2d1b1b;border:1px solid #5c2020;border-radius:8px;padding:16px 20px;margin-bottom:12px">
+      <div style="color:#ff6b6b;font-family:monospace;font-size:13px;margin-bottom:6px">${escapeHtml(loc)}</div>
+      <div style="color:#ffa0a0;font-size:15px;font-weight:500">${escapeHtml(err.message)}</div>${snippet}</div>`;
+  }).join("\n");
+  return `<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<title>Compile Error - MindMatrix Dev</title>
+<style>*{box-sizing:border-box;margin:0;padding:0}body{background:#1a1a2e;color:#e0e0e0;font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,sans-serif;padding:40px 20px;min-height:100vh}</style></head>
+<body><div style="max-width:800px;margin:0 auto">
+<div style="display:flex;align-items:center;gap:12px;margin-bottom:24px">
+<div style="background:#5c2020;color:#ff6b6b;font-size:14px;font-weight:600;padding:4px 10px;border-radius:4px">COMPILE ERROR</div>
+<div style="color:#888;font-size:13px">${errors.length} error${errors.length !== 1 ? "s" : ""}</div></div>
+${cards}
+<div style="color:#666;font-size:12px;margin-top:24px;text-align:center">Fix the error and save -- the page will reload automatically.</div></div>
+<script>const ws=new WebSocket('ws://'+location.host+'/__mm_dev');ws.onmessage=e=>{const m=JSON.parse(e.data);if(m.type==='workflow:compiled'||m.type==='workflow:rebuild')location.reload()};ws.onclose=()=>setTimeout(()=>location.reload(),2000)</script>
+</body></html>`;
+}
+function errorOverlayMiddleware() {
+  return (req, res, next) => {
+    if (!currentErrors || !req.url) return next();
+    const url = req.url;
+    if (url.startsWith("/api") || url.startsWith("/health") || url.startsWith("/ws") || url.startsWith("/__mm_dev") || url.startsWith("/@") || url.startsWith("/node_modules")) return next();
+    const accept = req.headers?.accept ?? "";
+    if (!accept.includes("text/html")) return next();
+    res.writeHead(500, { "Content-Type": "text/html; charset=utf-8" });
+    res.end(renderErrorOverlay(currentErrors));
+  };
+}
+async function resolveDevToken(apiUrl, explicit) {
+  if (explicit) return explicit;
+  try {
+    const { resolveToken: resolveToken2 } = await Promise.resolve().then(() => (init_auth(), auth_exports));
+    const s = resolveToken2(apiUrl);
+    if (s) return s;
+  } catch {
+  }
+  try {
+    const resp = await fetch(`${apiUrl}/auth/login`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ email: "admin@mindmatrix.com", password: "Admin123!" })
+    });
+    if (resp.ok) {
+      const data = await resp.json();
+      const token = data.token ?? data.access_token;
+      if (token) {
+        try {
+          const { saveCredentials: saveCredentials2 } = await Promise.resolve().then(() => (init_auth(), auth_exports));
+          saveCredentials2(apiUrl, token);
+        } catch {
+        }
+        return token;
+      }
+    }
+  } catch {
+  }
+  return process.env.MINDMATRIX_TOKEN;
+}
+async function checkBackendHealth(apiUrl) {
+  try {
+    const base = apiUrl.replace(/\/api\/v1\/?$/, "");
+    const resp = await fetch(`${base}/health`, { signal: AbortSignal.timeout(5e3) });
+    if (resp.ok) {
+      const d = await resp.json();
+      return { ok: true, version: d.version, db: d.database };
+    }
+    return { ok: resp.status < 500 };
+  } catch {
+    return { ok: false };
+  }
+}
+async function initialBuildDeploy(src, outDir, mode, apiUrl, token) {
+  console.log("[mm-dev] Compiling project...");
+  const buildResult = await build({ src, outDir, mode, skipTypeCheck: true });
+  if (buildResult.errors > 0) {
+    currentErrors = buildResult.errorDetails.map((e) => ({ file: e.file, message: e.message, line: e.line }));
+    console.error(`[mm-dev] Build failed with ${buildResult.errors} error(s) -- error overlay active`);
+    return { buildResult, deployed: false, slug: void 0 };
+  }
+  currentErrors = null;
+  if (buildResult.compiled === 0) return { buildResult, deployed: false, slug: void 0 };
+  console.log(`[mm-dev] Compiled ${buildResult.compiled} definition(s)`);
+  try {
+    const { deploy: deploy2 } = await Promise.resolve().then(() => (init_deploy(), deploy_exports));
+    const result = await deploy2({ apiUrl, token, dir: outDir });
+    const total = result.created.length + result.updated.length + result.versioned.length;
+    if (total > 0) console.log(`[mm-dev] Deployed: ${result.created.length} created, ${result.updated.length} updated`);
+    return { buildResult, deployed: true, slug: buildResult.definitions?.[0]?.slug };
+  } catch (e) {
+    console.warn(`[mm-dev] Deploy failed: ${e instanceof Error ? e.message : e}`);
+    return { buildResult, deployed: false, slug: void 0 };
+  }
+}
+function printBanner(o) {
+  const l = "-".repeat(58);
+  console.log(`
+  ${l}
+  MindMatrix Dev Server
+  ${l}
+`);
+  console.log(`  Preview:    http://localhost:${o.port}`);
+  console.log(`  API Proxy:  /api/* -> ${o.apiUrl}`);
+  console.log(`  WebSocket:  ws://localhost:${o.port}/__mm_dev`);
+  console.log(`  Watching:   ${o.src} (${o.include.join(", ")})
+`);
+  console.log(`  Backend:    ${o.health.ok ? "connected" : "unreachable"}${o.health.version ? ` (v${o.health.version})` : ""}`);
+  if (o.health.db) console.log(`  Database:   ${o.health.db}`);
+  console.log(`  Auth:       ${o.token ? "authenticated" : "no token"}`);
+  if (o.compiled > 0) {
+    console.log(`  Blueprint:  ${o.slug ?? "unknown"} (${o.compiled} defs)`);
+    console.log(`  Deploy:     ${o.deployed ? "synced" : "pending"}`);
+  }
+  if (o.errors > 0) console.log(`  Errors:     ${o.errors} compile error(s) -- overlay active`);
+  console.log(`
+  ${l}
+`);
+}
+function broadcast(clients, data) {
+  const msg = JSON.stringify(data);
+  for (const c of clients) {
+    try {
+      if (c.readyState === 1) c.send(msg);
+    } catch {
+      clients.delete(c);
+    }
+  }
 }
-
-// src/dev-server.ts
 async function createDevServer(options = {}) {
   const {
     port = 5199,
@@ -13390,44 +14477,87 @@ async function createDevServer(options = {}) {
     include = ["**/*.workflow.tsx"],
     outDir = "dist/workflows",
     seed = false,
-    apiUrl = "http://localhost:4200/api/v1",
-    authToken = process.env.MINDMATRIX_TOKEN,
+    apiUrl: rawApiUrl = "auto",
+    authToken: explicitToken,
     ws: enableWs = true,
     open = false
   } = options;
   const clients = /* @__PURE__ */ new Set();
-  const pluginOptions = {
-    mode,
-    include,
-    outDir,
-    seedOnCompile: seed,
-    apiUrl,
-    authToken
-  };
-  const notifyPlugin = {
-    name: "mindmatrix-dev-notify",
+  let localServer = null;
+  let apiUrl;
+  let isLocalMode = false;
+  if (rawApiUrl === "local") {
+    localServer = await startLocalServer({ port: 4200 });
+    apiUrl = "http://localhost:4200/api/v1";
+    isLocalMode = true;
+  } else if (rawApiUrl === "auto") {
+    const defaultRemote = "https://dev.mindmatrix.club/api/v1";
+    const remoteHealth = await checkBackendHealth(defaultRemote);
+    if (remoteHealth.ok) {
+      apiUrl = defaultRemote;
+    } else {
+      const localHealth = await checkBackendHealth("http://localhost:4200/api/v1");
+      if (localHealth.ok) {
+        apiUrl = "http://localhost:4200/api/v1";
+      } else {
+        console.log("[mm-dev] No backend detected \u2014 starting local in-memory API server...");
+        localServer = await startLocalServer({ port: 4200 });
+        apiUrl = "http://localhost:4200/api/v1";
+        isLocalMode = true;
+      }
+    }
+  } else {
+    apiUrl = rawApiUrl;
+  }
+  const token = isLocalMode ? "dev-token-local" : await resolveDevToken(apiUrl, explicitToken);
+  const health = isLocalMode ? { ok: true, version: "local", db: "in-memory" } : await checkBackendHealth(apiUrl);
+  let initialSlug, initialCompiled = 0, initialDeployed = false, initialErrors = 0;
+  if (token && health.ok) {
+    const r = await initialBuildDeploy(src, outDir, mode, apiUrl, token);
+    initialCompiled = r.buildResult.compiled;
+    initialDeployed = r.deployed;
+    initialSlug = r.slug;
+    initialErrors = r.buildResult.errors;
+  }
+  if (seed && token && initialDeployed) {
+    try {
+      const { seedInstances: seedInstances2 } = await Promise.resolve().then(() => (init_seed(), seed_exports));
+      console.log("[mm-dev] Seeding sample instances...");
+      const sr = await seedInstances2({ apiUrl, token, dir: outDir });
+      console.log(`[mm-dev] Seeded ${sr.created} instance(s) across ${sr.definitions} definition(s)`);
+    } catch (e) {
+      console.warn(`[mm-dev] Seed failed: ${e instanceof Error ? e.message : e}`);
+    }
+  }
+  const pluginOpts = { mode, include, outDir, seedOnCompile: seed, apiUrl, authToken: token };
+  const proxyTarget = apiUrl.replace(/\/api\/v1\/?$/, "") || apiUrl;
+  let deployInFlight = false;
+  const compileDeployPlugin = {
+    name: "mindmatrix-dev-compile-deploy",
     enforce: "post",
-    handleHotUpdate(ctx) {
-      const isWorkflow = include.some((pattern) => {
-        const regex = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "<<GLOBSTAR>>").replace(/\*/g, "[^/]*").replace(/<<GLOBSTAR>>/g, ".*").replace(/\?/g, ".");
-        return new RegExp(regex).test(ctx.file);
-      });
-      if (!isWorkflow) return;
-      const message = JSON.stringify({
-        type: "workflow:compiled",
-        file: ctx.file,
-        timestamp: ctx.timestamp
-      });
-      for (const client of clients) {
+    async handleHotUpdate(ctx) {
+      const isWf = include.some((p) => new RegExp(p.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "<<G>>").replace(/\*/g, "[^/]*").replace(/<<G>>/g, ".*").replace(/\?/g, ".")).test(ctx.file));
+      if (!isWf) return;
+      const fn = ctx.file.split("/").pop() ?? ctx.file;
+      console.log(`[mm-dev] Recompiling ${fn}...`);
+      const br = await build({ src, outDir, mode, skipTypeCheck: true });
+      if (br.errors > 0) {
+        currentErrors = br.errorDetails.map((e) => ({ file: e.file, message: e.message, line: e.line }));
+        broadcast(clients, { type: "workflow:error", errors: br.errors, timestamp: ctx.timestamp });
+        return;
+      }
+      currentErrors = null;
+      if (token && !deployInFlight) {
+        deployInFlight = true;
         try {
-          if (client.readyState === 1) {
-            client.send(message);
-          }
+          const { deploy: d } = await Promise.resolve().then(() => (init_deploy(), deploy_exports));
+          await d({ apiUrl, token, dir: outDir });
         } catch {
-          clients.delete(client);
+        } finally {
+          deployInFlight = false;
         }
       }
-      console.log(`[mm-dev] Compiled ${ctx.file.split("/").pop()} \u2014 notified ${clients.size} client(s)`);
+      broadcast(clients, { type: "workflow:compiled", file: ctx.file, compiled: br.compiled, timestamp: ctx.timestamp });
     }
   };
   const viteConfig = {
@@ -13435,311 +14565,93 @@ async function createDevServer(options = {}) {
     server: {
       port,
       open,
-      host: true
+      host: true,
+      proxy: {
+        "/api": { target: proxyTarget, changeOrigin: true, secure: true, ws: true },
+        "/health": { target: proxyTarget, changeOrigin: true, secure: true },
+        "/ws": { target: proxyTarget.replace(/^http/, "ws"), changeOrigin: true, ws: true }
+      }
     },
     plugins: [
-      mindmatrixReact(pluginOptions),
-      notifyPlugin
+      mindmatrixReact(pluginOpts),
+      compileDeployPlugin,
+      { name: "mindmatrix-error-overlay", configureServer(server) {
+        server.middlewares.use(errorOverlayMiddleware());
+      } }
     ],
-    logLevel: "info"
+    logLevel: "warn"
   };
-  const { createServer } = await import("vite");
-  const vite = await createServer(viteConfig);
+  const { createServer: createServer2 } = await import("vite");
+  const vite = await createServer2(viteConfig);
   await vite.listen();
   const resolvedPort = vite.config.server.port ?? port;
   if (enableWs && vite.httpServer) {
     try {
-      const wsModule = await Function('return import("ws")')();
-      const WebSocketServer = wsModule.WebSocketServer ?? wsModule.default?.WebSocketServer;
-      if (WebSocketServer) {
-        const wss = new WebSocketServer({
-          server: vite.httpServer,
-          path: "/__mm_dev"
-        });
-        wss.on("connection", (socket) => {
-          clients.add(socket);
-          console.log(`[mm-dev] Editor connected (${clients.size} total)`);
-          socket.on("close", () => {
-            clients.delete(socket);
-            console.log(`[mm-dev] Editor disconnected (${clients.size} total)`);
-          });
-          socket.send(JSON.stringify({
-            type: "mm:connected",
-            version: "0.1.0",
-            capabilities: ["compile", "seed", "notify"]
-          }));
+      const wsM = await Function('return import("ws")')();
+      const WSS = wsM.WebSocketServer ?? wsM.default?.WebSocketServer;
+      if (WSS) {
+        const wss = new WSS({ server: vite.httpServer, path: "/__mm_dev" });
+        wss.on("connection", (s) => {
+          clients.add(s);
+          s.on("close", () => clients.delete(s));
+          s.send(JSON.stringify({ type: "mm:connected", version: "0.1.0", capabilities: ["compile", "deploy", "proxy", "notify", "error-overlay"] }));
         });
       }
     } catch {
-      console.warn("[mm-dev] ws package not available \u2014 WebSocket notifications disabled");
     }
   }
-  console.log(`
-[mm-dev] MindMatrix Dev Server running`);
-  console.log(`  Local:     http://localhost:${resolvedPort}`);
-  console.log(`  WebSocket: ws://localhost:${resolvedPort}/__mm_dev`);
-  console.log(`  Watching:  ${src} (${include.join(", ")})`);
-  if (seed) {
-    console.log(`  Seeding:   ${apiUrl}`);
-  }
-  console.log();
+  printBanner({ port: resolvedPort, apiUrl: isLocalMode ? `${apiUrl} (local in-memory)` : apiUrl, src, include, health, token: !!token, compiled: initialCompiled, deployed: initialDeployed, slug: initialSlug, errors: initialErrors });
   return {
     vite,
     port: resolvedPort,
     clients,
     async rebuild() {
-      console.log("[mm-dev] Full rebuild triggered...");
-      const result = await build({ src, outDir, mode });
-      const message = JSON.stringify({
-        type: "workflow:rebuild",
-        compiled: result.compiled,
-        errors: result.errors,
-        timestamp: Date.now()
-      });
-      for (const client of clients) {
-        try {
-          if (client.readyState === 1) client.send(message);
-        } catch {
-          clients.delete(client);
+      const r = await build({ src, outDir, mode });
+      if (r.errors > 0) {
+        currentErrors = r.errorDetails.map((e) => ({ file: e.file, message: e.message, line: e.line }));
+      } else {
+        currentErrors = null;
+        if (token) {
+          try {
+            const { deploy: d } = await Promise.resolve().then(() => (init_deploy(), deploy_exports));
+            await d({ apiUrl, token, dir: outDir });
+          } catch {
+          }
         }
       }
-      return result;
+      broadcast(clients, { type: "workflow:rebuild", compiled: r.compiled, errors: r.errors, timestamp: Date.now() });
+      return r;
     },
     async close() {
-      for (const client of clients) {
+      for (const c of clients) {
         try {
-          client.close();
+          c.close();
         } catch {
         }
       }
       clients.clear();
+      currentErrors = null;
       await vite.close();
-      console.log("[mm-dev] Server stopped");
+      if (localServer) {
+        await localServer.close();
+      }
     }
   };
 }
 
-// src/cli/deploy.ts
-var import_glob2 = require("glob");
-var import_fs4 = require("fs");
-var import_path3 = require("path");
-async function deploy(options) {
-  const dir = options.dir ?? "dist/workflows";
-  const targetLabel = options.targetName ? ` (target: ${options.targetName})` : "";
-  console.log(`[mindmatrix-react] Deploying workflows from ${dir} to ${options.apiUrl}${targetLabel}...`);
-  const files = await (0, import_glob2.glob)(`${dir}/**/*.workflow.json`);
-  if (files.length === 0) {
-    console.log(`[mindmatrix-react] No workflow files found in ${dir}`);
-    return { created: [], updated: [], versioned: [], skipped: [], failed: [] };
-  }
-  const result = {
-    created: [],
-    updated: [],
-    versioned: [],
-    skipped: [],
-    failed: []
-  };
-  const deployedIRs = [];
-  for (const file2 of files) {
-    try {
-      const ir = JSON.parse((0, import_fs4.readFileSync)(file2, "utf-8"));
-      const slug = ir.slug;
-      if (options.dryRun) {
-        console.log(`  [dry-run] Would deploy ${slug} (${(0, import_path3.basename)(file2)})`);
-        continue;
-      }
-      const existing = await fetchExistingDefinition(options.apiUrl, options.token, slug);
-      if (!existing) {
-        await createDefinition(options.apiUrl, options.token, ir);
-        console.log(`  \u2713 ${slug} (created)`);
-        result.created.push(slug);
-      } else if (existing.instanceCount === 0 || options.force) {
-        await updateDefinition(options.apiUrl, options.token, existing.id, ir);
-        console.log(`  \u2713 ${slug} (updated)`);
-        result.updated.push(slug);
-      } else {
-        const newVersion = bumpVersion(existing.version);
-        ir.version = newVersion;
-        await createDefinition(options.apiUrl, options.token, ir);
-        console.log(`  \u2713 ${slug} v${newVersion} (new version, ${existing.instanceCount} instances on v${existing.version})`);
-        result.versioned.push(slug);
-      }
-      deployedIRs.push(ir);
-    } catch (error) {
-      const slug = (0, import_path3.basename)(file2).replace(".workflow.json", "");
-      const msg = error.message;
-      console.error(`  \u2717 ${slug}: ${msg}`);
-      result.failed.push({ slug, error: msg });
-    }
-  }
-  if (!options.dryRun) {
-    for (const ir of deployedIRs) {
-      const serviceResult = await syncServices(options.apiUrl, options.token, ir);
-      if (serviceResult) {
-        if (!result.services) {
-          result.services = { registered: [], updated: [], failed: [] };
-        }
-        result.services.registered.push(...serviceResult.registered);
-        result.services.updated.push(...serviceResult.updated);
-        result.services.failed.push(...serviceResult.failed);
-      }
-    }
-  }
-  if (options.reportFile) {
-    (0, import_fs4.writeFileSync)(options.reportFile, JSON.stringify(result, null, 2), "utf-8");
-    console.log(`
-  Report written to ${options.reportFile}`);
-  }
-  const total = result.created.length + result.updated.length + result.versioned.length;
-  console.log(
-    `
-[mindmatrix-react] Deployed ${total} workflows (${result.created.length} created, ${result.updated.length} updated, ${result.versioned.length} versioned, ${result.failed.length} failed)`
-  );
-  if (result.services) {
-    const svcTotal = result.services.registered.length + result.services.updated.length;
-    if (svcTotal > 0 || result.services.failed.length > 0) {
-      console.log(
-        `[mindmatrix-react] Synced ${svcTotal} services (${result.services.registered.length} registered, ${result.services.updated.length} updated, ${result.services.failed.length} failed)`
-      );
-    }
-  }
-  return result;
-}
-async function fetchExistingDefinition(apiUrl, token, slug) {
-  try {
-    const res = await fetch(`${apiUrl}/workflow/definitions?slug=${encodeURIComponent(slug)}`, {
-      headers: { Authorization: `Bearer ${token}` }
-    });
-    if (!res.ok) return null;
-    const data = await res.json();
-    const definitions = Array.isArray(data) ? data : data.items ?? data.data;
-    if (!definitions || definitions.length === 0) return null;
-    const def = definitions[0];
-    return {
-      id: def.id,
-      slug: def.slug,
-      version: def.version || "0.1.0",
-      instanceCount: def.instanceCount ?? def.instance_count ?? 0
-    };
-  } catch {
-    return null;
-  }
-}
-async function createDefinition(apiUrl, token, ir) {
-  const res = await fetch(`${apiUrl}/workflow/definitions`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${token}`
-    },
-    body: JSON.stringify(ir)
-  });
-  if (!res.ok) {
-    const errorText = await res.text();
-    throw new Error(`Create failed: ${res.status} ${errorText}`);
-  }
-}
-async function updateDefinition(apiUrl, token, id, ir) {
-  const { slug: _slug, ...updatePayload } = ir;
-  const res = await fetch(`${apiUrl}/workflow/definitions/${id}`, {
-    method: "PATCH",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${token}`
-    },
-    body: JSON.stringify(updatePayload)
-  });
-  if (!res.ok) {
-    const errorText = await res.text();
-    throw new Error(`Update failed: ${res.status} ${errorText}`);
-  }
-}
-function bumpVersion(version) {
-  const parts = version.split(".");
-  if (parts.length !== 3) return `${version}.1`;
-  const patch = parseInt(parts[2], 10) || 0;
-  return `${parts[0]}.${parts[1]}.${patch + 1}`;
-}
-async function syncServices(apiUrl, token, ir) {
-  const metadata = ir.metadata;
-  const orchestration = metadata?.orchestration;
-  const services = orchestration?.services;
-  if (!services || Object.keys(services).length === 0) return null;
-  const result = { registered: [], updated: [], failed: [] };
-  for (const [name, config] of Object.entries(services)) {
-    try {
-      const registration = {
-        name,
-        connection: {
-          type: config.type || "webhook",
-          url: config.url,
-          queue: config.queue
-        },
-        actions: config.actions || [],
-        labels: config.labels || {}
-      };
-      const existing = await fetchExistingService(apiUrl, token, name);
-      if (existing) {
-        await fetch(`${apiUrl}/services/${existing.id}`, {
-          method: "PATCH",
-          headers: {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${token}`
-          },
-          body: JSON.stringify(registration)
-        });
-        console.log(`  \u2713 service: ${name} (updated)`);
-        result.updated.push(name);
-      } else {
-        const res = await fetch(`${apiUrl}/services`, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${token}`
-          },
-          body: JSON.stringify(registration)
-        });
-        if (!res.ok) {
-          const errorText = await res.text();
-          throw new Error(`Register failed: ${res.status} ${errorText}`);
-        }
-        console.log(`  \u2713 service: ${name} (registered)`);
-        result.registered.push(name);
-      }
-    } catch (error) {
-      const msg = error.message;
-      console.error(`  \u2717 service: ${name}: ${msg}`);
-      result.failed.push(name);
-    }
-  }
-  return result;
-}
-async function fetchExistingService(apiUrl, token, name) {
-  try {
-    const res = await fetch(`${apiUrl}/services?name=${encodeURIComponent(name)}`, {
-      headers: { Authorization: `Bearer ${token}` }
-    });
-    if (!res.ok) return null;
-    const data = await res.json();
-    const servicesList = Array.isArray(data) ? data : data.services ?? data.items ?? data.data;
-    if (!servicesList || servicesList.length === 0) return null;
-    const found = servicesList.find((s) => s.name === name);
-    return found ? { id: found.id, name: found.name } : null;
-  } catch {
-    return null;
-  }
-}
+// src/index.ts
+init_deploy();
 
 // src/envelope.ts
 var import_crypto3 = require("crypto");
-var import_fs5 = require("fs");
-var import_path4 = require("path");
-var import_glob3 = require("glob");
+var import_fs7 = require("fs");
+var import_path5 = require("path");
+var import_glob4 = require("glob");
 var import_core7 = require("@babel/core");
 init_babel();
 async function buildEnvelope(projectDir, options = {}) {
-  const root = (0, import_path4.resolve)(projectDir);
-  const slug = options.slug ?? (0, import_path4.basename)(root);
+  const root = (0, import_path5.resolve)(projectDir);
+  const slug = options.slug ?? (0, import_path5.basename)(root);
   const version = options.version ?? "0.1.0";
   const mode = options.mode ?? "infer";
   const patterns = options.include ?? [
@@ -13749,11 +14661,11 @@ async function buildEnvelope(projectDir, options = {}) {
   ];
   const discoveredFiles = [];
   for (const pattern of patterns) {
-    const matches = await (0, import_glob3.glob)(pattern, { absolute: true });
+    const matches = await (0, import_glob4.glob)(pattern, { absolute: true });
     discoveredFiles.push(...matches);
   }
   const uniqueFiles = [...new Set(discoveredFiles)];
-  const allSourceFiles = await (0, import_glob3.glob)(`${root}/**/*.{ts,tsx,js,jsx,css,json}`, {
+  const allSourceFiles = await (0, import_glob4.glob)(`${root}/**/*.{ts,tsx,js,jsx,css,json}`, {
     absolute: true,
     ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**"]
   });
@@ -13763,10 +14675,10 @@ async function buildEnvelope(projectDir, options = {}) {
   const errors = [];
   const sourceBindings = [];
   for (const file2 of uniqueFiles) {
-    const relativePath = (0, import_path4.relative)(root, file2);
+    const relativePath = (0, import_path5.relative)(root, file2);
     let fileContent;
     try {
-      fileContent = (0, import_fs5.readFileSync)(file2);
+      fileContent = (0, import_fs7.readFileSync)(file2);
     } catch {
       errors.push({ file: relativePath, message: "Could not read file" });
       continue;