@mmapp/react-compiler 0.1.0-alpha.1 → 0.1.0-alpha.3

package/dist/cli/index.js

@@ -29,6 +29,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/babel/extractors/state-extractor.ts
 function typeNameToSlug(name) {
@@ -445,25 +446,25 @@ function inferTransitionStates(transitions, states) {
   const stateArray = Array.from(states.values());
   const startStates = stateArray.filter((s) => s.type === "START");
   const regularStates = stateArray.filter((s) => s.type === "REGULAR");
-  const needsInference = transitions.filter((t22) => t22.from.length === 0 || !t22.to);
+  const needsInference = transitions.filter((t23) => t23.from.length === 0 || !t23.to);
   if (needsInference.length === 0) return;
   if (startStates.length === 1 && regularStates.length > 0) {
-    needsInference.forEach((t22, idx) => {
-      if (t22.from.length === 0) {
-        t22.from = [startStates[0].name];
+    needsInference.forEach((t23, idx) => {
+      if (t23.from.length === 0) {
+        t23.from = [startStates[0].name];
       }
-      if (!t22.to) {
-        t22.to = regularStates[idx % regularStates.length]?.name || startStates[0].name;
+      if (!t23.to) {
+        t23.to = regularStates[idx % regularStates.length]?.name || startStates[0].name;
       }
     });
   } else {
     const allStateNames = stateArray.map((s) => s.name);
-    needsInference.forEach((t22, idx) => {
-      if (t22.from.length === 0 && allStateNames.length > 0) {
-        t22.from = [allStateNames[0]];
+    needsInference.forEach((t23, idx) => {
+      if (t23.from.length === 0 && allStateNames.length > 0) {
+        t23.from = [allStateNames[0]];
       }
-      if (!t22.to && allStateNames.length > 1) {
-        t22.to = allStateNames[Math.min(idx + 1, allStateNames.length - 1)];
+      if (!t23.to && allStateNames.length > 1) {
+        t23.to = allStateNames[Math.min(idx + 1, allStateNames.length - 1)];
       }
     });
   }
@@ -651,11 +652,128 @@ var init_event_extractor = __esm({
 });
 
 // src/babel/transpilers/ts-to-expression.ts
+var ts_to_expression_exports = {};
+__export(ts_to_expression_exports, {
+  transpile: () => transpile,
+  transpileBlock: () => transpileBlock,
+  transpileExpression: () => transpileExpression
+});
 function transpileExpression(node, options = {}) {
   const ctx = new TranspileContext(options);
   const expr = ctx.visit(node);
   return { expression: expr, pure: ctx.isPure };
 }
+function transpile(node, options = {}) {
+  return transpileExpression(node, options).expression;
+}
+function transpileBlock(node, options = {}) {
+  const ctx = new TranspileContext(options);
+  const lines = visitStatements(node.body, ctx);
+  return { expression: lines, pure: ctx.isPure };
+}
+function visitStatements(stmts, ctx) {
+  return stmts.map((s) => visitStatement(s, ctx)).join("\n");
+}
+function visitStatement(stmt, ctx) {
+  if (t5.isVariableDeclaration(stmt)) {
+    const keyword = ctx.allMutable || stmt.kind !== "const" ? "let" : "const";
+    const decls = stmt.declarations.map((d) => {
+      const init2 = d.init ? ctx.visit(d.init) : "null";
+      const lhs = declaratorPattern(d.id);
+      return `${keyword} ${lhs} = ${init2}`;
+    });
+    return decls.join(";\n") + ";";
+  }
+  if (t5.isIfStatement(stmt)) {
+    const test2 = ctx.visit(stmt.test);
+    const consequent = visitBranchBody(stmt.consequent, ctx);
+    if (stmt.alternate) {
+      const alternate = visitBranchBody(stmt.alternate, ctx);
+      return `if (${test2}) ${consequent} else ${alternate}`;
+    }
+    return `if (${test2}) ${consequent}`;
+  }
+  if (t5.isForOfStatement(stmt)) {
+    const right = ctx.visit(stmt.right);
+    const varName = forOfPattern(stmt.left);
+    const body = visitBranchBody(stmt.body, ctx);
+    return `for (const ${varName} of ${right}) ${body}`;
+  }
+  if (t5.isWhileStatement(stmt)) {
+    const test2 = ctx.visit(stmt.test);
+    const body = visitBranchBody(stmt.body, ctx);
+    return `while (${test2}) ${body}`;
+  }
+  if (t5.isReturnStatement(stmt)) {
+    if (!stmt.argument) return "return;";
+    return `return ${ctx.visit(stmt.argument)};`;
+  }
+  if (t5.isExpressionStatement(stmt)) {
+    return ctx.visit(stmt.expression) + ";";
+  }
+  if (t5.isBlockStatement(stmt)) {
+    const inner = visitStatements(stmt.body, ctx);
+    return `{
+${indent(inner)}
+}`;
+  }
+  if (t5.isFunctionDeclaration(stmt) && stmt.id) {
+    const name = stmt.id.name;
+    const params = stmt.params.map((p) => t5.isIdentifier(p) ? p.name : "_").join(", ");
+    const body = visitStatements(stmt.body.body, ctx);
+    return `function ${name}(${params}) {
+${indent(body)}
+}`;
+  }
+  return ctx.opaque(`[${stmt.type}]`) + ";";
+}
+function visitBranchBody(node, ctx) {
+  if (t5.isBlockStatement(node)) {
+    const inner2 = visitStatements(node.body, ctx);
+    return `{
+${indent(inner2)}
+}`;
+  }
+  const inner = visitStatement(node, ctx);
+  return `{
+${indent(inner)}
+}`;
+}
+function declaratorPattern(node) {
+  if (t5.isIdentifier(node)) return node.name;
+  if (t5.isObjectPattern(node)) {
+    const props = node.properties.map((p) => {
+      if (t5.isRestElement(p)) {
+        return `...${t5.isIdentifier(p.argument) ? p.argument.name : "_"}`;
+      }
+      if (t5.isObjectProperty(p)) {
+        const key = t5.isIdentifier(p.key) ? p.key.name : "_";
+        const val = t5.isIdentifier(p.value) ? p.value.name : t5.isAssignmentPattern(p.value) && t5.isIdentifier(p.value.left) ? p.value.left.name : "_";
+        return key === val ? key : `${key}: ${val}`;
+      }
+      return "_";
+    });
+    return `{ ${props.join(", ")} }`;
+  }
+  if (t5.isArrayPattern(node)) {
+    const elems = node.elements.map(
+      (e) => e === null ? "" : t5.isIdentifier(e) ? e.name : "_"
+    );
+    return `[${elems.join(", ")}]`;
+  }
+  return "_";
+}
+function forOfPattern(left) {
+  if (t5.isVariableDeclaration(left)) {
+    const d = left.declarations[0];
+    if (d) return declaratorPattern(d.id);
+  }
+  if (t5.isIdentifier(left)) return left.name;
+  return "_";
+}
+function indent(code) {
+  return code.split("\n").map((l) => "  " + l).join("\n");
+}
 function fallbackGenerate(node) {
   if (t5.isIdentifier(node)) return node.name;
   if (t5.isStringLiteral(node)) return `"${node.value.replace(/"/g, '\\"')}"`;
@@ -675,6 +793,8 @@ var init_ts_to_expression = __esm({
         this.localFieldMap = options.localFieldMap ?? /* @__PURE__ */ new Map();
         this.derivedVarMap = options.derivedVarMap ?? /* @__PURE__ */ new Map();
         this.setterToFieldMap = options.setterToFieldMap ?? /* @__PURE__ */ new Map();
+        this.parameterMap = options.parameterMap ?? /* @__PURE__ */ new Map();
+        this.allMutable = options.allMutable ?? false;
       }
       /**
        * Emit an opaque JS fallback, marking the result as impure.
@@ -696,6 +816,8 @@ var init_ts_to_expression = __esm({
           if (snakeName) return `$local.${snakeName}`;
           const derivedInit = this.derivedVarMap.get(node.name);
           if (derivedInit) return `(${this.visit(derivedInit)})`;
+          const paramField = this.parameterMap.get(node.name);
+          if (paramField) return paramField;
           if (node.name === "undefined") return "null";
           if (node.name === "NaN") return "null";
           if (node.name === "Infinity") return "null";
@@ -743,6 +865,9 @@ var init_ts_to_expression = __esm({
         if (t5.isNewExpression(node)) {
           return this.visitNew(node);
         }
+        if (t5.isAssignmentExpression(node) && node.operator === "=" && t5.isIdentifier(node.left)) {
+          return `${node.left.name} = ${this.visit(node.right)}`;
+        }
         return this.opaque(fallbackGenerate(node));
       }
       // ---------------------------------------------------------------------------
@@ -943,6 +1068,11 @@ var init_ts_to_expression = __esm({
             return this.visitArrayHigherOrder("some", obj, args2);
           case "every":
             return this.visitArrayHigherOrder("every", obj, args2);
+          // --- Array push: arr.push(item) → arr = push(arr, item) ---
+          case "push": {
+            const [item] = this.visitArgsList(args2);
+            return `${obj} = push(${obj}, ${item})`;
+          }
           // --- Array mutation-free methods ---
           case "reverse":
             return `reverse(${obj})`;
@@ -2422,7 +2552,7 @@ function resolveType(annotation) {
   }
   if (t11.isTSUnionType(annotation)) {
     const allLiterals = annotation.types.every(
-      (t22) => t11.isTSLiteralType(t22) && (t11.isStringLiteral(t22.literal) || t11.isNumericLiteral(t22.literal))
+      (t23) => t11.isTSLiteralType(t23) && (t11.isStringLiteral(t23.literal) || t11.isNumericLiteral(t23.literal))
     );
     if (allLiterals) return "select";
     return "text";
@@ -2796,6 +2926,71 @@ function modelStateTypeToIR(type) {
   if (type === "final") return "END";
   return "REGULAR";
 }
+function parseActionArray(raw, actionCounter) {
+  if (!Array.isArray(raw)) return [];
+  const actions = [];
+  for (const item of raw) {
+    if (typeof item !== "object" || item === null) continue;
+    const a = item;
+    actions.push({
+      id: a.id ? String(a.id) : `auto_${++actionCounter.value}`,
+      type: String(a.type || a.action_type || "unknown"),
+      mode: a.mode || "auto",
+      config: a.config && typeof a.config === "object" ? a.config : {},
+      ...a.condition ? { condition: String(a.condition) } : {}
+    });
+  }
+  return actions;
+}
+function parseDuringArray(raw, actionCounter) {
+  if (!Array.isArray(raw)) return [];
+  const result = [];
+  for (const item of raw) {
+    if (typeof item !== "object" || item === null) continue;
+    const d = item;
+    result.push({
+      id: d.id ? String(d.id) : `during_${++actionCounter.value}`,
+      type: d.type || "interval",
+      ...d.interval_ms != null ? { interval_ms: Number(d.interval_ms) } : {},
+      ...d.cron ? { cron: String(d.cron) } : {},
+      ...d.delay_ms != null ? { delay_ms: Number(d.delay_ms) } : {},
+      ...d.condition ? { condition: String(d.condition) } : {},
+      actions: parseActionArray(d.actions, actionCounter)
+    });
+  }
+  return result;
+}
+function parseOnEventArray(raw, actionCounter) {
+  if (!Array.isArray(raw)) return [];
+  const result = [];
+  for (const item of raw) {
+    if (typeof item !== "object" || item === null) continue;
+    const e = item;
+    const actions = [];
+    if (Array.isArray(e.actions)) {
+      for (const a of e.actions) {
+        if (typeof a !== "object" || a === null) continue;
+        const act = a;
+        actions.push({
+          type: act.type || "set_field",
+          ...act.field ? { field: String(act.field) } : {},
+          ...act.expression ? { expression: String(act.expression) } : {},
+          ...act.key ? { key: String(act.key) } : {},
+          ...act.message ? { message: String(act.message) } : {},
+          ...act.config && typeof act.config === "object" ? { config: act.config } : {},
+          ...act.conditions && Array.isArray(act.conditions) ? { conditions: act.conditions.map(String) } : {}
+        });
+      }
+    }
+    result.push({
+      match: String(e.match || ""),
+      ...e.description ? { description: String(e.description) } : {},
+      ...e.conditions && Array.isArray(e.conditions) ? { conditions: e.conditions.map(String) } : {},
+      actions
+    });
+  }
+  return result;
+}
 function extractDefineModelCall(programPath, compilerState, actionCounter) {
   for (const node of programPath.node.body) {
     if (!t11.isExportDefaultDeclaration(node)) continue;
@@ -2835,17 +3030,27 @@ function extractDefineModelCall(programPath, compilerState, actionCounter) {
       const statesObj = config.states;
       for (const [name, stateConfig] of Object.entries(statesObj)) {
         const stateType = modelStateTypeToIR(stateConfig.type);
+        const on_enter = parseActionArray(stateConfig.on_enter, actionCounter);
+        const on_exit = parseActionArray(stateConfig.on_exit, actionCounter);
+        const during = parseDuringArray(stateConfig.during, actionCounter);
+        const on_event = parseOnEventArray(stateConfig.on_event, actionCounter);
         if (!compilerState.states.has(name)) {
           compilerState.states.set(name, {
             name,
             type: stateType,
             description: stateConfig.description,
-            on_enter: [],
-            during: [],
-            on_exit: []
+            on_enter,
+            during,
+            on_exit,
+            ...on_event.length > 0 ? { on_event } : {}
           });
         } else {
-          compilerState.states.get(name).type = stateType;
+          const existing = compilerState.states.get(name);
+          existing.type = stateType;
+          if (on_enter.length > 0) existing.on_enter = on_enter;
+          if (on_exit.length > 0) existing.on_exit = on_exit;
+          if (during.length > 0) existing.during = during;
+          if (on_event.length > 0) existing.on_event = on_event;
         }
       }
     }
@@ -2883,13 +3088,21 @@ function extractDefineModelCall(programPath, compilerState, actionCounter) {
         if (transConfig.guard) {
           conditions.push(parseGuardExpression(String(transConfig.guard)));
         }
+        if (transConfig.conditions && Array.isArray(transConfig.conditions)) {
+          for (const cond of transConfig.conditions) {
+            if (typeof cond === "object" && cond !== null) {
+              conditions.push(cond);
+            }
+          }
+        }
+        const actions = parseActionArray(transConfig.actions, actionCounter);
         compilerState.transitions.push({
           name,
           from,
           to,
           description: transConfig.description,
           conditions: conditions.length > 0 ? conditions : void 0,
-          actions: [],
+          actions,
           roles: transConfig.roles,
           auto: transConfig.auto,
           required_fields: transConfig.required_fields
@@ -3569,7 +3782,7 @@ var init_context_extractor = __esm({
 
 // ../player-core/dist/index.mjs
 function normalizeCategory(primary, ...tags) {
-  const uniqueTags = [...new Set(tags.filter((t22) => t22 !== primary))];
+  const uniqueTags = [...new Set(tags.filter((t23) => t23 !== primary))];
   uniqueTags.sort();
   return [primary, ...uniqueTags];
 }
@@ -3849,6 +4062,18 @@ function emitIR(extracted) {
       });
       stateNames.add(transition.to);
     }
+    for (const from of transition.from) {
+      if (from && !stateNames.has(from)) {
+        stateArray.push({
+          name: from,
+          type: "REGULAR",
+          on_enter: [],
+          during: [],
+          on_exit: []
+        });
+        stateNames.add(from);
+      }
+    }
   }
   const fieldNames = new Set(fields.map((f) => f.name));
   let normalizedView;
@@ -4278,16 +4503,16 @@ function emitWorkflowDefinition(extracted) {
     ...f.editable_when && { editable_when: f.editable_when },
     ...f.state_home && { state_home: f.state_home }
   }));
-  const transitions = ir.transitions.map((t22) => ({
-    name: t22.name,
-    from: t22.from,
-    to: t22.to,
-    description: t22.description || "",
-    roles: t22.roles || [],
-    auto: t22.auto || false,
-    conditions: t22.conditions || [],
-    actions: (t22.actions || []).map(convertAction),
-    required_fields: t22.required_fields || [],
+  const transitions = ir.transitions.map((t23) => ({
+    name: t23.name,
+    from: t23.from,
+    to: t23.to,
+    description: t23.description || "",
+    roles: t23.roles || [],
+    auto: t23.auto || false,
+    conditions: t23.conditions || [],
+    actions: (t23.actions || []).map(convertAction),
+    required_fields: t23.required_fields || [],
     priority: 0
   }));
   const state_data = {};
@@ -4823,7 +5048,7 @@ function createVisitor(options = {}) {
         }
       }
       if (mode !== "strict") return;
-      if (source.startsWith("@mindmatrix/") || source === "react" || source.startsWith("react/") || source.startsWith(".") || source.startsWith("/")) {
+      if (source.startsWith("@mindmatrix/") || source.startsWith("@mmapp/") || source === "react" || source.startsWith("react/") || source.startsWith(".") || source.startsWith("/")) {
         return;
       }
       const error = {
@@ -5403,7 +5628,7 @@ function compileModel(filename, source, options = {}) {
     ir,
     interfaceName,
     fieldNames: ir.fields.map((f) => f.name),
-    transitionNames: ir.transitions.map((t22) => t22.name),
+    transitionNames: ir.transitions.map((t23) => t23.name),
     stateNames: ir.states.map((s) => s.name),
     hasFieldOptions: Object.keys(rawFieldOptions).length > 0,
     fieldOptions: rawFieldOptions
@@ -5803,6 +6028,520 @@ var init_action_compiler = __esm({
   }
 });
 
+// src/babel/extractors/action-extractor.ts
+function extractAction(source, filename) {
+  let ast;
+  try {
+    ast = (0, import_parser.parse)(source, {
+      sourceType: "module",
+      plugins: ["typescript"],
+      strictMode: false
+    });
+  } catch {
+    return null;
+  }
+  const result = findDefaultExportedFunction(ast);
+  if (!result) return null;
+  const { name, params, body, returnTypeAnnotation, isAsync } = result;
+  const slug = toKebabCase(name);
+  const warnings = [];
+  const fields = params.map((p) => paramToField(p));
+  const parameterMap = /* @__PURE__ */ new Map();
+  for (const p of params) {
+    const snakeName = toSnakeCase3(p.name);
+    if (snakeName !== p.name) {
+      parameterMap.set(p.name, snakeName);
+    }
+  }
+  const humanName = name.replace(/([A-Z])/g, " $1").replace(/^./, (s) => s.toUpperCase()).trim();
+  const metadata = {
+    source_file: filename,
+    source_function: name,
+    provenance: {
+      frontend: "react-compiler",
+      source: "action-extractor",
+      compiler_version: "2.0.0"
+    }
+  };
+  if (returnTypeAnnotation) {
+    metadata.return_type = returnTypeAnnotation;
+  }
+  if (isAsync) {
+    const segments = splitAtAwaits(body.body);
+    const hasAwaits = segments.some((s) => s.kind === "await");
+    if (hasAwaits) {
+      const rewritten = rewriteAwaitReferences(segments);
+      const { states: states2, transitions: transitions2, bodyIsPure } = generateMultiStateIR(rewritten, warnings, parameterMap);
+      if (!bodyIsPure) {
+        warnings.push(`Async action '${name}' body contains untranslatable JS \u2014 wrapped in $expr() markers`);
+      }
+      const ir2 = {
+        slug,
+        name: humanName,
+        version: "0.1.0",
+        category: "action",
+        fields,
+        states: states2,
+        transitions: transitions2,
+        roles: [],
+        metadata: { ...metadata, async: true }
+      };
+      return { ir: ir2, bodyIsPure, warnings };
+    }
+  }
+  const transpileResult = transpileBlock(body, { allMutable: true, parameterMap });
+  const bodyExpr = transpileResult.expression;
+  if (!transpileResult.pure) {
+    warnings.push(`Action '${name}' body contains untranslatable JS \u2014 wrapped in $expr() markers`);
+  }
+  const states = [
+    {
+      name: "ready",
+      type: "START",
+      on_enter: [],
+      during: [],
+      on_exit: []
+    },
+    {
+      name: "done",
+      type: "END",
+      on_enter: [],
+      during: [],
+      on_exit: []
+    }
+  ];
+  const transitions = [
+    {
+      name: "execute",
+      from: ["ready"],
+      to: "done",
+      actions: [
+        {
+          id: "body",
+          type: "eval",
+          mode: "auto",
+          config: {
+            expression: bodyExpr
+          }
+        }
+      ]
+    }
+  ];
+  const ir = {
+    slug,
+    name: humanName,
+    version: "0.1.0",
+    category: "action",
+    fields,
+    states,
+    transitions,
+    roles: [],
+    metadata
+  };
+  return { ir, bodyIsPure: transpileResult.pure, warnings };
+}
+function findDefaultExportedFunction(ast) {
+  const topLevelVars = /* @__PURE__ */ new Map();
+  for (const node of ast.program.body) {
+    if (t18.isVariableDeclaration(node)) {
+      for (const decl of node.declarations) {
+        if (t18.isIdentifier(decl.id) && decl.init) {
+          if (t18.isArrowFunctionExpression(decl.init) || t18.isFunctionExpression(decl.init)) {
+            topLevelVars.set(decl.id.name, decl.init);
+          }
+        }
+      }
+    }
+  }
+  for (const node of ast.program.body) {
+    if (t18.isExportDefaultDeclaration(node)) {
+      const decl = node.declaration;
+      if (t18.isFunctionDeclaration(decl) && decl.body) {
+        const name = decl.id?.name ?? inferNameFromFile(decl) ?? "action";
+        return extractFromFunction(name, decl.params, decl.body, decl.returnType, decl.async);
+      }
+      if (t18.isArrowFunctionExpression(decl) || t18.isFunctionExpression(decl)) {
+        const name = t18.isFunctionExpression(decl) && decl.id ? decl.id.name : "action";
+        const body = ensureBlock(decl.body);
+        if (!body) return null;
+        return extractFromFunction(name, decl.params, body, decl.returnType, decl.async);
+      }
+      if (t18.isIdentifier(decl)) {
+        const fn = topLevelVars.get(decl.name);
+        if (fn) {
+          const body = ensureBlock(fn.body);
+          if (!body) return null;
+          return extractFromFunction(decl.name, fn.params, body, fn.returnType, fn.async);
+        }
+      }
+    }
+  }
+  return null;
+}
+function extractFromFunction(name, params, body, returnType, isAsync = false) {
+  const extracted = params.map((p) => extractParam(p));
+  const returnTypeAnnotation = returnType && t18.isTSTypeAnnotation(returnType) ? serializeTSType(returnType.typeAnnotation) : void 0;
+  return { name, params: extracted, body, returnTypeAnnotation, isAsync };
+}
+function ensureBlock(body) {
+  if (t18.isBlockStatement(body)) return body;
+  const ret = t18.returnStatement(body);
+  return t18.blockStatement([ret]);
+}
+function inferNameFromFile(_node) {
+  return null;
+}
+function extractParam(param) {
+  if (t18.isIdentifier(param)) {
+    return {
+      name: param.name,
+      typeAnnotation: param.typeAnnotation ? param.typeAnnotation.typeAnnotation : null,
+      optional: param.optional ?? false
+    };
+  }
+  if (t18.isAssignmentPattern(param)) {
+    const inner = param.left;
+    if (t18.isIdentifier(inner)) {
+      return {
+        name: inner.name,
+        typeAnnotation: inner.typeAnnotation ? inner.typeAnnotation.typeAnnotation : null,
+        optional: true,
+        defaultValue: param.right
+      };
+    }
+  }
+  if (t18.isRestElement(param)) {
+    const arg = param.argument;
+    return {
+      name: t18.isIdentifier(arg) ? arg.name : "rest",
+      typeAnnotation: null,
+      optional: true
+    };
+  }
+  return { name: "params", typeAnnotation: null, optional: false };
+}
+function paramToField(param) {
+  const fieldType = param.typeAnnotation ? tsTypeToFieldType2(param.typeAnnotation) : "text";
+  const field = {
+    name: toSnakeCase3(param.name),
+    type: fieldType,
+    required: !param.optional
+  };
+  if (param.defaultValue !== void 0) {
+    field.default_value = extractLiteralDefault(param.defaultValue);
+  }
+  return field;
+}
+function extractLiteralDefault(expr) {
+  if (!expr) return void 0;
+  if (t18.isStringLiteral(expr)) return expr.value;
+  if (t18.isNumericLiteral(expr)) return expr.value;
+  if (t18.isBooleanLiteral(expr)) return expr.value;
+  if (t18.isNullLiteral(expr)) return null;
+  if (t18.isArrayExpression(expr) && expr.elements.length === 0) return [];
+  if (t18.isObjectExpression(expr) && expr.properties.length === 0) return {};
+  return void 0;
+}
+function tsTypeToFieldType2(tsType) {
+  if (t18.isTSStringKeyword(tsType)) return "text";
+  if (t18.isTSNumberKeyword(tsType)) return "number";
+  if (t18.isTSBooleanKeyword(tsType)) return "boolean";
+  if (t18.isTSObjectKeyword(tsType)) return "json";
+  if (t18.isTSAnyKeyword(tsType) || t18.isTSUnknownKeyword(tsType)) return "json";
+  if (t18.isTSArrayType(tsType)) return "json";
+  if (t18.isTSUnionType(tsType)) {
+    const nonNullable = tsType.types.filter(
+      (t23) => !t18.isTSNullKeyword(t23) && !t18.isTSUndefinedKeyword(t23)
+    );
+    if (nonNullable.length === 1) {
+      return tsTypeToFieldType2(nonNullable[0]);
+    }
+    if (nonNullable.every((t23) => t18.isTSLiteralType(t23) && t18.isStringLiteral(t23.literal))) {
+      return "select";
+    }
+    return "text";
+  }
+  if (t18.isTSTypeReference(tsType) && t18.isIdentifier(tsType.typeName)) {
+    const name = tsType.typeName.name;
+    if (name === "Date") return "datetime";
+    if (name === "string") return "text";
+    if (name === "number") return "number";
+    if (name === "boolean") return "boolean";
+  }
+  return "text";
+}
+function serializeTSType(tsType) {
+  if (t18.isTSStringKeyword(tsType)) return "string";
+  if (t18.isTSNumberKeyword(tsType)) return "number";
+  if (t18.isTSBooleanKeyword(tsType)) return "boolean";
+  if (t18.isTSVoidKeyword(tsType)) return "void";
+  if (t18.isTSAnyKeyword(tsType)) return "any";
+  if (t18.isTSTypeReference(tsType) && t18.isIdentifier(tsType.typeName)) {
+    return tsType.typeName.name;
+  }
+  if (t18.isTSArrayType(tsType)) return `${serializeTSType(tsType.elementType)}[]`;
+  if (t18.isTSPromiseType(tsType)) {
+    return `Promise<${tsType.typeParameter ? serializeTSType(tsType.typeParameter.params[0]) : "unknown"}>`;
+  }
+  return "unknown";
+}
+function splitAtAwaits(body) {
+  const segments = [];
+  let current = [];
+  let index = 0;
+  for (const stmt of body) {
+    const awaitInfo = extractAwait(stmt);
+    if (!awaitInfo) {
+      current.push(stmt);
+      continue;
+    }
+    if (current.length > 0) {
+      segments.push({ index: index++, kind: "sync", statements: current });
+      current = [];
+    }
+    segments.push({
+      index: index++,
+      kind: "await",
+      statements: [stmt],
+      awaitTarget: awaitInfo.callee,
+      awaitArgs: awaitInfo.args,
+      resultBinding: awaitInfo.binding
+    });
+  }
+  if (current.length > 0) {
+    segments.push({ index: index++, kind: "sync", statements: current });
+  }
+  return segments;
+}
+function extractAwait(stmt) {
+  if (t18.isVariableDeclaration(stmt)) {
+    const decl = stmt.declarations[0];
+    if (decl?.init && t18.isAwaitExpression(decl.init)) {
+      const arg = decl.init.argument;
+      if (t18.isCallExpression(arg)) {
+        return {
+          callee: getCalleeName(arg.callee),
+          args: arg.arguments,
+          binding: t18.isIdentifier(decl.id) ? decl.id.name : void 0
+        };
+      }
+    }
+  }
+  if (t18.isExpressionStatement(stmt) && t18.isAwaitExpression(stmt.expression)) {
+    const arg = stmt.expression.argument;
+    if (t18.isCallExpression(arg)) {
+      return {
+        callee: getCalleeName(arg.callee),
+        args: arg.arguments,
+        binding: void 0
+      };
+    }
+  }
+  if (t18.isReturnStatement(stmt) && stmt.argument && t18.isAwaitExpression(stmt.argument)) {
+    const arg = stmt.argument.argument;
+    if (t18.isCallExpression(arg)) {
+      return {
+        callee: getCalleeName(arg.callee),
+        args: arg.arguments,
+        binding: void 0
+      };
+    }
+  }
+  return null;
+}
+function getCalleeName(callee) {
+  if (t18.isIdentifier(callee)) return callee.name;
+  if (t18.isMemberExpression(callee) && t18.isIdentifier(callee.object) && t18.isIdentifier(callee.property)) {
+    return `${callee.object.name}_${callee.property.name}`;
+  }
+  return "unknown_action";
+}
+function rewriteAwaitReferences(segments) {
+  const bindings = /* @__PURE__ */ new Map();
+  const slugCounts = /* @__PURE__ */ new Map();
+  return segments.map((seg) => {
+    if (seg.kind === "await" && seg.resultBinding) {
+      const slug = toSnakeCase3(seg.awaitTarget ?? "unknown");
+      const count = (slugCounts.get(slug) ?? 0) + 1;
+      slugCounts.set(slug, count);
+      const key = count > 1 ? `${slug}_${count}` : slug;
+      bindings.set(seg.resultBinding, `action_results.${key}`);
+    }
+    if (seg.kind === "sync" && bindings.size > 0) {
+      return {
+        ...seg,
+        statements: seg.statements.map(
+          (stmt) => rewriteIdentifiersInStatement(stmt, bindings)
+        )
+      };
+    }
+    return seg;
+  });
+}
+function rewriteIdentifiersInStatement(stmt, _bindings) {
+  return stmt;
+}
+function generateMultiStateIR(segments, _warnings, parameterMap) {
+  const states = [];
+  const transitions = [];
+  let bodyIsPure = true;
+  const awaitBindings = /* @__PURE__ */ new Map();
+  const slugCounts = /* @__PURE__ */ new Map();
+  for (const seg of segments) {
+    if (seg.kind === "await" && seg.resultBinding) {
+      const slug = toSnakeCase3(seg.awaitTarget ?? "unknown");
+      const count = (slugCounts.get(slug) ?? 0) + 1;
+      slugCounts.set(slug, count);
+      const key = count > 1 ? `${slug}_${count}` : slug;
+      awaitBindings.set(seg.resultBinding, `action_results.${key}`);
+    }
+  }
+  states.push({ name: "ready", type: "START", on_enter: [], during: [], on_exit: [] });
+  const usedStateNames = /* @__PURE__ */ new Set();
+  let prevState = "ready";
+  let transitionCount = 0;
+  let pendingSyncStmts = [];
+  for (const seg of segments) {
+    if (seg.kind === "sync") {
+      pendingSyncStmts.push(...seg.statements);
+      continue;
+    }
+    const targetSlug = toSnakeCase3(seg.awaitTarget ?? "unknown");
+    let stateName = `awaiting_${targetSlug}`;
+    if (usedStateNames.has(stateName)) {
+      let suffix = 2;
+      while (usedStateNames.has(`${stateName}_${suffix}`)) suffix++;
+      stateName = `${stateName}_${suffix}`;
+    }
+    usedStateNames.add(stateName);
+    states.push({ name: stateName, type: "REGULAR", on_enter: [], during: [], on_exit: [] });
+    const actions = [];
+    if (pendingSyncStmts.length > 0) {
+      const block = t18.blockStatement(pendingSyncStmts);
+      const transpiled = transpileBlock(block, {
+        allMutable: true,
+        derivedVarMap: buildDerivedVarMap(awaitBindings),
+        parameterMap
+      });
+      if (!transpiled.pure) bodyIsPure = false;
+      actions.push({
+        id: `pre_${transitionCount}`,
+        type: "eval",
+        mode: "auto",
+        config: { expression: transpiled.expression }
+      });
+      pendingSyncStmts = [];
+    }
+    const callConfig = {
+      definition_slug: seg.awaitTarget,
+      result_key: targetSlug
+    };
+    if (seg.awaitArgs && seg.awaitArgs.length > 0) {
+      const params = {};
+      for (let i = 0; i < seg.awaitArgs.length; i++) {
+        const arg = seg.awaitArgs[i];
+        if (t18.isObjectExpression(arg)) {
+          for (const prop2 of arg.properties) {
+            if (t18.isObjectProperty(prop2) && t18.isIdentifier(prop2.key)) {
+              const { expression: valExpr } = transpileArgExpression(prop2.value, awaitBindings);
+              params[prop2.key.name] = valExpr;
+            }
+          }
+        } else {
+          const { expression: valExpr } = transpileArgExpression(arg, awaitBindings);
+          params[`arg${i}`] = valExpr;
+        }
+      }
+      if (Object.keys(params).length > 0) {
+        callConfig.params = params;
+      }
+    }
+    actions.push({
+      id: `call_${targetSlug}`,
+      type: "call_workflow",
+      mode: "auto",
+      config: callConfig
+    });
+    const transName = transitionCount === 0 ? "execute" : `on_${getStateSuffix(prevState)}_complete`;
+    transitions.push({
+      name: transName,
+      from: [prevState],
+      to: stateName,
+      actions
+    });
+    prevState = stateName;
+    transitionCount++;
+  }
+  states.push({ name: "done", type: "END", on_enter: [], during: [], on_exit: [] });
+  const finalActions = [];
+  if (pendingSyncStmts.length > 0) {
+    const block = t18.blockStatement(pendingSyncStmts);
+    const transpiled = transpileBlock(block, {
+      allMutable: true,
+      derivedVarMap: buildDerivedVarMap(awaitBindings),
+      parameterMap
+    });
+    if (!transpiled.pure) bodyIsPure = false;
+    finalActions.push({
+      id: "post_final",
+      type: "eval",
+      mode: "auto",
+      config: { expression: transpiled.expression }
+    });
+  }
+  const finalTransName = transitionCount === 0 ? "execute" : `on_${getStateSuffix(prevState)}_complete`;
+  transitions.push({
+    name: finalTransName,
+    from: [prevState],
+    to: "done",
+    actions: finalActions
+  });
+  return { states, transitions, bodyIsPure };
+}
+function getStateSuffix(stateName) {
+  return stateName.replace(/^awaiting_/, "");
+}
+function transpileArgExpression(expr, bindings) {
+  if (t18.isIdentifier(expr)) {
+    const replacement = bindings.get(expr.name);
+    if (replacement) return { expression: replacement };
+    return { expression: `state_data.${toSnakeCase3(expr.name)}` };
+  }
+  if (t18.isMemberExpression(expr) && t18.isIdentifier(expr.object)) {
+    const replacement = bindings.get(expr.object.name);
+    if (replacement && t18.isIdentifier(expr.property)) {
+      return { expression: `${replacement}.${expr.property.name}` };
+    }
+  }
+  if (t18.isStringLiteral(expr)) return { expression: `'${expr.value}'` };
+  if (t18.isNumericLiteral(expr)) return { expression: String(expr.value) };
+  if (t18.isBooleanLiteral(expr)) return { expression: String(expr.value) };
+  const { transpile: transpile2 } = (init_ts_to_expression(), __toCommonJS(ts_to_expression_exports));
+  return { expression: transpile2(expr, { derivedVarMap: buildDerivedVarMap(bindings) }) };
+}
+function buildDerivedVarMap(bindings) {
+  const map = /* @__PURE__ */ new Map();
+  for (const [varName, path] of bindings) {
+    map.set(varName, t18.identifier(path));
+  }
+  return map;
+}
+function toKebabCase(name) {
+  return name.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "");
+}
+function toSnakeCase3(name) {
+  return name.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
+}
+var import_parser, t18;
+var init_action_extractor = __esm({
+  "src/babel/extractors/action-extractor.ts"() {
+    "use strict";
+    import_parser = require("@babel/parser");
+    t18 = __toESM(require("@babel/types"));
+    init_ts_to_expression();
+  }
+});
+
 // src/incremental-compiler.ts
 function hashContent(content) {
   let hash = 5381;
@@ -6156,24 +6895,56 @@ function parseModuleManifest(source) {
     }
     if (contributions.length > 0) manifest.contributions = contributions;
   }
+  const configSchemaBlock = extractObjectBlock(source, "configSchema");
+  if (configSchemaBlock) {
+    const configSchema = {};
+    const modelSlugMatch = configSchemaBlock.match(/modelSlug:\s*['"]([^'"]+)['"]/);
+    if (modelSlugMatch) configSchema.modelSlug = modelSlugMatch[1];
+    const defaultsBlock = extractObjectBlock(configSchemaBlock, "defaults");
+    if (defaultsBlock) {
+      const defaults = {};
+      const kvRegex = /(\w+):\s*(?:'([^']*)'|"([^"]*)"|(\d+(?:\.\d+)?)|(\btrue\b|\bfalse\b))/g;
+      let kv;
+      while ((kv = kvRegex.exec(defaultsBlock)) !== null) {
+        const key = kv[1];
+        const val = kv[2] ?? kv[3] ?? (kv[4] !== void 0 ? Number(kv[4]) : kv[5] === "true");
+        defaults[key] = val;
+      }
+      configSchema.defaults = defaults;
+    }
+    manifest.configSchema = configSchema;
+  }
   const depsBlock = extractArrayBlock(source, "dependencies");
   if (depsBlock) {
     const dependencies = [];
-    const depRegex = /\{\s*slug:\s*['"]([^'"]+)['"][^}]*\}/g;
-    let dm;
-    while ((dm = depRegex.exec(depsBlock)) !== null) {
-      const entry = { slug: dm[1] };
-      const verMatch = dm[0].match(/version:\s*['"]([^'"]+)['"]/);
+    const depBlocks = extractNestedObjects(depsBlock);
+    for (const block of depBlocks) {
+      const slugMatch = block.match(/slug:\s*['"]([^'"]+)['"]/);
+      if (!slugMatch) continue;
+      const entry = { slug: slugMatch[1] };
+      const verMatch = block.match(/version:\s*['"]([^'"]+)['"]/);
       if (verMatch) entry.version = verMatch[1];
-      const reqMatch = dm[0].match(/required:\s*(true|false)/);
+      const reqMatch = block.match(/required:\s*(true|false)/);
       if (reqMatch) entry.required = reqMatch[1] === "true";
-      const prefixMatch = dm[0].match(/prefix:\s*['"]([^'"]+)['"]/);
+      const prefixMatch = block.match(/prefix:\s*['"]([^'"]+)['"]/);
       if (prefixMatch) entry.routeConfig = { prefix: prefixMatch[1] };
+      const configBlock = extractObjectBlock(block, "config");
+      if (configBlock) {
+        const config = {};
+        const kvRegex = /(\w+):\s*(?:'([^']*)'|"([^"]*)"|(\d+(?:\.\d+)?)|(\btrue\b|\bfalse\b))/g;
+        let kv;
+        while ((kv = kvRegex.exec(configBlock)) !== null) {
+          const key = kv[1];
+          const val = kv[2] ?? kv[3] ?? (kv[4] !== void 0 ? Number(kv[4]) : kv[5] === "true");
+          config[key] = val;
+        }
+        if (Object.keys(config).length > 0) entry.config = config;
+      }
       dependencies.push(entry);
     }
     if (dependencies.length > 0) manifest.dependencies = dependencies;
   }
-  const hasRichFields = manifest.routes || manifest.actions || manifest.contributions || manifest.capabilities || manifest.dependencies;
+  const hasRichFields = manifest.routes || manifest.actions || manifest.contributions || manifest.capabilities || manifest.dependencies || manifest.configSchema;
   return hasRichFields ? manifest : null;
 }
 function parseDependencyRouteConfigs(files) {
@@ -6269,6 +7040,9 @@ function isModelFile2(filename) {
 function isServerActionFile2(filename) {
   return /\.server\.(ts|tsx)$/.test(filename);
 }
+function isActionFile(filename) {
+  return /^actions\/.*\.(ts|tsx)$/.test(filename) && !filename.endsWith(".server.ts") && !filename.endsWith(".test.ts") && !filename.endsWith(".test.tsx");
+}
 function isComponentFile(filename) {
   return /components\/.*\.(tsx?|jsx?)$/.test(filename) && !filename.endsWith(".test.ts") && !filename.endsWith(".test.tsx");
 }
@@ -6285,7 +7059,7 @@ function isModuleManifestFile(filename) {
   return /mm\.module\.(ts|tsx|js)$/.test(filename);
 }
 function isCompilableFile(filename) {
-  return isWorkflowFile(filename) || isModelFile2(filename) || isServerActionFile2(filename) || isPageFile2(filename) || isComponentFile(filename);
+  return isWorkflowFile(filename) || isModelFile2(filename) || isServerActionFile2(filename) || isActionFile(filename) || isPageFile2(filename) || isComponentFile(filename);
 }
 function compileFile(filename, source, mode) {
   const errors = [];
@@ -6567,10 +7341,87 @@ function extractComponentProps(source) {
   if (!match) return [];
   return match[1].split(",").map((p) => p.trim().split(/[\s=:]/)[0].replace(/^\.{3}/, "").trim()).filter(Boolean);
 }
+function generateModuleTypeStubs(childDefinitions, _modelResults) {
+  const stubs = {};
+  for (const child of childDefinitions) {
+    if (!child.slug) continue;
+    const category = child.category;
+    const isModel = category === "data" || Array.isArray(category) && category.includes("model") || Array.isArray(category) && category.includes("data");
+    if (!isModel || !child.fields || child.fields.length === 0) continue;
+    const interfaceName = slugToInterfaceName(child.slug) + "Fields";
+    const lines = [
+      `// Auto-generated type stub for model: ${child.slug}`,
+      `// Do not edit \u2014 regenerated on each build.`,
+      ``,
+      `export interface ${interfaceName} {`
+    ];
+    for (const field of child.fields) {
+      const tsType = irFieldTypeToTs(field.type || "string");
+      const optional = field.required ? "" : "?";
+      const desc = field.description;
+      if (desc) {
+        lines.push(`  /** ${desc} */`);
+      }
+      lines.push(`  ${field.name}${optional}: ${tsType};`);
+    }
+    lines.push(`}`);
+    lines.push(``);
+    lines.push(`export declare const ${slugToCamelCase(child.slug)}Slug: '${child.slug}';`);
+    lines.push(``);
+    stubs[`types/modules/${child.slug}.d.ts`] = lines.join("\n");
+  }
+  return stubs;
+}
+function slugToInterfaceName(slug) {
+  return slug.split("-").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
+}
+function slugToCamelCase(slug) {
+  const parts = slug.split("-");
+  return parts[0] + parts.slice(1).map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
+}
+function irFieldTypeToTs(type) {
+  switch (type) {
+    case "string":
+    case "text":
+    case "email":
+    case "url":
+    case "phone":
+    case "slug":
+    case "color":
+    case "password":
+      return "string";
+    case "number":
+    case "integer":
+    case "float":
+    case "currency":
+    case "percent":
+      return "number";
+    case "boolean":
+    case "toggle":
+      return "boolean";
+    case "date":
+    case "datetime":
+    case "timestamp":
+      return "string";
+    case "json":
+    case "object":
+      return "Record<string, unknown>";
+    case "array":
+      return "unknown[]";
+    case "enum":
+      return "string";
+    case "file":
+    case "image":
+      return "string";
+    default:
+      return "unknown";
+  }
+}
 function buildComposedResult(files, fileIRs, config, errors, warnings, options = {}) {
   const usePhase2 = options.usePhase2Modules !== false;
   const workflowIRs = [];
   const modelIRs = [];
+  const actionDefinitionIRs = [];
   const serverActionEntries = [];
   let modelResults;
   let actionResult;
@@ -6609,6 +7460,17 @@ function buildComposedResult(files, fileIRs, config, errors, warnings, options =
       }
     }
   }
+  for (const [filename, source] of Object.entries(files)) {
+    if (isActionFile(filename)) {
+      const result = extractAction(source, filename);
+      if (result) {
+        actionDefinitionIRs.push(result.ir);
+        for (const w of result.warnings) {
+          warnings.push({ file: filename, message: w, severity: "warning" });
+        }
+      }
+    }
+  }
   if (usePhase2) {
     const modelFiles = {};
     for (const [filename, source] of Object.entries(files)) {
@@ -6659,7 +7521,11 @@ function buildComposedResult(files, fileIRs, config, errors, warnings, options =
       });
     }
   }
-  const childDefinitions = [...workflowIRs, ...modelIRs];
+  const childDefinitions = [
+    ...workflowIRs,
+    ...modelIRs,
+    ...actionDefinitionIRs
+  ];
   let routeTable = [];
   if (routeResult) {
     routeTable = routeResult.routes.map((r) => ({
@@ -6735,6 +7601,22 @@ function buildComposedResult(files, fileIRs, config, errors, warnings, options =
       }
     }
   }
+  if (options.resolvedModules && options.resolvedModules.length > 0) {
+    for (const mod of options.resolvedModules) {
+      if (mod.serverActions && mod.serverActions.length > 0) {
+        for (const action of mod.serverActions) {
+          const namespacedName = `${mod.slug}:${action.name}`;
+          if (!serverActionEntries.some((a) => a.name === namespacedName)) {
+            serverActionEntries.push({
+              ...action,
+              name: namespacedName,
+              sourceFile: `${mod.slug}/${action.sourceFile}`
+            });
+          }
+        }
+      }
+    }
+  }
   const allIRs = Object.values(fileIRs);
   const parentIR = mergeIRs(allIRs, config);
   if (!parentIR.metadata) parentIR.metadata = {};
@@ -6747,6 +7629,7 @@ function buildComposedResult(files, fileIRs, config, errors, warnings, options =
   parentMeta.composition = {
     workflowCount: workflowIRs.length,
     modelCount: modelIRs.length,
+    actionCount: actionDefinitionIRs.length,
     serverActionCount: serverActionEntries.length,
     routeCount: routeTable.length,
     componentCount: Object.keys(componentDefinitions).length,
@@ -6778,6 +7661,20 @@ function buildComposedResult(files, fileIRs, config, errors, warnings, options =
   if (manifest?.contributions) {
     parentMeta.slot_contributions = manifest.contributions;
   }
+  if (manifest?.configSchema) {
+    parentMeta.configSchema = manifest.configSchema;
+  }
+  if (manifest?.dependencies) {
+    const depConfigs = {};
+    for (const dep of manifest.dependencies) {
+      if (dep.config) {
+        depConfigs[dep.slug] = dep.config;
+      }
+    }
+    if (Object.keys(depConfigs).length > 0) {
+      parentMeta.module_configs = depConfigs;
+    }
+  }
   const compilableFiles = Object.keys(files).filter(isCompilableFile);
   const importLinks = resolveImportLinks(files, compilableFiles);
   const pageExperiences = {};
@@ -6892,6 +7789,7 @@ function buildComposedResult(files, fileIRs, config, errors, warnings, options =
       }
     }
   }
+  const typeStubs = generateModuleTypeStubs(childDefinitions, modelResults);
   return {
     ir: parentIR,
     childDefinitions,
@@ -6905,7 +7803,8 @@ function buildComposedResult(files, fileIRs, config, errors, warnings, options =
     importLinks,
     modelResults,
     actionResult,
-    routeResult
+    routeResult,
+    typeStubs
   };
 }
 function compileProject(files, options = {}) {
@@ -6949,6 +7848,7 @@ var init_project_compiler = __esm({
     init_model_compiler();
     init_route_extractor();
     init_action_compiler();
+    init_action_extractor();
     init_incremental_compiler();
     IncrementalProjectCompiler = class {
       constructor() {
@@ -7167,10 +8067,10 @@ ${output}`);
       fileMap[rel] = (0, import_fs2.readFileSync)(f, "utf-8");
     }
     (0, import_fs2.mkdirSync)(outDir, { recursive: true });
-    const result = compileProject2(fileMap, { mode });
-    const errors = result.errors.filter((e) => e.severity === "error");
-    const warnings = result.errors.filter((e) => e.severity === "warning");
-    const definitions2 = [result.ir];
+    const result2 = compileProject2(fileMap, { mode });
+    const errors = result2.errors.filter((e) => e.severity === "error");
+    const warnings = result2.errors.filter((e) => e.severity === "warning");
+    const definitions2 = [result2.ir];
     const errorDetails2 = [];
     for (const err of errors) {
       errorDetails2.push({ file: err.file, message: err.message, line: err.line });
@@ -7179,11 +8079,11 @@ ${output}`);
     for (const warn of warnings) {
       console.warn(`  ! ${warn.file}${warn.line ? `:${warn.line}` : ""} ${warn.message}`);
     }
-    const irPath = (0, import_path.join)(outDir, `${result.ir.slug}.workflow.json`);
-    (0, import_fs2.writeFileSync)(irPath, JSON.stringify(result.ir, null, 2), "utf-8");
+    const irPath = (0, import_path.join)(outDir, `${result2.ir.slug}.workflow.json`);
+    (0, import_fs2.writeFileSync)(irPath, JSON.stringify(result2.ir, null, 2), "utf-8");
     console.log(`  + ${(0, import_path.basename)(irPath)}`);
-    const seenSlugs = /* @__PURE__ */ new Set([result.ir.slug]);
-    for (const child of result.childDefinitions) {
+    const seenSlugs = /* @__PURE__ */ new Set([result2.ir.slug]);
+    for (const child of result2.childDefinitions) {
       if (seenSlugs.has(child.slug)) continue;
       seenSlugs.add(child.slug);
       definitions2.push(child);
@@ -7213,14 +8113,14 @@ ${output}`);
   for (const file2 of allFiles) {
     try {
       const code = (0, import_fs2.readFileSync)(file2, "utf-8");
-      const result = (0, import_core4.transformSync)(code, {
+      const result2 = (0, import_core4.transformSync)(code, {
         filename: file2,
         plugins: [[babelPlugin, { mode }]],
         parserOpts: { plugins: ["jsx", "typescript"], attachComment: true }
       });
-      const ir = result?.metadata?.mindmatrixIR;
-      const definition = result?.metadata?.mindmatrixDefinition;
-      const canonical = result?.metadata?.mindmatrixCanonical;
+      const ir = result2?.metadata?.mindmatrixIR;
+      const definition = result2?.metadata?.mindmatrixDefinition;
+      const canonical = result2?.metadata?.mindmatrixCanonical;
       if (ir) {
         definitions.push(ir);
         const irErrors = ir.metadata?.errors;
@@ -7285,7 +8185,37 @@ ${output}`);
   }
   console.log(`
 [mindmatrix-react] Compiled ${compiled} workflows, ${errorCount} errors, ${warningCount} warnings`);
-  return { compiled, errors: errorCount, warnings: warningCount, definitions, errorDetails };
+  const result = { compiled, errors: errorCount, warnings: warningCount, definitions, errorDetails };
+  if (options.watch) {
+    await startWatchMode(options);
+  }
+  return result;
+}
+async function startWatchMode(options) {
+  const { watch: fsWatch } = await import("fs");
+  const srcDir = options.src ?? "src/workflows";
+  let debounce = null;
+  console.log(`
+[mindmatrix-react] Watching ${srcDir} for changes... (Ctrl+C to stop)
+`);
+  fsWatch(srcDir, { recursive: true }, (_event, filename) => {
+    if (!filename) return;
+    if (!filename.match(/\.(tsx?|jsx?)$/)) return;
+    if (filename.includes("node_modules") || filename.includes("dist")) return;
+    if (debounce) clearTimeout(debounce);
+    debounce = setTimeout(async () => {
+      const ts = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+      console.log(`
+[${ts}] Change detected: ${filename} \u2014 recompiling...`);
+      try {
+        await build({ ...options, watch: false, skipTypeCheck: true });
+      } catch (e) {
+        console.error(`[mindmatrix-react] Rebuild failed:`, e.message);
+      }
+    }, 300);
+  });
+  return new Promise(() => {
+  });
 }
 var import_glob, import_fs2, import_core4, import_path, import_child_process;
 var init_build = __esm({
@@ -7349,10 +8279,10 @@ function emitRadiusShorthand(corners) {
 }
 function emitColorValue(color) {
   if (isTokenRef(color)) {
-    return t18.stringLiteral(`token:${color.name}`);
+    return t19.stringLiteral(`token:${color.name}`);
   }
   if (typeof color === "string") {
-    return t18.stringLiteral(color);
+    return t19.stringLiteral(color);
   }
   if (typeof color === "object" && color !== null) {
     const c = color;
@@ -7360,37 +8290,37 @@ function emitColorValue(color) {
       const a = typeof c.a === "number" ? c.a : 1;
       if (a === 1) {
         const hex = `#${hexByte(c.r)}${hexByte(c.g)}${hexByte(c.b)}`;
-        return t18.stringLiteral(hex);
+        return t19.stringLiteral(hex);
       }
-      return t18.stringLiteral(`rgba(${c.r}, ${c.g}, ${c.b}, ${a})`);
+      return t19.stringLiteral(`rgba(${c.r}, ${c.g}, ${c.b}, ${a})`);
     }
   }
-  return t18.stringLiteral("inherit");
+  return t19.stringLiteral("inherit");
 }
 function hexByte(n) {
   return Math.round(n).toString(16).padStart(2, "0");
 }
 function prop(key, value) {
-  return t18.objectProperty(t18.identifier(key), valueToExpression(value));
+  return t19.objectProperty(t19.identifier(key), valueToExpression(value));
 }
 function valueToExpression(value) {
-  if (typeof value === "string") return t18.stringLiteral(value);
-  if (typeof value === "number") return t18.numericLiteral(value);
-  if (typeof value === "boolean") return t18.booleanLiteral(value);
-  if (value === null) return t18.nullLiteral();
-  if (value === void 0) return t18.identifier("undefined");
+  if (typeof value === "string") return t19.stringLiteral(value);
+  if (typeof value === "number") return t19.numericLiteral(value);
+  if (typeof value === "boolean") return t19.booleanLiteral(value);
+  if (value === null) return t19.nullLiteral();
+  if (value === void 0) return t19.identifier("undefined");
   if (Array.isArray(value)) {
-    return t18.arrayExpression(value.map((v) => valueToExpression(v)));
+    return t19.arrayExpression(value.map((v) => valueToExpression(v)));
   }
   if (typeof value === "object") {
     const entries = Object.entries(value);
-    return t18.objectExpression(
+    return t19.objectExpression(
       entries.map(
-        ([k, v]) => t18.objectProperty(t18.identifier(k), valueToExpression(v))
+        ([k, v]) => t19.objectProperty(t19.identifier(k), valueToExpression(v))
       )
     );
   }
-  return t18.identifier("undefined");
+  return t19.identifier("undefined");
 }
 function emitSxProp(style) {
   if (!style || typeof style !== "object") return null;
@@ -7402,8 +8332,8 @@ function emitSxProp(style) {
     props.push(...emitSpacingShorthand("m", style.margin));
   }
   if (style.backgroundColor) {
-    props.push(t18.objectProperty(
-      t18.identifier("bg"),
+    props.push(t19.objectProperty(
+      t19.identifier("bg"),
       emitColorValue(style.backgroundColor)
     ));
   }
@@ -7432,8 +8362,8 @@ function emitSxProp(style) {
     props.push(prop("opacity", style.opacity));
   }
   if (style.color) {
-    props.push(t18.objectProperty(
-      t18.identifier("color"),
+    props.push(t19.objectProperty(
+      t19.identifier("color"),
       emitColorValue(style.color)
     ));
   }
@@ -7448,9 +8378,9 @@ function emitSxProp(style) {
       const sxKey = STATE_TO_SX_KEY[state] || state;
       if (typeof override === "object" && override !== null) {
         const subProp = emitSxProp(override);
-        if (subProp && t18.isJSXExpressionContainer(subProp.value) && t18.isObjectExpression(subProp.value.expression)) {
-          props.push(t18.objectProperty(
-            t18.identifier(sxKey),
+        if (subProp && t19.isJSXExpressionContainer(subProp.value) && t19.isObjectExpression(subProp.value.expression)) {
+          props.push(t19.objectProperty(
+            t19.identifier(sxKey),
             subProp.value.expression
           ));
         }
@@ -7458,16 +8388,16 @@ function emitSxProp(style) {
     }
   }
   if (props.length === 0) return null;
-  return t18.jsxAttribute(
-    t18.jsxIdentifier("sx"),
-    t18.jsxExpressionContainer(t18.objectExpression(props))
+  return t19.jsxAttribute(
+    t19.jsxIdentifier("sx"),
+    t19.jsxExpressionContainer(t19.objectExpression(props))
   );
 }
-var t18, STATE_TO_SX_KEY;
+var t19, STATE_TO_SX_KEY;
 var init_sx_emitter = __esm({
   "src/decompiler/sx-emitter.ts"() {
     "use strict";
-    t18 = __toESM(require("@babel/types"));
+    t19 = __toESM(require("@babel/types"));
     STATE_TO_SX_KEY = {
       hovered: "hover",
       pressed: "pressed",
@@ -7616,34 +8546,34 @@ function splitTopLevelArgs(input) {
 }
 function emitBindingExpression(expr, symbols) {
   if (expr === "[Expression]" || expr === '"[Expression]"') {
-    return t19.nullLiteral();
+    return t20.nullLiteral();
   }
   const resolved = resolveIRTokens(expr, symbols);
   const fieldsMatch = resolved.match(/^fields\.(\w+)$/);
   if (fieldsMatch) {
-    return t19.identifier(toCamelCase(fieldsMatch[1]));
+    return t20.identifier(toCamelCase(fieldsMatch[1]));
   }
   const setFieldMatch = resolved.match(/^set_field\((\w+),\s*(.+)\)$/);
   if (setFieldMatch) {
     const setter = setterName(setFieldMatch[1]);
-    return t19.callExpression(
-      t19.identifier(setter),
+    return t20.callExpression(
+      t20.identifier(setter),
       [emitBindingExpression(setFieldMatch[2].trim(), symbols)]
     );
   }
   if (/^\w+$/.test(resolved)) {
-    return t19.identifier(toCamelCase(resolved));
+    return t20.identifier(toCamelCase(resolved));
   }
   if (/^[\w$]+(?:\??\.[\w$]+)+$/.test(resolved)) {
     const parts = resolved.split(/(\??\.)/).filter(Boolean);
-    let node = t19.identifier(parts[0]);
+    let node = t20.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 = t19.optionalMemberExpression(
+      node = t20.optionalMemberExpression(
         node,
-        t19.identifier(prop2),
+        t20.identifier(prop2),
         false,
         isOptional
       );
@@ -7652,34 +8582,34 @@ function emitBindingExpression(expr, symbols) {
   }
   if (/[=<>!+\-*/%&|^~?:,()[\]{}]/.test(resolved)) {
     try {
-      return (0, import_parser.parseExpression)(resolved, {
+      return (0, import_parser2.parseExpression)(resolved, {
         plugins: ["typescript", "jsx"]
       });
     } catch {
-      return t19.stringLiteral(resolved);
+      return t20.stringLiteral(resolved);
     }
   }
-  return t19.stringLiteral(resolved);
+  return t20.stringLiteral(resolved);
 }
 function emitConfigAttribute(key, value) {
   if (typeof value === "string") {
     if (value.includes('"') || value.includes("\\") || value.includes("\n")) {
-      return t19.jsxAttribute(
-        t19.jsxIdentifier(key),
-        t19.jsxExpressionContainer(t19.stringLiteral(value))
+      return t20.jsxAttribute(
+        t20.jsxIdentifier(key),
+        t20.jsxExpressionContainer(t20.stringLiteral(value))
       );
     }
-    return t19.jsxAttribute(
-      t19.jsxIdentifier(key),
-      t19.stringLiteral(value)
+    return t20.jsxAttribute(
+      t20.jsxIdentifier(key),
+      t20.stringLiteral(value)
     );
   }
   if (typeof value === "boolean" && value === true) {
-    return t19.jsxAttribute(t19.jsxIdentifier(key), null);
+    return t20.jsxAttribute(t20.jsxIdentifier(key), null);
   }
-  return t19.jsxAttribute(
-    t19.jsxIdentifier(key),
-    t19.jsxExpressionContainer(valueToExpression(value))
+  return t20.jsxAttribute(
+    t20.jsxIdentifier(key),
+    t20.jsxExpressionContainer(valueToExpression(value))
   );
 }
 function toCamelCase(str) {
@@ -7694,9 +8624,9 @@ function buildJSXTree(node, imports, symbols) {
     const fragmentChildren = (node.children || []).map(
       (child) => buildJSXTree(child, imports, symbols)
     );
-    return t19.jsxFragment(
-      t19.jsxOpeningFragment(),
-      t19.jsxClosingFragment(),
+    return t20.jsxFragment(
+      t20.jsxOpeningFragment(),
+      t20.jsxClosingFragment(),
       fragmentChildren
     );
   }
@@ -7714,13 +8644,13 @@ function buildJSXTree(node, imports, symbols) {
   if (node.bindings) {
     for (const [key, expr] of Object.entries(node.bindings)) {
       let emitted = emitBindingExpression(expr, symbols);
-      if (isEventHandlerKey(key) && !t19.isArrowFunctionExpression(emitted) && !t19.isFunctionExpression(emitted)) {
-        emitted = t19.arrowFunctionExpression([], emitted);
+      if (isEventHandlerKey(key) && !t20.isArrowFunctionExpression(emitted) && !t20.isFunctionExpression(emitted)) {
+        emitted = t20.arrowFunctionExpression([], emitted);
       }
       attributes.push(
-        t19.jsxAttribute(
-          t19.jsxIdentifier(key),
-          t19.jsxExpressionContainer(emitted)
+        t20.jsxAttribute(
+          t20.jsxIdentifier(key),
+          t20.jsxExpressionContainer(emitted)
         )
       );
     }
@@ -7736,30 +8666,30 @@ function buildJSXTree(node, imports, symbols) {
     }
   }
   const isSelfClosing = jsxChildren.length === 0;
-  const element = t19.jsxElement(
-    t19.jsxOpeningElement(
-      t19.jsxIdentifier(componentName),
+  const element = t20.jsxElement(
+    t20.jsxOpeningElement(
+      t20.jsxIdentifier(componentName),
       attributes,
       isSelfClosing
     ),
-    isSelfClosing ? null : t19.jsxClosingElement(t19.jsxIdentifier(componentName)),
+    isSelfClosing ? null : t20.jsxClosingElement(t20.jsxIdentifier(componentName)),
     jsxChildren,
     isSelfClosing
   );
   if (node.visible_when) {
     addImport(imports, "@mindmatrix/react", "Show");
-    return t19.jsxElement(
-      t19.jsxOpeningElement(
-        t19.jsxIdentifier("Show"),
+    return t20.jsxElement(
+      t20.jsxOpeningElement(
+        t20.jsxIdentifier("Show"),
         [
-          t19.jsxAttribute(
-            t19.jsxIdentifier("when"),
-            t19.jsxExpressionContainer(emitBindingExpression(node.visible_when, symbols))
+          t20.jsxAttribute(
+            t20.jsxIdentifier("when"),
+            t20.jsxExpressionContainer(emitBindingExpression(node.visible_when, symbols))
           )
         ],
         false
       ),
-      t19.jsxClosingElement(t19.jsxIdentifier("Show")),
+      t20.jsxClosingElement(t20.jsxIdentifier("Show")),
       [element],
       false
     );
@@ -7773,12 +8703,12 @@ function addImport(tracker, source, name) {
   if (!tracker.has(source)) tracker.set(source, /* @__PURE__ */ new Set());
   tracker.get(source).add(name);
 }
-var t19, import_parser, REACT_ATOMS;
+var t20, import_parser2, REACT_ATOMS;
 var init_ast_builder = __esm({
   "src/decompiler/ast-builder.ts"() {
     "use strict";
-    t19 = __toESM(require("@babel/types"));
-    import_parser = require("@babel/parser");
+    t20 = __toESM(require("@babel/types"));
+    import_parser2 = require("@babel/parser");
     init_sx_emitter();
     REACT_ATOMS = /* @__PURE__ */ new Set([
       "Stack",
@@ -7830,8 +8760,8 @@ function fieldTypeAnnotation(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 t20.tsUnionType(
-      options.map((o) => t20.tsLiteralType(t20.stringLiteral(String(o))))
+    return t21.tsUnionType(
+      options.map((o) => t21.tsLiteralType(t21.stringLiteral(String(o))))
     );
   }
   switch (field.type) {
@@ -7841,25 +8771,25 @@ function fieldTypeAnnotation(field) {
     case "url":
     case "phone":
     case "color":
-      return t20.tsStringKeyword();
+      return t21.tsStringKeyword();
     case "number":
     case "currency":
     case "percentage":
     case "rating":
     case "duration":
     case "auto_number":
-      return t20.tsNumberKeyword();
+      return t21.tsNumberKeyword();
     case "boolean":
-      return t20.tsBooleanKeyword();
+      return t21.tsBooleanKeyword();
     case "date":
     case "datetime":
     case "created_at":
     case "updated_at":
-      return t20.tsTypeReference(t20.identifier("Date"));
+      return t21.tsTypeReference(t21.identifier("Date"));
     case "select":
-      return t20.tsStringKeyword();
+      return t21.tsStringKeyword();
     case "multi_select":
-      return t20.tsArrayType(t20.tsStringKeyword());
+      return t21.tsArrayType(t21.tsStringKeyword());
     // string[]
     case "json":
       return null;
@@ -7879,24 +8809,24 @@ function emitFieldDeclarations(fields, imports) {
     const defaultExpr = field.default_value !== void 0 ? valueToExpression(field.default_value) : inferDefaultFromType(field.type);
     const args2 = [defaultExpr];
     if (field.state_home?.scope === "ephemeral") {
-      args2.push(t20.objectExpression([
-        t20.objectProperty(t20.identifier("ephemeral"), t20.booleanLiteral(true))
+      args2.push(t21.objectExpression([
+        t21.objectProperty(t21.identifier("ephemeral"), t21.booleanLiteral(true))
       ]));
     }
-    const declaration = t20.variableDeclaration("const", [
-      t20.variableDeclarator(
-        t20.arrayPattern([
-          t20.identifier(camelName),
-          t20.identifier(setter)
+    const declaration = t21.variableDeclaration("const", [
+      t21.variableDeclarator(
+        t21.arrayPattern([
+          t21.identifier(camelName),
+          t21.identifier(setter)
         ]),
-        t20.callExpression(t20.identifier("useState"), args2)
+        t21.callExpression(t21.identifier("useState"), args2)
       )
     ]);
     if (field.default_value !== null) {
       const tsType = fieldTypeAnnotation(field);
       if (tsType) {
         const callExpr = declaration.declarations[0].init;
-        callExpr.typeParameters = t20.tsTypeParameterInstantiation([tsType]);
+        callExpr.typeParameters = t21.tsTypeParameterInstantiation([tsType]);
       }
     }
     statements.push(declaration);
@@ -7912,22 +8842,22 @@ function inferDefaultFromType(fieldType) {
     case "phone":
     case "color":
     case "select":
-      return t20.stringLiteral("");
+      return t21.stringLiteral("");
     case "number":
     case "currency":
     case "percentage":
     case "rating":
     case "duration":
     case "auto_number":
-      return t20.numericLiteral(0);
+      return t21.numericLiteral(0);
     case "boolean":
-      return t20.booleanLiteral(false);
+      return t21.booleanLiteral(false);
     case "multi_select":
-      return t20.arrayExpression([]);
+      return t21.arrayExpression([]);
     case "json":
-      return t20.objectExpression([]);
+      return t21.objectExpression([]);
     default:
-      return t20.nullLiteral();
+      return t21.nullLiteral();
   }
 }
 function emitStateEffects(states, imports) {
@@ -7936,9 +8866,9 @@ function emitStateEffects(states, imports) {
     if (state.on_enter.length > 0) {
       addImport2(imports, "@mindmatrix/react", "useOnEnter");
       statements.push(
-        t20.expressionStatement(
-          t20.callExpression(t20.identifier("useOnEnter"), [
-            t20.stringLiteral(state.name),
+        t21.expressionStatement(
+          t21.callExpression(t21.identifier("useOnEnter"), [
+            t21.stringLiteral(state.name),
             emitActionCallback(state.on_enter)
           ])
         )
@@ -7947,9 +8877,9 @@ function emitStateEffects(states, imports) {
     if (state.on_exit.length > 0) {
       addImport2(imports, "@mindmatrix/react", "useOnExit");
       statements.push(
-        t20.expressionStatement(
-          t20.callExpression(t20.identifier("useOnExit"), [
-            t20.stringLiteral(state.name),
+        t21.expressionStatement(
+          t21.callExpression(t21.identifier("useOnExit"), [
+            t21.stringLiteral(state.name),
             emitActionCallback(state.on_exit)
           ])
         )
@@ -7959,15 +8889,15 @@ function emitStateEffects(states, imports) {
       addImport2(imports, "@mindmatrix/react", "useWhileIn");
       for (const during of state.during) {
         const args2 = [
-          t20.stringLiteral(state.name)
+          t21.stringLiteral(state.name)
         ];
         if (during.interval_ms) {
-          args2.push(t20.numericLiteral(during.interval_ms));
+          args2.push(t21.numericLiteral(during.interval_ms));
         }
         args2.push(emitActionCallback(during.actions));
         statements.push(
-          t20.expressionStatement(
-            t20.callExpression(t20.identifier("useWhileIn"), args2)
+          t21.expressionStatement(
+            t21.callExpression(t21.identifier("useWhileIn"), args2)
           )
         );
       }
@@ -7986,55 +8916,55 @@ function emitTransitionDeclarations(transitions, imports) {
     const fromArr = normalizeFrom(transition.from);
     if (fromArr.length === 1) {
       configProps.push(
-        t20.objectProperty(t20.identifier("from"), t20.stringLiteral(fromArr[0]))
+        t21.objectProperty(t21.identifier("from"), t21.stringLiteral(fromArr[0]))
       );
     } else if (fromArr.length > 1) {
       configProps.push(
-        t20.objectProperty(
-          t20.identifier("from"),
-          t20.arrayExpression(fromArr.map((s) => t20.stringLiteral(s)))
+        t21.objectProperty(
+          t21.identifier("from"),
+          t21.arrayExpression(fromArr.map((s) => t21.stringLiteral(s)))
         )
       );
     }
     configProps.push(
-      t20.objectProperty(t20.identifier("to"), t20.stringLiteral(transition.to))
+      t21.objectProperty(t21.identifier("to"), t21.stringLiteral(transition.to))
     );
     if (transition.conditions && transition.conditions.length > 0) {
       configProps.push(
-        t20.objectProperty(
-          t20.identifier("when"),
+        t21.objectProperty(
+          t21.identifier("when"),
           emitConditionExpression(transition.conditions)
         )
       );
     }
     if (transition.roles && transition.roles.length > 0) {
       configProps.push(
-        t20.objectProperty(
-          t20.identifier("roles"),
-          t20.arrayExpression(transition.roles.map((r) => t20.stringLiteral(r)))
+        t21.objectProperty(
+          t21.identifier("roles"),
+          t21.arrayExpression(transition.roles.map((r) => t21.stringLiteral(r)))
         )
       );
     }
     if (transition.auto) {
       configProps.push(
-        t20.objectProperty(t20.identifier("auto"), t20.booleanLiteral(true))
+        t21.objectProperty(t21.identifier("auto"), t21.booleanLiteral(true))
       );
     }
     if (transition.required_fields && transition.required_fields.length > 0) {
       configProps.push(
-        t20.objectProperty(
-          t20.identifier("requiredFields"),
-          t20.arrayExpression(transition.required_fields.map((f) => t20.stringLiteral(f)))
+        t21.objectProperty(
+          t21.identifier("requiredFields"),
+          t21.arrayExpression(transition.required_fields.map((f) => t21.stringLiteral(f)))
         )
       );
     }
     statements.push(
-      t20.variableDeclaration("const", [
-        t20.variableDeclarator(
-          t20.identifier(varName),
-          t20.callExpression(t20.identifier("useTransition"), [
-            t20.stringLiteral(transition.name),
-            t20.objectExpression(configProps)
+      t21.variableDeclaration("const", [
+        t21.variableDeclarator(
+          t21.identifier(varName),
+          t21.callExpression(t21.identifier("useTransition"), [
+            t21.stringLiteral(transition.name),
+            t21.objectExpression(configProps)
           ])
         )
       ])
@@ -8049,59 +8979,59 @@ function emitActionCallback(actions) {
     if (stmt) body.push(stmt);
   }
   if (body.length === 0) {
-    body.push(t20.emptyStatement());
+    body.push(t21.emptyStatement());
   }
-  return t20.arrowFunctionExpression([], t20.blockStatement(body));
+  return t21.arrowFunctionExpression([], t21.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 ? t20.identifier(String(action.config.expression)) : valueToExpression(action.config.value ?? null);
-      return t20.expressionStatement(
-        t20.callExpression(t20.identifier(setter), [expr])
+      const expr = action.config.expression ? t21.identifier(String(action.config.expression)) : valueToExpression(action.config.value ?? null);
+      return t21.expressionStatement(
+        t21.callExpression(t21.identifier(setter), [expr])
       );
     }
     case "log_event":
     case "log": {
       const msg = action.config.message ?? action.config.event ?? action.type;
-      return t20.expressionStatement(
-        t20.callExpression(
-          t20.memberExpression(t20.identifier("console"), t20.identifier("log")),
-          [t20.stringLiteral(String(msg))]
+      return t21.expressionStatement(
+        t21.callExpression(
+          t21.memberExpression(t21.identifier("console"), t21.identifier("log")),
+          [t21.stringLiteral(String(msg))]
         )
       );
     }
     case "emit_event": {
       const eventName = String(action.config.event ?? action.config.name ?? "unknown");
-      const args2 = [t20.stringLiteral(eventName)];
+      const args2 = [t21.stringLiteral(eventName)];
       if (action.config.payload) {
         args2.push(valueToExpression(action.config.payload));
       }
-      return t20.expressionStatement(
-        t20.callExpression(t20.identifier("emitEvent"), args2)
+      return t21.expressionStatement(
+        t21.callExpression(t21.identifier("emitEvent"), args2)
       );
     }
     case "call_workflow": {
       const slug = String(action.config.slug ?? action.config.workflow ?? "unknown");
-      const args2 = [t20.stringLiteral(slug)];
+      const args2 = [t21.stringLiteral(slug)];
       if (action.config.params) {
         args2.push(valueToExpression(action.config.params));
       }
-      return t20.expressionStatement(
-        t20.callExpression(t20.identifier("callWorkflow"), args2)
+      return t21.expressionStatement(
+        t21.callExpression(t21.identifier("callWorkflow"), args2)
       );
     }
     case "spawn_instance":
     case "spawn_subworkflow": {
       const slug = String(action.config.slug ?? action.config.workflow ?? "unknown");
-      const args2 = [t20.stringLiteral(slug)];
+      const args2 = [t21.stringLiteral(slug)];
       if (action.config.params || action.config.input) {
         args2.push(valueToExpression(action.config.params ?? action.config.input));
       }
-      return t20.expressionStatement(
-        t20.callExpression(t20.identifier("spawnInstance"), args2)
+      return t21.expressionStatement(
+        t21.callExpression(t21.identifier("spawnInstance"), args2)
       );
     }
     case "http_request":
@@ -8109,22 +9039,22 @@ function emitSingleAction(action) {
     case "call_webhook": {
       const url = String(action.config.url ?? "");
       const method = String(action.config.method ?? "POST");
-      return t20.expressionStatement(
-        t20.callExpression(t20.identifier("fetch"), [
-          t20.stringLiteral(url),
-          t20.objectExpression([
-            t20.objectProperty(t20.identifier("method"), t20.stringLiteral(method))
+      return t21.expressionStatement(
+        t21.callExpression(t21.identifier("fetch"), [
+          t21.stringLiteral(url),
+          t21.objectExpression([
+            t21.objectProperty(t21.identifier("method"), t21.stringLiteral(method))
           ])
         ])
       );
     }
     case "delay": {
       const ms = Number(action.config.duration_ms ?? action.config.delay_ms ?? 1e3);
-      return t20.expressionStatement(
-        t20.awaitExpression(
-          t20.callExpression(
-            t20.identifier("delay"),
-            [t20.numericLiteral(ms)]
+      return t21.expressionStatement(
+        t21.awaitExpression(
+          t21.callExpression(
+            t21.identifier("delay"),
+            [t21.numericLiteral(ms)]
           )
         )
       );
@@ -8132,17 +9062,17 @@ function emitSingleAction(action) {
     case "notify":
     case "send_notification": {
       const msg = String(action.config.message ?? action.config.body ?? "");
-      return t20.expressionStatement(
-        t20.callExpression(t20.identifier("notify"), [t20.stringLiteral(msg)])
+      return t21.expressionStatement(
+        t21.callExpression(t21.identifier("notify"), [t21.stringLiteral(msg)])
       );
     }
     case "noop":
       return null;
     default: {
       const comment = ` ${action.type}(${JSON.stringify(action.config)}) `;
-      const voidExpr = t20.unaryExpression("void", t20.numericLiteral(0));
-      t20.addComment(voidExpr, "leading", comment, false);
-      return t20.expressionStatement(voidExpr);
+      const voidExpr = t21.unaryExpression("void", t21.numericLiteral(0));
+      t21.addComment(voidExpr, "leading", comment, false);
+      return t21.expressionStatement(voidExpr);
     }
   }
 }
@@ -8152,16 +9082,16 @@ function emitConditionExpression(conditions) {
   }
   let result = emitSingleCondition(conditions[0]);
   for (let i = 1; i < conditions.length; i++) {
-    result = t20.logicalExpression("&&", result, emitSingleCondition(conditions[i]));
+    result = t21.logicalExpression("&&", result, emitSingleCondition(conditions[i]));
   }
   return result;
 }
 function emitSingleCondition(cond) {
   if (cond.expression) {
-    return t20.identifier(cond.expression);
+    return t21.identifier(cond.expression);
   }
   if (cond.field && cond.operator) {
-    const fieldExpr = t20.identifier(toCamelCase2(cond.field));
+    const fieldExpr = t21.identifier(toCamelCase2(cond.field));
     const valueExpr = valueToExpression(cond.value);
     const opMap = {
       eq: "===",
@@ -8173,25 +9103,25 @@ function emitSingleCondition(cond) {
     };
     const jsOp = opMap[cond.operator];
     if (jsOp) {
-      return t20.binaryExpression(jsOp, fieldExpr, valueExpr);
+      return t21.binaryExpression(jsOp, fieldExpr, valueExpr);
     }
     if (cond.operator === "is_set") {
-      return t20.binaryExpression("!==", fieldExpr, t20.nullLiteral());
+      return t21.binaryExpression("!==", fieldExpr, t21.nullLiteral());
     }
     if (cond.operator === "is_empty") {
-      return t20.binaryExpression("===", fieldExpr, t20.nullLiteral());
+      return t21.binaryExpression("===", fieldExpr, t21.nullLiteral());
     }
     if (cond.operator === "contains" && typeof cond.value === "string") {
-      return t20.callExpression(
-        t20.memberExpression(fieldExpr, t20.identifier("includes")),
-        [t20.stringLiteral(cond.value)]
+      return t21.callExpression(
+        t21.memberExpression(fieldExpr, t21.identifier("includes")),
+        [t21.stringLiteral(cond.value)]
       );
     }
     if (cond.operator === "in" && Array.isArray(cond.value)) {
-      return t20.callExpression(
-        t20.memberExpression(
-          t20.arrayExpression(cond.value.map((v) => valueToExpression(v))),
-          t20.identifier("includes")
+      return t21.callExpression(
+        t21.memberExpression(
+          t21.arrayExpression(cond.value.map((v) => valueToExpression(v))),
+          t21.identifier("includes")
         ),
         [fieldExpr]
       );
@@ -8200,14 +9130,14 @@ function emitSingleCondition(cond) {
   if (cond.OR && cond.OR.length > 0) {
     let result = emitSingleCondition(cond.OR[0]);
     for (let i = 1; i < cond.OR.length; i++) {
-      result = t20.logicalExpression("||", result, emitSingleCondition(cond.OR[i]));
+      result = t21.logicalExpression("||", result, emitSingleCondition(cond.OR[i]));
     }
     return result;
   }
   if (cond.AND && cond.AND.length > 0) {
     return emitConditionExpression(cond.AND);
   }
-  return t20.booleanLiteral(true);
+  return t21.booleanLiteral(true);
 }
 function emitRoleDeclarations(metadata, imports) {
   const roleDeps = metadata?.roleDependencies;
@@ -8217,10 +9147,10 @@ function emitRoleDeclarations(metadata, imports) {
   for (const role of roleDeps) {
     const varName = `is${toPascalCase(role)}`;
     statements.push(
-      t20.variableDeclaration("const", [
-        t20.variableDeclarator(
-          t20.identifier(varName),
-          t20.callExpression(t20.identifier("useRole"), [t20.stringLiteral(role)])
+      t21.variableDeclaration("const", [
+        t21.variableDeclarator(
+          t21.identifier(varName),
+          t21.callExpression(t21.identifier("useRole"), [t21.stringLiteral(role)])
         )
       ])
     );
@@ -8255,44 +9185,44 @@ function emitQueryDeclarations(metadata, imports) {
       const optionProps = [];
       if (ds.pageSize) {
         optionProps.push(
-          t20.objectProperty(t20.identifier("limit"), t20.numericLiteral(ds.pageSize))
+          t21.objectProperty(t21.identifier("limit"), t21.numericLiteral(ds.pageSize))
         );
       }
       if (ds.sort) {
         optionProps.push(
-          t20.objectProperty(t20.identifier("orderBy"), t20.stringLiteral(ds.sort))
+          t21.objectProperty(t21.identifier("orderBy"), t21.stringLiteral(ds.sort))
         );
       }
       if (ds.filter && Object.keys(ds.filter).length > 0) {
         optionProps.push(
-          t20.objectProperty(t20.identifier("filter"), valueToExpression(ds.filter))
+          t21.objectProperty(t21.identifier("filter"), valueToExpression(ds.filter))
         );
       }
       if (ds.search) {
         optionProps.push(
-          t20.objectProperty(t20.identifier("search"), t20.stringLiteral(ds.search))
+          t21.objectProperty(t21.identifier("search"), t21.stringLiteral(ds.search))
         );
       }
       if (ds.groupBy) {
         optionProps.push(
-          t20.objectProperty(t20.identifier("groupBy"), t20.stringLiteral(ds.groupBy))
+          t21.objectProperty(t21.identifier("groupBy"), t21.stringLiteral(ds.groupBy))
         );
       }
-      const queryTarget = modelVarName ? t20.identifier(modelVarName) : t20.stringLiteral(slug);
+      const queryTarget = modelVarName ? t21.identifier(modelVarName) : t21.stringLiteral(slug);
       const args2 = [queryTarget];
       if (optionProps.length > 0) {
-        args2.push(t20.objectExpression(optionProps));
+        args2.push(t21.objectExpression(optionProps));
       }
       statements.push(
-        t20.variableDeclaration("const", [
-          t20.variableDeclarator(
-            t20.objectPattern([
-              t20.objectProperty(
-                t20.identifier("data"),
-                t20.identifier(varName)
+        t21.variableDeclaration("const", [
+          t21.variableDeclarator(
+            t21.objectPattern([
+              t21.objectProperty(
+                t21.identifier("data"),
+                t21.identifier(varName)
               )
             ]),
-            t20.callExpression(t20.identifier("useQuery"), args2)
+            t21.callExpression(t21.identifier("useQuery"), args2)
           )
         ])
       );
@@ -8308,13 +9238,13 @@ function emitQueryDeclarations(metadata, imports) {
         addImport2(imports, modelPath, `default as ${modelVarName2}`);
         addedModelImports?.add(slug);
       }
-      const mutTarget = modelVarName2 ? t20.identifier(modelVarName2) : t20.stringLiteral(slug);
+      const mutTarget = modelVarName2 ? t21.identifier(modelVarName2) : t21.stringLiteral(slug);
       const varName = `${toCamelCase2(slug.replace(/-/g, "_"))}Mutation`;
       statements.push(
-        t20.variableDeclaration("const", [
-          t20.variableDeclarator(
-            t20.identifier(varName),
-            t20.callExpression(t20.identifier("useMutation"), [mutTarget])
+        t21.variableDeclaration("const", [
+          t21.variableDeclarator(
+            t21.identifier(varName),
+            t21.callExpression(t21.identifier("useMutation"), [mutTarget])
           )
         ])
       );
@@ -8329,9 +9259,9 @@ function emitChangeWatchers(metadata, imports) {
   const statements = [];
   for (const watcher of watchers) {
     statements.push(
-      t20.expressionStatement(
-        t20.callExpression(t20.identifier("useOnChange"), [
-          t20.stringLiteral(watcher.field),
+      t21.expressionStatement(
+        t21.callExpression(t21.identifier("useOnChange"), [
+          t21.stringLiteral(watcher.field),
           emitActionCallback(watcher.actions)
         ])
       )
@@ -8355,9 +9285,9 @@ function emitEventSubscriptions(onEvent, imports) {
       }
     }));
     statements.push(
-      t20.expressionStatement(
-        t20.callExpression(t20.identifier("useOnEvent"), [
-          t20.stringLiteral(sub.match),
+      t21.expressionStatement(
+        t21.callExpression(t21.identifier("useOnEvent"), [
+          t21.stringLiteral(sub.match),
           emitActionCallback(actions)
         ])
       )
@@ -8372,9 +9302,9 @@ function emitTransitionEffects(metadata, imports) {
   const statements = [];
   for (const effect of effects) {
     statements.push(
-      t20.expressionStatement(
-        t20.callExpression(t20.identifier("useOnTransition"), [
-          t20.stringLiteral(effect.transition),
+      t21.expressionStatement(
+        t21.callExpression(t21.identifier("useOnTransition"), [
+          t21.stringLiteral(effect.transition),
           emitActionCallback(effect.actions)
         ])
       )
@@ -8403,20 +9333,20 @@ function emitLocalDefaultDeclarations(experience, existingFields, imports) {
     const setter = `set${toPascalCase(key)}`;
     let defaultExpr;
     if (value === void 0 || value === null) {
-      defaultExpr = t20.identifier("undefined");
+      defaultExpr = t21.identifier("undefined");
     } else if (typeof value === "string" && /^[a-zA-Z]\w*$/.test(value) && value !== key) {
-      defaultExpr = t20.identifier("undefined");
+      defaultExpr = t21.identifier("undefined");
     } else {
       defaultExpr = valueToExpression(value);
     }
     statements.push(
-      t20.variableDeclaration("const", [
-        t20.variableDeclarator(
-          t20.arrayPattern([
-            t20.identifier(camelName),
-            t20.identifier(setter)
+      t21.variableDeclaration("const", [
+        t21.variableDeclarator(
+          t21.arrayPattern([
+            t21.identifier(camelName),
+            t21.identifier(setter)
           ]),
-          t20.callExpression(t20.identifier("useState"), [defaultExpr])
+          t21.callExpression(t21.identifier("useState"), [defaultExpr])
         )
       ])
     );
@@ -8444,31 +9374,31 @@ function normalizeFrom(from) {
 function correctFromFields(transitions) {
   if (transitions.length <= 1) return transitions;
   const fromValues = /* @__PURE__ */ new Set();
-  for (const t22 of transitions) {
-    const arr = normalizeFrom(t22.from);
+  for (const t23 of transitions) {
+    const arr = normalizeFrom(t23.from);
     for (const f of arr) fromValues.add(f);
   }
   if (fromValues.size !== 1) return transitions;
   const stateNames = /* @__PURE__ */ new Set([...fromValues]);
-  for (const t22 of transitions) {
-    stateNames.add(t22.to);
+  for (const t23 of transitions) {
+    stateNames.add(t23.to);
   }
-  const allNamesAreStates = transitions.every((t22) => stateNames.has(t22.name));
+  const allNamesAreStates = transitions.every((t23) => stateNames.has(t23.name));
   if (!allNamesAreStates) return transitions;
-  return transitions.map((t22) => ({
-    ...t22,
-    from: [t22.name]
+  return transitions.map((t23) => ({
+    ...t23,
+    from: [t23.name]
   }));
 }
 function addImport2(tracker, source, name) {
   if (!tracker.has(source)) tracker.set(source, /* @__PURE__ */ new Set());
   tracker.get(source).add(name);
 }
-var t20;
+var t21;
 var init_state_emitter = __esm({
   "src/decompiler/state-emitter.ts"() {
     "use strict";
-    t20 = __toESM(require("@babel/types"));
+    t21 = __toESM(require("@babel/types"));
     init_sx_emitter();
   }
 });
@@ -8661,12 +9591,12 @@ function emitImportStatements(tracker) {
     for (const name of names) {
       if (name.startsWith("default as ")) {
         const localName = name.slice("default as ".length);
-        specifiers.push(t21.importDefaultSpecifier(t21.identifier(localName)));
+        specifiers.push(t22.importDefaultSpecifier(t22.identifier(localName)));
       } else {
-        specifiers.push(t21.importSpecifier(t21.identifier(name), t21.identifier(name)));
+        specifiers.push(t22.importSpecifier(t22.identifier(name), t22.identifier(name)));
       }
     }
-    result.push(t21.importDeclaration(specifiers, t21.stringLiteral(source)));
+    result.push(t22.importDeclaration(specifiers, t22.stringLiteral(source)));
   }
   return result;
 }
@@ -8721,24 +9651,24 @@ function decompile(definition, options) {
   componentBody.push(...effectHookStmts);
   if (definition.experience) {
     const jsxTree = buildJSXTree(definition.experience, imports, symbols);
-    componentBody.push(t21.returnStatement(jsxTree));
+    componentBody.push(t22.returnStatement(jsxTree));
   } else {
-    componentBody.push(t21.returnStatement(t21.nullLiteral()));
+    componentBody.push(t22.returnStatement(t22.nullLiteral()));
   }
-  const func = t21.functionDeclaration(
-    t21.identifier(componentName),
+  const func = t22.functionDeclaration(
+    t22.identifier(componentName),
     [],
-    t21.blockStatement(componentBody)
+    t22.blockStatement(componentBody)
   );
   const programBody = [];
   programBody.push(...emitImportStatements(imports));
-  const exportDecl = t21.exportDefaultDeclaration(func);
+  const exportDecl = t22.exportDefaultDeclaration(func);
   if (includeAnnotation) {
-    t21.addComment(exportDecl, "leading", buildWorkflowAnnotation(definition), false);
+    t22.addComment(exportDecl, "leading", buildWorkflowAnnotation(definition), false);
   }
   programBody.push(exportDecl);
-  const program2 = t21.program(programBody);
-  const file2 = t21.file(program2);
+  const program2 = t22.program(programBody);
+  const file2 = t22.file(program2);
   const { code } = (0, import_generator.default)(file2, {
     retainLines: false,
     compact: false,
@@ -8750,11 +9680,11 @@ function decompile(definition, options) {
     componentName
   };
 }
-var t21, import_generator;
+var t22, import_generator;
 var init_decompiler = __esm({
   "src/decompiler/index.ts"() {
     "use strict";
-    t21 = __toESM(require("@babel/types"));
+    t22 = __toESM(require("@babel/types"));
     import_generator = __toESM(require("@babel/generator"));
     init_ast_builder();
     init_state_emitter();
@@ -8783,18 +9713,18 @@ function camelCase(str) {
 function correctTransitionFromFields(transitions) {
   if (transitions.length <= 1) return transitions;
   const fromValues = /* @__PURE__ */ new Set();
-  for (const t22 of transitions) {
-    const arr = Array.isArray(t22.from) ? t22.from : [t22.from];
+  for (const t23 of transitions) {
+    const arr = Array.isArray(t23.from) ? t23.from : [t23.from];
     for (const f of arr) fromValues.add(f);
   }
   if (fromValues.size !== 1) return transitions;
   const stateNames = /* @__PURE__ */ new Set([...fromValues]);
-  for (const t22 of transitions) {
-    stateNames.add(t22.to);
+  for (const t23 of transitions) {
+    stateNames.add(t23.to);
   }
-  const allNamesAreStates = transitions.every((t22) => stateNames.has(t22.name));
+  const allNamesAreStates = transitions.every((t23) => stateNames.has(t23.name));
   if (!allNamesAreStates) return transitions;
-  return transitions.map((t22) => ({ ...t22, from: [t22.name] }));
+  return transitions.map((t23) => ({ ...t23, from: [t23.name] }));
 }
 function fieldTypeToTS(fieldType, field) {
   const options = getFieldOptions(field);
@@ -8915,6 +9845,134 @@ function serializeDefault(value) {
   }
   return JSON.stringify(value);
 }
+function serializeValue(value, indent2) {
+  const pad = " ".repeat(indent2);
+  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 "[]";
+    if (value.every((v) => typeof v === "string" || typeof v === "number" || typeof v === "boolean")) {
+      return `[${value.map((v) => serializeValue(v, 0)).join(", ")}]`;
+    }
+    const items = value.map((v) => `${pad}  ${serializeValue(v, indent2 + 2)},`);
+    return `[
+${items.join("\n")}
+${pad}]`;
+  }
+  if (typeof value === "object") {
+    return serializeObject(value, indent2);
+  }
+  return JSON.stringify(value);
+}
+function serializeObject(obj, indent2) {
+  const pad = " ".repeat(indent2);
+  const entries = Object.entries(obj).filter(([, v]) => v !== void 0);
+  if (entries.length === 0) return "{}";
+  const simple = entries.every(([, v]) => typeof v === "string" || typeof v === "number" || typeof v === "boolean" || v === null);
+  if (simple && entries.length <= 3) {
+    const parts = entries.map(([k, v]) => `${safeKey(k)}: ${serializeValue(v, 0)}`);
+    return `{ ${parts.join(", ")} }`;
+  }
+  const lines = entries.map(([k, v]) => `${pad}  ${safeKey(k)}: ${serializeValue(v, indent2 + 2)},`);
+  return `{
+${lines.join("\n")}
+${pad}}`;
+}
+function serializeActions(actions, indent2) {
+  const pad = " ".repeat(indent2);
+  if (!actions || actions.length === 0) return [];
+  const lines = [];
+  lines.push(`${pad}[`);
+  for (const action of actions) {
+    const inner = indent2 + 2;
+    const ip = " ".repeat(inner);
+    lines.push(`${ip}{`);
+    if (action.id) lines.push(`${ip}  id: '${esc2(String(action.id))}',`);
+    if (action.type) lines.push(`${ip}  type: '${esc2(String(action.type))}',`);
+    if (action.mode) lines.push(`${ip}  mode: '${esc2(String(action.mode))}',`);
+    if (action.condition) lines.push(`${ip}  condition: '${esc2(String(action.condition))}',`);
+    if (action.config && typeof action.config === "object" && Object.keys(action.config).length > 0) {
+      lines.push(`${ip}  config: ${serializeValue(action.config, inner + 2)},`);
+    }
+    lines.push(`${ip}},`);
+  }
+  lines.push(`${pad}]`);
+  return lines;
+}
+function serializeConditions(conditions, indent2) {
+  const pad = " ".repeat(indent2);
+  if (!conditions || conditions.length === 0) return [];
+  const lines = [];
+  lines.push(`${pad}[`);
+  for (const cond of conditions) {
+    lines.push(`${" ".repeat(indent2 + 2)}${serializeObject(cond, indent2 + 2)},`);
+  }
+  lines.push(`${pad}]`);
+  return lines;
+}
+function serializeDuring(during, indent2) {
+  const pad = " ".repeat(indent2);
+  if (!during || during.length === 0) return [];
+  const lines = [];
+  lines.push(`${pad}[`);
+  for (const d of during) {
+    const inner = indent2 + 2;
+    const ip = " ".repeat(inner);
+    lines.push(`${ip}{`);
+    if (d.id) lines.push(`${ip}  id: '${esc2(String(d.id))}',`);
+    if (d.type) lines.push(`${ip}  type: '${esc2(String(d.type))}',`);
+    if (d.schedule && typeof d.schedule === "object") {
+      lines.push(`${ip}  schedule: ${serializeValue(d.schedule, inner + 2)},`);
+    }
+    if (d.interval_ms != null) lines.push(`${ip}  interval_ms: ${d.interval_ms},`);
+    if (d.cron) lines.push(`${ip}  cron: '${esc2(String(d.cron))}',`);
+    if (d.delay_ms != null) lines.push(`${ip}  delay_ms: ${d.delay_ms},`);
+    if (d.condition) lines.push(`${ip}  condition: '${esc2(String(d.condition))}',`);
+    if (d.actions && Array.isArray(d.actions) && d.actions.length > 0) {
+      const actLines = serializeActions(d.actions, inner + 2);
+      lines.push(`${ip}  actions: ${actLines[0]?.trim()}`);
+      for (let i = 1; i < actLines.length; i++) lines.push(actLines[i]);
+      const lastIdx = lines.length - 1;
+      if (!lines[lastIdx].trimEnd().endsWith(",")) lines[lastIdx] += ",";
+    }
+    lines.push(`${ip}},`);
+  }
+  lines.push(`${pad}]`);
+  return lines;
+}
+function serializeOnEvent(events, indent2) {
+  const pad = " ".repeat(indent2);
+  if (!events || events.length === 0) return [];
+  const lines = [];
+  lines.push(`${pad}[`);
+  for (const evt of events) {
+    const inner = indent2 + 2;
+    const ip = " ".repeat(inner);
+    lines.push(`${ip}{`);
+    if (evt.match) lines.push(`${ip}  match: '${esc2(String(evt.match))}',`);
+    if (evt.description) lines.push(`${ip}  description: '${esc2(String(evt.description))}',`);
+    if (evt.conditions && Array.isArray(evt.conditions) && evt.conditions.length > 0) {
+      const conds = evt.conditions.map((c) => `'${esc2(c)}'`);
+      if (conds.length === 1) {
+        lines.push(`${ip}  conditions: [${conds[0]}],`);
+      } else {
+        lines.push(`${ip}  conditions: [`);
+        for (const c of conds) lines.push(`${ip}    ${c},`);
+        lines.push(`${ip}  ],`);
+      }
+    }
+    if (evt.actions && Array.isArray(evt.actions) && evt.actions.length > 0) {
+      const actLines = serializeActions(evt.actions, inner + 2);
+      lines.push(`${ip}  actions: ${actLines[0]?.trim()}`);
+      for (let i = 1; i < actLines.length; i++) lines.push(actLines[i]);
+      if (!lines[lines.length - 1].trimEnd().endsWith(",")) lines[lines.length - 1] += ",";
+    }
+    lines.push(`${ip}},`);
+  }
+  lines.push(`${pad}]`);
+  return lines;
+}
 function generateModelFile(slug, fields, states, transitions, meta) {
   const typeName = pascalCase3(slug);
   const interfaceName = `${typeName}Fields`;
@@ -8968,17 +10026,49 @@ function generateModelFile(slug, fields, states, transitions, meta) {
     const sortedStates = [...validStates].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 hasOnEnter = state.on_enter && state.on_enter.length > 0;
+      const hasOnExit = state.on_exit && state.on_exit.length > 0;
+      const hasDuring = state.during && state.during.length > 0;
+      const hasOnEvent = state.on_event && state.on_event.length > 0;
+      const hasLifecycle = hasOnEnter || hasOnExit || hasDuring || hasOnEvent;
+      if (!hasLifecycle) {
+        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}},`);
+        continue;
       }
-      const body = props.length > 0 ? ` ${props.join(", ")} ` : "";
-      lines.push(`    ${safeKey(state.name)}: {${body}},`);
+      lines.push(`    ${safeKey(state.name)}: {`);
+      if (state.type === "START") lines.push(`      type: 'initial',`);
+      else if (state.type === "END") lines.push(`      type: 'final',`);
+      if (state.description) lines.push(`      description: '${esc2(state.description)}',`);
+      if (hasOnEnter) {
+        const actLines = serializeActions(state.on_enter, 8);
+        lines.push(`      on_enter: ${actLines[0]?.trim()}`);
+        for (let i = 1; i < actLines.length; i++) lines.push(actLines[i]);
+        if (!lines[lines.length - 1].trimEnd().endsWith(",")) lines[lines.length - 1] += ",";
+      }
+      if (hasOnExit) {
+        const actLines = serializeActions(state.on_exit, 8);
+        lines.push(`      on_exit: ${actLines[0]?.trim()}`);
+        for (let i = 1; i < actLines.length; i++) lines.push(actLines[i]);
+        if (!lines[lines.length - 1].trimEnd().endsWith(",")) lines[lines.length - 1] += ",";
+      }
+      if (hasDuring) {
+        const durLines = serializeDuring(state.during, 8);
+        lines.push(`      during: ${durLines[0]?.trim()}`);
+        for (let i = 1; i < durLines.length; i++) lines.push(durLines[i]);
+        if (!lines[lines.length - 1].trimEnd().endsWith(",")) lines[lines.length - 1] += ",";
+      }
+      if (hasOnEvent) {
+        const evtLines = serializeOnEvent(state.on_event, 8);
+        lines.push(`      on_event: ${evtLines[0]?.trim()}`);
+        for (let i = 1; i < evtLines.length; i++) lines.push(evtLines[i]);
+        if (!lines[lines.length - 1].trimEnd().endsWith(",")) lines[lines.length - 1] += ",";
+      }
+      lines.push(`    },`);
     }
     lines.push(`  },`);
   }
@@ -8988,23 +10078,51 @@ function generateModelFile(slug, fields, states, transitions, meta) {
     lines.push(`  transitions: {`);
     for (const trans of sortedTrans) {
       const fromArr = Array.isArray(trans.from) ? trans.from : [trans.from];
-      const parts = [];
+      const hasConditions = trans.conditions && trans.conditions.length > 0;
+      const hasActions = trans.actions && trans.actions.length > 0;
+      const hasRichContent = hasConditions || hasActions;
+      if (!hasRichContent) {
+        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(", ")} },`);
+        continue;
+      }
+      lines.push(`    ${safeKey(trans.name)}: {`);
       if (fromArr.length === 1) {
-        parts.push(`from: '${esc2(fromArr[0])}'`);
+        lines.push(`      from: '${esc2(fromArr[0])}',`);
       } else {
-        parts.push(`from: [${fromArr.map((f) => `'${esc2(f)}'`).join(", ")}]`);
+        lines.push(`      from: [${fromArr.map((f) => `'${esc2(f)}'`).join(", ")}],`);
       }
-      parts.push(`to: '${esc2(trans.to)}'`);
+      lines.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`);
+        lines.push(`      roles: [${trans.roles.map((r) => `'${esc2(r)}'`).join(", ")}],`);
       }
+      if (trans.auto) lines.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(`      required_fields: [${trans.required_fields.map((f) => `'${esc2(f)}'`).join(", ")}],`);
+      }
+      if (hasConditions) {
+        const condLines = serializeConditions(trans.conditions, 8);
+        lines.push(`      conditions: ${condLines[0]?.trim()}`);
+        for (let i = 1; i < condLines.length; i++) lines.push(condLines[i]);
+        if (!lines[lines.length - 1].trimEnd().endsWith(",")) lines[lines.length - 1] += ",";
       }
-      lines.push(`    ${safeKey(trans.name)}: { ${parts.join(", ")} },`);
+      if (hasActions) {
+        const actLines = serializeActions(trans.actions, 8);
+        lines.push(`      actions: ${actLines[0]?.trim()}`);
+        for (let i = 1; i < actLines.length; i++) lines.push(actLines[i]);
+        if (!lines[lines.length - 1].trimEnd().endsWith(",")) lines[lines.length - 1] += ",";
+      }
+      lines.push(`    },`);
     }
     lines.push(`  },`);
   }
@@ -9406,8 +10524,22 @@ function generateMainWithPages(definition, pages, childViews) {
   delete strippedMeta.queries;
   delete strippedMeta.mutations;
   delete strippedMeta.mutationTargets;
+  const strippedStates = definition.states.map((s) => ({
+    ...s,
+    on_enter: [],
+    on_exit: [],
+    during: [],
+    on_event: void 0
+  }));
+  const strippedTransitions = definition.transitions.map((t23) => ({
+    ...t23,
+    actions: [],
+    conditions: void 0
+  }));
   const modifiedDef = {
     ...definition,
+    states: strippedStates,
+    transitions: strippedTransitions,
     experience: mainTree,
     metadata: strippedMeta
   };
@@ -9622,6 +10754,70 @@ ${typedProps.join("\n")}
   }
   return result.code;
 }
+function generateActionFile(child) {
+  const isSimple = isSimpleActionDefinition(child);
+  if (isSimple) {
+    return generateSimpleActionFile(child);
+  }
+  return generateModelFile(
+    child.slug,
+    child.fields,
+    child.states,
+    child.transitions,
+    {
+      version: child.version,
+      category: "action",
+      description: child.description
+    }
+  );
+}
+function isSimpleActionDefinition(child) {
+  const stateNames = child.states.map((s) => s.name);
+  const hasReady = stateNames.includes("ready");
+  const hasDone = stateNames.includes("done");
+  if (!hasReady || !hasDone || stateNames.length !== 2) return false;
+  if (child.transitions.length !== 1) return false;
+  const exec = child.transitions[0];
+  if (exec.name !== "execute") return false;
+  if (exec.actions.length !== 1) return false;
+  const action = exec.actions[0];
+  if (action.type !== "eval") return false;
+  const config = action.config;
+  return typeof config.expression === "string";
+}
+function generateSimpleActionFile(child) {
+  const exec = child.transitions[0];
+  const evalAction = exec.actions[0];
+  const expression = String(evalAction.config.expression || "");
+  const params = child.fields.map((f) => {
+    const paramName = camelCase(f.name);
+    const tsType = fieldTypeToTS(f.type, f);
+    const optional = f.required === false ? "?" : "";
+    return `${paramName}${optional}: ${tsType}`;
+  });
+  const funcName = camelCase(child.slug);
+  const meta = child.metadata;
+  const sourceFn = typeof meta?.source_function === "string" ? meta.source_function : funcName;
+  const returnType = typeof meta?.return_type === "string" ? meta.return_type : "void";
+  const lines = [];
+  const bodyLines = expression.split("\n").map((l) => `  ${l}`).join("\n");
+  lines.push(`/**`);
+  if (child.description) {
+    lines.push(` * ${child.description}`);
+  } else {
+    lines.push(` * ${child.name || sourceFn}`);
+  }
+  lines.push(` */`);
+  lines.push(`export default function ${sourceFn}(${params.join(", ")}): ${returnType} {`);
+  if (bodyLines.trim()) {
+    lines.push(bodyLines);
+  } else {
+    lines.push(`  // TODO: implement`);
+  }
+  lines.push(`}`);
+  lines.push(``);
+  return lines.join("\n");
+}
 function emitServerActionsFromMetadata(definition, files) {
   const meta = definition.metadata;
   const serverActions = meta?.serverActions;
@@ -9685,10 +10881,10 @@ function reduceRouterTransitions(transitions, states) {
   }
   const kept = [];
   const seenKeys = /* @__PURE__ */ new Set();
-  for (const t22 of transitions) {
-    const fromArr = Array.isArray(t22.from) ? t22.from : [t22.from];
+  for (const t23 of transitions) {
+    const fromArr = Array.isArray(t23.from) ? t23.from : [t23.from];
     const fromState = fromArr[0];
-    const toState = t22.to;
+    const toState = t23.to;
     if (!fromState || !stateNames.has(fromState) || !stateNames.has(toState)) continue;
     const fromRole = fromState.split("_")[0];
     const toRole = toState.split("_")[0];
@@ -9698,7 +10894,7 @@ function reduceRouterTransitions(transitions, states) {
     const crossRoleHome = homeStates.has(fromState) && homeStates.has(toState);
     if (sameRole || crossRoleHome) {
       seenKeys.add(key);
-      kept.push(t22);
+      kept.push(t23);
     }
   }
   return kept;
@@ -9830,11 +11026,11 @@ function decompileProjectEnhanced(definition) {
             }
           }
         }
-        const transNames = new Set(existing.transitions.map((t22) => t22.name));
-        for (const t22 of child.transitions) {
-          if (!transNames.has(t22.name)) {
-            existing.transitions.push(t22);
-            transNames.add(t22.name);
+        const transNames = new Set(existing.transitions.map((t23) => t23.name));
+        for (const t23 of child.transitions) {
+          if (!transNames.has(t23.name)) {
+            existing.transitions.push(t23);
+            transNames.add(t23.name);
           }
         }
         if (child.version && child.version !== "0.1.0" && (!existing.version || existing.version === "0.1.0")) {
@@ -9851,7 +11047,18 @@ function decompileProjectEnhanced(definition) {
   }
   for (const [childSlug, child] of mergedChildren) {
     const isRouter = childSlug.endsWith("-router") || child.category === "router";
+    const isAction = child.category === "action";
     const childTransitions = isRouter ? reduceRouterTransitions(child.transitions, child.states) : child.transitions;
+    if (isAction) {
+      const actionFilePath = `actions/${childSlug}.ts`;
+      files.push({
+        path: actionFilePath,
+        role: "model",
+        content: generateActionFile({ ...child, transitions: childTransitions })
+      });
+      actionPaths.push(actionFilePath);
+      continue;
+    }
     if (child.fields.length > 0 && !emittedModelSlugs.has(childSlug)) {
       const childModelPath = `models/${childSlug}.ts`;
       files.push({
@@ -9891,7 +11098,23 @@ function decompileProjectEnhanced(definition) {
     const mainContent = generateMainWithPages(definition, extractedPages, extractedChildViews);
     files.push({ path: mainPath, role: "view-entry", content: mainContent });
   } else {
-    const mainResult = decompile(definition);
+    const mainDef = decision.emitModels ? {
+      ...definition,
+      states: definition.states.map((s) => ({
+        ...s,
+        on_enter: [],
+        on_exit: [],
+        during: [],
+        on_event: void 0
+      })),
+      // Also strip transition actions — model file has them
+      transitions: definition.transitions.map((t23) => ({
+        ...t23,
+        actions: [],
+        conditions: void 0
+      }))
+    } : definition;
+    const mainResult = decompile(mainDef);
     files.push({ path: mainPath, role: "view-entry", content: mainResult.code });
   }
   entryPaths.push(mainPath);
@@ -10339,7 +11562,12 @@ function generatePackageJson2(name) {
         deploy: "mmrc deploy --build --src ."
       },
       dependencies: {
-        "@mindmatrix/react": "workspace:*"
+        "@mmapp/react": "^0.1.0-alpha.1"
+      },
+      devDependencies: {
+        typescript: "^5.5.0",
+        "@types/react": "^18.0.0",
+        react: "^18.0.0"
       }
     },
     null,
@@ -10351,7 +11579,7 @@ function generateMmConfig2(name, opts) {
   const desc = opts.description ?? `${title} blueprint.`;
   const icon = opts.icon ?? "box";
   const author = opts.author ?? "MindMatrix";
-  return `import { defineBlueprint } from '@mindmatrix/react';
+  return `import { defineBlueprint } from '@mmapp/react';
 
 export default defineBlueprint({
   slug: '${name}',
@@ -10384,7 +11612,7 @@ function generateModel(name) {
  * States: draft \u2192 active \u2192 archived
  */
 
-import { defineModel } from '@mindmatrix/react';
+import { defineModel } from '@mmapp/react';
 
 export interface ${pascal}ItemFields {
   title: string;
@@ -10437,6 +11665,28 @@ export default defineModel({
 });
 `;
 }
+function generateTsconfig() {
+  return JSON.stringify(
+    {
+      compilerOptions: {
+        target: "ES2020",
+        module: "ESNext",
+        moduleResolution: "bundler",
+        jsx: "react-jsx",
+        strict: true,
+        esModuleInterop: true,
+        skipLibCheck: true,
+        forceConsistentCasingInFileNames: true,
+        declaration: false,
+        noEmit: true
+      },
+      include: ["**/*.ts", "**/*.tsx"],
+      exclude: ["node_modules", "dist"]
+    },
+    null,
+    2
+  );
+}
 function generateLayout(name) {
   const title = toTitleCase(name);
   return `/**
@@ -10453,8 +11703,8 @@ import {
   Icon,
   Button,
   Divider,
-} from '@mindmatrix/react/atoms';
-import { useRouter } from '@mindmatrix/react';
+} from '@mmapp/react/atoms';
+import { useRouter } from '@mmapp/react';
 
 export default function Layout({ children }: { children: React.ReactNode }) {
   const router = useRouter();
@@ -10513,11 +11763,12 @@ function generatePage(name) {
  * Index page \u2014 lists items with create and search.
  */
 
+import { useState } from 'react';
 import itemModel from '../models/item';
 import {
-  useQuery, useMutation, useRouter, useState,
-  Stack, Row, Text, Button, Icon, Card, Show, Each, TextInput, Badge,
-} from '@mindmatrix/react';
+  useQuery, useMutation, useRouter,
+  Stack, Row, Text, Button, Icon, Card, Show, TextInput, Badge,
+} from '@mmapp/react';
 
 const PRIORITY_COLORS: Record<string, string> = {
   high: 'token:error',
@@ -10588,22 +11839,20 @@ export default function ${pascal}Home() {
       {/* Item list */}
       <Show when={!loading && filtered.length > 0}>
         <Stack gap={4}>
-          <Each items={filtered} keyField="id">
-            {(item) => (
-              <Card padding={12}>
-                <Row align="center" gap={12}>
-                  <Stack flex={1} gap={2}>
-                    <Text weight="medium" value={item.fields.title} />
-                    <Show when={!!item.fields.description}>
-                      <Text size="sm" variant="muted" value={item.fields.description} />
-                    </Show>
-                  </Stack>
-                  <Badge value={item.fields.priority} />
-                  <Badge value={item.state} variant={item.state === 'active' ? 'success' : 'default'} />
-                </Row>
-              </Card>
-            )}
-          </Each>
+          {filtered.map((item: any) => (
+            <Card key={item.id} padding={12}>
+              <Row align="center" gap={12}>
+                <Stack flex={1} gap={2}>
+                  <Text weight="medium" value={item.fields.title} />
+                  <Show when={!!item.fields.description}>
+                    <Text size="sm" variant="muted" value={item.fields.description} />
+                  </Show>
+                </Stack>
+                <Badge value={item.fields.priority} />
+                <Badge value={item.state} variant={item.state === 'active' ? 'success' : 'default'} />
+              </Row>
+            </Card>
+          ))}
         </Stack>
       </Show>
     </Stack>
@@ -10630,6 +11879,7 @@ async function init(options) {
   (0, import_fs7.mkdirSync)((0, import_path6.join)(blueprintDir, "app"), { recursive: true });
   const files = [
     ["package.json", generatePackageJson2(name)],
+    ["tsconfig.json", generateTsconfig()],
     ["mm.config.ts", generateMmConfig2(name, options)],
     ["models/item.ts", generateModel(name)],
     ["app/layout.tsx", generateLayout(name)],
@@ -10831,7 +12081,7 @@ async function test(options = {}) {
   const t1 = performance.now();
   console.log(` \u2713 (${((t1 - t0) / 1e3).toFixed(1)}s)`);
   process.stdout.write(`  Decompiling IR...`);
-  const t22 = performance.now();
+  const t23 = performance.now();
   let decompFiles;
   try {
     const decompInput = {
@@ -10850,7 +12100,7 @@ async function test(options = {}) {
     process.exit(1);
   }
   const t32 = performance.now();
-  console.log(` \u2713 (${((t32 - t22) / 1e3).toFixed(1)}s)`);
+  console.log(` \u2713 (${((t32 - t23) / 1e3).toFixed(1)}s)`);
   process.stdout.write(`  Recompiling...`);
   const t42 = performance.now();
   let ir2;
@@ -10916,7 +12166,7 @@ async function test(options = {}) {
     diffs,
     timings: {
       compile: t1 - t0,
-      decompile: t32 - t22,
+      decompile: t32 - t23,
       recompile: t52 - t42,
       compare: t72 - t62
     }
@@ -10945,11 +12195,11 @@ function compareFields(diffs, fields1, fields2) {
   }
   return { fieldMatch, fieldCount };
 }
-function isCompatibleType(t1, t22) {
+function isCompatibleType(t1, t23) {
   const stringTypes = /* @__PURE__ */ new Set(["text", "rich_text", "email", "url", "phone", "color", "select"]);
   const numberTypes = /* @__PURE__ */ new Set(["number", "currency", "percentage", "rating", "duration"]);
-  if (stringTypes.has(t1) && stringTypes.has(t22)) return true;
-  if (numberTypes.has(t1) && numberTypes.has(t22)) return true;
+  if (stringTypes.has(t1) && stringTypes.has(t23)) return true;
+  if (numberTypes.has(t1) && numberTypes.has(t23)) return true;
   return false;
 }
 function compareStates(diffs, states1, states2) {
@@ -11001,8 +12251,8 @@ function compareStates(diffs, states1, states2) {
   return { stateMatch, stateCount };
 }
 function compareTransitions(diffs, transitions1, transitions2) {
-  const map1 = new Map(transitions1.map((t22) => [t22.name, t22]));
-  const map2 = new Map(transitions2.map((t22) => [t22.name, t22]));
+  const map1 = new Map(transitions1.map((t23) => [t23.name, t23]));
+  const map2 = new Map(transitions2.map((t23) => [t23.name, t23]));
   const transitionCount = map1.size;
   let transitionMatch = 0;
   if (transitions1.length !== transitions2.length) {
@@ -11014,36 +12264,36 @@ function compareTransitions(diffs, transitions1, transitions2) {
     });
   }
   for (const [name, t1] of map1) {
-    const t22 = map2.get(name);
-    if (!t22) {
+    const t23 = map2.get(name);
+    if (!t23) {
       diffs.push({ path: `transitions[${name}]`, expected: name, actual: void 0, severity: "error" });
       continue;
     }
     let matched = true;
-    if (t1.to !== t22.to) {
-      diffs.push({ path: `transitions[${name}].to`, expected: t1.to, actual: t22.to, severity: "error" });
+    if (t1.to !== t23.to) {
+      diffs.push({ path: `transitions[${name}].to`, expected: t1.to, actual: t23.to, severity: "error" });
       matched = false;
     }
     const from1 = [...t1.from].sort();
-    const from2 = [...t22.from].sort();
+    const from2 = [...t23.from].sort();
     if (JSON.stringify(from1) !== JSON.stringify(from2)) {
       diffs.push({ path: `transitions[${name}].from`, expected: from1, actual: from2, severity: "error" });
       matched = false;
     }
     const roles1 = [...t1.roles ?? []].sort();
-    const roles2 = [...t22.roles ?? []].sort();
+    const roles2 = [...t23.roles ?? []].sort();
     if (JSON.stringify(roles1) !== JSON.stringify(roles2)) {
       diffs.push({ path: `transitions[${name}].roles`, expected: roles1, actual: roles2, severity: "error" });
       matched = false;
     }
     const req1 = [...t1.required_fields ?? []].sort();
-    const req2 = [...t22.required_fields ?? []].sort();
+    const req2 = [...t23.required_fields ?? []].sort();
     if (JSON.stringify(req1) !== JSON.stringify(req2)) {
       diffs.push({ path: `transitions[${name}].required_fields`, expected: req1, actual: req2, severity: "error" });
       matched = false;
     }
-    if (!!t1.auto !== !!t22.auto) {
-      diffs.push({ path: `transitions[${name}].auto`, expected: t1.auto, actual: t22.auto, severity: "error" });
+    if (!!t1.auto !== !!t23.auto) {
+      diffs.push({ path: `transitions[${name}].auto`, expected: t1.auto, actual: t23.auto, severity: "error" });
       matched = false;
     }
     if (matched) transitionMatch++;