@mmapp/react-compiler 0.1.0-alpha.18 → 0.1.0-alpha.19

package/dist/chunk-RY7POBNT.mjs

@@ -0,0 +1,3127 @@
+// src/decompiler/index.ts
+import * as t4 from "@babel/types";
+import generate from "@babel/generator";
+
+// src/decompiler/ast-builder.ts
+import * as t2 from "@babel/types";
+import { parseExpression } from "@babel/parser";
+
+// src/decompiler/sx-emitter.ts
+import * as t from "@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 t.stringLiteral(`token:${color.name}`);
+  }
+  if (typeof color === "string") {
+    return t.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 t.stringLiteral(hex);
+      }
+      return t.stringLiteral(`rgba(${c.r}, ${c.g}, ${c.b}, ${a})`);
+    }
+  }
+  return t.stringLiteral("inherit");
+}
+function hexByte(n) {
+  return Math.round(n).toString(16).padStart(2, "0");
+}
+function prop(key, value) {
+  return t.objectProperty(t.identifier(key), valueToExpression(value));
+}
+function valueToExpression(value) {
+  if (typeof value === "string") return t.stringLiteral(value);
+  if (typeof value === "number") return t.numericLiteral(value);
+  if (typeof value === "boolean") return t.booleanLiteral(value);
+  if (value === null || value === void 0) return t.identifier("undefined");
+  if (Array.isArray(value)) {
+    return t.arrayExpression(value.map((v) => valueToExpression(v)));
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value);
+    return t.objectExpression(
+      entries.map(
+        ([k, v]) => t.objectProperty(t.identifier(k), valueToExpression(v))
+      )
+    );
+  }
+  return t.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(t.objectProperty(
+      t.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(t.objectProperty(
+      t.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 && t.isJSXExpressionContainer(subProp.value) && t.isObjectExpression(subProp.value.expression)) {
+          props.push(t.objectProperty(
+            t.identifier(sxKey),
+            subProp.value.expression
+          ));
+        }
+      }
+    }
+  }
+  if (props.length === 0) return null;
+  return t.jsxAttribute(
+    t.jsxIdentifier("sx"),
+    t.jsxExpressionContainer(t.objectExpression(props))
+  );
+}
+
+// src/decompiler/ast-builder.ts
+function buildSymbolTable(fields, metadata, transitions, experience) {
+  const locals = /* @__PURE__ */ new Map();
+  const setters = /* @__PURE__ */ new Map();
+  const queries = /* @__PURE__ */ new Map();
+  const transMap = /* @__PURE__ */ new Map();
+  for (const field of fields) {
+    if (field.computed) continue;
+    const camel = toCamelCase(field.name);
+    locals.set(field.name, camel);
+    setters.set(field.name, setterName(field.name));
+  }
+  const dataSources = metadata?.dataSources;
+  if (dataSources) {
+    for (const ds of dataSources) {
+      if (ds.type !== "workflow") continue;
+      const varName = toCamelCase(ds.name.replace(/-/g, "_"));
+      queries.set(ds.name, varName);
+      queries.set(ds.name.replace(/-/g, "_"), varName);
+    }
+  }
+  for (const trans of transitions) {
+    transMap.set(trans.name, toCamelCase(trans.name));
+  }
+  if (experience) {
+    collectLocalDefaults(experience, locals, setters);
+  }
+  return { locals, setters, queries, transitions: transMap };
+}
+function collectLocalDefaults(node, locals, setters) {
+  if (node.config?.localDefaults && typeof node.config.localDefaults === "object") {
+    for (const key of Object.keys(node.config.localDefaults)) {
+      if (key.includes(".")) continue;
+      if (!locals.has(key)) {
+        const camel = toCamelCase(key);
+        locals.set(key, camel);
+        setters.set(key, setterName(key));
+      }
+    }
+  }
+  if (node.children) {
+    for (const child of node.children) {
+      collectLocalDefaults(child, locals, setters);
+    }
+  }
+}
+var REACT_ATOMS = /* @__PURE__ */ new Set([
+  "Stack",
+  "Row",
+  "Column",
+  "Grid",
+  "Divider",
+  "Spacer",
+  "Text",
+  "Heading",
+  "Field",
+  "Image",
+  "Badge",
+  "Icon",
+  "Button",
+  "Link",
+  "Show",
+  "Each",
+  "Card",
+  "Tabs",
+  "Accordion",
+  "Section",
+  "Modal",
+  "TextInput",
+  "Select",
+  "Markdown",
+  "ScrollArea",
+  "Canvas3D",
+  "DataGrid",
+  "AnimatedBox",
+  "ServerGrid",
+  "Chart",
+  "MetricCard",
+  "Slot"
+]);
+function resolveIRTokens(expr, symbols) {
+  let result = expr;
+  const exprMatch = result.match(/^\$expr\((.+)\)$/s);
+  if (exprMatch) {
+    return resolveIRTokens(exprMatch[1], symbols);
+  }
+  const seqMatch = result.match(/^\$action\.seq\((.+)\)$/);
+  if (seqMatch) {
+    const actions = splitTopLevelArgs(seqMatch[1]);
+    const resolved = actions.map((a) => resolveIRTokens(a.trim(), symbols));
+    return `() => { ${resolved.join("; ")}; }`;
+  }
+  while (result.includes("$action.setLocal(")) {
+    const updated = resolveOneSetLocal(result, symbols);
+    if (updated === result) break;
+    result = updated;
+  }
+  result = result.replace(/\$action\.transition\("([^"]+)"\)/g, (_, name) => {
+    const varName = symbols.transitions.get(name) || toCamelCase(name);
+    return `${varName}()`;
+  });
+  result = result.replace(/\$instance\.\[/g, "[");
+  result = result.replace(/\$instance\??\.(?:state_data\.)?(\w+)/g, (_, field) => {
+    return symbols.queries.get(field) || toCamelCase(field);
+  });
+  result = result.replace(/\$local\.(\w+)/g, (_, field) => {
+    return symbols.locals.get(field) || toCamelCase(field);
+  });
+  const concatMatch = result.match(/^\$fn\.concat\((.+)\)$/);
+  if (concatMatch) {
+    const parts = splitTopLevelArgs(concatMatch[1]);
+    return "`" + parts.map((p) => `\${${p.trim()}}`).join("") + "`";
+  }
+  const notMatch = result.match(/^not\((.+)\)$/);
+  if (notMatch) {
+    return `!(${resolveIRTokens(notMatch[1], symbols)})`;
+  }
+  return result;
+}
+function resolveOneSetLocal(expr, symbols) {
+  const prefix = "$action.setLocal(";
+  const idx = expr.indexOf(prefix);
+  if (idx === -1) return expr;
+  let depth = 0;
+  let end = -1;
+  for (let i = idx + prefix.length - 1; i < expr.length; i++) {
+    if (expr[i] === "(") depth++;
+    else if (expr[i] === ")") {
+      depth--;
+      if (depth === 0) {
+        end = i;
+        break;
+      }
+    }
+  }
+  if (end === -1) return expr;
+  const inner = expr.substring(idx + prefix.length, end);
+  const fieldMatch = inner.match(/^"([^"]+)",\s*/);
+  if (!fieldMatch) return expr;
+  const field = fieldMatch[1];
+  const value = inner.substring(fieldMatch[0].length);
+  const setter = symbols.setters.get(field) || setterName(field);
+  const resolvedValue = resolveIRTokens(value.trim(), symbols);
+  return expr.substring(0, idx) + `${setter}(${resolvedValue})` + expr.substring(end + 1);
+}
+function splitTopLevelArgs(input) {
+  const result = [];
+  let depth = 0;
+  let inStr = null;
+  let current = "";
+  for (let i = 0; i < input.length; i++) {
+    const ch = input[i];
+    if ((ch === '"' || ch === "'" || ch === "`") && (i === 0 || input[i - 1] !== "\\")) {
+      if (inStr === ch) inStr = null;
+      else if (!inStr) inStr = ch;
+    }
+    if (!inStr) {
+      if (ch === "(" || ch === "[" || ch === "{") depth++;
+      else if (ch === ")" || ch === "]" || ch === "}") depth--;
+      else if (ch === "," && depth === 0) {
+        result.push(current);
+        current = "";
+        continue;
+      }
+    }
+    current += ch;
+  }
+  if (current.trim()) result.push(current);
+  return result;
+}
+function emitBindingExpression(expr, symbols) {
+  if (expr === "[Expression]" || expr === '"[Expression]"') {
+    return t2.nullLiteral();
+  }
+  const resolved = resolveIRTokens(expr, symbols);
+  const fieldsMatch = resolved.match(/^fields\.(\w+)$/);
+  if (fieldsMatch) {
+    return t2.identifier(toCamelCase(fieldsMatch[1]));
+  }
+  const setFieldMatch = resolved.match(/^set_field\((\w+),\s*(.+)\)$/);
+  if (setFieldMatch) {
+    const setter = setterName(setFieldMatch[1]);
+    return t2.callExpression(
+      t2.identifier(setter),
+      [emitBindingExpression(setFieldMatch[2].trim(), symbols)]
+    );
+  }
+  if (/^\w+$/.test(resolved)) {
+    return t2.identifier(toCamelCase(resolved));
+  }
+  if (/^[\w$]+(?:\??\.[\w$]+)+$/.test(resolved)) {
+    const parts = resolved.split(/(\??\.)/).filter(Boolean);
+    let node = t2.identifier(parts[0]);
+    for (let i = 1; i < parts.length; i += 2) {
+      const isOptional = parts[i] === "?.";
+      const prop2 = parts[i + 1];
+      if (!prop2) break;
+      node = t2.optionalMemberExpression(
+        node,
+        t2.identifier(prop2),
+        false,
+        isOptional
+      );
+    }
+    return node;
+  }
+  if (/[=<>!+\-*/%&|^~?:,()[\]{}]/.test(resolved)) {
+    try {
+      return parseExpression(resolved, {
+        plugins: ["typescript", "jsx"]
+      });
+    } catch {
+      return t2.stringLiteral(resolved);
+    }
+  }
+  return t2.stringLiteral(resolved);
+}
+function emitConfigAttribute(key, value) {
+  if (typeof value === "string") {
+    return t2.jsxAttribute(
+      t2.jsxIdentifier(key),
+      t2.stringLiteral(value)
+    );
+  }
+  if (typeof value === "boolean" && value === true) {
+    return t2.jsxAttribute(t2.jsxIdentifier(key), null);
+  }
+  return t2.jsxAttribute(
+    t2.jsxIdentifier(key),
+    t2.jsxExpressionContainer(valueToExpression(value))
+  );
+}
+function toCamelCase(str) {
+  return str.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}
+function setterName(snakeName) {
+  const camel = toCamelCase(snakeName);
+  return `set${camel.charAt(0).toUpperCase()}${camel.slice(1)}`;
+}
+function buildJSXTree(node, imports, symbols) {
+  if (!node.component) {
+    const fragmentChildren = (node.children || []).map(
+      (child) => buildJSXTree(child, imports, symbols)
+    );
+    return t2.jsxFragment(
+      t2.jsxOpeningFragment(),
+      t2.jsxClosingFragment(),
+      fragmentChildren
+    );
+  }
+  const componentName = node.component;
+  if (REACT_ATOMS.has(componentName)) {
+    addImport(imports, "@mindmatrix/react", componentName);
+  }
+  const attributes = [];
+  if (node.config) {
+    for (const [key, value] of Object.entries(node.config)) {
+      if (key === "localDefaults") continue;
+      attributes.push(emitConfigAttribute(key, value));
+    }
+  }
+  if (node.bindings) {
+    for (const [key, expr] of Object.entries(node.bindings)) {
+      let emitted = emitBindingExpression(expr, symbols);
+      if (isEventHandlerKey(key) && !t2.isArrowFunctionExpression(emitted) && !t2.isFunctionExpression(emitted)) {
+        emitted = t2.arrowFunctionExpression([], emitted);
+      }
+      attributes.push(
+        t2.jsxAttribute(
+          t2.jsxIdentifier(key),
+          t2.jsxExpressionContainer(emitted)
+        )
+      );
+    }
+  }
+  if (node.style && typeof node.style === "object" && Object.keys(node.style).length > 0) {
+    const sxAttr = emitSxProp(node.style);
+    if (sxAttr) attributes.push(sxAttr);
+  }
+  const jsxChildren = [];
+  if (node.children) {
+    for (const child of node.children) {
+      jsxChildren.push(buildJSXTree(child, imports, symbols));
+    }
+  }
+  const isSelfClosing = jsxChildren.length === 0;
+  const element = t2.jsxElement(
+    t2.jsxOpeningElement(
+      t2.jsxIdentifier(componentName),
+      attributes,
+      isSelfClosing
+    ),
+    isSelfClosing ? null : t2.jsxClosingElement(t2.jsxIdentifier(componentName)),
+    jsxChildren,
+    isSelfClosing
+  );
+  if (node.visible_when) {
+    addImport(imports, "@mindmatrix/react", "Show");
+    return t2.jsxElement(
+      t2.jsxOpeningElement(
+        t2.jsxIdentifier("Show"),
+        [
+          t2.jsxAttribute(
+            t2.jsxIdentifier("when"),
+            t2.jsxExpressionContainer(emitBindingExpression(node.visible_when, symbols))
+          )
+        ],
+        false
+      ),
+      t2.jsxClosingElement(t2.jsxIdentifier("Show")),
+      [element],
+      false
+    );
+  }
+  return element;
+}
+function isEventHandlerKey(key) {
+  return /^on[A-Z]/.test(key);
+}
+function addImport(tracker, source, name) {
+  if (!tracker.has(source)) tracker.set(source, /* @__PURE__ */ new Set());
+  tracker.get(source).add(name);
+}
+
+// src/decompiler/state-emitter.ts
+import * as t3 from "@babel/types";
+function toCamelCase2(str) {
+  return str.replace(/[-_]([a-z])/g, (_, c) => c.toUpperCase());
+}
+function toPascalCase(str) {
+  const camel = toCamelCase2(str);
+  return camel.charAt(0).toUpperCase() + camel.slice(1);
+}
+function fieldTypeAnnotation(field) {
+  const f = field;
+  const validation = f.validation;
+  const options = validation?.options || f.metadata?.options || f.options;
+  if (options && Array.isArray(options) && options.length > 0 && (field.type === "select" || field.type === "text")) {
+    return t3.tsUnionType(
+      options.map((o) => t3.tsLiteralType(t3.stringLiteral(String(o))))
+    );
+  }
+  switch (field.type) {
+    case "text":
+    case "rich_text":
+    case "email":
+    case "url":
+    case "phone":
+    case "color":
+      return t3.tsStringKeyword();
+    case "number":
+    case "currency":
+    case "percentage":
+    case "rating":
+    case "duration":
+    case "auto_number":
+      return t3.tsNumberKeyword();
+    case "boolean":
+      return t3.tsBooleanKeyword();
+    case "date":
+    case "datetime":
+    case "created_at":
+    case "updated_at":
+      return t3.tsTypeReference(t3.identifier("Date"));
+    case "select":
+      return t3.tsStringKeyword();
+    case "multi_select":
+      return t3.tsArrayType(t3.tsStringKeyword());
+    // string[]
+    case "json":
+      return null;
+    // Inferred from default
+    default:
+      return null;
+  }
+}
+function emitFieldDeclarations(fields, imports) {
+  if (fields.length === 0) return [];
+  addImport2(imports, "@mindmatrix/react", "useState");
+  const statements = [];
+  for (const field of fields) {
+    if (field.computed) continue;
+    const camelName = toCamelCase2(field.name);
+    const setter = `set${toPascalCase(field.name)}`;
+    const defaultExpr = field.default_value !== void 0 && field.default_value !== null ? valueToExpression(field.default_value) : inferDefaultFromType(field.type);
+    const args = [defaultExpr];
+    if (field.state_home?.scope === "ephemeral") {
+      args.push(t3.objectExpression([
+        t3.objectProperty(t3.identifier("ephemeral"), t3.booleanLiteral(true))
+      ]));
+    }
+    const declaration = t3.variableDeclaration("const", [
+      t3.variableDeclarator(
+        t3.arrayPattern([
+          t3.identifier(camelName),
+          t3.identifier(setter)
+        ]),
+        t3.callExpression(t3.identifier("useState"), args)
+      )
+    ]);
+    const tsType = fieldTypeAnnotation(field);
+    if (tsType) {
+      const callExpr = declaration.declarations[0].init;
+      callExpr.typeParameters = t3.tsTypeParameterInstantiation([tsType]);
+    }
+    statements.push(declaration);
+  }
+  return statements;
+}
+function inferDefaultFromType(fieldType) {
+  switch (fieldType) {
+    case "text":
+    case "rich_text":
+    case "email":
+    case "url":
+    case "phone":
+    case "color":
+    case "select":
+      return t3.stringLiteral("");
+    case "number":
+    case "currency":
+    case "percentage":
+    case "rating":
+    case "duration":
+    case "auto_number":
+      return t3.numericLiteral(0);
+    case "boolean":
+      return t3.booleanLiteral(false);
+    case "multi_select":
+    case "json":
+      return t3.arrayExpression([]);
+    default:
+      return t3.nullLiteral();
+  }
+}
+function emitStateEffects(states, imports) {
+  const statements = [];
+  for (const state of states) {
+    if (state.on_enter.length > 0) {
+      addImport2(imports, "@mindmatrix/react", "useOnEnter");
+      statements.push(
+        t3.expressionStatement(
+          t3.callExpression(t3.identifier("useOnEnter"), [
+            t3.stringLiteral(state.name),
+            emitActionCallback(state.on_enter)
+          ])
+        )
+      );
+    }
+    if (state.on_exit.length > 0) {
+      addImport2(imports, "@mindmatrix/react", "useOnExit");
+      statements.push(
+        t3.expressionStatement(
+          t3.callExpression(t3.identifier("useOnExit"), [
+            t3.stringLiteral(state.name),
+            emitActionCallback(state.on_exit)
+          ])
+        )
+      );
+    }
+    if (state.during.length > 0) {
+      addImport2(imports, "@mindmatrix/react", "useWhileIn");
+      for (const during of state.during) {
+        const args = [
+          t3.stringLiteral(state.name)
+        ];
+        if (during.interval_ms) {
+          args.push(t3.numericLiteral(during.interval_ms));
+        }
+        args.push(emitActionCallback(during.actions));
+        statements.push(
+          t3.expressionStatement(
+            t3.callExpression(t3.identifier("useWhileIn"), args)
+          )
+        );
+      }
+    }
+  }
+  return statements;
+}
+function emitTransitionDeclarations(transitions, imports) {
+  if (transitions.length === 0) return [];
+  addImport2(imports, "@mindmatrix/react", "useTransition");
+  const correctedTransitions = correctFromFields(transitions);
+  const statements = [];
+  for (const transition of correctedTransitions) {
+    const varName = toCamelCase2(transition.name);
+    const configProps = [];
+    const fromArr = normalizeFrom(transition.from);
+    if (fromArr.length === 1) {
+      configProps.push(
+        t3.objectProperty(t3.identifier("from"), t3.stringLiteral(fromArr[0]))
+      );
+    } else if (fromArr.length > 1) {
+      configProps.push(
+        t3.objectProperty(
+          t3.identifier("from"),
+          t3.arrayExpression(fromArr.map((s) => t3.stringLiteral(s)))
+        )
+      );
+    }
+    configProps.push(
+      t3.objectProperty(t3.identifier("to"), t3.stringLiteral(transition.to))
+    );
+    if (transition.conditions && transition.conditions.length > 0) {
+      configProps.push(
+        t3.objectProperty(
+          t3.identifier("when"),
+          emitConditionExpression(transition.conditions)
+        )
+      );
+    }
+    if (transition.roles && transition.roles.length > 0) {
+      configProps.push(
+        t3.objectProperty(
+          t3.identifier("roles"),
+          t3.arrayExpression(transition.roles.map((r) => t3.stringLiteral(r)))
+        )
+      );
+    }
+    if (transition.auto) {
+      configProps.push(
+        t3.objectProperty(t3.identifier("auto"), t3.booleanLiteral(true))
+      );
+    }
+    if (transition.required_fields && transition.required_fields.length > 0) {
+      configProps.push(
+        t3.objectProperty(
+          t3.identifier("requiredFields"),
+          t3.arrayExpression(transition.required_fields.map((f) => t3.stringLiteral(f)))
+        )
+      );
+    }
+    statements.push(
+      t3.variableDeclaration("const", [
+        t3.variableDeclarator(
+          t3.identifier(varName),
+          t3.callExpression(t3.identifier("useTransition"), [
+            t3.stringLiteral(transition.name),
+            t3.objectExpression(configProps)
+          ])
+        )
+      ])
+    );
+  }
+  return statements;
+}
+function emitActionCallback(actions) {
+  const body = [];
+  for (const action of actions) {
+    const stmt = emitSingleAction(action);
+    if (stmt) body.push(stmt);
+  }
+  if (body.length === 0) {
+    body.push(t3.emptyStatement());
+  }
+  return t3.arrowFunctionExpression([], t3.blockStatement(body));
+}
+function emitSingleAction(action) {
+  switch (action.type) {
+    case "set_field": {
+      if (!action.config.field) return null;
+      const setter = `set${toPascalCase(String(action.config.field))}`;
+      const expr = action.config.expression ? t3.identifier(String(action.config.expression)) : valueToExpression(action.config.value ?? null);
+      return t3.expressionStatement(
+        t3.callExpression(t3.identifier(setter), [expr])
+      );
+    }
+    case "log_event":
+    case "log": {
+      const msg = action.config.message ?? action.config.event ?? action.type;
+      return t3.expressionStatement(
+        t3.callExpression(
+          t3.memberExpression(t3.identifier("console"), t3.identifier("log")),
+          [t3.stringLiteral(String(msg))]
+        )
+      );
+    }
+    case "emit_event": {
+      const eventName = String(action.config.event ?? action.config.name ?? "unknown");
+      const args = [t3.stringLiteral(eventName)];
+      if (action.config.payload) {
+        args.push(valueToExpression(action.config.payload));
+      }
+      return t3.expressionStatement(
+        t3.callExpression(t3.identifier("emitEvent"), args)
+      );
+    }
+    case "call_workflow": {
+      const slug = String(action.config.slug ?? action.config.workflow ?? "unknown");
+      const args = [t3.stringLiteral(slug)];
+      if (action.config.params) {
+        args.push(valueToExpression(action.config.params));
+      }
+      return t3.expressionStatement(
+        t3.callExpression(t3.identifier("callWorkflow"), args)
+      );
+    }
+    case "spawn_instance":
+    case "spawn_subworkflow": {
+      const slug = String(action.config.slug ?? action.config.workflow ?? "unknown");
+      const args = [t3.stringLiteral(slug)];
+      if (action.config.params || action.config.input) {
+        args.push(valueToExpression(action.config.params ?? action.config.input));
+      }
+      return t3.expressionStatement(
+        t3.callExpression(t3.identifier("spawnInstance"), args)
+      );
+    }
+    case "http_request":
+    case "webhook":
+    case "call_webhook": {
+      const url = String(action.config.url ?? "");
+      const method = String(action.config.method ?? "POST");
+      return t3.expressionStatement(
+        t3.callExpression(t3.identifier("fetch"), [
+          t3.stringLiteral(url),
+          t3.objectExpression([
+            t3.objectProperty(t3.identifier("method"), t3.stringLiteral(method))
+          ])
+        ])
+      );
+    }
+    case "delay": {
+      const ms = Number(action.config.duration_ms ?? action.config.delay_ms ?? 1e3);
+      return t3.expressionStatement(
+        t3.awaitExpression(
+          t3.callExpression(
+            t3.identifier("delay"),
+            [t3.numericLiteral(ms)]
+          )
+        )
+      );
+    }
+    case "notify":
+    case "send_notification": {
+      const msg = String(action.config.message ?? action.config.body ?? "");
+      return t3.expressionStatement(
+        t3.callExpression(t3.identifier("notify"), [t3.stringLiteral(msg)])
+      );
+    }
+    case "noop":
+      return null;
+    default: {
+      const comment = ` ${action.type}(${JSON.stringify(action.config)}) `;
+      const voidExpr = t3.unaryExpression("void", t3.numericLiteral(0));
+      t3.addComment(voidExpr, "leading", comment, false);
+      return t3.expressionStatement(voidExpr);
+    }
+  }
+}
+function emitConditionExpression(conditions) {
+  if (conditions.length === 1) {
+    return emitSingleCondition(conditions[0]);
+  }
+  let result = emitSingleCondition(conditions[0]);
+  for (let i = 1; i < conditions.length; i++) {
+    result = t3.logicalExpression("&&", result, emitSingleCondition(conditions[i]));
+  }
+  return result;
+}
+function emitSingleCondition(cond) {
+  if (cond.expression) {
+    return t3.identifier(cond.expression);
+  }
+  if (cond.field && cond.operator) {
+    const fieldExpr = t3.identifier(toCamelCase2(cond.field));
+    const valueExpr = valueToExpression(cond.value);
+    const opMap = {
+      eq: "===",
+      ne: "!==",
+      gt: ">",
+      gte: ">=",
+      lt: "<",
+      lte: "<="
+    };
+    const jsOp = opMap[cond.operator];
+    if (jsOp) {
+      return t3.binaryExpression(jsOp, fieldExpr, valueExpr);
+    }
+    if (cond.operator === "is_set") {
+      return t3.binaryExpression("!==", fieldExpr, t3.nullLiteral());
+    }
+    if (cond.operator === "is_empty") {
+      return t3.binaryExpression("===", fieldExpr, t3.nullLiteral());
+    }
+    if (cond.operator === "contains" && typeof cond.value === "string") {
+      return t3.callExpression(
+        t3.memberExpression(fieldExpr, t3.identifier("includes")),
+        [t3.stringLiteral(cond.value)]
+      );
+    }
+    if (cond.operator === "in" && Array.isArray(cond.value)) {
+      return t3.callExpression(
+        t3.memberExpression(
+          t3.arrayExpression(cond.value.map((v) => valueToExpression(v))),
+          t3.identifier("includes")
+        ),
+        [fieldExpr]
+      );
+    }
+  }
+  if (cond.OR && cond.OR.length > 0) {
+    let result = emitSingleCondition(cond.OR[0]);
+    for (let i = 1; i < cond.OR.length; i++) {
+      result = t3.logicalExpression("||", result, emitSingleCondition(cond.OR[i]));
+    }
+    return result;
+  }
+  if (cond.AND && cond.AND.length > 0) {
+    return emitConditionExpression(cond.AND);
+  }
+  return t3.booleanLiteral(true);
+}
+function emitRoleDeclarations(metadata, imports) {
+  const roleDeps = metadata?.roleDependencies;
+  if (!roleDeps || roleDeps.length === 0) return [];
+  addImport2(imports, "@mindmatrix/react", "useRole");
+  const statements = [];
+  for (const role of roleDeps) {
+    const varName = `is${toPascalCase(role)}`;
+    statements.push(
+      t3.variableDeclaration("const", [
+        t3.variableDeclarator(
+          t3.identifier(varName),
+          t3.callExpression(t3.identifier("useRole"), [t3.stringLiteral(role)])
+        )
+      ])
+    );
+  }
+  return statements;
+}
+function emitQueryDeclarations(metadata, imports) {
+  const statements = [];
+  const dataSources = metadata?.dataSources;
+  const modelImports = metadata?.modelImports;
+  const addedModelImports = /* @__PURE__ */ new Set();
+  if (dataSources && dataSources.length > 0) {
+    addImport2(imports, "@mindmatrix/react", "useQuery");
+    const usedVarNames = /* @__PURE__ */ new Set();
+    for (const ds of dataSources) {
+      if (ds.type !== "workflow") continue;
+      const slug = ds.slug || ds.name;
+      const baseName = ds.name.includes(".") ? ds.name.split(".").pop() : ds.name;
+      let varName = toCamelCase2(baseName.replace(/-/g, "_"));
+      if (usedVarNames.has(varName)) {
+        let suffix = 2;
+        while (usedVarNames.has(`${varName}${suffix}`)) suffix++;
+        varName = `${varName}${suffix}`;
+      }
+      usedVarNames.add(varName);
+      const modelPath = modelImports?.[slug];
+      const modelVarName = modelPath ? `${toCamelCase2(slug.replace(/-/g, "_"))}Model` : void 0;
+      if (modelPath && modelVarName && !addedModelImports.has(slug)) {
+        addImport2(imports, modelPath, `default as ${modelVarName}`);
+        addedModelImports.add(slug);
+      }
+      const optionProps = [];
+      if (ds.pageSize) {
+        optionProps.push(
+          t3.objectProperty(t3.identifier("limit"), t3.numericLiteral(ds.pageSize))
+        );
+      }
+      if (ds.sort) {
+        optionProps.push(
+          t3.objectProperty(t3.identifier("orderBy"), t3.stringLiteral(ds.sort))
+        );
+      }
+      if (ds.filter && Object.keys(ds.filter).length > 0) {
+        optionProps.push(
+          t3.objectProperty(t3.identifier("filter"), valueToExpression(ds.filter))
+        );
+      }
+      if (ds.search) {
+        optionProps.push(
+          t3.objectProperty(t3.identifier("search"), t3.stringLiteral(ds.search))
+        );
+      }
+      if (ds.groupBy) {
+        optionProps.push(
+          t3.objectProperty(t3.identifier("groupBy"), t3.stringLiteral(ds.groupBy))
+        );
+      }
+      const queryTarget = modelVarName ? t3.identifier(modelVarName) : t3.stringLiteral(slug);
+      const args = [queryTarget];
+      if (optionProps.length > 0) {
+        args.push(t3.objectExpression(optionProps));
+      }
+      statements.push(
+        t3.variableDeclaration("const", [
+          t3.variableDeclarator(
+            t3.objectPattern([
+              t3.objectProperty(
+                t3.identifier("data"),
+                t3.identifier(varName)
+              )
+            ]),
+            t3.callExpression(t3.identifier("useQuery"), args)
+          )
+        ])
+      );
+    }
+  }
+  const mutationTargets = metadata?.mutationTargets;
+  if (mutationTargets && mutationTargets.length > 0) {
+    addImport2(imports, "@mindmatrix/react", "useMutation");
+    for (const slug of mutationTargets) {
+      const modelPath = modelImports?.[slug];
+      const modelVarName2 = modelPath ? `${toCamelCase2(slug.replace(/-/g, "_"))}Model` : void 0;
+      if (modelPath && modelVarName2 && !addedModelImports?.has(slug)) {
+        addImport2(imports, modelPath, `default as ${modelVarName2}`);
+        addedModelImports?.add(slug);
+      }
+      const mutTarget = modelVarName2 ? t3.identifier(modelVarName2) : t3.stringLiteral(slug);
+      const varName = `${toCamelCase2(slug.replace(/-/g, "_"))}Mutation`;
+      statements.push(
+        t3.variableDeclaration("const", [
+          t3.variableDeclarator(
+            t3.identifier(varName),
+            t3.callExpression(t3.identifier("useMutation"), [mutTarget])
+          )
+        ])
+      );
+    }
+  }
+  return statements;
+}
+function emitChangeWatchers(metadata, imports) {
+  const watchers = metadata?.fieldWatchers;
+  if (!watchers || watchers.length === 0) return [];
+  addImport2(imports, "@mindmatrix/react", "useOnChange");
+  const statements = [];
+  for (const watcher of watchers) {
+    statements.push(
+      t3.expressionStatement(
+        t3.callExpression(t3.identifier("useOnChange"), [
+          t3.stringLiteral(watcher.field),
+          emitActionCallback(watcher.actions)
+        ])
+      )
+    );
+  }
+  return statements;
+}
+function emitEventSubscriptions(onEvent, imports) {
+  if (!onEvent || onEvent.length === 0) return [];
+  addImport2(imports, "@mindmatrix/react", "useOnEvent");
+  const statements = [];
+  for (const sub of onEvent) {
+    const actions = sub.actions.map((a, i) => ({
+      id: `event_${i}`,
+      type: a.type,
+      mode: "auto",
+      config: {
+        ...a.field && { field: a.field },
+        ...a.expression && { expression: a.expression },
+        ...a.message && { message: a.message }
+      }
+    }));
+    statements.push(
+      t3.expressionStatement(
+        t3.callExpression(t3.identifier("useOnEvent"), [
+          t3.stringLiteral(sub.match),
+          emitActionCallback(actions)
+        ])
+      )
+    );
+  }
+  return statements;
+}
+function emitTransitionEffects(metadata, imports) {
+  const effects = metadata?.transitionEffects;
+  if (!effects || effects.length === 0) return [];
+  addImport2(imports, "@mindmatrix/react", "useOnTransition");
+  const statements = [];
+  for (const effect of effects) {
+    statements.push(
+      t3.expressionStatement(
+        t3.callExpression(t3.identifier("useOnTransition"), [
+          t3.stringLiteral(effect.transition),
+          emitActionCallback(effect.actions)
+        ])
+      )
+    );
+  }
+  return statements;
+}
+function emitLocalDefaultDeclarations(experience, existingFields, imports) {
+  const allDefaults = /* @__PURE__ */ new Map();
+  collectAllLocalDefaults(experience, allDefaults);
+  const existingNames = /* @__PURE__ */ new Set();
+  for (const f of existingFields) {
+    if (f.computed) continue;
+    existingNames.add(f.name);
+    existingNames.add(toCamelCase2(f.name));
+  }
+  const emittedCamelNames = /* @__PURE__ */ new Set();
+  const statements = [];
+  for (const [key, value] of allDefaults) {
+    if (key.includes(".")) continue;
+    if (existingNames.has(key) || existingNames.has(toCamelCase2(key))) continue;
+    const camelName = toCamelCase2(key);
+    if (emittedCamelNames.has(camelName)) continue;
+    emittedCamelNames.add(camelName);
+    addImport2(imports, "@mindmatrix/react", "useState");
+    const setter = `set${toPascalCase(key)}`;
+    let defaultExpr;
+    if (value === void 0 || value === null) {
+      defaultExpr = t3.identifier("undefined");
+    } else if (typeof value === "string" && /^[a-zA-Z]\w*$/.test(value) && value !== key) {
+      defaultExpr = t3.identifier("undefined");
+    } else {
+      defaultExpr = valueToExpression(value);
+    }
+    statements.push(
+      t3.variableDeclaration("const", [
+        t3.variableDeclarator(
+          t3.arrayPattern([
+            t3.identifier(camelName),
+            t3.identifier(setter)
+          ]),
+          t3.callExpression(t3.identifier("useState"), [defaultExpr])
+        )
+      ])
+    );
+  }
+  return statements;
+}
+function collectAllLocalDefaults(node, out) {
+  if (node.config?.localDefaults && typeof node.config.localDefaults === "object") {
+    const ld = node.config.localDefaults;
+    for (const [key, value] of Object.entries(ld)) {
+      if (!out.has(key)) out.set(key, value);
+    }
+  }
+  if (node.children) {
+    for (const child of node.children) {
+      collectAllLocalDefaults(child, out);
+    }
+  }
+}
+function normalizeFrom(from) {
+  if (Array.isArray(from)) return from;
+  if (typeof from === "string") return [from];
+  return [];
+}
+function correctFromFields(transitions) {
+  if (transitions.length <= 1) return transitions;
+  const fromValues = /* @__PURE__ */ new Set();
+  for (const t5 of transitions) {
+    const arr = normalizeFrom(t5.from);
+    for (const f of arr) fromValues.add(f);
+  }
+  if (fromValues.size !== 1) return transitions;
+  const stateNames = /* @__PURE__ */ new Set([...fromValues]);
+  for (const t5 of transitions) {
+    stateNames.add(t5.to);
+  }
+  const allNamesAreStates = transitions.every((t5) => stateNames.has(t5.name));
+  if (!allNamesAreStates) return transitions;
+  return transitions.map((t5) => ({
+    ...t5,
+    from: [t5.name]
+  }));
+}
+function addImport2(tracker, source, name) {
+  if (!tracker.has(source)) tracker.set(source, /* @__PURE__ */ new Set());
+  tracker.get(source).add(name);
+}
+
+// src/decompiler/split-strategy.ts
+var SMALL_FIELD_LIMIT = 5;
+var SMALL_STATE_LIMIT = 1;
+var MEDIUM_FIELD_LIMIT = 15;
+var MEDIUM_STATE_LIMIT = 5;
+function determineSplitStrategy(def) {
+  const fieldCount = def.fields.length;
+  const stateCount = def.states.length;
+  const hasExperience = !!def.experience || !!def.views?.default;
+  const hasChildren = Array.isArray(def.metadata?.childSlugs) && def.metadata.childSlugs.length > 0;
+  if (def.category === "blueprint" || hasChildren) {
+    return {
+      tier: "large",
+      emitModels: fieldCount > 0,
+      emitPages: hasExperience,
+      emitActions: true,
+      emitConfig: true,
+      reason: "blueprint or has children \u2014 always full project"
+    };
+  }
+  if (fieldCount > MEDIUM_FIELD_LIMIT || stateCount > MEDIUM_STATE_LIMIT) {
+    return {
+      tier: "large",
+      emitModels: true,
+      emitPages: hasExperience,
+      emitActions: true,
+      emitConfig: true,
+      reason: "large definition (>15 fields or >5 states)"
+    };
+  }
+  if (fieldCount > SMALL_FIELD_LIMIT || stateCount > SMALL_STATE_LIMIT) {
+    const hasRoutes = hasExperience && hasRouteStructure(def);
+    return {
+      tier: "medium",
+      emitModels: fieldCount > 0,
+      emitPages: hasRoutes,
+      emitActions: false,
+      emitConfig: true,
+      reason: "medium definition (>5 fields or >1 state)"
+    };
+  }
+  return {
+    tier: "single",
+    emitModels: false,
+    emitPages: false,
+    emitActions: false,
+    emitConfig: false,
+    reason: "small definition \u2014 single file sufficient"
+  };
+}
+function hasRouteStructure(def) {
+  const exp = def.experience;
+  if (!exp) return false;
+  function walk(node) {
+    const comp = node.component || node.layout || "";
+    if (comp === "Router" || comp === "Route") return true;
+    if (node.children) {
+      for (const c of node.children) {
+        if (walk(c)) return true;
+      }
+    }
+    return false;
+  }
+  return walk(exp);
+}
+
+// src/decompiler/config-generator.ts
+function extractConfigData(def, modelPaths, entryPaths, actionPaths) {
+  const meta = def.metadata;
+  return {
+    slug: def.slug,
+    name: def.name || pascalCase(def.slug),
+    version: def.version,
+    category: def.category,
+    description: def.description || void 0,
+    mode: meta?.mode || void 0,
+    defaultRuntime: meta?.defaultRuntime || void 0,
+    models: modelPaths,
+    entries: entryPaths,
+    actions: actionPaths,
+    roles: (def.roles || []).map((r) => r.name)
+  };
+}
+function generateMmConfig(config) {
+  const isBlueprint = config.category === "blueprint";
+  const fnName = isBlueprint ? "defineBlueprint" : "defineWorkspace";
+  const label = isBlueprint ? "Blueprint" : "Workspace";
+  const lines = [
+    `/**`,
+    ` * MindMatrix ${label.toLowerCase()} configuration.`,
+    ` *`,
+    ` * Auto-generated from workflow definition "${config.slug}".`,
+    ` */`,
+    ``,
+    `import { ${fnName} } from '@mindmatrix/react';`,
+    ``,
+    `export default ${fnName}({`,
+    `  slug: '${esc(config.slug)}',`,
+    `  name: '${esc(config.name)}',`,
+    `  version: '${esc(config.version)}',`,
+    `  category: '${esc(config.category)}',`
+  ];
+  if (config.description) {
+    lines.push(`  description: '${esc(config.description)}',`);
+  }
+  if (isBlueprint) {
+    if (config.mode) {
+      lines.push(`  mode: '${esc(config.mode)}',`);
+    }
+    if (config.defaultRuntime) {
+      lines.push(`  defaultRuntime: '${esc(config.defaultRuntime)}',`);
+    }
+  }
+  if (config.models.length > 0) {
+    lines.push(`  models: [`);
+    for (const m of config.models) {
+      lines.push(`    '${esc(m)}',`);
+    }
+    lines.push(`  ],`);
+  }
+  if (config.entries.length > 0) {
+    lines.push(`  entries: [`);
+    for (const e of config.entries) {
+      lines.push(`    '${esc(e)}',`);
+    }
+    lines.push(`  ],`);
+  }
+  if (config.actions.length > 0) {
+    lines.push(`  actions: [`);
+    for (const a of config.actions) {
+      lines.push(`    '${esc(a)}',`);
+    }
+    lines.push(`  ],`);
+  }
+  if (config.roles.length > 0) {
+    lines.push(`  roles: [${config.roles.map((r) => `'${esc(r)}'`).join(", ")}],`);
+  }
+  lines.push(`});`);
+  lines.push(``);
+  return lines.join("\n");
+}
+function esc(s) {
+  return s.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+function pascalCase(slug) {
+  return slug.split(/[-_]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join("");
+}
+
+// src/decompiler/project-decompiler.ts
+function pascalCase2(slug) {
+  return slug.split(/[-_]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join("");
+}
+function camelCase(str) {
+  return str.replace(/[-_]([a-z])/g, (_, c) => c.toUpperCase());
+}
+function correctTransitionFromFields(transitions) {
+  if (transitions.length <= 1) return transitions;
+  const fromValues = /* @__PURE__ */ new Set();
+  for (const t5 of transitions) {
+    const arr = Array.isArray(t5.from) ? t5.from : [t5.from];
+    for (const f of arr) fromValues.add(f);
+  }
+  if (fromValues.size !== 1) return transitions;
+  const stateNames = /* @__PURE__ */ new Set([...fromValues]);
+  for (const t5 of transitions) {
+    stateNames.add(t5.to);
+  }
+  const allNamesAreStates = transitions.every((t5) => stateNames.has(t5.name));
+  if (!allNamesAreStates) return transitions;
+  return transitions.map((t5) => ({ ...t5, from: [t5.name] }));
+}
+function fieldTypeToTS(fieldType, field) {
+  const options = getFieldOptions(field);
+  if (options && options.length > 0 && (fieldType === "select" || fieldType === "text")) {
+    return options.map((o) => `'${esc2(String(o))}'`).join(" | ");
+  }
+  switch (fieldType) {
+    case "text":
+    case "rich_text":
+    case "email":
+    case "url":
+    case "phone":
+    case "color":
+    case "select":
+      return "string";
+    case "number":
+    case "currency":
+    case "percentage":
+    case "rating":
+    case "duration":
+    case "auto_number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "date":
+    case "datetime":
+    case "created_at":
+    case "updated_at":
+      return "Date";
+    case "multi_select":
+      return "string[]";
+    case "json":
+    case "object":
+      return "Record<string, unknown>";
+    case "array":
+      return "string[]";
+    case "file":
+    case "image":
+      return "string";
+    case "relation":
+    case "lookup":
+      return "string";
+    default:
+      return "unknown";
+  }
+}
+function getFieldOptions(field) {
+  if (!field) return null;
+  const f = field;
+  const validation = f.validation;
+  if (validation?.options && Array.isArray(validation.options)) {
+    return validation.options;
+  }
+  const meta = f.metadata;
+  if (meta?.options && Array.isArray(meta.options)) {
+    return meta.options;
+  }
+  if (f.options && Array.isArray(f.options)) {
+    return f.options;
+  }
+  return null;
+}
+function safeKey(name) {
+  return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name) ? name : `'${esc2(name)}'`;
+}
+function fieldTypeToModelType(fieldType) {
+  switch (fieldType) {
+    case "text":
+    case "rich_text":
+    case "email":
+    case "url":
+    case "phone":
+    case "color":
+    case "select":
+      return "string";
+    case "number":
+    case "currency":
+    case "percentage":
+    case "rating":
+    case "duration":
+    case "auto_number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "date":
+    case "datetime":
+    case "created_at":
+    case "updated_at":
+      return "date";
+    case "multi_select":
+      return "array";
+    case "json":
+    case "object":
+      return "json";
+    case "array":
+      return "array";
+    case "file":
+    case "image":
+      return "file";
+    case "relation":
+    case "lookup":
+      return "relation";
+    default:
+      return fieldType;
+  }
+}
+function serializeDefault(value) {
+  if (value === void 0 || value === null) return "null";
+  if (typeof value === "string") return `'${esc2(value)}'`;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (Array.isArray(value)) {
+    if (value.length === 0) return "[]";
+    return `[${value.map((v) => serializeDefault(v)).join(", ")}]`;
+  }
+  return JSON.stringify(value);
+}
+function generateModelFile(slug, fields, states, transitions, meta) {
+  const typeName = pascalCase2(slug);
+  const interfaceName = `${typeName}Fields`;
+  const version = meta?.version || "0.1.0";
+  const category = meta?.category || "data";
+  const lines = [];
+  lines.push(`import { defineModel } from "@mindmatrix/react";`);
+  lines.push(``);
+  const sortedFields = [...fields].sort((a, b) => a.name.localeCompare(b.name));
+  if (sortedFields.length > 0) {
+    lines.push(`export interface ${interfaceName} {`);
+    for (const field of sortedFields) {
+      const tsType = fieldTypeToTS(field.type, field);
+      const optional = field.required ? "" : "?";
+      lines.push(`  ${camelCase(field.name)}${optional}: ${tsType};`);
+    }
+    lines.push(`}`);
+    lines.push(``);
+  }
+  lines.push(`export default defineModel({`);
+  lines.push(`  slug: '${esc2(slug)}',`);
+  lines.push(`  version: '${esc2(version)}',`);
+  lines.push(`  category: '${esc2(category)}',`);
+  if (meta?.description) {
+    lines.push(`  description: '${esc2(meta.description)}',`);
+  }
+  if (sortedFields.length > 0) {
+    lines.push(`  fields: {`);
+    for (const field of sortedFields) {
+      const props = [];
+      props.push(`type: '${fieldTypeToModelType(field.type)}'`);
+      if (field.required) {
+        props.push(`required: true`);
+      }
+      if (field.default_value !== void 0 && field.default_value !== null && field.default_value !== "" && field.default_value !== 0 && field.default_value !== false) {
+        props.push(`default: ${serializeDefault(field.default_value)}`);
+      }
+      const options = getFieldOptions(field);
+      if (options && options.length > 0) {
+        const enumStr = options.map((o) => `'${esc2(String(o))}'`).join(", ");
+        props.push(`enum: [${enumStr}]`);
+      }
+      lines.push(`    ${camelCase(field.name)}: { ${props.join(", ")} },`);
+    }
+    lines.push(`  },`);
+  }
+  if (states.length > 0) {
+    const sortedStates = [...states].sort((a, b) => a.name.localeCompare(b.name));
+    lines.push(`  states: {`);
+    for (const state of sortedStates) {
+      const props = [];
+      if (state.type === "START") {
+        props.push(`type: 'initial'`);
+      } else if (state.type === "END") {
+        props.push(`type: 'final'`);
+      }
+      if (state.description) {
+        props.push(`description: '${esc2(state.description)}'`);
+      }
+      const body = props.length > 0 ? ` ${props.join(", ")} ` : "";
+      lines.push(`    ${safeKey(state.name)}: {${body}},`);
+    }
+    lines.push(`  },`);
+  }
+  if (transitions.length > 0) {
+    const correctedTrans = correctTransitionFromFields(transitions);
+    const sortedTrans = [...correctedTrans].sort((a, b) => a.name.localeCompare(b.name));
+    lines.push(`  transitions: {`);
+    for (const trans of sortedTrans) {
+      const fromArr = Array.isArray(trans.from) ? trans.from : [trans.from];
+      const parts = [];
+      if (fromArr.length === 1) {
+        parts.push(`from: '${esc2(fromArr[0])}'`);
+      } else {
+        parts.push(`from: [${fromArr.map((f) => `'${esc2(f)}'`).join(", ")}]`);
+      }
+      parts.push(`to: '${esc2(trans.to)}'`);
+      if (trans.roles && trans.roles.length > 0) {
+        parts.push(`roles: [${trans.roles.map((r) => `'${esc2(r)}'`).join(", ")}]`);
+      }
+      if (trans.auto) {
+        parts.push(`auto: true`);
+      }
+      if (trans.required_fields && trans.required_fields.length > 0) {
+        parts.push(`required_fields: [${trans.required_fields.map((f) => `'${esc2(f)}'`).join(", ")}]`);
+      }
+      lines.push(`    ${safeKey(trans.name)}: { ${parts.join(", ")} },`);
+    }
+    lines.push(`  },`);
+  }
+  lines.push(`});`);
+  lines.push(``);
+  return lines.join("\n");
+}
+function generateLayoutFile(slug, roles) {
+  const componentName = `${pascalCase2(slug)}Layout`;
+  const lines = [
+    `/**`,
+    ` * ${componentName} \u2014 root layout with auth guards.`,
+    ` */`,
+    ``,
+    `import { useRole, Stack } from '@mindmatrix/react';`,
+    ``,
+    `interface LayoutProps {`,
+    `  children: React.ReactNode;`,
+    `}`,
+    ``,
+    `export default function ${componentName}({ children }: LayoutProps) {`
+  ];
+  for (const role of roles) {
+    const varName = `is${pascalCase2(role.name)}`;
+    lines.push(`  const ${varName} = useRole('${esc2(role.name)}');`);
+  }
+  if (roles.length > 0) {
+    lines.push(``);
+    const roleChecks = roles.map((r) => `is${pascalCase2(r.name)}`).join(" || ");
+    lines.push(`  const isAuthorized = ${roleChecks};`);
+    lines.push(``);
+    lines.push(`  if (!isAuthorized) {`);
+    lines.push(`    return <Stack sx={{ p: 32, align: 'center' }}>Access denied</Stack>;`);
+    lines.push(`  }`);
+  }
+  lines.push(``);
+  lines.push(`  return (`);
+  lines.push(`    <Stack sx={{ minH: '100vh' }}>`);
+  lines.push(`      {children}`);
+  lines.push(`    </Stack>`);
+  lines.push(`  );`);
+  lines.push(`}`);
+  lines.push(``);
+  return lines.join("\n");
+}
+function extractRouteTable(childDefinitions) {
+  if (!childDefinitions) return [];
+  const router = childDefinitions.find(
+    (c) => c.slug.endsWith("-router") || c.category === "router"
+  );
+  if (!router?.states) return [];
+  return router.states.filter((s) => s.description?.startsWith("Route:")).map((s) => {
+    const route = s.description.replace(/^Route:\s*/, "").replace(/^\//, "");
+    const parts = route.split("/");
+    return {
+      stateName: s.name,
+      role: parts[0] || "shared",
+      page: parts.slice(1).join("/") || parts[0],
+      path: route
+    };
+  });
+}
+function findPageTitle(node, maxDepth = 5) {
+  const queue = [{ n: node, d: 0 }];
+  while (queue.length > 0) {
+    const { n, d } = queue.shift();
+    if (d > maxDepth) continue;
+    if ((n.component === "Text" || n.component === "Heading") && (n.config?.level === 2 || n.config?.variant === "h2")) {
+      if (n.config?.text) return n.config.text;
+      if (n.children?.length) {
+        const parts = n.children.filter((c) => c.config?.value).map((c) => c.config.value);
+        if (parts.length > 0) return parts.join("");
+      }
+    }
+    if (n.children) {
+      for (const child of n.children) {
+        queue.push({ n: child, d: d + 1 });
+      }
+    }
+  }
+  return null;
+}
+function detectPageRole(node) {
+  const when = node.bindings?.when || "";
+  if (/isAdmin|is_admin/i.test(when)) return "admin";
+  if (/isDriver|is_driver/i.test(when)) return "driver";
+  if (/isRider|is_rider/i.test(when)) return "rider";
+  const ld = node.config?.localDefaults || {};
+  const keys = Object.keys(ld);
+  if (keys.some((k) => k.startsWith("driver.") || k === "is_online")) return "driver";
+  if (keys.some((k) => k.startsWith("earnings.") || k.startsWith("matching."))) return "driver";
+  if (keys.some((k) => k.startsWith("rider."))) return "rider";
+  if (keys.includes("ride.current_fare") || keys.includes("time_left")) return "driver";
+  if (keys.includes("selected_vehicle") || keys.includes("driver_location")) return "rider";
+  if (keys.includes("date_from") || keys.includes("date_to")) return "rider";
+  if (keys.includes("cvv") || keys.includes("card_number")) return "rider";
+  const title = findPageTitle(node);
+  if (title) {
+    const lower = title.toLowerCase();
+    if (lower.includes("driver") || lower.includes("earning") || lower.includes("navigation")) return "driver";
+    if (lower.includes("ride request") || lower.includes("ride acceptance")) return "driver";
+    if (lower.includes("payment method") || lower.includes("ride history")) return "rider";
+    if (lower.includes("your ride") || lower.includes("where to") || lower.includes("ride tracking")) return "rider";
+    if (lower.includes("analytics") || lower.includes("surge") || lower.includes("fleet")) return "admin";
+  }
+  return "shared";
+}
+function isChildWorkflowView(node, childSlugs) {
+  const title = findPageTitle(node);
+  if (!title) return false;
+  if (title.includes("#")) return true;
+  const titleSlug = title.toLowerCase().replace(/[^a-z0-9\s]/g, "").trim().replace(/\s+/g, "-");
+  return childSlugs.has(titleSlug);
+}
+function titleToSlug(title) {
+  const MAP = {
+    "where to?": "home",
+    "where to": "home",
+    "your ride": "ride-tracking",
+    "incoming ride request": "ride-acceptance"
+  };
+  const lower = title.toLowerCase();
+  if (MAP[lower]) return MAP[lower];
+  return lower.replace(/[^a-z0-9\s]/g, "").trim().replace(/\s+/g, "-");
+}
+function scoreRouteMatch(title, route) {
+  const titleSlug = title.toLowerCase().replace(/[^a-z0-9\s]/g, "").trim().replace(/\s+/g, "-");
+  const titleWords = new Set(titleSlug.split("-").filter((w) => w.length > 2));
+  let score = 0;
+  for (const word of route.page.split("-")) {
+    if (titleWords.has(word)) score += 2;
+  }
+  if (titleSlug.includes(route.page) || route.page.includes(titleSlug)) {
+    score += 3;
+  }
+  return score;
+}
+function extractRoleGuard(node) {
+  const when = node.bindings?.when || "";
+  const match = when.match(/\$instance\.(is\w+)/);
+  return match ? match[1] : void 0;
+}
+function collectDataSources(node) {
+  const sources = [];
+  const nodeDS = node.dataSources;
+  if (Array.isArray(nodeDS)) sources.push(...nodeDS);
+  if (node.children) {
+    for (const child of node.children) {
+      const childDS = child.dataSources;
+      if (Array.isArray(childDS)) sources.push(...childDS);
+    }
+  }
+  return sources;
+}
+function stripLocalDefaults(node) {
+  if (!node.config?.localDefaults) return node;
+  const { localDefaults, ...rest } = node.config;
+  return { ...node, config: Object.keys(rest).length > 0 ? rest : void 0 };
+}
+function getPageContentTree(node) {
+  if (node.component === "Show" && node.children?.length === 1) {
+    return stripLocalDefaults(node.children[0]);
+  }
+  return stripLocalDefaults(node);
+}
+function inferFieldType(value) {
+  if (typeof value === "boolean") return "boolean";
+  if (typeof value === "number") return "number";
+  return "text";
+}
+function extractPageSections(experience, childDefinitions) {
+  if (!experience?.children) return { pages: [], childViews: [] };
+  const routerExtracted = extractFromRouterExperience(experience);
+  if (routerExtracted) return routerExtracted;
+  const routeTable = extractRouteTable(childDefinitions);
+  const childSlugs = new Set(
+    (childDefinitions || []).filter((c) => !c.slug.endsWith("-router") && c.category !== "router").map((c) => c.slug)
+  );
+  const pages = [];
+  const childViews = [];
+  const candidates = [];
+  for (let i = 0; i < experience.children.length; i++) {
+    const child = experience.children[i];
+    if (isChildWorkflowView(child, childSlugs)) {
+      childViews.push(child);
+      continue;
+    }
+    const title = findPageTitle(child);
+    const role = detectPageRole(child);
+    const localDefaults = child.config?.localDefaults || {};
+    const roleGuard = extractRoleGuard(child);
+    const dataSources = collectDataSources(child);
+    candidates.push({
+      title,
+      role,
+      index: i,
+      node: child,
+      localDefaults,
+      roleGuard,
+      dataSources: dataSources.length > 0 ? dataSources : void 0
+    });
+  }
+  const assignments = /* @__PURE__ */ new Map();
+  const usedRoutes = /* @__PURE__ */ new Set();
+  for (const cand of candidates) {
+    if (!cand.title) continue;
+    const roleRoutes = routeTable.filter(
+      (r) => r.role === cand.role && !usedRoutes.has(r.stateName)
+    );
+    let bestRoute = null;
+    let bestScore = 0;
+    for (const route of roleRoutes) {
+      const score = scoreRouteMatch(cand.title, route);
+      if (score > bestScore) {
+        bestScore = score;
+        bestRoute = route;
+      }
+    }
+    if (bestRoute && bestScore >= 3) {
+      assignments.set(cand.index, bestRoute);
+      usedRoutes.add(bestRoute.stateName);
+    }
+  }
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const cand of candidates) {
+      if (assignments.has(cand.index)) continue;
+      const remaining = routeTable.filter(
+        (r) => r.role === cand.role && !usedRoutes.has(r.stateName)
+      );
+      if (remaining.length === 1) {
+        assignments.set(cand.index, remaining[0]);
+        usedRoutes.add(remaining[0].stateName);
+        changed = true;
+      } else if (remaining.length > 1 && cand.title) {
+        let bestRoute = null;
+        let bestScore = 0;
+        for (const route of remaining) {
+          const score = scoreRouteMatch(cand.title, route);
+          if (score > bestScore) {
+            bestScore = score;
+            bestRoute = route;
+          }
+        }
+        if (bestRoute && bestScore > 0) {
+          assignments.set(cand.index, bestRoute);
+          usedRoutes.add(bestRoute.stateName);
+          changed = true;
+        }
+      }
+    }
+  }
+  for (const cand of candidates) {
+    const route = assignments.get(cand.index);
+    const slug = route?.page || titleToSlug(cand.title || `page-${cand.index}`);
+    const filePath = `app/${cand.role}/${slug}.tsx`;
+    const componentName = pascalCase2(slug) + "Page";
+    pages.push({
+      route: route?.path || `${cand.role}/${slug}`,
+      role: cand.role,
+      slug,
+      title: cand.title || slug,
+      componentName,
+      tree: cand.node,
+      filePath,
+      localDefaults: cand.localDefaults,
+      roleGuard: cand.roleGuard,
+      dataSources: cand.dataSources
+    });
+  }
+  return { pages, childViews };
+}
+function extractFromRouterExperience(experience) {
+  if (!experience.children) return null;
+  const routerNode = experience.children.find((c) => c.component === "Router");
+  if (!routerNode?.children) return null;
+  const routes = routerNode.children.filter((c) => c.component === "Route");
+  if (routes.length === 0) return null;
+  const pages = [];
+  const seenPaths = /* @__PURE__ */ new Set();
+  for (const route of routes) {
+    const routePath = route.config?.path || "";
+    if (route.config?.exact && routePath === "/") continue;
+    if (seenPaths.has(routePath)) continue;
+    seenPaths.add(routePath);
+    const segments = routePath.replace(/^\//, "").split("/").filter(Boolean);
+    const role = segments.length > 1 ? segments[0] : "shared";
+    const slug = segments.length > 1 ? segments.slice(1).join("-") : segments[0] || "page0";
+    const filePath = `app/${role}/${slug}.tsx`;
+    const componentName = pascalCase2(slug) + "Page";
+    const rawPageTree = route.children?.[0] || route;
+    const pageTree = { ...rawPageTree };
+    if (pageTree.config) {
+      const { gap, padding, ...restConfig } = pageTree.config;
+      pageTree.config = Object.keys(restConfig).length > 0 ? restConfig : void 0;
+    }
+    const localDefaults = pageTree.config?.localDefaults || {};
+    pages.push({
+      route: routePath,
+      role,
+      slug,
+      title: findPageTitle(pageTree) || slug,
+      componentName,
+      tree: pageTree,
+      filePath,
+      localDefaults
+    });
+  }
+  return pages.length > 0 ? { pages, childViews: [] } : null;
+}
+function generatePageFileFromSection(page, modelSlugToPath) {
+  const fields = Object.entries(page.localDefaults).filter(([key]) => !key.includes(".")).map(([key, value]) => ({
+    name: key,
+    type: inferFieldType(value),
+    required: false,
+    default_value: value ?? void 0
+  }));
+  const contentTree = getPageContentTree(page.tree);
+  const metadata = {};
+  if (page.dataSources && page.dataSources.length > 0) {
+    metadata.dataSources = page.dataSources;
+    if (modelSlugToPath) {
+      const modelImports = {};
+      for (const ds of page.dataSources) {
+        const dsObj = ds;
+        if (dsObj.type !== "workflow") continue;
+        const slug = dsObj.slug || dsObj.name;
+        if (!slug) continue;
+        const modelPath = modelSlugToPath.get(slug);
+        if (modelPath) {
+          const pageDir = page.filePath.split("/").slice(0, -1).join("/");
+          const rel = computeRelativeImport(pageDir, modelPath);
+          modelImports[slug] = rel;
+        }
+      }
+      if (Object.keys(modelImports).length > 0) {
+        metadata.modelImports = modelImports;
+      }
+    }
+  }
+  const pageInput = {
+    slug: page.slug,
+    name: page.componentName,
+    version: "1.0.0",
+    category: "page",
+    states: [],
+    transitions: [],
+    fields,
+    roles: [],
+    experience: contentTree,
+    metadata: Object.keys(metadata).length > 0 ? metadata : void 0
+  };
+  return decompile(pageInput, {
+    componentName: page.componentName,
+    includeAnnotation: false
+  }).code;
+}
+function computeRelativeImport(fromDir, toFile) {
+  const fromParts = fromDir.split("/").filter(Boolean);
+  const toParts = toFile.replace(/\.(ts|tsx)$/, "").split("/").filter(Boolean);
+  let common = 0;
+  while (common < fromParts.length && common < toParts.length && fromParts[common] === toParts[common]) {
+    common++;
+  }
+  const ups = fromParts.length - common;
+  const downs = toParts.slice(common);
+  if (ups === 0 && downs.length === 0) return "./index";
+  const prefix = ups > 0 ? "../".repeat(ups) : "./";
+  return prefix + downs.join("/");
+}
+function generateMainWithPages(definition, pages, childViews) {
+  const mainChildren = [];
+  for (const page of pages) {
+    if (page.roleGuard) {
+      mainChildren.push({
+        id: `page-${page.slug}`,
+        component: "Show",
+        bindings: { when: `$instance.${page.roleGuard}` },
+        children: [{ id: `${page.slug}-ref`, component: page.componentName }]
+      });
+    } else {
+      mainChildren.push({
+        id: `page-${page.slug}`,
+        component: page.componentName
+      });
+    }
+  }
+  for (const cv of childViews) {
+    mainChildren.push(cv);
+  }
+  const mainTree = {
+    id: "root",
+    component: "Stack",
+    children: mainChildren
+  };
+  const modifiedDef = { ...definition, experience: mainTree };
+  const result = decompile(modifiedDef, { includeAnnotation: true });
+  const pageImports = pages.map((p) => `import ${p.componentName} from './${p.filePath.replace(/\.tsx$/, "")}';`).join("\n");
+  const code = result.code;
+  const importRegex = /^import .+$/gm;
+  let lastImportEnd = -1;
+  let m;
+  while ((m = importRegex.exec(code)) !== null) {
+    lastImportEnd = m.index + m[0].length;
+  }
+  if (lastImportEnd > 0) {
+    return code.slice(0, lastImportEnd) + "\n" + pageImports + code.slice(lastImportEnd);
+  }
+  return pageImports + "\n" + code;
+}
+var SERVER_ACTION_TYPES = /* @__PURE__ */ new Set([
+  "http_request",
+  "webhook",
+  "call_webhook",
+  "notify",
+  "send_notification",
+  "call_workflow",
+  "spawn_instance",
+  "spawn_subworkflow",
+  "emit_event",
+  "custom"
+]);
+function extractServerActions(states, transitions) {
+  const seen = /* @__PURE__ */ new Set();
+  const actions = [];
+  function collect(defs) {
+    for (const action of defs) {
+      if (SERVER_ACTION_TYPES.has(action.type) && !seen.has(action.id)) {
+        seen.add(action.id);
+        const slug = String(action.config.name || action.config.event || action.config.slug || action.type);
+        const name = camelCase(slug.replace(/[^a-zA-Z0-9_-]/g, "-"));
+        actions.push({ name, type: action.type, config: action.config });
+      }
+    }
+  }
+  for (const state of states) {
+    collect(state.on_enter);
+    collect(state.on_exit);
+    for (const during of state.during) {
+      collect(during.actions);
+    }
+  }
+  for (const trans of transitions) {
+    collect(trans.actions);
+  }
+  return actions;
+}
+function generateServerActionFile(slug, actions) {
+  const lines = [
+    `/**`,
+    ` * Server actions for "${slug}".`,
+    ` *`,
+    ` * These run server-side during state transitions.`,
+    ` */`,
+    ``,
+    `import type { TransitionContext } from '@mindmatrix/react';`,
+    ``
+  ];
+  for (const action of actions) {
+    lines.push(`/** ${actionComment(action)} */`);
+    lines.push(`export async function ${action.name}(ctx: TransitionContext): Promise<void> {`);
+    lines.push(`  const { instance, env } = ctx;`);
+    switch (action.type) {
+      case "http_request":
+      case "webhook":
+      case "call_webhook": {
+        const url = String(action.config.url || "https://api.example.com/webhook");
+        const method = String(action.config.method || "POST");
+        lines.push(`  await fetch('${esc2(url)}', {`);
+        lines.push(`    method: '${method}',`);
+        lines.push(`    headers: { 'Content-Type': 'application/json' },`);
+        lines.push(`    body: JSON.stringify({ instanceId: instance.id }),`);
+        lines.push(`  });`);
+        break;
+      }
+      case "notify":
+      case "send_notification": {
+        const msg = String(action.config.message || action.config.body || "Notification");
+        lines.push(`  await env.notify({ message: '${esc2(msg)}', instanceId: instance.id });`);
+        break;
+      }
+      case "call_workflow":
+      case "spawn_instance":
+      case "spawn_subworkflow": {
+        const target = String(action.config.slug || action.config.workflow || "child-workflow");
+        lines.push(`  await env.spawn('${esc2(target)}', { parentId: instance.id });`);
+        break;
+      }
+      case "emit_event": {
+        const event = String(action.config.event || action.config.name || "custom-event");
+        lines.push(`  await env.emit('${esc2(event)}', { instanceId: instance.id });`);
+        break;
+      }
+      case "custom": {
+        const expr = action.config.expression || action.config.body;
+        if (expr) {
+          lines.push(`  // Original expression: ${String(expr).replace(/\n/g, "\\n").slice(0, 200)}`);
+        }
+        lines.push(`  // TODO: Implement custom action logic`);
+        lines.push(`  throw new Error('Not implemented \u2014 decompiled stub');`);
+        break;
+      }
+      default:
+        lines.push(`  // TODO: Implement ${action.type} logic`);
+    }
+    lines.push(`}`);
+    lines.push(``);
+  }
+  return lines.join("\n");
+}
+function actionComment(action) {
+  switch (action.type) {
+    case "http_request":
+    case "webhook":
+    case "call_webhook":
+      return `HTTP ${action.config.method || "POST"} to ${action.config.url || "webhook"}`;
+    case "notify":
+    case "send_notification":
+      return `Send notification: ${action.config.message || ""}`;
+    case "call_workflow":
+    case "spawn_instance":
+    case "spawn_subworkflow":
+      return `Spawn workflow: ${action.config.slug || action.config.workflow || ""}`;
+    case "emit_event":
+      return `Emit event: ${action.config.event || action.config.name || ""}`;
+    case "custom":
+      return `Custom action: ${action.name}`;
+    default:
+      return `Server action: ${action.type}`;
+  }
+}
+function emitComponentDefinitions(definition, files) {
+  const meta = definition.metadata;
+  const componentDefs = meta?.componentDefinitions;
+  if (!componentDefs) return;
+  for (const [name, def] of Object.entries(componentDefs)) {
+    const content = generateComponentFromDefinition(name, def.experience, def.props);
+    files.push({
+      path: `components/${name}.tsx`,
+      role: "component",
+      content
+    });
+  }
+}
+function inferPropType(propName, experience) {
+  const usages = [];
+  collectPropUsages(propName, experience, usages);
+  if (propName.startsWith("on") && propName.length > 2 && propName[2] === propName[2].toUpperCase()) {
+    return "(() => void)";
+  }
+  const boolNames = ["show", "is", "has", "enable", "disable", "compact", "track", "follow"];
+  if (boolNames.some((b) => propName.toLowerCase().startsWith(b))) return "boolean";
+  for (const usage of usages) {
+    if (usage.includes(".address") || usage.includes("Address")) return "{ address: string; latitude: number; longitude: number }";
+    if (usage.includes(".toFixed")) return "number";
+    if (usage.includes(".toLocaleString")) return "number";
+    if (usage.includes(".heading")) return "{ latitude: number; longitude: number; heading: number }";
+    if (usage.includes(".length")) return "unknown[]";
+  }
+  if (/url|src|image|avatar|icon/i.test(propName)) return "string";
+  if (/count|amount|total|rating|eta|minutes|radius|zoom/i.test(propName)) return "number";
+  if (/style|sx/i.test(propName)) return "React.CSSProperties";
+  if (/items|list|zones|options/i.test(propName)) return "unknown[]";
+  if (/location|position|point/i.test(propName)) return "{ latitude: number; longitude: number }";
+  return "unknown";
+}
+function collectPropUsages(propName, node, out) {
+  if (node.bindings) {
+    for (const expr of Object.values(node.bindings)) {
+      if (typeof expr === "string" && expr.includes(propName)) {
+        out.push(expr);
+      }
+    }
+  }
+  if (node.visible_when && typeof node.visible_when === "string" && node.visible_when.includes(propName)) {
+    out.push(node.visible_when);
+  }
+  if (node.children) {
+    for (const child of node.children) {
+      collectPropUsages(propName, child, out);
+    }
+  }
+}
+function generateComponentFromDefinition(name, experience, props) {
+  const pageInput = {
+    slug: name.toLowerCase(),
+    name,
+    version: "1.0.0",
+    category: "component",
+    states: [],
+    transitions: [],
+    fields: [],
+    roles: [],
+    experience
+  };
+  const result = decompile(pageInput, {
+    componentName: name,
+    includeAnnotation: false
+  });
+  if (props.length > 0) {
+    const typedProps = props.map((p) => {
+      const type = inferPropType(p, experience);
+      const isCallback = p.startsWith("on") && p.length > 2 && p[2] === p[2].toUpperCase();
+      const optional = isCallback ? "?" : "";
+      return `  ${p}${optional}: ${type};`;
+    });
+    const propsInterface = `interface ${name}Props {
+${typedProps.join("\n")}
+}
+
+`;
+    const code = result.code.replace(
+      `export default function ${name}()`,
+      `${propsInterface}export default function ${name}({ ${props.join(", ")} }: ${name}Props)`
+    );
+    return code;
+  }
+  return result.code;
+}
+function emitServerActionsFromMetadata(definition, files) {
+  const meta = definition.metadata;
+  const serverActions = meta?.serverActions;
+  if (!serverActions || serverActions.length === 0) return [];
+  const actionsWithBodies = serverActions.filter((a) => a.body);
+  if (actionsWithBodies.length === 0) return [];
+  const byFile = /* @__PURE__ */ new Map();
+  for (const action of actionsWithBodies) {
+    const file2 = action.sourceFile || `actions/${action.name}.server.ts`;
+    if (!byFile.has(file2)) byFile.set(file2, []);
+    byFile.get(file2).push(action);
+  }
+  const emittedPaths = [];
+  for (const [filePath, actions] of byFile) {
+    const content = generateServerActionFileFromBodies(filePath, actions);
+    const existing = files.findIndex((f) => f.path === filePath);
+    if (existing !== -1) {
+      files[existing].content = content;
+    } else {
+      files.push({ path: filePath, role: "server-action", content });
+    }
+    emittedPaths.push(filePath);
+  }
+  return emittedPaths;
+}
+function generateServerActionFileFromBodies(filePath, actions) {
+  const lines = [
+    `/**`,
+    ` * Server actions \u2014 ${filePath}`,
+    ` *`,
+    ` * Auto-generated from preserved function bodies.`,
+    ` */`,
+    ``,
+    `import type { TransitionContext, ActionResult } from '@mindmatrix/react';`,
+    ``
+  ];
+  for (const action of actions) {
+    if (action.body) {
+      lines.push(action.body);
+      lines.push(``);
+    }
+  }
+  return lines.join("\n");
+}
+function reduceRouterTransitions(transitions, states) {
+  if (transitions.length === 0) return transitions;
+  const stateNames = new Set(states.map((s) => s.name));
+  const roleGroups = /* @__PURE__ */ new Map();
+  for (const state of states) {
+    const parts = state.name.split("_");
+    const role = parts[0];
+    if (!roleGroups.has(role)) roleGroups.set(role, []);
+    roleGroups.get(role).push(state.name);
+  }
+  const homeStates = /* @__PURE__ */ new Set();
+  for (const [, group] of roleGroups) {
+    const home = group.find(
+      (s) => s.includes("HOME") || s.includes("DASHBOARD") || s.includes("ANALYTICS")
+    ) || group[0];
+    homeStates.add(home);
+  }
+  const kept = [];
+  const seenKeys = /* @__PURE__ */ new Set();
+  for (const t5 of transitions) {
+    const fromArr = Array.isArray(t5.from) ? t5.from : [t5.from];
+    const fromState = fromArr[0];
+    const toState = t5.to;
+    if (!fromState || !stateNames.has(fromState) || !stateNames.has(toState)) continue;
+    const fromRole = fromState.split("_")[0];
+    const toRole = toState.split("_")[0];
+    const key = `${fromState}\u2192${toState}`;
+    if (seenKeys.has(key)) continue;
+    const sameRole = fromRole === toRole;
+    const crossRoleHome = homeStates.has(fromState) && homeStates.has(toState);
+    if (sameRole || crossRoleHome) {
+      seenKeys.add(key);
+      kept.push(t5);
+    }
+  }
+  return kept;
+}
+function decompileProjectEnhanced(definition) {
+  const slug = definition.slug;
+  const decision = determineSplitStrategy(definition);
+  const files = [];
+  const modelPaths = [];
+  const entryPaths = [];
+  const actionPaths = [];
+  if (decision.tier === "single") {
+    const result = decompile(definition);
+    files.push({
+      path: "main.workflow.tsx",
+      role: "view-entry",
+      content: result.code
+    });
+    emitComponentDefinitions(definition, files);
+    emitServerActionsFromMetadata(definition, files);
+    return { files, entryFile: "main.workflow.tsx", slug, splitDecision: decision };
+  }
+  if (decision.emitModels && definition.fields.length > 0) {
+    const modelPath = `models/${slug}.ts`;
+    const modelContent = generateModelFile(
+      slug,
+      definition.fields,
+      definition.states,
+      definition.transitions,
+      { version: definition.version, category: Array.isArray(definition.category) ? definition.category[0] : definition.category, description: definition.description }
+    );
+    files.push({ path: modelPath, role: "model", content: modelContent });
+    modelPaths.push(modelPath);
+  }
+  if (decision.emitActions) {
+    const serverActions = extractServerActions(definition.states, definition.transitions);
+    if (serverActions.length > 0) {
+      const actionPath = `actions/${slug}.server.ts`;
+      const actionContent = generateServerActionFile(slug, serverActions);
+      files.push({ path: actionPath, role: "server-action", content: actionContent });
+      actionPaths.push(actionPath);
+    }
+  }
+  let pagesExtracted = false;
+  let extractedPages = [];
+  let extractedChildViews = [];
+  let routerIsCompilerGenerated = false;
+  if (decision.emitPages && definition.experience) {
+    const routerNode = definition.experience.children?.find(
+      (c) => c.component === "Router"
+    );
+    routerIsCompilerGenerated = !!routerNode;
+    const { pages, childViews } = extractPageSections(
+      definition.experience,
+      definition.childDefinitions
+    );
+    if (pages.length > 0) {
+      pagesExtracted = true;
+      extractedPages = pages;
+      extractedChildViews = childViews;
+      const modelSlugToPath = /* @__PURE__ */ new Map();
+      modelSlugToPath.set(slug, `models/${slug}.ts`);
+      if (definition.childDefinitions) {
+        for (const child of definition.childDefinitions) {
+          const cs = child.slug;
+          if (!cs.endsWith("-router") && child.category !== "router") {
+            modelSlugToPath.set(cs, `models/${cs}.ts`);
+          }
+        }
+      }
+      for (const page of pages) {
+        const pageContent = generatePageFileFromSection(page, modelSlugToPath);
+        files.push({ path: page.filePath, role: "page", content: pageContent });
+      }
+    }
+  }
+  if (definition.roles && definition.roles.length > 0 && decision.tier === "large") {
+    const layoutContent = generateLayoutFile(slug, definition.roles);
+    files.push({ path: "app/layout.tsx", role: "layout", content: layoutContent });
+  }
+  const emittedModelSlugs = new Set(modelPaths.map((p) => p.replace("models/", "").replace(".ts", "")));
+  const mergedChildren = /* @__PURE__ */ new Map();
+  if (definition.childDefinitions && definition.childDefinitions.length > 0) {
+    for (const child of definition.childDefinitions) {
+      const childSlug = child.slug;
+      if (childSlug === slug) continue;
+      const isRouter = childSlug.endsWith("-router") || child.category === "router";
+      if (isRouter && routerIsCompilerGenerated) continue;
+      if (!mergedChildren.has(childSlug)) {
+        mergedChildren.set(childSlug, { ...child });
+      } else {
+        const existing = mergedChildren.get(childSlug);
+        const fieldMap = new Map(existing.fields.map((f) => [f.name, f]));
+        for (const f of child.fields) {
+          if (fieldMap.has(f.name)) {
+            const ef = fieldMap.get(f.name);
+            if (f.required && !ef.required) ef.required = true;
+            if (f.default_value != null && (ef.default_value == null || ef.default_value === "" || ef.default_value === 0 || ef.default_value === false)) {
+              ef.default_value = f.default_value;
+            }
+          } else {
+            existing.fields.push(f);
+            fieldMap.set(f.name, f);
+          }
+        }
+        if (child.states.length > existing.states.length) {
+          const existingByName = new Map(existing.states.map((s) => [s.name, s]));
+          existing.states = child.states.map((s) => {
+            const ex = existingByName.get(s.name);
+            if (ex && (ex.on_enter.length || ex.on_exit.length || ex.during.length)) {
+              return { ...s, on_enter: ex.on_enter, on_exit: ex.on_exit, during: ex.during };
+            }
+            return s;
+          });
+          const childNames = new Set(child.states.map((s) => s.name));
+          const hasStart = child.states.some((s) => s.type === "START");
+          for (const s of existingByName.values()) {
+            if (!childNames.has(s.name)) {
+              if (s.name === "draft" && s.type === "START" && hasStart) continue;
+              existing.states.push(s);
+            }
+          }
+        } else {
+          const stateNames = new Set(existing.states.map((s) => s.name));
+          for (const s of child.states) {
+            if (!stateNames.has(s.name)) {
+              existing.states.push(s);
+              stateNames.add(s.name);
+            }
+          }
+        }
+        const transNames = new Set(existing.transitions.map((t5) => t5.name));
+        for (const t5 of child.transitions) {
+          if (!transNames.has(t5.name)) {
+            existing.transitions.push(t5);
+            transNames.add(t5.name);
+          }
+        }
+        if (child.version && child.version !== "0.1.0" && (!existing.version || existing.version === "0.1.0")) {
+          existing.version = child.version;
+        }
+        if (child.category && child.category !== "data" && (!existing.category || existing.category === "data")) {
+          existing.category = child.category;
+        }
+        if (child.description && !existing.description) {
+          existing.description = child.description;
+        }
+      }
+    }
+  }
+  for (const [childSlug, child] of mergedChildren) {
+    const isRouter = childSlug.endsWith("-router") || child.category === "router";
+    const childTransitions = isRouter ? reduceRouterTransitions(child.transitions, child.states) : child.transitions;
+    if (child.fields.length > 0 && !emittedModelSlugs.has(childSlug)) {
+      const childModelPath = `models/${childSlug}.ts`;
+      files.push({
+        path: childModelPath,
+        role: "model",
+        content: generateModelFile(
+          childSlug,
+          child.fields,
+          child.states,
+          childTransitions,
+          { version: child.version, category: Array.isArray(child.category) ? child.category[0] : child.category, description: child.description }
+        )
+      });
+      modelPaths.push(childModelPath);
+      emittedModelSlugs.add(childSlug);
+    }
+    const childInput = {
+      ...child,
+      version: child.version || definition.version,
+      category: child.category || definition.category,
+      transitions: childTransitions,
+      experience: child.views?.default
+    };
+    const childResult = decompile(childInput, {
+      componentName: pascalCase2(childSlug),
+      includeAnnotation: true
+    });
+    const childPath = `${childSlug}.workflow.tsx`;
+    files.push({ path: childPath, role: "view-entry", content: childResult.code });
+    entryPaths.push(childPath);
+  }
+  emitComponentDefinitions(definition, files);
+  const emittedActionPaths = emitServerActionsFromMetadata(definition, files);
+  actionPaths.push(...emittedActionPaths);
+  const mainPath = "main.workflow.tsx";
+  if (pagesExtracted) {
+    const mainContent = generateMainWithPages(definition, extractedPages, extractedChildViews);
+    files.push({ path: mainPath, role: "view-entry", content: mainContent });
+  } else {
+    const mainResult = decompile(definition);
+    files.push({ path: mainPath, role: "view-entry", content: mainResult.code });
+  }
+  entryPaths.push(mainPath);
+  if (decision.emitConfig) {
+    const configData = extractConfigData(
+      definition,
+      [...new Set(modelPaths)],
+      [...new Set(entryPaths)],
+      [...new Set(actionPaths)]
+    );
+    const configContent = generateMmConfig(configData);
+    files.push({ path: "mm.config.ts", role: "config", content: configContent });
+  }
+  files.push({
+    path: "package.json",
+    role: "config",
+    content: generatePackageJson(definition)
+  });
+  files.push({
+    path: "tsconfig.json",
+    role: "config",
+    content: TSCONFIG_TEMPLATE
+  });
+  return {
+    files,
+    entryFile: mainPath,
+    slug,
+    splitDecision: decision
+  };
+}
+var TSCONFIG_TEMPLATE = JSON.stringify({
+  compilerOptions: {
+    target: "ES2022",
+    module: "ESNext",
+    moduleResolution: "bundler",
+    jsx: "react-jsx",
+    strict: true,
+    esModuleInterop: true,
+    skipLibCheck: true,
+    forceConsistentCasingInFileNames: true,
+    declaration: true,
+    sourceMap: true,
+    outDir: "dist",
+    rootDir: ".",
+    baseUrl: ".",
+    paths: { "@/*": ["./*"] }
+  },
+  include: ["**/*.ts", "**/*.tsx"],
+  exclude: ["node_modules", "dist"]
+}, null, 2) + "\n";
+function generatePackageJson(def) {
+  const pkg = {
+    name: `@mindmatrix/blueprint-${def.slug}`,
+    version: def.version || "1.0.0",
+    description: def.description || "",
+    type: "module",
+    main: "main.workflow.tsx",
+    scripts: {
+      "type-check": "tsc --noEmit",
+      build: "mmrc build --src .",
+      deploy: "mmrc deploy --build --src ."
+    },
+    peerDependencies: {
+      react: ">=18.0.0",
+      "@mindmatrix/react": "workspace:*"
+    },
+    devDependencies: {
+      "@mindmatrix/react-compiler": "workspace:*",
+      "@types/react": "^19.0.0",
+      typescript: "^5.4.0"
+    }
+  };
+  return JSON.stringify(pkg, null, 2) + "\n";
+}
+function esc2(s) {
+  return s.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+
+// src/decompiler/index.ts
+function pascalCase3(slug) {
+  return slug.split(/[-_]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join("");
+}
+function emitImportStatements(tracker) {
+  const result = [];
+  const sources = [...tracker.keys()].sort();
+  for (const source of sources) {
+    const names = [...tracker.get(source)].sort();
+    const specifiers = [];
+    for (const name of names) {
+      if (name.startsWith("default as ")) {
+        const localName = name.slice("default as ".length);
+        specifiers.push(t4.importDefaultSpecifier(t4.identifier(localName)));
+      } else {
+        specifiers.push(t4.importSpecifier(t4.identifier(name), t4.identifier(name)));
+      }
+    }
+    result.push(t4.importDeclaration(specifiers, t4.stringLiteral(source)));
+  }
+  return result;
+}
+function buildWorkflowAnnotation(def) {
+  const parts = [
+    `@workflow slug="${def.slug}" version="${def.version}" category="${def.category}"`
+  ];
+  if (def.description) {
+    parts.push(`@description ${def.description}`);
+  }
+  return `*
+ * ${parts.join("\n * ")}
+ `;
+}
+function decompile(definition, options) {
+  const imports = /* @__PURE__ */ new Map();
+  const includeAnnotation = options?.includeAnnotation ?? true;
+  const componentName = options?.componentName ?? definition.metadata?.displayName ?? pascalCase3(definition.slug);
+  const symbols = buildSymbolTable(
+    definition.fields,
+    definition.metadata,
+    definition.transitions,
+    definition.experience
+  );
+  const componentBody = [];
+  const sortedFields = [...definition.fields].sort((a, b) => a.name.localeCompare(b.name));
+  const fieldStmts = emitFieldDeclarations(sortedFields, imports);
+  componentBody.push(...fieldStmts);
+  if (definition.experience) {
+    const localDefaultStmts = emitLocalDefaultDeclarations(
+      definition.experience,
+      definition.fields,
+      imports
+    );
+    componentBody.push(...localDefaultStmts);
+  }
+  const queryStmts = emitQueryDeclarations(definition.metadata, imports);
+  componentBody.push(...queryStmts);
+  const roleStmts = emitRoleDeclarations(definition.metadata, imports);
+  componentBody.push(...roleStmts);
+  const sortedStates = [...definition.states].sort((a, b) => a.name.localeCompare(b.name));
+  const effectStmts = emitStateEffects(sortedStates, imports);
+  componentBody.push(...effectStmts);
+  const watcherStmts = emitChangeWatchers(definition.metadata, imports);
+  componentBody.push(...watcherStmts);
+  const eventStmts = emitEventSubscriptions(definition.on_event, imports);
+  componentBody.push(...eventStmts);
+  const sortedTransitions = [...definition.transitions].sort((a, b) => a.name.localeCompare(b.name));
+  const transStmts = emitTransitionDeclarations(sortedTransitions, imports);
+  componentBody.push(...transStmts);
+  const effectHookStmts = emitTransitionEffects(definition.metadata, imports);
+  componentBody.push(...effectHookStmts);
+  if (definition.experience) {
+    const jsxTree = buildJSXTree(definition.experience, imports, symbols);
+    componentBody.push(t4.returnStatement(jsxTree));
+  } else {
+    componentBody.push(t4.returnStatement(t4.nullLiteral()));
+  }
+  const func = t4.functionDeclaration(
+    t4.identifier(componentName),
+    [],
+    t4.blockStatement(componentBody)
+  );
+  const programBody = [];
+  programBody.push(...emitImportStatements(imports));
+  const exportDecl = t4.exportDefaultDeclaration(func);
+  if (includeAnnotation) {
+    t4.addComment(exportDecl, "leading", buildWorkflowAnnotation(definition), false);
+  }
+  programBody.push(exportDecl);
+  const program2 = t4.program(programBody);
+  const file2 = t4.file(program2);
+  const { code } = generate(file2, {
+    retainLines: false,
+    compact: false,
+    jsescOption: { minimal: true }
+  });
+  return {
+    code,
+    imports: [...imports.keys()],
+    componentName
+  };
+}
+
+// src/decompiler/project.ts
+function pascalCase4(slug) {
+  return slug.split(/[-_]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join("");
+}
+function camelCase2(str) {
+  return str.replace(/[-_]([a-z])/g, (_, c) => c.toUpperCase());
+}
+function fieldTypeToTS2(fieldType, field) {
+  const options = getFieldOptions2(field);
+  if (options && options.length > 0 && (fieldType === "select" || fieldType === "text")) {
+    return options.map((o) => `'${o.replace(/'/g, "\\'")}'`).join(" | ");
+  }
+  switch (fieldType) {
+    case "text":
+    case "rich_text":
+    case "email":
+    case "url":
+    case "phone":
+    case "color":
+    case "select":
+      return "string";
+    case "number":
+    case "currency":
+    case "percentage":
+    case "rating":
+    case "duration":
+    case "auto_number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "date":
+    case "datetime":
+    case "created_at":
+    case "updated_at":
+      return "Date";
+    case "multi_select":
+      return "string[]";
+    case "json":
+      return "Record<string, unknown>";
+    case "file":
+    case "image":
+      return "string";
+    // URL
+    case "relation":
+    case "lookup":
+      return "string";
+    // ID reference
+    default:
+      return "unknown";
+  }
+}
+function getFieldOptions2(field) {
+  if (!field) return null;
+  const f = field;
+  const validation = f.validation;
+  if (validation?.options && Array.isArray(validation.options)) return validation.options;
+  const meta = f.metadata;
+  if (meta?.options && Array.isArray(meta.options)) return meta.options;
+  if (f.options && Array.isArray(f.options)) return f.options;
+  return null;
+}
+function generateModelFile2(slug, fields) {
+  const typeName = pascalCase4(slug);
+  const lines = [
+    `/**`,
+    ` * ${typeName} \u2014 data model interface.`,
+    ` *`,
+    ` * Auto-generated from workflow definition "${slug}".`,
+    ` * Fields: ${fields.length}`,
+    ` */`,
+    ``,
+    `export interface ${typeName} {`
+  ];
+  for (const field of fields) {
+    const tsType = fieldTypeToTS2(field.type, field);
+    const optional = field.required ? "" : "?";
+    const comment = field.label ? ` /** ${field.label} */` : "";
+    if (comment) lines.push(`  ${comment}`);
+    lines.push(`  ${camelCase2(field.name)}${optional}: ${tsType};`);
+  }
+  lines.push(`}`);
+  lines.push(``);
+  return lines.join("\n");
+}
+function generateStateEnum(slug, states) {
+  if (states.length === 0) return "";
+  const enumName = `${pascalCase4(slug)}State`;
+  const lines = [
+    ``,
+    `export enum ${enumName} {`
+  ];
+  for (const state of states) {
+    const enumKey = pascalCase4(state.name);
+    lines.push(`  ${enumKey} = '${state.name}',`);
+  }
+  lines.push(`}`);
+  lines.push(``);
+  return lines.join("\n");
+}
+function extractServerActions2(states, transitions) {
+  const seen = /* @__PURE__ */ new Set();
+  const actions = [];
+  const SERVER_ACTION_TYPES2 = /* @__PURE__ */ new Set([
+    "http_request",
+    "webhook",
+    "call_webhook",
+    "notify",
+    "send_notification",
+    "call_workflow",
+    "spawn_instance",
+    "spawn_subworkflow",
+    "emit_event"
+  ]);
+  function collectFromActions(defs) {
+    for (const action of defs) {
+      if (SERVER_ACTION_TYPES2.has(action.type) && !seen.has(action.id)) {
+        seen.add(action.id);
+        const name = actionToFunctionName(action);
+        actions.push({ name, type: action.type, config: action.config });
+      }
+    }
+  }
+  for (const state of states) {
+    collectFromActions(state.on_enter);
+    collectFromActions(state.on_exit);
+    for (const during of state.during) {
+      collectFromActions(during.actions);
+    }
+  }
+  for (const trans of transitions) {
+    collectFromActions(trans.actions);
+  }
+  return actions;
+}
+function actionToFunctionName(action) {
+  const slug = action.config.name ?? action.config.event ?? action.config.slug ?? action.type;
+  return camelCase2(String(slug).replace(/[^a-zA-Z0-9_-]/g, "-"));
+}
+function generateServerActionFile2(actions) {
+  const lines = [
+    `/**`,
+    ` * Server actions \u2014 backend handlers for workflow transitions.`,
+    ` *`,
+    ` * These functions run server-side during state transitions.`,
+    ` * Each receives a TransitionContext with instance data and utilities.`,
+    ` */`,
+    ``,
+    `import type { TransitionContext } from '@mindmatrix/react';`,
+    ``
+  ];
+  for (const action of actions) {
+    const comment = actionComment2(action.type, action.config);
+    lines.push(`/** ${comment} */`);
+    lines.push(`export async function ${action.name}(ctx: TransitionContext): Promise<void> {`);
+    lines.push(`  const { instance, env } = ctx;`);
+    switch (action.type) {
+      case "http_request":
+      case "webhook":
+      case "call_webhook": {
+        const url = String(action.config.url ?? "https://api.example.com/webhook");
+        const method = String(action.config.method ?? "POST");
+        lines.push(`  await fetch('${url}', {`);
+        lines.push(`    method: '${method}',`);
+        lines.push(`    headers: { 'Content-Type': 'application/json' },`);
+        lines.push(`    body: JSON.stringify({ instanceId: instance.id }),`);
+        lines.push(`  });`);
+        break;
+      }
+      case "notify":
+      case "send_notification": {
+        const msg = String(action.config.message ?? action.config.body ?? "Notification");
+        lines.push(`  // Send notification: "${msg}"`);
+        lines.push(`  await env.notify({ message: '${msg}', instanceId: instance.id });`);
+        break;
+      }
+      case "call_workflow":
+      case "spawn_instance":
+      case "spawn_subworkflow": {
+        const slug = String(action.config.slug ?? action.config.workflow ?? "child-workflow");
+        lines.push(`  await env.spawn('${slug}', { parentId: instance.id });`);
+        break;
+      }
+      case "emit_event": {
+        const event = String(action.config.event ?? action.config.name ?? "custom-event");
+        lines.push(`  await env.emit('${event}', { instanceId: instance.id });`);
+        break;
+      }
+      default:
+        lines.push(`  // TODO: Implement ${action.type} logic`);
+    }
+    lines.push(`}`);
+    lines.push(``);
+  }
+  return lines.join("\n");
+}
+function actionComment2(type, config) {
+  switch (type) {
+    case "http_request":
+    case "webhook":
+    case "call_webhook":
+      return `HTTP ${config.method ?? "POST"} to ${config.url ?? "webhook endpoint"}`;
+    case "notify":
+    case "send_notification":
+      return `Send notification: ${config.message ?? config.body ?? ""}`;
+    case "call_workflow":
+    case "spawn_instance":
+    case "spawn_subworkflow":
+      return `Spawn child workflow: ${config.slug ?? config.workflow ?? ""}`;
+    case "emit_event":
+      return `Emit event: ${config.event ?? config.name ?? ""}`;
+    default:
+      return `Server action: ${type}`;
+  }
+}
+function generateConfigFile(def) {
+  const lines = [
+    `/**`,
+    ` * Blueprint configuration for "${def.name || pascalCase4(def.slug)}".`,
+    ` */`,
+    ``,
+    `import { defineBlueprint } from '@mindmatrix/react';`,
+    ``,
+    `export default defineBlueprint({`,
+    `  slug: '${def.slug}',`,
+    `  name: '${(def.name || pascalCase4(def.slug)).replace(/'/g, "\\'")}',`,
+    `  version: '${def.version}',`,
+    `  category: '${def.category}',`
+  ];
+  if (def.description) {
+    lines.push(`  description: '${def.description.replace(/'/g, "\\'")}',`);
+  }
+  if (def.roles && def.roles.length > 0) {
+    lines.push(`  roles: [`);
+    for (const role of def.roles) {
+      const perms = role.permissions.map((p) => `'${p}'`).join(", ");
+      lines.push(`    { name: '${role.name}', permissions: [${perms}] },`);
+    }
+    lines.push(`  ],`);
+  }
+  lines.push(`});`);
+  lines.push(``);
+  return lines.join("\n");
+}
+function extractPages(experience, slug) {
+  if (!experience || !experience.children) return [];
+  const pages = [];
+  const rootChildren = experience.children;
+  for (const child of rootChildren) {
+    const isRoutePage = child.visible_when && /activeRoute|route|isOn/i.test(child.visible_when);
+    const isPageId = child.id && /page|route|view/i.test(child.id);
+    const isShowRoute = child.component === "Show" && child.config?.when && /activeRoute|route/i.test(String(child.config.when));
+    if (isRoutePage || isPageId || isShowRoute) {
+      const routeName = extractRouteName(child) || child.id || `page-${pages.length}`;
+      const componentName = pascalCase4(routeName.replace(/^\//, "").replace(/\//g, "-") || `${slug}-page`);
+      pages.push({
+        route: routeName,
+        componentName,
+        tree: child,
+        filePath: `pages/${componentName}.tsx`
+      });
+    }
+  }
+  return pages;
+}
+function extractRouteName(node) {
+  if (node.visible_when) {
+    const match = node.visible_when.match(/['"]\/([^'"]+)['"]/);
+    if (match) return match[1];
+    const boolMatch = node.visible_when.match(/isOn([A-Z]\w+)/);
+    if (boolMatch) return boolMatch[1].toLowerCase();
+  }
+  if (node.config?.when) {
+    const match = String(node.config.when).match(/['"]\/([^'"]+)['"]/);
+    if (match) return match[1];
+  }
+  return "";
+}
+function generatePageFile(page, _slug) {
+  const pageInput = {
+    slug: page.route || "page",
+    name: page.componentName,
+    version: "1.0.0",
+    category: "page",
+    states: [],
+    transitions: [],
+    fields: [],
+    roles: [],
+    experience: page.tree
+  };
+  const result = decompile(pageInput, {
+    componentName: page.componentName,
+    includeAnnotation: false
+  });
+  return result.code;
+}
+function generateMainFile(def, pages, hasModel, serverActionNames, options) {
+  if (pages.length === 0) {
+    const result = decompile(def, options);
+    return result.code;
+  }
+  const slug = def.slug;
+  const componentName = options?.componentName ?? pascalCase4(slug);
+  const importLines = [];
+  const reactImports = /* @__PURE__ */ new Set();
+  const nonComputed = def.fields.filter((f) => !f.computed);
+  if (nonComputed.length > 0) reactImports.add("useState");
+  for (const state of def.states) {
+    if (state.on_enter.length > 0) reactImports.add("useOnEnter");
+    if (state.on_exit.length > 0) reactImports.add("useOnExit");
+    if (state.during.length > 0) reactImports.add("useWhileIn");
+  }
+  if (def.transitions.length > 0) reactImports.add("useTransition");
+  reactImports.add("Stack");
+  if (reactImports.size > 0) {
+    const sorted = [...reactImports].sort();
+    importLines.push(`import { ${sorted.join(", ")} } from '@mindmatrix/react';`);
+  }
+  if (hasModel) {
+    const typeName = pascalCase4(slug);
+    importLines.push(`import type { ${typeName} } from './models/${slug}';`);
+  }
+  if (serverActionNames.length > 0) {
+    const names = serverActionNames.join(", ");
+    importLines.push(`import { ${names} } from './actions/${slug}.server';`);
+  }
+  for (const page of pages) {
+    importLines.push(`import { ${page.componentName} } from './${page.filePath.replace(/\.tsx$/, "")}';`);
+  }
+  const bodyLines = [];
+  for (const field of nonComputed) {
+    const name = camelCase2(field.name);
+    const setter = `set${pascalCase4(field.name)}`;
+    const defaultVal = fieldDefaultLiteral(field);
+    bodyLines.push(`  const [${name}, ${setter}] = useState(${defaultVal});`);
+  }
+  if (nonComputed.length > 0) bodyLines.push(``);
+  for (const state of def.states) {
+    if (state.on_enter.length > 0) {
+      const actions = state.on_enter.map((a) => actionToInlineCode(a)).filter(Boolean);
+      bodyLines.push(`  useOnEnter('${state.name}', () => {`);
+      for (const a of actions) bodyLines.push(`    ${a}`);
+      bodyLines.push(`  });`);
+    }
+    if (state.on_exit.length > 0) {
+      const actions = state.on_exit.map((a) => actionToInlineCode(a)).filter(Boolean);
+      bodyLines.push(`  useOnExit('${state.name}', () => {`);
+      for (const a of actions) bodyLines.push(`    ${a}`);
+      bodyLines.push(`  });`);
+    }
+  }
+  for (const trans of def.transitions) {
+    const varName = camelCase2(trans.name);
+    const from = trans.from.length === 1 ? `'${trans.from[0]}'` : `[${trans.from.map((f) => `'${f}'`).join(", ")}]`;
+    bodyLines.push(`  const ${varName} = useTransition('${trans.name}', { from: ${from}, to: '${trans.to}' });`);
+  }
+  if (def.transitions.length > 0) bodyLines.push(``);
+  bodyLines.push(`  return (`);
+  bodyLines.push(`    <Stack sx={{ minHeight: '100vh' }}>`);
+  for (const page of pages) {
+    bodyLines.push(`      <${page.componentName} />`);
+  }
+  bodyLines.push(`    </Stack>`);
+  bodyLines.push(`  );`);
+  const lines = [
+    ...importLines,
+    ``,
+    `/**`,
+    ` * @workflow slug="${slug}" version="${def.version}" category="${def.category}"`,
+    ...def.description ? [` * @description ${def.description}`] : [],
+    ` */`,
+    `export default function ${componentName}() {`,
+    ...bodyLines,
+    `}`,
+    ``
+  ];
+  return lines.join("\n");
+}
+function fieldDefaultLiteral(field) {
+  if (field.default_value !== void 0) {
+    if (typeof field.default_value === "string") return `'${field.default_value}'`;
+    return JSON.stringify(field.default_value);
+  }
+  switch (field.type) {
+    case "text":
+    case "rich_text":
+    case "email":
+    case "url":
+    case "phone":
+    case "color":
+    case "select":
+      return "''";
+    case "number":
+    case "currency":
+    case "percentage":
+    case "rating":
+    case "duration":
+    case "auto_number":
+      return "0";
+    case "boolean":
+      return "false";
+    case "date":
+    case "datetime":
+      return "null";
+    case "multi_select":
+    case "json":
+      return "[]";
+    default:
+      return "null";
+  }
+}
+function actionToInlineCode(action) {
+  switch (action.type) {
+    case "set_field": {
+      const field = String(action.config.field ?? "");
+      const setter = `set${pascalCase4(field)}`;
+      const val = action.config.expression ? String(action.config.expression) : JSON.stringify(action.config.value ?? null);
+      return `${setter}(${val});`;
+    }
+    case "log_event":
+    case "log":
+      return `console.log('${action.config.message ?? action.config.event ?? action.type}');`;
+    case "noop":
+      return "";
+    default:
+      return `// ${action.type}: ${JSON.stringify(action.config)}`;
+  }
+}
+function decompileProject(definition, options) {
+  const files = [];
+  const slug = definition.slug;
+  const pages = options?.skipPages ? [] : extractPages(definition.experience, slug);
+  const serverActions = options?.skipActions ? [] : extractServerActions2(definition.states, definition.transitions);
+  const hasFields = definition.fields.length > 0;
+  if (hasFields && !options?.skipModels) {
+    let modelContent = generateModelFile2(slug, definition.fields);
+    if (definition.states.length > 0) {
+      modelContent += generateStateEnum(slug, definition.states);
+    }
+    files.push({
+      path: `models/${slug}.ts`,
+      role: "model",
+      content: modelContent
+    });
+  }
+  if (serverActions.length > 0) {
+    files.push({
+      path: `actions/${slug}.server.ts`,
+      role: "server-action",
+      content: generateServerActionFile2(serverActions)
+    });
+  }
+  for (const page of pages) {
+    files.push({
+      path: page.filePath,
+      role: "page",
+      content: generatePageFile(page, slug)
+    });
+  }
+  if (!options?.skipConfig) {
+    files.push({
+      path: "mm.config.ts",
+      role: "config",
+      content: generateConfigFile(definition)
+    });
+  }
+  if (definition.childDefinitions && definition.childDefinitions.length > 0) {
+    for (const child of definition.childDefinitions) {
+      const childSlug = child.slug;
+      const childFileName = `${childSlug}.workflow.tsx`;
+      const childInput = {
+        ...child,
+        experience: child.views?.default
+      };
+      if (child.category === "data" && child.fields.length > 0 && !options?.skipModels) {
+        let childModelContent = generateModelFile2(childSlug, child.fields);
+        if (child.states.length > 0) {
+          childModelContent += generateStateEnum(childSlug, child.states);
+        }
+        files.push({
+          path: `models/${childSlug}.ts`,
+          role: "model",
+          content: childModelContent
+        });
+      }
+      if (!options?.skipActions) {
+        const childServerActions = extractServerActions2(child.states, child.transitions);
+        if (childServerActions.length > 0) {
+          files.push({
+            path: `actions/${childSlug}.server.ts`,
+            role: "server-action",
+            content: generateServerActionFile2(childServerActions)
+          });
+        }
+      }
+      const childResult = decompile(childInput, {
+        componentName: pascalCase4(childSlug),
+        includeAnnotation: true
+      });
+      files.push({
+        path: childFileName,
+        role: "view-entry",
+        content: childResult.code
+      });
+    }
+  }
+  const mainContent = generateMainFile(
+    definition,
+    pages,
+    hasFields && !options?.skipModels,
+    serverActions.map((a) => a.name),
+    options
+  );
+  files.push({
+    path: "main.workflow.tsx",
+    role: "view-entry",
+    content: mainContent
+  });
+  return {
+    files,
+    entryFile: "main.workflow.tsx",
+    slug
+  };
+}
+function shouldDecompileAsProject(def) {
+  const meta = def.metadata;
+  const childSlugs = meta?.childSlugs;
+  const hasChildren = Array.isArray(childSlugs) && childSlugs.length > 0;
+  return hasChildren || def.states.length > 1 && def.transitions.length > 0 && (def.fields.length > 0 || def.category === "blueprint");
+}
+
+export {
+  decompileProject,
+  shouldDecompileAsProject,
+  decompileProjectEnhanced,
+  decompile
+};