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

package/dist/index.js

@@ -445,25 +445,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 +651,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 init = d.init ? ctx.visit(d.init) : "null";
+      const lhs = declaratorPattern(d.id);
+      return `${keyword} ${lhs} = ${init}`;
+    });
+    return decls.join(";\n") + ";";
+  }
+  if (t5.isIfStatement(stmt)) {
+    const test = ctx.visit(stmt.test);
+    const consequent = visitBranchBody(stmt.consequent, ctx);
+    if (stmt.alternate) {
+      const alternate = visitBranchBody(stmt.alternate, ctx);
+      return `if (${test}) ${consequent} else ${alternate}`;
+    }
+    return `if (${test}) ${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 test = ctx.visit(stmt.test);
+    const body = visitBranchBody(stmt.body, ctx);
+    return `while (${test}) ${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 +792,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 +815,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 +864,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 +1067,11 @@ var init_ts_to_expression = __esm({
             return this.visitArrayHigherOrder("some", obj, args);
           case "every":
             return this.visitArrayHigherOrder("every", obj, args);
+          // --- Array push: arr.push(item) → arr = push(arr, item) ---
+          case "push": {
+            const [item] = this.visitArgsList(args);
+            return `${obj} = push(${obj}, ${item})`;
+          }
           // --- Array mutation-free methods ---
           case "reverse":
             return `reverse(${obj})`;
@@ -1747,7 +1876,7 @@ var init_component_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];
 }
@@ -2027,6 +2156,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;
@@ -2462,16 +2603,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 = {};
@@ -3255,7 +3396,7 @@ function resolveType(annotation) {
   }
   if (t15.isTSUnionType(annotation)) {
     const allLiterals = annotation.types.every(
-      (t22) => t15.isTSLiteralType(t22) && (t15.isStringLiteral(t22.literal) || t15.isNumericLiteral(t22.literal))
+      (t23) => t15.isTSLiteralType(t23) && (t15.isStringLiteral(t23.literal) || t15.isNumericLiteral(t23.literal))
     );
     if (allLiterals) return "select";
     return "text";
@@ -3629,6 +3770,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 (!t15.isExportDefaultDeclaration(node)) continue;
@@ -3668,17 +3874,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;
         }
       }
     }
@@ -3716,13 +3932,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
@@ -4830,7 +5054,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 = {
@@ -5244,7 +5468,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
@@ -5664,6 +5888,520 @@ var init_action_compiler = __esm({
   }
 });
 
+// src/babel/extractors/action-extractor.ts
+function extractAction(source, filename) {
+  let ast;
+  try {
+    ast = (0, import_parser2.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 (t22.isVariableDeclaration(node)) {
+      for (const decl of node.declarations) {
+        if (t22.isIdentifier(decl.id) && decl.init) {
+          if (t22.isArrowFunctionExpression(decl.init) || t22.isFunctionExpression(decl.init)) {
+            topLevelVars.set(decl.id.name, decl.init);
+          }
+        }
+      }
+    }
+  }
+  for (const node of ast.program.body) {
+    if (t22.isExportDefaultDeclaration(node)) {
+      const decl = node.declaration;
+      if (t22.isFunctionDeclaration(decl) && decl.body) {
+        const name = decl.id?.name ?? inferNameFromFile(decl) ?? "action";
+        return extractFromFunction(name, decl.params, decl.body, decl.returnType, decl.async);
+      }
+      if (t22.isArrowFunctionExpression(decl) || t22.isFunctionExpression(decl)) {
+        const name = t22.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 (t22.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 && t22.isTSTypeAnnotation(returnType) ? serializeTSType(returnType.typeAnnotation) : void 0;
+  return { name, params: extracted, body, returnTypeAnnotation, isAsync };
+}
+function ensureBlock(body) {
+  if (t22.isBlockStatement(body)) return body;
+  const ret = t22.returnStatement(body);
+  return t22.blockStatement([ret]);
+}
+function inferNameFromFile(_node) {
+  return null;
+}
+function extractParam(param) {
+  if (t22.isIdentifier(param)) {
+    return {
+      name: param.name,
+      typeAnnotation: param.typeAnnotation ? param.typeAnnotation.typeAnnotation : null,
+      optional: param.optional ?? false
+    };
+  }
+  if (t22.isAssignmentPattern(param)) {
+    const inner = param.left;
+    if (t22.isIdentifier(inner)) {
+      return {
+        name: inner.name,
+        typeAnnotation: inner.typeAnnotation ? inner.typeAnnotation.typeAnnotation : null,
+        optional: true,
+        defaultValue: param.right
+      };
+    }
+  }
+  if (t22.isRestElement(param)) {
+    const arg = param.argument;
+    return {
+      name: t22.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 (t22.isStringLiteral(expr)) return expr.value;
+  if (t22.isNumericLiteral(expr)) return expr.value;
+  if (t22.isBooleanLiteral(expr)) return expr.value;
+  if (t22.isNullLiteral(expr)) return null;
+  if (t22.isArrayExpression(expr) && expr.elements.length === 0) return [];
+  if (t22.isObjectExpression(expr) && expr.properties.length === 0) return {};
+  return void 0;
+}
+function tsTypeToFieldType2(tsType) {
+  if (t22.isTSStringKeyword(tsType)) return "text";
+  if (t22.isTSNumberKeyword(tsType)) return "number";
+  if (t22.isTSBooleanKeyword(tsType)) return "boolean";
+  if (t22.isTSObjectKeyword(tsType)) return "json";
+  if (t22.isTSAnyKeyword(tsType) || t22.isTSUnknownKeyword(tsType)) return "json";
+  if (t22.isTSArrayType(tsType)) return "json";
+  if (t22.isTSUnionType(tsType)) {
+    const nonNullable = tsType.types.filter(
+      (t23) => !t22.isTSNullKeyword(t23) && !t22.isTSUndefinedKeyword(t23)
+    );
+    if (nonNullable.length === 1) {
+      return tsTypeToFieldType2(nonNullable[0]);
+    }
+    if (nonNullable.every((t23) => t22.isTSLiteralType(t23) && t22.isStringLiteral(t23.literal))) {
+      return "select";
+    }
+    return "text";
+  }
+  if (t22.isTSTypeReference(tsType) && t22.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 (t22.isTSStringKeyword(tsType)) return "string";
+  if (t22.isTSNumberKeyword(tsType)) return "number";
+  if (t22.isTSBooleanKeyword(tsType)) return "boolean";
+  if (t22.isTSVoidKeyword(tsType)) return "void";
+  if (t22.isTSAnyKeyword(tsType)) return "any";
+  if (t22.isTSTypeReference(tsType) && t22.isIdentifier(tsType.typeName)) {
+    return tsType.typeName.name;
+  }
+  if (t22.isTSArrayType(tsType)) return `${serializeTSType(tsType.elementType)}[]`;
+  if (t22.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 (t22.isVariableDeclaration(stmt)) {
+    const decl = stmt.declarations[0];
+    if (decl?.init && t22.isAwaitExpression(decl.init)) {
+      const arg = decl.init.argument;
+      if (t22.isCallExpression(arg)) {
+        return {
+          callee: getCalleeName(arg.callee),
+          args: arg.arguments,
+          binding: t22.isIdentifier(decl.id) ? decl.id.name : void 0
+        };
+      }
+    }
+  }
+  if (t22.isExpressionStatement(stmt) && t22.isAwaitExpression(stmt.expression)) {
+    const arg = stmt.expression.argument;
+    if (t22.isCallExpression(arg)) {
+      return {
+        callee: getCalleeName(arg.callee),
+        args: arg.arguments,
+        binding: void 0
+      };
+    }
+  }
+  if (t22.isReturnStatement(stmt) && stmt.argument && t22.isAwaitExpression(stmt.argument)) {
+    const arg = stmt.argument.argument;
+    if (t22.isCallExpression(arg)) {
+      return {
+        callee: getCalleeName(arg.callee),
+        args: arg.arguments,
+        binding: void 0
+      };
+    }
+  }
+  return null;
+}
+function getCalleeName(callee) {
+  if (t22.isIdentifier(callee)) return callee.name;
+  if (t22.isMemberExpression(callee) && t22.isIdentifier(callee.object) && t22.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 = t22.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 (t22.isObjectExpression(arg)) {
+          for (const prop2 of arg.properties) {
+            if (t22.isObjectProperty(prop2) && t22.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 = t22.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 (t22.isIdentifier(expr)) {
+    const replacement = bindings.get(expr.name);
+    if (replacement) return { expression: replacement };
+    return { expression: `state_data.${toSnakeCase3(expr.name)}` };
+  }
+  if (t22.isMemberExpression(expr) && t22.isIdentifier(expr.object)) {
+    const replacement = bindings.get(expr.object.name);
+    if (replacement && t22.isIdentifier(expr.property)) {
+      return { expression: `${replacement}.${expr.property.name}` };
+    }
+  }
+  if (t22.isStringLiteral(expr)) return { expression: `'${expr.value}'` };
+  if (t22.isNumericLiteral(expr)) return { expression: String(expr.value) };
+  if (t22.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, t22.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_parser2, t22;
+var init_action_extractor = __esm({
+  "src/babel/extractors/action-extractor.ts"() {
+    "use strict";
+    import_parser2 = require("@babel/parser");
+    t22 = __toESM(require("@babel/types"));
+    init_ts_to_expression();
+  }
+});
+
 // src/incremental-compiler.ts
 function hashContent(content) {
   let hash = 5381;
@@ -6017,24 +6755,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) {
@@ -6130,6 +6900,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");
 }
@@ -6146,7 +6919,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 = [];
@@ -6428,10 +7201,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;
@@ -6470,6 +7320,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)) {
@@ -6520,7 +7381,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) => ({
@@ -6596,6 +7461,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 = {};
@@ -6608,6 +7489,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,
@@ -6639,6 +7521,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 = {};
@@ -6753,6 +7649,7 @@ function buildComposedResult(files, fileIRs, config, errors, warnings, options =
       }
     }
   }
+  const typeStubs = generateModuleTypeStubs(childDefinitions, modelResults);
   return {
     ir: parentIR,
     childDefinitions,
@@ -6766,7 +7663,8 @@ function buildComposedResult(files, fileIRs, config, errors, warnings, options =
     importLinks,
     modelResults,
     actionResult,
-    routeResult
+    routeResult,
+    typeStubs
   };
 }
 function compileProject(files, options = {}) {
@@ -6810,6 +7708,7 @@ var init_project_compiler = __esm({
     init_model_compiler();
     init_route_extractor();
     init_action_compiler();
+    init_action_extractor();
     init_incremental_compiler();
     IncrementalProjectCompiler = class {
       constructor() {
@@ -8148,20 +9047,20 @@ 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) {
@@ -9013,7 +9912,7 @@ function compareTransitions(diffs, original, roundTripped) {
       severity: "error"
     });
   }
-  const rtMap = new Map(roundTripped.map((t22) => [t22.name, t22]));
+  const rtMap = new Map(roundTripped.map((t23) => [t23.name, t23]));
   for (const transition of original) {
     const rt = rtMap.get(transition.name);
     if (!rt) {
@@ -9550,10 +10449,10 @@ ${output}`);
       fileMap[rel] = (0, import_fs3.readFileSync)(f, "utf-8");
     }
     (0, import_fs3.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 });
@@ -9562,11 +10461,11 @@ ${output}`);
     for (const warn of warnings) {
       console.warn(`  ! ${warn.file}${warn.line ? `:${warn.line}` : ""} ${warn.message}`);
     }
-    const irPath = (0, import_path2.join)(outDir, `${result.ir.slug}.workflow.json`);
-    (0, import_fs3.writeFileSync)(irPath, JSON.stringify(result.ir, null, 2), "utf-8");
+    const irPath = (0, import_path2.join)(outDir, `${result2.ir.slug}.workflow.json`);
+    (0, import_fs3.writeFileSync)(irPath, JSON.stringify(result2.ir, null, 2), "utf-8");
     console.log(`  + ${(0, import_path2.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);
@@ -9596,14 +10495,14 @@ ${output}`);
   for (const file2 of allFiles) {
     try {
       const code = (0, import_fs3.readFileSync)(file2, "utf-8");
-      const result = (0, import_core6.transformSync)(code, {
+      const result2 = (0, import_core6.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;
@@ -9668,7 +10567,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(() => {
+  });
 }
 
 // src/dev-server.ts