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

package/dist/babel/index.js

@@ -35,7 +35,7 @@ __export(babel_exports, {
 module.exports = __toCommonJS(babel_exports);
 
 // src/babel/visitor.ts
-var t17 = __toESM(require("@babel/types"));
+var t21 = __toESM(require("@babel/types"));
 
 // src/babel/extractors/state-extractor.ts
 var t = __toESM(require("@babel/types"));
@@ -441,25 +441,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((t18) => t18.from.length === 0 || !t18.to);
+  const needsInference = transitions.filter((t22) => t22.from.length === 0 || !t22.to);
   if (needsInference.length === 0) return;
   if (startStates.length === 1 && regularStates.length > 0) {
-    needsInference.forEach((t18, idx) => {
-      if (t18.from.length === 0) {
-        t18.from = [startStates[0].name];
+    needsInference.forEach((t22, idx) => {
+      if (t22.from.length === 0) {
+        t22.from = [startStates[0].name];
       }
-      if (!t18.to) {
-        t18.to = regularStates[idx % regularStates.length]?.name || startStates[0].name;
+      if (!t22.to) {
+        t22.to = regularStates[idx % regularStates.length]?.name || startStates[0].name;
       }
     });
   } else {
     const allStateNames = stateArray.map((s) => s.name);
-    needsInference.forEach((t18, idx) => {
-      if (t18.from.length === 0 && allStateNames.length > 0) {
-        t18.from = [allStateNames[0]];
+    needsInference.forEach((t22, idx) => {
+      if (t22.from.length === 0 && allStateNames.length > 0) {
+        t22.from = [allStateNames[0]];
       }
-      if (!t18.to && allStateNames.length > 1) {
-        t18.to = allStateNames[Math.min(idx + 1, allStateNames.length - 1)];
+      if (!t22.to && allStateNames.length > 1) {
+        t22.to = allStateNames[Math.min(idx + 1, allStateNames.length - 1)];
       }
     });
   }
@@ -649,6 +649,8 @@ var TranspileContext = class {
     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.
@@ -670,6 +672,8 @@ var TranspileContext = class {
       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";
@@ -717,6 +721,9 @@ var TranspileContext = class {
     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));
   }
   // ---------------------------------------------------------------------------
@@ -917,6 +924,11 @@ var TranspileContext = class {
         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})`;
@@ -2752,6 +2764,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;
@@ -2791,17 +2868,29 @@ 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);
+        const stateRuntime = stateConfig.runtime;
         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 } : {},
+            ...stateRuntime ? { runtime: stateRuntime } : {}
           });
         } 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;
         }
       }
     }
@@ -2839,16 +2928,26 @@ 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);
+        const transRuntime = transConfig.runtime;
         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
+          required_fields: transConfig.required_fields,
+          ...transRuntime ? { runtime: transRuntime } : {}
         });
       }
     }
@@ -2865,6 +2964,9 @@ function extractDefineModelCall(programPath, compilerState, actionCounter) {
     if (config.metadata && typeof config.metadata === "object") {
       compilerState.metadata.modelMetadata = config.metadata;
     }
+    if (config.orchestration && typeof config.orchestration === "object" && !Array.isArray(config.orchestration)) {
+      compilerState.metadata.orchestration = config.orchestration;
+    }
     return true;
   }
   return false;
@@ -3039,164 +3141,2020 @@ function extractModelFile(path, state) {
   }
 }
 
-// src/babel/extractors/server-action-extractor.ts
+// src/babel/extractors/flow-extractor.ts
 var t12 = __toESM(require("@babel/types"));
-function isServerActionFile(filename) {
-  if (!filename) return false;
-  return /\.server\.(ts|tsx|js|jsx)$/.test(filename);
+
+// src/babel/extractors/workflow-shorthand.ts
+function makeState(name, type) {
+  return {
+    name,
+    type,
+    on_enter: [],
+    during: [],
+    on_exit: []
+  };
 }
-function extractServerActions(path, state) {
-  const compilerState = state;
-  const serverActions = [];
-  for (const node of path.node.body) {
-    if (t12.isExportNamedDeclaration(node)) {
-      const decl = node.declaration;
-      if (t12.isFunctionDeclaration(decl) && decl.id) {
-        const action = extractFunctionAction(decl);
-        if (action) {
-          const comments = node.leadingComments || decl.leadingComments || [];
-          action.description = extractDescription(comments);
-          serverActions.push(action);
+function makeTransition(name, from, to) {
+  return {
+    name,
+    from: [from],
+    to,
+    actions: []
+  };
+}
+function dedupeTransitions(ts) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const t22 of ts) {
+    const key = `${t22.name}::${t22.from.join(",")}::${t22.to}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      out.push(t22);
+    }
+  }
+  return out;
+}
+var TOKEN_RE = /(<->)|<-(\w+)-|(<-)|(?:-(\w+)->)|(->)|(\|)|([a-zA-Z_]\w*)/g;
+function tokenize(line) {
+  const tokens = [];
+  let m;
+  TOKEN_RE.lastIndex = 0;
+  while ((m = TOKEN_RE.exec(line)) !== null) {
+    if (m[1]) {
+      tokens.push({ kind: "arrow", direction: "bidirectional" });
+    } else if (m[2]) {
+      tokens.push({ kind: "arrow", direction: "backward", name: m[2] });
+    } else if (m[3]) {
+      tokens.push({ kind: "arrow", direction: "backward" });
+    } else if (m[4]) {
+      tokens.push({ kind: "arrow", direction: "forward", name: m[4] });
+    } else if (m[5]) {
+      tokens.push({ kind: "arrow", direction: "forward" });
+    } else if (m[6]) {
+      tokens.push({ kind: "branch" });
+    } else if (m[7]) {
+      tokens.push({ kind: "state", name: m[7] });
+    }
+  }
+  return tokens;
+}
+function parseTokens(tokens, stateMap, transitions, outgoingCounts) {
+  let lastState = null;
+  for (let i = 0; i < tokens.length; i++) {
+    const tok = tokens[i];
+    if (tok.kind === "state") {
+      stateMap.set(tok.name, stateMap.has(tok.name) ? stateMap.get(tok.name) : true);
+      lastState = tok.name;
+      continue;
+    }
+    if (tok.kind === "branch") {
+      continue;
+    }
+    if (tok.kind === "arrow") {
+      let nextIdx = i + 1;
+      const targets = [];
+      while (nextIdx < tokens.length) {
+        const next = tokens[nextIdx];
+        if (next.kind === "state") {
+          targets.push(next.name);
+          stateMap.set(next.name, stateMap.has(next.name) ? stateMap.get(next.name) : true);
+          nextIdx++;
+          if (nextIdx < tokens.length && tokens[nextIdx].kind === "branch") {
+            nextIdx++;
+            continue;
+          }
+          break;
+        } else {
+          nextIdx++;
         }
       }
-      if (t12.isVariableDeclaration(decl)) {
-        for (const varDecl of decl.declarations) {
-          if (!t12.isIdentifier(varDecl.id)) continue;
-          const init = varDecl.init;
-          if (t12.isArrowFunctionExpression(init) || t12.isFunctionExpression(init)) {
-            const action = {
-              name: varDecl.id.name,
-              async: init.async || false,
-              params: init.params.filter((p) => t12.isIdentifier(p)).map((p) => p.name)
-            };
-            if (init.params.length > 0) {
-              const firstParam = init.params[0];
-              if (t12.isIdentifier(firstParam) && firstParam.typeAnnotation) {
-                action.contextType = extractTypeName(firstParam.typeAnnotation);
-              }
+      if (lastState && targets.length > 0) {
+        for (const target of targets) {
+          if (tok.direction === "forward" || tok.direction === "bidirectional") {
+            const name = tok.name || `to_${target}`;
+            transitions.push(makeTransition(name, lastState, target));
+            outgoingCounts.set(lastState, (outgoingCounts.get(lastState) || 0) + 1);
+          }
+          if (tok.direction === "backward" || tok.direction === "bidirectional") {
+            const name = tok.name || `to_${lastState}`;
+            transitions.push(makeTransition(name, target, lastState));
+            outgoingCounts.set(target, (outgoingCounts.get(target) || 0) + 1);
+          }
+        }
+        lastState = targets[targets.length > 1 ? 0 : 0];
+        if (targets.length === 1) {
+          lastState = targets[0];
+        }
+        i = nextIdx - 1;
+      }
+    }
+  }
+}
+function parseMultiLine(lines) {
+  const allStateNames = [];
+  const allTransitions = [];
+  const stateMap = /* @__PURE__ */ new Map();
+  const outgoingCounts = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const tokens = tokenize(trimmed);
+    const hasStates = tokens.some((t22) => t22.kind === "state");
+    const hasForwardArrows = tokens.some(
+      (t22) => t22.kind === "arrow" && (t22.direction === "forward" || t22.direction === "bidirectional")
+    );
+    if (hasStates && hasForwardArrows) {
+      for (const tok of tokens) {
+        if (tok.kind === "state" && !allStateNames.includes(tok.name)) {
+          allStateNames.push(tok.name);
+        }
+      }
+      parseTokens(tokens, stateMap, allTransitions, outgoingCounts);
+    } else if (!hasStates && tokens.some((t22) => t22.kind === "arrow")) {
+      let arrowIndex = 0;
+      for (const tok of tokens) {
+        if (tok.kind === "arrow") {
+          if (arrowIndex < allStateNames.length - 1) {
+            const left = allStateNames[arrowIndex];
+            const right = allStateNames[arrowIndex + 1];
+            if (tok.direction === "backward" || tok.direction === "bidirectional") {
+              const name = tok.name || `to_${left}`;
+              allTransitions.push(makeTransition(name, right, left));
+              outgoingCounts.set(right, (outgoingCounts.get(right) || 0) + 1);
+            }
+            if (tok.direction === "forward" || tok.direction === "bidirectional") {
+              const name = tok.name || `to_${right}`;
+              allTransitions.push(makeTransition(name, left, right));
+              outgoingCounts.set(left, (outgoingCounts.get(left) || 0) + 1);
             }
-            serverActions.push(action);
           }
+          arrowIndex++;
+        }
+      }
+    } else if (hasStates) {
+      parseTokens(tokens, stateMap, allTransitions, outgoingCounts);
+      for (const tok of tokens) {
+        if (tok.kind === "state" && !allStateNames.includes(tok.name)) {
+          allStateNames.push(tok.name);
         }
       }
     }
   }
-  if (serverActions.length > 0) {
-    if (!compilerState.metadata) compilerState.metadata = {};
-    compilerState.metadata.serverActions = serverActions;
+  return { stateNames: allStateNames, transitions: dedupeTransitions(allTransitions) };
+}
+function parseArrowSyntax(arrow) {
+  const lines = arrow.split("\n");
+  const { stateNames, transitions } = parseMultiLine(lines);
+  if (stateNames.length === 0) {
+    return { states: [], transitions: [] };
+  }
+  const hasOutgoing = /* @__PURE__ */ new Set();
+  for (const t22 of transitions) {
+    for (const from of t22.from) {
+      hasOutgoing.add(from);
+    }
+  }
+  const states = stateNames.map((name, idx) => {
+    let type = "REGULAR";
+    if (idx === 0) {
+      type = "START";
+    } else if (!hasOutgoing.has(name)) {
+      type = "END";
+    }
+    return makeState(name, type);
+  });
+  return { states, transitions };
+}
+function parseFieldRecord(fields) {
+  return Object.entries(fields).map(([name, typeStr]) => {
+    let required = false;
+    let raw = typeStr.trim();
+    if (raw.endsWith("!")) {
+      required = true;
+      raw = raw.slice(0, -1).trim();
+    }
+    let defaultValue;
+    const eqIdx = raw.indexOf("=");
+    let typePart = raw;
+    if (eqIdx !== -1) {
+      typePart = raw.slice(0, eqIdx).trim();
+      const valStr = raw.slice(eqIdx + 1).trim();
+      try {
+        defaultValue = JSON.parse(valStr);
+      } catch {
+        defaultValue = valStr;
+      }
+    }
+    const TYPE_MAP = {
+      string: "text",
+      str: "text",
+      text: "text",
+      number: "number",
+      num: "number",
+      int: "number",
+      integer: "number",
+      float: "number",
+      bool: "boolean",
+      boolean: "boolean",
+      date: "date",
+      datetime: "datetime",
+      email: "email",
+      url: "url",
+      json: "json",
+      object: "json",
+      array: "json",
+      select: "select",
+      enum: "select",
+      file: "file",
+      image: "image",
+      currency: "currency",
+      phone: "phone",
+      address: "address",
+      rich_text: "rich_text",
+      richtext: "rich_text",
+      color: "color",
+      rating: "rating"
+    };
+    const fieldType = TYPE_MAP[typePart.toLowerCase()] || typePart;
+    const field = {
+      name,
+      type: fieldType
+    };
+    if (required) field.required = true;
+    if (defaultValue !== void 0) field.default_value = defaultValue;
+    return field;
+  });
+}
+function parseWorkflowShorthand(slug, fieldsOrArrow, arrowString) {
+  let fields = [];
+  let arrow;
+  if (typeof fieldsOrArrow === "string") {
+    arrow = fieldsOrArrow;
+  } else {
+    fields = parseFieldRecord(fieldsOrArrow);
+    arrow = arrowString || "";
   }
+  const { states, transitions } = parseArrowSyntax(arrow);
+  return { slug, fields, states, transitions };
 }
-function extractFunctionAction(decl) {
-  if (!decl.id) return null;
-  const action = {
-    name: decl.id.name,
-    async: decl.async || false,
-    params: decl.params.filter((p) => t12.isIdentifier(p)).map((p) => p.name)
-  };
-  if (decl.params.length > 0) {
-    const firstParam = decl.params[0];
-    if (t12.isIdentifier(firstParam) && firstParam.typeAnnotation) {
-      action.contextType = extractTypeName(firstParam.typeAnnotation);
+
+// src/babel/extractors/flow-extractor.ts
+function isImperativeWorkflowFile(path, _filename) {
+  for (const node of path.node.body) {
+    if (t12.isExportDefaultDeclaration(node)) {
+      const decl = node.declaration;
+      if (t12.isFunctionDeclaration(decl) && decl.async && decl.params.length > 0) {
+        const param = decl.params[0];
+        if (t12.isIdentifier(param) && param.typeAnnotation) {
+          return true;
+        }
+      }
+      if (t12.isCallExpression(decl) && t12.isIdentifier(decl.callee) && decl.callee.name === "workflow") {
+        return true;
+      }
     }
   }
-  return action;
+  return false;
 }
-function extractTypeName(annotation) {
-  if (t12.isTSTypeAnnotation(annotation)) {
-    const typeNode = annotation.typeAnnotation;
-    if (t12.isTSTypeReference(typeNode) && t12.isIdentifier(typeNode.typeName)) {
-      return typeNode.typeName.name;
+var VALIDATION_FNS = /* @__PURE__ */ new Set(["validate", "assert"]);
+function roleCondition(role) {
+  return { type: "role", field: role, operator: "eq", value: true };
+}
+var TS_TYPE_MAP = {
+  Date: "datetime",
+  Record: "json",
+  Map: "json",
+  Set: "json",
+  URL: "url"
+};
+var NAME_TYPE_MAP = {
+  email: "email",
+  url: "url",
+  website: "url",
+  phone: "phone"
+};
+function resolveType2(annotation) {
+  if (t12.isTSStringKeyword(annotation)) return "text";
+  if (t12.isTSNumberKeyword(annotation)) return "number";
+  if (t12.isTSBooleanKeyword(annotation)) return "boolean";
+  if (t12.isTSTypeReference(annotation) && t12.isIdentifier(annotation.typeName)) {
+    const name = annotation.typeName.name;
+    if (TS_TYPE_MAP[name]) return TS_TYPE_MAP[name];
+    if (name === "Array") return "multi_select";
+    return name.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "");
+  }
+  if (t12.isTSArrayType(annotation)) return "multi_select";
+  if (t12.isTSUnionType(annotation)) {
+    const allLiterals = annotation.types.every(
+      (t22) => t12.isTSLiteralType(t22) && (t12.isStringLiteral(t22.literal) || t12.isNumericLiteral(t22.literal))
+    );
+    if (allLiterals) return "select";
+    return "text";
+  }
+  if (t12.isTSLiteralType(annotation) && t12.isStringLiteral(annotation.literal)) return "text";
+  if (t12.isTSLiteralType(annotation) && t12.isNumericLiteral(annotation.literal)) return "number";
+  return "text";
+}
+function extractUnionOptions2(annotation) {
+  if (!t12.isTSUnionType(annotation)) return void 0;
+  const options = [];
+  for (const member of annotation.types) {
+    if (t12.isTSLiteralType(member) && t12.isStringLiteral(member.literal)) {
+      options.push(member.literal.value);
     }
   }
-  return void 0;
+  return options.length > 0 ? options : void 0;
 }
-function extractDescription(comments) {
-  for (const comment of comments) {
-    if (comment.type !== "CommentBlock") continue;
-    const lines = comment.value.split("\n");
-    for (const line of lines) {
-      const trimmed = line.replace(/^\s*\*\s?/, "").trim();
-      if (trimmed && !trimmed.startsWith("@")) {
-        return trimmed;
+function extractFieldsFromInterface2(declaration) {
+  const fields = [];
+  for (const member of declaration.body.body) {
+    if (!t12.isTSPropertySignature(member)) continue;
+    if (!t12.isIdentifier(member.key)) continue;
+    const name = member.key.name;
+    const required = !member.optional;
+    const typeAnno = member.typeAnnotation;
+    let fieldType = typeAnno ? resolveType2(typeAnno.typeAnnotation) : "text";
+    if (NAME_TYPE_MAP[name]) fieldType = NAME_TYPE_MAP[name];
+    const field = {
+      name,
+      type: fieldType,
+      label: name.replace(/([A-Z])/g, " $1").replace(/^./, (c) => c.toUpperCase()),
+      required,
+      default_value: getDefaultForType(fieldType)
+    };
+    if (typeAnno) {
+      const options = extractUnionOptions2(typeAnno.typeAnnotation);
+      if (options) {
+        field.validation = { options };
       }
     }
+    fields.push(field);
   }
-  return void 0;
+  return fields;
 }
-
-// src/babel/extractors/server-action-hook-extractor.ts
-var t13 = __toESM(require("@babel/types"));
-function extractServerActionHook(path, state) {
-  const args = path.node.arguments;
-  if (args.length < 1) return;
-  const nameArg = args[0];
-  if (!t13.isStringLiteral(nameArg)) return;
-  const compilerState = state;
-  const entry = {
-    name: nameArg.value
-  };
-  if (args.length > 1 && t13.isObjectExpression(args[1])) {
-    for (const prop of args[1].properties) {
-      if (!t13.isObjectProperty(prop) || !t13.isIdentifier(prop.key)) continue;
-      if (prop.key.name === "instanceId" && t13.isStringLiteral(prop.value)) {
-        entry.staticInstanceId = prop.value.value;
-      }
+function getDefaultForType(type) {
+  switch (type) {
+    case "text":
+    case "email":
+    case "url":
+    case "phone":
+    case "select":
+      return "";
+    case "number":
+    case "currency":
+      return 0;
+    case "boolean":
+      return false;
+    case "multi_select":
+      return [];
+    case "json":
+      return {};
+    default:
+      return null;
+  }
+}
+function extractNodeValue2(node) {
+  if (t12.isStringLiteral(node)) return node.value;
+  if (t12.isNumericLiteral(node)) return node.value;
+  if (t12.isBooleanLiteral(node)) return node.value;
+  if (t12.isNullLiteral(node)) return null;
+  if (t12.isArrayExpression(node)) {
+    return node.elements.map((el) => {
+      if (!el || t12.isSpreadElement(el)) return null;
+      return extractNodeValue2(el);
+    });
+  }
+  if (t12.isObjectExpression(node)) {
+    const obj = {};
+    for (const prop of node.properties) {
+      if (!t12.isObjectProperty(prop)) continue;
+      const key = t12.isIdentifier(prop.key) ? prop.key.name : t12.isStringLiteral(prop.key) ? prop.key.value : null;
+      if (key) obj[key] = extractNodeValue2(prop.value);
     }
+    return obj;
   }
-  const parent = path.parentPath;
-  if (parent?.isVariableDeclarator() && t13.isIdentifier(parent.node.id)) {
-    entry.variableName = parent.node.id.name;
+  if (t12.isTemplateLiteral(node)) {
+    return node.quasis.map((q) => q.value.raw).join("${}");
   }
-  if (!compilerState.metadata) compilerState.metadata = {};
-  const meta = compilerState.metadata;
-  if (!meta.serverActionHooks) meta.serverActionHooks = [];
-  meta.serverActionHooks.push(entry);
+  if (t12.isIdentifier(node)) {
+    if (node.name === "undefined") return void 0;
+    return node.name;
+  }
+  if (t12.isMemberExpression(node)) {
+    return memberExprToString(node);
+  }
+  if (t12.isTSAsExpression(node)) return extractNodeValue2(node.expression);
+  if (t12.isArrowFunctionExpression(node) || t12.isFunctionExpression(node)) {
+    return "[Function]";
+  }
+  return "[Expression]";
 }
-
-// src/babel/extractors/server-state-extractor.ts
-var t14 = __toESM(require("@babel/types"));
-function extractServerState(path, state) {
-  const args = path.node.arguments;
-  if (args.length < 1) return;
-  const compilerState = state;
-  const entry = {};
-  const instanceArg = args[0];
-  if (t14.isStringLiteral(instanceArg)) {
-    entry.staticInstanceId = instanceArg.value;
+function memberExprToString(node) {
+  const obj = t12.isIdentifier(node.object) ? node.object.name : t12.isMemberExpression(node.object) ? memberExprToString(node.object) : "[object]";
+  const prop = t12.isIdentifier(node.property) ? node.property.name : t12.isStringLiteral(node.property) ? node.property.value : "[property]";
+  return `${obj}.${prop}`;
+}
+function analyzeStateFn(fn, paramName, actionCounter) {
+  const onEnter = [];
+  const validations = [];
+  const conditions = [];
+  const roles = [];
+  const requiredFields = [];
+  const during = [];
+  const onEvent = [];
+  let timeout;
+  let runtime;
+  if (!fn.body || !t12.isBlockStatement(fn.body)) {
+    return { onEnter, validations, conditions, roles, requiredFields, during, onEvent, timeout, runtime };
+  }
+  for (const stmt of fn.body.body) {
+    processStatement(stmt, paramName, actionCounter, {
+      onEnter,
+      validations,
+      conditions,
+      roles,
+      requiredFields,
+      during,
+      onEvent,
+      setTimeout: (t22) => {
+        timeout = t22;
+      },
+      setRuntime: (r) => {
+        runtime = r;
+      }
+    });
   }
-  if (args.length > 1 && t14.isObjectExpression(args[1])) {
-    for (const prop of args[1].properties) {
-      if (!t14.isObjectProperty(prop) || !t14.isIdentifier(prop.key)) continue;
-      if (prop.key.name === "enabled" && t14.isBooleanLiteral(prop.value)) {
-        if (!prop.value.value) entry.disabled = true;
+  return { onEnter, validations, conditions, roles, requiredFields, during, onEvent, timeout, runtime };
+}
+function processStatement(stmt, paramName, actionCounter, ctx) {
+  if (t12.isExpressionStatement(stmt)) {
+    processExpression(stmt.expression, paramName, actionCounter, ctx);
+    return;
+  }
+  if (t12.isIfStatement(stmt)) {
+    const testStr = expressionToIR(stmt.test, paramName);
+    if (t12.isBlockStatement(stmt.consequent)) {
+      for (const inner of stmt.consequent.body) {
+        processStatement(inner, paramName, actionCounter, {
+          ...ctx,
+          ifCondition: testStr
+        });
       }
     }
+    return;
   }
-  const parent = path.parentPath;
-  if (parent?.isVariableDeclarator()) {
-    if (t14.isIdentifier(parent.node.id)) {
-      entry.variableName = parent.node.id.name;
-    } else if (t14.isObjectPattern(parent.node.id)) {
-      const props = parent.node.id.properties.filter((p) => t14.isObjectProperty(p) && t14.isIdentifier(p.key)).map((p) => p.key.name);
-      if (props.length > 0) {
-        entry.variableName = props.join(", ");
+  if (t12.isVariableDeclaration(stmt)) {
+    for (const decl of stmt.declarations) {
+      if (decl.init && t12.isAwaitExpression(decl.init)) {
+        processExpression(decl.init, paramName, actionCounter, ctx);
       }
     }
   }
-  if (!compilerState.metadata) compilerState.metadata = {};
-  const meta = compilerState.metadata;
-  if (!meta.serverStateSubscriptions) meta.serverStateSubscriptions = [];
-  meta.serverStateSubscriptions.push(entry);
-  meta.requiresSSE = true;
 }
-
-// src/babel/extractors/grammar-island-extractor.ts
-var t15 = __toESM(require("@babel/types"));
-var GRAMMAR_TAGS = /* @__PURE__ */ new Set(["cedar", "sql", "cron", "dmn", "graphql", "jsonpath"]);
-function parseCedar(source) {
-  const policies = [];
-  const policyRegex = /(permit|forbid)\s*\(([^)]*)\)(?:\s*when\s*\{([^}]*)\})?/g;
-  let match;
+function processExpression(expr, paramName, actionCounter, ctx) {
+  if (t12.isAssignmentExpression(expr) && t12.isMemberExpression(expr.left)) {
+    const left = memberExprToString(expr.left);
+    if (left.startsWith(`${paramName}.`)) {
+      const field = left.slice(paramName.length + 1);
+      const valueExpr = expressionToIR(expr.right, paramName);
+      const action = {
+        id: `auto_${++actionCounter.value}`,
+        type: "set_field",
+        mode: "auto",
+        config: { field, expression: valueExpr },
+        ...ctx.ifCondition ? { condition: ctx.ifCondition } : {}
+      };
+      ctx.onEnter.push(action);
+      return;
+    }
+  }
+  if (t12.isAssignmentExpression(expr) && expr.operator !== "=" && t12.isMemberExpression(expr.left)) {
+    const left = memberExprToString(expr.left);
+    if (left.startsWith(`${paramName}.`)) {
+      const field = left.slice(paramName.length + 1);
+      const op = expr.operator.replace("=", "");
+      const valueExpr = expressionToIR(expr.right, paramName);
+      const action = {
+        id: `auto_${++actionCounter.value}`,
+        type: "set_field",
+        mode: "auto",
+        config: { field, expression: `state_data.${field} ${op} ${valueExpr}` },
+        ...ctx.ifCondition ? { condition: ctx.ifCondition } : {}
+      };
+      ctx.onEnter.push(action);
+      return;
+    }
+  }
+  if (t12.isCallExpression(expr) || t12.isAwaitExpression(expr) && t12.isCallExpression(expr.argument)) {
+    const call = t12.isAwaitExpression(expr) ? expr.argument : expr;
+    const fnName = t12.isIdentifier(call.callee) ? call.callee.name : t12.isMemberExpression(call.callee) && t12.isIdentifier(call.callee.property) ? call.callee.property.name : null;
+    if (!fnName) return;
+    if (VALIDATION_FNS.has(fnName)) {
+      extractValidation(call, paramName, ctx);
+      return;
+    }
+    if (fnName === "log") {
+      const event = call.arguments[0] ? extractNodeValue2(call.arguments[0]) : "";
+      const data = call.arguments[1] ? extractNodeValue2(call.arguments[1]) : void 0;
+      ctx.onEnter.push({
+        id: `auto_${++actionCounter.value}`,
+        type: "log_event",
+        mode: "auto",
+        config: { event: String(event), ...data ? { data } : {} },
+        ...ctx.ifCondition ? { condition: ctx.ifCondition } : {}
+      });
+      return;
+    }
+    if (fnName === "notify") {
+      const to = call.arguments[0] ? expressionToIR(call.arguments[0], paramName) : "";
+      const message = call.arguments[1] ? extractNodeValue2(call.arguments[1]) : "";
+      const opts = call.arguments[2] ? extractNodeValue2(call.arguments[2]) : {};
+      ctx.onEnter.push({
+        id: `auto_${++actionCounter.value}`,
+        type: "send_notification",
+        mode: "auto",
+        config: {
+          to: String(to),
+          message: String(message),
+          ...opts
+        },
+        ...ctx.ifCondition ? { condition: ctx.ifCondition } : {}
+      });
+      return;
+    }
+    if (fnName === "emit") {
+      const event = call.arguments[0] ? extractNodeValue2(call.arguments[0]) : "";
+      const payload = call.arguments[1] ? extractNodeValue2(call.arguments[1]) : void 0;
+      ctx.onEnter.push({
+        id: `auto_${++actionCounter.value}`,
+        type: "emit_event",
+        mode: "auto",
+        config: { event: String(event), ...payload ? { payload } : {} },
+        ...ctx.ifCondition ? { condition: ctx.ifCondition } : {}
+      });
+      return;
+    }
+    if (fnName === "requireRole") {
+      for (const arg of call.arguments) {
+        if (t12.isStringLiteral(arg)) ctx.roles.push(arg.value);
+      }
+      return;
+    }
+    if (fnName === "requireField") {
+      for (const arg of call.arguments) {
+        if (t12.isStringLiteral(arg)) ctx.requiredFields.push(arg.value);
+      }
+      return;
+    }
+    if (fnName === "runtime") {
+      if (call.arguments[0] && t12.isStringLiteral(call.arguments[0])) {
+        ctx.setRuntime(call.arguments[0].value);
+      }
+      return;
+    }
+    if (fnName === "guard") {
+      if (call.arguments[0] && t12.isStringLiteral(call.arguments[0])) {
+        ctx.conditions.push({ expression: call.arguments[0].value });
+      }
+      return;
+    }
+    if (fnName === "every") {
+      const interval = call.arguments[0] && t12.isStringLiteral(call.arguments[0]) ? call.arguments[0].value : "1h";
+      const intervalMs = parseDuration(interval);
+      const opts = call.arguments[1] ? extractNodeValue2(call.arguments[1]) : {};
+      const duringAction = {
+        id: `during_${++actionCounter.value}`,
+        type: "interval",
+        interval_ms: intervalMs,
+        ...typeof opts === "object" && opts !== null && opts.when ? { condition: opts.when } : {},
+        actions: []
+        // Placeholder — body analysis would extract inner actions
+      };
+      ctx.during.push(duringAction);
+      return;
+    }
+    if (fnName === "cron") {
+      const cronExpr = call.arguments[0] && t12.isStringLiteral(call.arguments[0]) ? call.arguments[0].value : "* * * * *";
+      ctx.during.push({
+        id: `during_${++actionCounter.value}`,
+        type: "cron",
+        cron: cronExpr,
+        actions: []
+      });
+      return;
+    }
+    if (fnName === "after") {
+      const delay = call.arguments[0] && t12.isStringLiteral(call.arguments[0]) ? call.arguments[0].value : "1h";
+      ctx.during.push({
+        id: `during_${++actionCounter.value}`,
+        type: "timeout",
+        delay_ms: parseDuration(delay),
+        actions: []
+      });
+      return;
+    }
+    if (fnName === "on" && !t12.isAwaitExpression(expr)) {
+      const pattern = call.arguments[0] && t12.isStringLiteral(call.arguments[0]) ? call.arguments[0].value : "*";
+      const opts = call.arguments[1] ? extractNodeValue2(call.arguments[1]) : {};
+      const optsObj = typeof opts === "object" && opts !== null ? opts : {};
+      ctx.onEvent.push({
+        match: pattern,
+        ...optsObj.when ? { conditions: [String(optsObj.when)] } : {},
+        actions: []
+      });
+      return;
+    }
+    if (fnName === "timeout") {
+      const duration = call.arguments[0] && t12.isStringLiteral(call.arguments[0]) ? call.arguments[0].value : "1h";
+      const opts = call.arguments[1] ? extractNodeValue2(call.arguments[1]) : {};
+      const optsObj = typeof opts === "object" && opts !== null ? opts : {};
+      ctx.setTimeout({
+        duration,
+        fallback: {
+          ...optsObj.transition ? { transition: String(optsObj.transition) } : {},
+          ...optsObj.action ? { action: String(optsObj.action) } : {}
+        }
+      });
+      return;
+    }
+    if (fnName === "restrict") {
+      return;
+    }
+  }
+}
+function extractValidation(call, paramName, ctx) {
+  const condArg = call.arguments[0];
+  const msgArg = call.arguments[1];
+  const sevArg = call.arguments[2];
+  const message = msgArg && t12.isStringLiteral(msgArg) ? msgArg.value : "Validation failed";
+  const severity = sevArg && t12.isStringLiteral(sevArg) && sevArg.value === "warning" ? "warning" : "error";
+  if (!condArg) return;
+  const field = extractFieldFromCondition(condArg, paramName);
+  const exprStr = expressionToIR(condArg, paramName);
+  if (field) {
+    const validation = {};
+    if (t12.isBinaryExpression(condArg) && (condArg.operator === ">" || condArg.operator === ">=")) {
+      if (isLengthAccess(condArg.left, paramName, field) && t12.isNumericLiteral(condArg.right)) {
+        validation.minLength = condArg.right.value + (condArg.operator === ">" ? 1 : 0);
+      } else if (isFieldAccess(condArg.left, paramName, field) && t12.isNumericLiteral(condArg.right)) {
+        validation.min = condArg.right.value + (condArg.operator === ">" ? 1e-3 : 0);
+      }
+    }
+    if (t12.isBinaryExpression(condArg) && (condArg.operator === "<" || condArg.operator === "<=")) {
+      if (isFieldAccess(condArg.left, paramName, field) && t12.isNumericLiteral(condArg.right)) {
+        validation.max = condArg.right.value;
+      }
+    }
+    if (t12.isCallExpression(condArg) && t12.isMemberExpression(condArg.callee) && t12.isRegExpLiteral(condArg.callee.object) && t12.isIdentifier(condArg.callee.property) && condArg.callee.property.name === "test") {
+      if (!validation.rules) validation.rules = [];
+      validation.rules.push({
+        expression: `MATCHES(value, "${condArg.callee.object.pattern}")`,
+        message: "",
+        // Will be set from the validate() message arg
+        severity: "error"
+      });
+    }
+    ctx.validations.push({ field, validation, message, severity });
+  } else {
+    ctx.validations.push({
+      field: "__cross__",
+      validation: { rules: [{ expression: exprStr, message, severity }] },
+      message,
+      severity
+    });
+  }
+}
+function extractFieldFromCondition(node, paramName) {
+  if (t12.isMemberExpression(node)) {
+    const str = memberExprToString(node);
+    if (str.startsWith(`${paramName}.`)) {
+      const parts = str.slice(paramName.length + 1).split(".");
+      return parts[0];
+    }
+  }
+  if (t12.isBinaryExpression(node)) {
+    return extractFieldFromCondition(node.left, paramName) || extractFieldFromCondition(node.right, paramName);
+  }
+  if (t12.isCallExpression(node) && t12.isMemberExpression(node.callee)) {
+    return extractFieldFromCondition(node.callee.object, paramName);
+  }
+  if (t12.isCallExpression(node) && t12.isMemberExpression(node.callee) && t12.isRegExpLiteral(node.callee.object) && node.arguments[0]) {
+    return extractFieldFromCondition(node.arguments[0], paramName);
+  }
+  if (t12.isLogicalExpression(node)) {
+    return extractFieldFromCondition(node.left, paramName) || extractFieldFromCondition(node.right, paramName);
+  }
+  if (t12.isUnaryExpression(node)) {
+    return extractFieldFromCondition(node.argument, paramName);
+  }
+  return null;
+}
+function isLengthAccess(node, paramName, field) {
+  if (!t12.isMemberExpression(node)) return false;
+  const str = memberExprToString(node);
+  return str === `${paramName}.${field}.length`;
+}
+function isFieldAccess(node, paramName, field) {
+  if (!t12.isMemberExpression(node)) return false;
+  const str = memberExprToString(node);
+  return str === `${paramName}.${field}`;
+}
+function expressionToIR(node, paramName) {
+  if (t12.isStringLiteral(node)) return `"${node.value}"`;
+  if (t12.isNumericLiteral(node)) return String(node.value);
+  if (t12.isBooleanLiteral(node)) return String(node.value);
+  if (t12.isNullLiteral(node)) return "null";
+  if (t12.isIdentifier(node)) {
+    if (node.name === paramName) return "state_data";
+    if (node.name === "actor") return "context";
+    if (node.name === "instance") return "instance";
+    return node.name;
+  }
+  if (t12.isMemberExpression(node)) {
+    const str = memberExprToString(node);
+    if (str.startsWith(`${paramName}.`)) return "state_data." + str.slice(paramName.length + 1);
+    if (str.startsWith("actor.")) return "context." + str.slice(6);
+    if (str.startsWith("Date.")) {
+      if (str === "Date.now") return "NOW()";
+    }
+    return str;
+  }
+  if (t12.isCallExpression(node)) {
+    if (t12.isMemberExpression(node.callee) && t12.isIdentifier(node.callee.property)) {
+      const obj = expressionToIR(node.callee.object, paramName);
+      const method = node.callee.property.name;
+      if (method === "now" && obj === "Date") return "NOW()";
+      if (method === "includes") {
+        const arg = node.arguments[0] ? expressionToIR(node.arguments[0], paramName) : "";
+        return `CONTAINS(${obj}, ${arg})`;
+      }
+      if (method === "length") return `LEN(${obj})`;
+    }
+    if (t12.isIdentifier(node.callee) && node.callee.name === "Date") {
+      if (t12.isMemberExpression(node) && t12.isIdentifier(node.property) && node.property.name === "now") {
+        return "NOW()";
+      }
+    }
+    return "[call]";
+  }
+  if (t12.isBinaryExpression(node)) {
+    const left = expressionToIR(node.left, paramName);
+    const right = expressionToIR(node.right, paramName);
+    return `${left} ${node.operator} ${right}`;
+  }
+  if (t12.isLogicalExpression(node)) {
+    const left = expressionToIR(node.left, paramName);
+    const right = expressionToIR(node.right, paramName);
+    const op = node.operator === "&&" ? "AND" : node.operator === "||" ? "OR" : node.operator;
+    return `${left} ${op} ${right}`;
+  }
+  if (t12.isUnaryExpression(node)) {
+    if (node.operator === "!") return `NOT(${expressionToIR(node.argument, paramName)})`;
+    return `${node.operator}${expressionToIR(node.argument, paramName)}`;
+  }
+  if (t12.isConditionalExpression(node)) {
+    return `IF(${expressionToIR(node.test, paramName)}, ${expressionToIR(node.consequent, paramName)}, ${expressionToIR(node.alternate, paramName)})`;
+  }
+  if (t12.isTemplateLiteral(node)) {
+    const parts = [];
+    for (let i = 0; i < node.quasis.length; i++) {
+      parts.push(node.quasis[i].value.raw);
+      if (i < node.expressions.length) {
+        parts.push(`{{ ${expressionToIR(node.expressions[i], paramName)} }}`);
+      }
+    }
+    return `"${parts.join("")}"`;
+  }
+  if (t12.isRegExpLiteral(node)) return node.pattern;
+  return "[expr]";
+}
+function extractCallSequence(body, paramName, localFnNames, importedFns) {
+  const calls = [];
+  for (const stmt of body.body) {
+    extractCallsFromStatement(stmt, paramName, localFnNames, importedFns, calls);
+  }
+  return calls;
+}
+function extractCallsFromStatement(stmt, paramName, localFnNames, importedFns, calls, condition) {
+  if (t12.isExpressionStatement(stmt)) {
+    const expr = stmt.expression;
+    if (t12.isAwaitExpression(expr)) {
+      const call = extractWorkflowCall(expr.argument, paramName, localFnNames, importedFns);
+      if (call) {
+        if (condition) call.condition = condition;
+        calls.push(call);
+      }
+    }
+    if (t12.isCallExpression(expr) && t12.isIdentifier(expr.callee) && expr.callee.name === "allowTransition") {
+    }
+  }
+  if (t12.isVariableDeclaration(stmt)) {
+    for (const decl of stmt.declarations) {
+      if (decl.init && t12.isAwaitExpression(decl.init)) {
+        const call = extractWorkflowCall(decl.init.argument, paramName, localFnNames, importedFns);
+        if (call) {
+          if (condition) call.condition = condition;
+          calls.push(call);
+        }
+      }
+    }
+  }
+  if (t12.isIfStatement(stmt)) {
+    const condStr = expressionToIR(stmt.test, paramName);
+    if (t12.isBlockStatement(stmt.consequent)) {
+      for (const inner of stmt.consequent.body) {
+        extractCallsFromStatement(inner, paramName, localFnNames, importedFns, calls, condStr);
+      }
+    }
+    if (stmt.alternate) {
+      const negCond = `NOT(${condStr})`;
+      if (t12.isBlockStatement(stmt.alternate)) {
+        for (const inner of stmt.alternate.body) {
+          extractCallsFromStatement(inner, paramName, localFnNames, importedFns, calls, negCond);
+        }
+      } else if (t12.isIfStatement(stmt.alternate)) {
+        extractCallsFromStatement(stmt.alternate, paramName, localFnNames, importedFns, calls);
+      }
+    }
+  }
+  if (t12.isTryStatement(stmt)) {
+    const tryBlockCalls = [];
+    if (stmt.block) {
+      for (const inner of stmt.block.body) {
+        extractCallsFromStatement(inner, paramName, localFnNames, importedFns, tryBlockCalls, condition);
+      }
+    }
+    calls.push(...tryBlockCalls);
+    if (stmt.handler && stmt.handler.body) {
+      const catchBody = stmt.handler.body;
+      const compensationActions = [];
+      const catchParamName = stmt.handler.param && t12.isIdentifier(stmt.handler.param) ? stmt.handler.param.name : "error";
+      const hasReturn = catchBody.body.some((s) => t12.isReturnStatement(s));
+      for (const inner of catchBody.body) {
+        if (t12.isReturnStatement(inner)) continue;
+        extractCallsFromStatement(inner, paramName, localFnNames, importedFns, compensationActions, condition);
+      }
+      calls.push({
+        type: "stateCall",
+        name: `__compensation_${calls.length}`,
+        options: {
+          __isCompensation: true,
+          __tryBlockCallNames: tryBlockCalls.map((c) => c.name),
+          __compensationCalls: compensationActions,
+          __hasReturn: hasReturn,
+          __catchParam: catchParamName,
+          __catchBody: catchBody
+        }
+      });
+    }
+  }
+  if (t12.isSwitchStatement(stmt)) {
+  }
+}
+function extractWorkflowCall(node, paramName, localFnNames, importedFns) {
+  if (t12.isCallExpression(node)) {
+    const callee = node.callee;
+    if (t12.isIdentifier(callee) && callee.name === "named" && node.arguments.length >= 2) {
+      const name = t12.isStringLiteral(node.arguments[0]) ? node.arguments[0].value : "";
+      const inner = node.arguments[1];
+      if (t12.isCallExpression(inner) || t12.isAwaitExpression(inner)) {
+        const innerNode = t12.isAwaitExpression(inner) ? inner.argument : inner;
+        const innerCall = extractWorkflowCall(innerNode, paramName, localFnNames, importedFns);
+        if (innerCall) {
+          innerCall.transitionName = name;
+          return innerCall;
+        }
+      }
+      return null;
+    }
+    if (t12.isIdentifier(callee) && callee.name === "userAction") {
+      const name = node.arguments[0] && t12.isStringLiteral(node.arguments[0]) ? node.arguments[0].value : "action";
+      const opts = node.arguments[1] ? extractNodeValue2(node.arguments[1]) : {};
+      return { type: "userAction", name, options: opts };
+    }
+    if (t12.isIdentifier(callee) && callee.name === "userChoice") {
+      const choices = node.arguments[0] ? extractNodeValue2(node.arguments[0]) : {};
+      return { type: "userChoice", name: "choice", choices };
+    }
+    if (t12.isIdentifier(callee) && callee.name === "delay") {
+      const duration = node.arguments[0] && t12.isStringLiteral(node.arguments[0]) ? node.arguments[0].value : "0";
+      return { type: "delay", name: `delay_${duration}` };
+    }
+    if (t12.isIdentifier(callee) && callee.name === "on") {
+      const pattern = node.arguments[0] && t12.isStringLiteral(node.arguments[0]) ? node.arguments[0].value : "*";
+      const opts = node.arguments[1] ? extractNodeValue2(node.arguments[1]) : {};
+      opts.__eventPattern = pattern;
+      return { type: "awaitOn", name: pattern.replace(/[^a-zA-Z0-9]/g, "_"), options: opts };
+    }
+    if (t12.isMemberExpression(callee) && t12.isIdentifier(callee.object) && callee.object.name === "Promise" && t12.isIdentifier(callee.property)) {
+      if (callee.property.name === "all" && node.arguments[0] && t12.isArrayExpression(node.arguments[0])) {
+        const parallelCalls = [];
+        for (const el of node.arguments[0].elements) {
+          if (!el || t12.isSpreadElement(el)) continue;
+          const innerNode = t12.isAwaitExpression(el) ? el.argument : el;
+          const c = extractWorkflowCall(innerNode, paramName, localFnNames, importedFns);
+          if (c) parallelCalls.push(c);
+        }
+        return { type: "promiseAll", name: "parallel", parallelCalls };
+      }
+      if (callee.property.name === "race" && node.arguments[0] && t12.isArrayExpression(node.arguments[0])) {
+        const parallelCalls = [];
+        for (const el of node.arguments[0].elements) {
+          if (!el || t12.isSpreadElement(el)) continue;
+          const innerNode = t12.isAwaitExpression(el) ? el.argument : el;
+          const c = extractWorkflowCall(innerNode, paramName, localFnNames, importedFns);
+          if (c) parallelCalls.push(c);
+        }
+        return { type: "promiseRace", name: "race", parallelCalls };
+      }
+    }
+    if (t12.isIdentifier(callee) && localFnNames.has(callee.name)) {
+      return { type: "stateCall", name: callee.name };
+    }
+    if (t12.isIdentifier(callee) && importedFns.has(callee.name)) {
+      return {
+        type: "serviceCall",
+        name: callee.name,
+        importSource: importedFns.get(callee.name)
+      };
+    }
+  }
+  return null;
+}
+function extractAllowTransitions(body) {
+  const result = [];
+  for (const stmt of body.body) {
+    if (!t12.isExpressionStatement(stmt)) continue;
+    const expr = stmt.expression;
+    if (!t12.isCallExpression(expr)) continue;
+    if (!t12.isIdentifier(expr.callee) || expr.callee.name !== "allowTransition") continue;
+    const nameArg = expr.arguments[0];
+    const optsArg = expr.arguments[1];
+    if (!t12.isStringLiteral(nameArg)) continue;
+    const name = nameArg.value;
+    const opts = optsArg && t12.isObjectExpression(optsArg) ? extractNodeValue2(optsArg) : {};
+    let from = [];
+    if (typeof opts.from === "string") from = [opts.from];
+    else if (Array.isArray(opts.from)) from = opts.from.map(String);
+    result.push({
+      name,
+      from,
+      to: String(opts.to || ""),
+      ...opts.roles ? { roles: opts.roles } : {},
+      ...opts.require ? { require: opts.require } : {},
+      ...opts.when ? { when: String(opts.when) } : {}
+    });
+  }
+  return result;
+}
+function parseDuration(str) {
+  const match = str.match(/^(\d+(?:\.\d+)?)\s*(ms|s|m|h|d|w)$/);
+  if (!match) return 0;
+  const value = parseFloat(match[1]);
+  switch (match[2]) {
+    case "ms":
+      return value;
+    case "s":
+      return value * 1e3;
+    case "m":
+      return value * 6e4;
+    case "h":
+      return value * 36e5;
+    case "d":
+      return value * 864e5;
+    case "w":
+      return value * 6048e5;
+    default:
+      return 0;
+  }
+}
+function toSnakeCase2(name) {
+  return name.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
+}
+function fnNameToSlug(name) {
+  return name.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "");
+}
+function extractStateDataRefs(expression) {
+  const refs = [];
+  const regex = /state_data\.(\w+)/g;
+  let match;
+  while ((match = regex.exec(expression)) !== null) {
+    refs.push(match[1]);
+  }
+  return [...new Set(refs)];
+}
+function detectComputedFieldsFromActions(compilerState, stateFnInfos) {
+  for (const [, info] of stateFnInfos) {
+    for (const action of info.onEnter) {
+      if (action.type !== "set_field") continue;
+      const config = action.config;
+      if (!config?.field || !config?.expression) continue;
+      const targetField = config.field;
+      const expression = config.expression;
+      const refs = extractStateDataRefs(expression);
+      const deps = refs.filter((r) => r !== targetField);
+      if (deps.length === 0) continue;
+      const field = compilerState.fields.find((f) => f.name === targetField);
+      if (field) {
+        field.computed = expression;
+        field.computed_deps = deps;
+      }
+    }
+  }
+}
+function detectComputedFieldGetters(path, paramName, paramTypeName, compilerState) {
+  for (const node of path.node.body) {
+    if (!t12.isFunctionDeclaration(node)) continue;
+    if (node.async) continue;
+    if (!node.id) continue;
+    if (node.params.length !== 1) continue;
+    const fnParam = node.params[0];
+    if (!t12.isIdentifier(fnParam)) continue;
+    if (fnParam.typeAnnotation && t12.isTSTypeAnnotation(fnParam.typeAnnotation)) {
+      const typeAnno = fnParam.typeAnnotation.typeAnnotation;
+      if (t12.isTSTypeReference(typeAnno) && t12.isIdentifier(typeAnno.typeName)) {
+        if (typeAnno.typeName.name !== paramTypeName) continue;
+      } else {
+        continue;
+      }
+    } else {
+      continue;
+    }
+    const hasReturnType = node.returnType && t12.isTSTypeAnnotation(node.returnType);
+    if (!node.body || !t12.isBlockStatement(node.body)) continue;
+    const returnStmt = node.body.body.find(
+      (s) => t12.isReturnStatement(s)
+    );
+    if (!returnStmt?.argument) continue;
+    const getterParamName = fnParam.name;
+    const expression = expressionToIR(returnStmt.argument, getterParamName);
+    const deps = extractStateDataRefs(expression);
+    if (deps.length === 0) continue;
+    const fieldName = node.id.name;
+    let field = compilerState.fields.find((f) => f.name === fieldName);
+    if (field) {
+      field.computed = expression;
+      field.computed_deps = deps;
+    } else {
+      let fieldType = "text";
+      if (hasReturnType) {
+        const retType = node.returnType.typeAnnotation;
+        fieldType = resolveType2(retType);
+      }
+      compilerState.fields.push({
+        name: fieldName,
+        type: fieldType,
+        label: fieldName.replace(/([A-Z])/g, " $1").replace(/^./, (c) => c.toUpperCase()),
+        required: false,
+        computed: expression,
+        computed_deps: deps
+      });
+    }
+  }
+}
+function extractImperativeWorkflow(path, state) {
+  const compilerState = state;
+  if (!compilerState.actionCounter) compilerState.actionCounter = 0;
+  const actionCounter = { value: compilerState.actionCounter };
+  const importedFns = /* @__PURE__ */ new Map();
+  const stdLibImports = /* @__PURE__ */ new Set();
+  for (const node of path.node.body) {
+    if (t12.isImportDeclaration(node)) {
+      const source = node.source.value;
+      for (const spec of node.specifiers) {
+        const localName = spec.local.name;
+        if (source.includes("@mmapp/react") || source.includes("@mindmatrix/react")) {
+          stdLibImports.add(localName);
+        } else {
+          importedFns.set(localName, source);
+        }
+      }
+    }
+  }
+  for (const node of path.node.body) {
+    if (t12.isExportDefaultDeclaration(node) && t12.isCallExpression(node.declaration)) {
+      const call = node.declaration;
+      if (t12.isIdentifier(call.callee) && call.callee.name === "workflow") {
+        const slugArg = call.arguments[0] && t12.isStringLiteral(call.arguments[0]) ? call.arguments[0].value : "workflow";
+        let fieldsOrArrow = "";
+        let arrowString;
+        if (call.arguments.length === 2) {
+          const arg1 = call.arguments[1];
+          if (t12.isStringLiteral(arg1)) {
+            fieldsOrArrow = arg1.value;
+          } else if (t12.isTemplateLiteral(arg1)) {
+            fieldsOrArrow = arg1.quasis.map((q) => q.value.raw).join("");
+          } else if (t12.isObjectExpression(arg1)) {
+            fieldsOrArrow = extractNodeValue2(arg1);
+          }
+        } else if (call.arguments.length >= 3) {
+          const arg1 = call.arguments[1];
+          const arg2 = call.arguments[2];
+          if (t12.isObjectExpression(arg1)) {
+            fieldsOrArrow = extractNodeValue2(arg1);
+          }
+          if (t12.isStringLiteral(arg2)) {
+            arrowString = arg2.value;
+          } else if (t12.isTemplateLiteral(arg2)) {
+            arrowString = arg2.quasis.map((q) => q.value.raw).join("");
+          }
+        }
+        const result = parseWorkflowShorthand(slugArg, fieldsOrArrow, arrowString);
+        compilerState.metadata.slug = result.slug;
+        compilerState.metadata.category = "workflow";
+        compilerState.fields.push(...result.fields);
+        for (const s of result.states) {
+          compilerState.states.set(s.name, s);
+        }
+        compilerState.transitions.push(...result.transitions);
+        compilerState.actionCounter = actionCounter.value;
+        return;
+      }
+    }
+  }
+  let parentFn = null;
+  let parentName = "";
+  let paramName = "";
+  let paramTypeName = "";
+  for (const node of path.node.body) {
+    if (t12.isExportDefaultDeclaration(node) && t12.isFunctionDeclaration(node.declaration)) {
+      const fn = node.declaration;
+      if (fn.async && fn.params.length > 0) {
+        parentFn = fn;
+        parentName = fn.id?.name || "workflow";
+        const param = fn.params[0];
+        if (t12.isIdentifier(param)) {
+          paramName = param.name;
+          if (param.typeAnnotation && t12.isTSTypeAnnotation(param.typeAnnotation)) {
+            const typeAnno = param.typeAnnotation.typeAnnotation;
+            if (t12.isTSTypeReference(typeAnno) && t12.isIdentifier(typeAnno.typeName)) {
+              paramTypeName = typeAnno.typeName.name;
+            }
+          }
+        }
+      }
+    }
+  }
+  if (!parentFn || !paramName) return;
+  const slug = fnNameToSlug(parentName.replace(/Workflow$/, ""));
+  compilerState.metadata.slug = slug;
+  compilerState.metadata.category = "workflow";
+  for (const node of path.node.body) {
+    if (t12.isTSInterfaceDeclaration(node) && node.id.name === paramTypeName) {
+      const fields = extractFieldsFromInterface2(node);
+      compilerState.fields.push(...fields);
+      compilerState.metadata.name = paramTypeName;
+    }
+    if (t12.isExportNamedDeclaration(node) && t12.isTSInterfaceDeclaration(node.declaration) && node.declaration.id.name === paramTypeName) {
+      const fields = extractFieldsFromInterface2(node.declaration);
+      compilerState.fields.push(...fields);
+      compilerState.metadata.name = paramTypeName;
+    }
+  }
+  const localFns = /* @__PURE__ */ new Map();
+  const localFnNames = /* @__PURE__ */ new Set();
+  for (const node of path.node.body) {
+    if (t12.isFunctionDeclaration(node) && node.async && node.id) {
+      if (node.id.name !== parentName) {
+        localFns.set(node.id.name, node);
+        localFnNames.add(node.id.name);
+      }
+    }
+    if (t12.isExportNamedDeclaration(node) && t12.isFunctionDeclaration(node.declaration) && node.declaration.async && node.declaration.id) {
+      if (node.declaration.id.name !== parentName) {
+        localFns.set(node.declaration.id.name, node.declaration);
+        localFnNames.add(node.declaration.id.name);
+      }
+    }
+  }
+  for (const node of path.node.body) {
+    if (t12.isExportNamedDeclaration(node) && t12.isVariableDeclaration(node.declaration)) {
+      for (const decl of node.declaration.declarations) {
+        if (t12.isIdentifier(decl.id) && decl.id.name === "defaults" && t12.isObjectExpression(decl.init)) {
+          const defaults = extractNodeValue2(decl.init);
+          for (const [name, value] of Object.entries(defaults)) {
+            const field = compilerState.fields.find((f) => f.name === name);
+            if (field && value !== void 0) {
+              field.default_value = value;
+            }
+          }
+        }
+      }
+    }
+  }
+  const stateFnInfos = /* @__PURE__ */ new Map();
+  for (const [name, fn] of localFns) {
+    const fnParamName = fn.params[0] && t12.isIdentifier(fn.params[0]) ? fn.params[0].name : paramName;
+    const analysis = analyzeStateFn(fn, fnParamName, actionCounter);
+    stateFnInfos.set(name, {
+      name,
+      node: fn,
+      params: fn.params.map((p) => t12.isIdentifier(p) ? p.name : ""),
+      ...analysis
+    });
+  }
+  detectComputedFieldsFromActions(compilerState, stateFnInfos);
+  detectComputedFieldGetters(path, paramName, paramTypeName, compilerState);
+  const callSequence = extractCallSequence(
+    parentFn.body,
+    paramName,
+    localFnNames,
+    importedFns
+  );
+  const allowTransitions = extractAllowTransitions(parentFn.body);
+  const referencedStates = /* @__PURE__ */ new Set();
+  let firstStateName = "";
+  let prevStateName = "";
+  let transitionIndex = 0;
+  for (const call of callSequence) {
+    const stateName = toSnakeCase2(call.name);
+    switch (call.type) {
+      case "stateCall": {
+        if (call.name.startsWith("__compensation_") && call.options?.__isCompensation) {
+          const compOpts = call.options;
+          const tryCallNames = compOpts.__tryBlockCallNames || [];
+          const compensationCalls = compOpts.__compensationCalls || [];
+          const hasReturn = compOpts.__hasReturn;
+          const catchBody = compOpts.__catchBody;
+          const compIndex = ++transitionIndex;
+          const compStateName = `compensation_${compIndex}`;
+          const compActions = [];
+          if (catchBody) {
+            for (const innerStmt of catchBody.body) {
+              if (t12.isReturnStatement(innerStmt)) continue;
+              if (t12.isExpressionStatement(innerStmt)) {
+                const innerExpr = innerStmt.expression;
+                if (t12.isAssignmentExpression(innerExpr) && t12.isMemberExpression(innerExpr.left)) {
+                  const left = memberExprToString(innerExpr.left);
+                  if (left.startsWith(`${paramName}.`)) {
+                    const field = left.slice(paramName.length + 1);
+                    const valueExpr = expressionToIR(innerExpr.right, paramName);
+                    compActions.push({
+                      id: `auto_${++actionCounter.value}`,
+                      type: "set_field",
+                      mode: "auto",
+                      config: { field, expression: valueExpr }
+                    });
+                  }
+                }
+                if (t12.isAwaitExpression(innerExpr) && t12.isCallExpression(innerExpr.argument)) {
+                  const innerCall = innerExpr.argument;
+                  const fnName = t12.isIdentifier(innerCall.callee) ? innerCall.callee.name : null;
+                  if (fnName && importedFns.has(fnName)) {
+                    compActions.push({
+                      id: `auto_${++actionCounter.value}`,
+                      type: "call_workflow",
+                      mode: "auto",
+                      config: { definition_slug: fnNameToSlug(fnName), blocking: true }
+                    });
+                  }
+                  if (fnName === "log") {
+                    const event = innerCall.arguments[0] ? extractNodeValue2(innerCall.arguments[0]) : "";
+                    compActions.push({
+                      id: `auto_${++actionCounter.value}`,
+                      type: "log_event",
+                      mode: "auto",
+                      config: { event: String(event) }
+                    });
+                  }
+                  if (fnName === "notify") {
+                    const to = innerCall.arguments[0] ? expressionToIR(innerCall.arguments[0], paramName) : "";
+                    const message = innerCall.arguments[1] ? extractNodeValue2(innerCall.arguments[1]) : "";
+                    compActions.push({
+                      id: `auto_${++actionCounter.value}`,
+                      type: "send_notification",
+                      mode: "auto",
+                      config: { to: String(to), message: String(message) }
+                    });
+                  }
+                  if (fnName === "emit") {
+                    const event = innerCall.arguments[0] ? extractNodeValue2(innerCall.arguments[0]) : "";
+                    compActions.push({
+                      id: `auto_${++actionCounter.value}`,
+                      type: "emit_event",
+                      mode: "auto",
+                      config: { event: String(event) }
+                    });
+                  }
+                }
+                if (t12.isCallExpression(innerExpr)) {
+                  const fnName = t12.isIdentifier(innerExpr.callee) ? innerExpr.callee.name : null;
+                  if (fnName === "log") {
+                    const event = innerExpr.arguments[0] ? extractNodeValue2(innerExpr.arguments[0]) : "";
+                    compActions.push({
+                      id: `auto_${++actionCounter.value}`,
+                      type: "log_event",
+                      mode: "auto",
+                      config: { event: String(event) }
+                    });
+                  }
+                  if (fnName === "notify") {
+                    const to = innerExpr.arguments[0] ? expressionToIR(innerExpr.arguments[0], paramName) : "";
+                    const message = innerExpr.arguments[1] ? extractNodeValue2(innerExpr.arguments[1]) : "";
+                    compActions.push({
+                      id: `auto_${++actionCounter.value}`,
+                      type: "send_notification",
+                      mode: "auto",
+                      config: { to: String(to), message: String(message) }
+                    });
+                  }
+                  if (fnName === "emit") {
+                    const event = innerExpr.arguments[0] ? extractNodeValue2(innerExpr.arguments[0]) : "";
+                    compActions.push({
+                      id: `auto_${++actionCounter.value}`,
+                      type: "emit_event",
+                      mode: "auto",
+                      config: { event: String(event) }
+                    });
+                  }
+                }
+              }
+              if (t12.isIfStatement(innerStmt) && t12.isBlockStatement(innerStmt.consequent)) {
+                const condStr = expressionToIR(innerStmt.test, paramName);
+                for (const ifInner of innerStmt.consequent.body) {
+                  if (t12.isExpressionStatement(ifInner)) {
+                    const ifExpr = ifInner.expression;
+                    if (t12.isAssignmentExpression(ifExpr) && t12.isMemberExpression(ifExpr.left)) {
+                      const left = memberExprToString(ifExpr.left);
+                      if (left.startsWith(`${paramName}.`)) {
+                        const field = left.slice(paramName.length + 1);
+                        const valueExpr = expressionToIR(ifExpr.right, paramName);
+                        compActions.push({
+                          id: `auto_${++actionCounter.value}`,
+                          type: "set_field",
+                          mode: "auto",
+                          config: { field, expression: valueExpr },
+                          condition: condStr
+                        });
+                      }
+                    }
+                    if (t12.isAwaitExpression(ifExpr) && t12.isCallExpression(ifExpr.argument)) {
+                      const ifCall = ifExpr.argument;
+                      const fnName = t12.isIdentifier(ifCall.callee) ? ifCall.callee.name : null;
+                      if (fnName && importedFns.has(fnName)) {
+                        compActions.push({
+                          id: `auto_${++actionCounter.value}`,
+                          type: "call_workflow",
+                          mode: "auto",
+                          config: { definition_slug: fnNameToSlug(fnName), blocking: true },
+                          condition: condStr
+                        });
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+          for (const cc of compensationCalls) {
+            if (cc.type === "serviceCall") {
+              compActions.push({
+                id: `auto_${++actionCounter.value}`,
+                type: "call_workflow",
+                mode: "auto",
+                config: { definition_slug: fnNameToSlug(cc.name), blocking: true }
+              });
+            }
+          }
+          compilerState.states.set(compStateName, {
+            name: compStateName,
+            type: hasReturn ? "END" : "REGULAR",
+            on_enter: compActions,
+            during: [],
+            on_exit: []
+          });
+          for (const tryCallName of tryCallNames) {
+            let tryStateName;
+            if (localFnNames.has(tryCallName)) {
+              tryStateName = toSnakeCase2(tryCallName);
+            } else if (importedFns.has(tryCallName)) {
+              tryStateName = `awaiting_${toSnakeCase2(tryCallName)}`;
+            } else {
+              tryStateName = toSnakeCase2(tryCallName);
+            }
+            if (compilerState.states.has(tryStateName)) {
+              compilerState.transitions.push({
+                name: `error_to_${compStateName}`,
+                from: [tryStateName],
+                to: compStateName,
+                conditions: [{ expression: "error != null" }],
+                actions: [],
+                auto: true
+              });
+            }
+          }
+          if (!hasReturn) {
+            prevStateName = compStateName;
+          }
+          break;
+        }
+        referencedStates.add(call.name);
+        if (!firstStateName) firstStateName = stateName;
+        const info = stateFnInfos.get(call.name);
+        if (info && !compilerState.states.has(stateName)) {
+          compilerState.states.set(stateName, {
+            name: stateName,
+            type: !firstStateName || stateName === toSnakeCase2(callSequence[0]?.name || "") ? "START" : "REGULAR",
+            on_enter: info.onEnter,
+            during: info.during,
+            on_exit: [],
+            ...info.onEvent.length > 0 ? { on_event: info.onEvent } : {},
+            ...info.timeout ? { timeout: info.timeout } : {},
+            ...info.runtime ? { runtime: info.runtime } : {}
+          });
+        } else if (!compilerState.states.has(stateName)) {
+          compilerState.states.set(stateName, {
+            name: stateName,
+            type: "REGULAR",
+            on_enter: [],
+            during: [],
+            on_exit: []
+          });
+        }
+        if (prevStateName && prevStateName !== stateName) {
+          const transName = call.transitionName || `to_${stateName}`;
+          const conditions = [];
+          if (call.condition) {
+            conditions.push({ expression: call.condition });
+          }
+          if (info?.roles.length) {
+            for (const role of info.roles) {
+              conditions.push(roleCondition(role));
+            }
+          }
+          compilerState.transitions.push({
+            name: transName,
+            from: [prevStateName],
+            to: stateName,
+            conditions: conditions.length > 0 ? conditions : void 0,
+            actions: [],
+            ...info?.requiredFields.length ? { required_fields: info.requiredFields } : {},
+            auto: true
+          });
+        }
+        prevStateName = stateName;
+        break;
+      }
+      case "userAction": {
+        const awaitState = `awaiting_${call.name}`;
+        if (!compilerState.states.has(awaitState)) {
+          compilerState.states.set(awaitState, {
+            name: awaitState,
+            type: "REGULAR",
+            on_enter: [],
+            during: [],
+            on_exit: []
+          });
+        }
+        if (prevStateName) {
+          compilerState.transitions.push({
+            name: `to_${awaitState}`,
+            from: [prevStateName],
+            to: awaitState,
+            actions: [],
+            auto: true,
+            ...call.condition ? { conditions: [{ expression: call.condition }] } : {}
+          });
+        }
+        const opts = call.options || {};
+        const conditions = [];
+        if (opts.roles && Array.isArray(opts.roles)) {
+          for (const role of opts.roles) {
+            conditions.push(roleCondition(role));
+          }
+        }
+        if (opts.when && typeof opts.when === "string") {
+          conditions.push({ expression: opts.when });
+        }
+        compilerState.transitions.push({
+          name: call.name,
+          from: [awaitState],
+          to: "",
+          // Will be resolved later (next state in sequence)
+          conditions: conditions.length > 0 ? conditions : void 0,
+          actions: [],
+          ...opts.require ? { required_fields: opts.require } : {}
+        });
+        prevStateName = awaitState;
+        break;
+      }
+      case "userChoice": {
+        const choiceState = prevStateName || "choice";
+        if (call.choices) {
+          for (const [optionName, optionConfig] of Object.entries(call.choices)) {
+            const config = optionConfig;
+            const conditions = [];
+            if (config.roles && Array.isArray(config.roles)) {
+              for (const role of config.roles) {
+                conditions.push(roleCondition(role));
+              }
+            }
+            if (config.when && typeof config.when === "string") {
+              conditions.push({ expression: config.when });
+            }
+            compilerState.transitions.push({
+              name: optionName,
+              from: [choiceState],
+              to: "",
+              // Resolved by switch/case handling
+              conditions: conditions.length > 0 ? conditions : void 0,
+              actions: [],
+              ...config.require ? { required_fields: config.require } : {}
+            });
+          }
+        }
+        break;
+      }
+      case "serviceCall": {
+        const serviceSlug = fnNameToSlug(call.name);
+        const serviceState = `awaiting_${toSnakeCase2(call.name)}`;
+        compilerState.states.set(serviceState, {
+          name: serviceState,
+          type: "REGULAR",
+          on_enter: [{
+            id: `auto_${++actionCounter.value}`,
+            type: "call_workflow",
+            mode: "auto",
+            config: {
+              definition_slug: serviceSlug,
+              blocking: true
+            }
+          }],
+          during: [],
+          on_exit: []
+        });
+        if (prevStateName) {
+          compilerState.transitions.push({
+            name: `call_${toSnakeCase2(call.name)}`,
+            from: [prevStateName],
+            to: serviceState,
+            actions: [],
+            auto: true,
+            ...call.condition ? { conditions: [{ expression: call.condition }] } : {}
+          });
+        }
+        prevStateName = serviceState;
+        break;
+      }
+      case "awaitOn": {
+        const eventState = `awaiting_${call.name}`;
+        const opts = call.options || {};
+        const eventPattern = opts.__eventPattern ? String(opts.__eventPattern) : call.name.replace(/_/g, ":");
+        const awaitOnMetadata = {
+          event_pattern: eventPattern
+        };
+        if (opts.when && typeof opts.when === "string") {
+          awaitOnMetadata.event_condition = String(opts.when);
+        }
+        if (opts.timeout) {
+          awaitOnMetadata.event_timeout = String(opts.timeout);
+        }
+        const awaitState = {
+          name: eventState,
+          type: "REGULAR",
+          on_enter: [],
+          during: [],
+          on_exit: [],
+          ...opts.timeout ? { timeout: { duration: String(opts.timeout) } } : {}
+        };
+        if (awaitOnMetadata) awaitState.metadata = awaitOnMetadata;
+        compilerState.states.set(eventState, awaitState);
+        if (prevStateName) {
+          compilerState.transitions.push({
+            name: `await_${call.name}`,
+            from: [prevStateName],
+            to: eventState,
+            actions: [],
+            auto: true,
+            ...call.condition ? { conditions: [{ expression: call.condition }] } : {}
+          });
+        }
+        const eventConditions = [];
+        if (opts.when && typeof opts.when === "string") {
+          eventConditions.push({ expression: String(opts.when) });
+        }
+        compilerState.transitions.push({
+          name: `${call.name}_matched`,
+          from: [eventState],
+          to: "",
+          // Resolved to next state
+          conditions: eventConditions.length > 0 ? eventConditions : void 0,
+          actions: [],
+          auto: true
+        });
+        prevStateName = eventState;
+        break;
+      }
+      case "promiseAll": {
+        const parallelState = `parallel_${++transitionIndex}`;
+        const parallelActions = [];
+        for (const pc of call.parallelCalls || []) {
+          if (pc.type === "serviceCall") {
+            parallelActions.push({
+              id: `auto_${++actionCounter.value}`,
+              type: "call_workflow",
+              mode: "auto",
+              config: {
+                definition_slug: fnNameToSlug(pc.name),
+                blocking: true
+              }
+            });
+          }
+        }
+        compilerState.states.set(parallelState, {
+          name: parallelState,
+          type: "REGULAR",
+          on_enter: parallelActions,
+          during: [],
+          on_exit: []
+        });
+        if (prevStateName) {
+          compilerState.transitions.push({
+            name: `to_${parallelState}`,
+            from: [prevStateName],
+            to: parallelState,
+            actions: [],
+            auto: true
+          });
+        }
+        prevStateName = parallelState;
+        break;
+      }
+      case "delay": {
+        const delayState = `delay_${++transitionIndex}`;
+        const durationMatch = call.name.match(/delay_(.+)/);
+        const duration = durationMatch ? durationMatch[1] : "0";
+        compilerState.states.set(delayState, {
+          name: delayState,
+          type: "REGULAR",
+          on_enter: [],
+          during: [],
+          on_exit: [],
+          timeout: { duration, fallback: {} }
+        });
+        if (prevStateName) {
+          compilerState.transitions.push({
+            name: `to_${delayState}`,
+            from: [prevStateName],
+            to: delayState,
+            actions: [],
+            auto: true
+          });
+        }
+        prevStateName = delayState;
+        break;
+      }
+    }
+  }
+  if (prevStateName && compilerState.states.has(prevStateName)) {
+    const lastState = compilerState.states.get(prevStateName);
+    const hasOutgoing = compilerState.transitions.some((t22) => t22.from.includes(prevStateName));
+    if (!hasOutgoing) {
+      lastState.type = "END";
+    }
+  }
+  if (firstStateName && compilerState.states.has(firstStateName)) {
+    compilerState.states.get(firstStateName).type = "START";
+  }
+  for (let i = 0; i < compilerState.transitions.length; i++) {
+    const trans = compilerState.transitions[i];
+    if (trans.to === "" && i + 1 < compilerState.transitions.length) {
+      const nextTrans = compilerState.transitions[i + 1];
+      if (nextTrans.to) {
+        trans.to = nextTrans.to;
+      } else if (nextTrans.from.length > 0) {
+      }
+    }
+  }
+  const stateSequence = callSequence.filter((c) => c.type === "stateCall" || c.type === "serviceCall" || c.type === "userAction" || c.type === "awaitOn").map((c) => {
+    if (c.type === "stateCall") return toSnakeCase2(c.name);
+    if (c.type === "userAction") return `awaiting_${c.name}`;
+    if (c.type === "serviceCall") return `awaiting_${toSnakeCase2(c.name)}`;
+    if (c.type === "awaitOn") return `awaiting_${c.name}`;
+    return c.name;
+  });
+  for (const trans of compilerState.transitions) {
+    if (trans.to === "") {
+      const fromState = trans.from[0];
+      const idx = stateSequence.indexOf(fromState);
+      if (idx >= 0 && idx + 1 < stateSequence.length) {
+        trans.to = stateSequence[idx + 1];
+      }
+    }
+  }
+  for (const at of allowTransitions) {
+    const resolvedTo = at.to === "$self" ? "__self__" : toSnakeCase2(at.to);
+    const resolvedFrom = at.from.map((f) => toSnakeCase2(f));
+    const conditions = [];
+    if (at.roles) {
+      for (const role of at.roles) {
+        conditions.push(roleCondition(role));
+      }
+    }
+    if (at.when) {
+      conditions.push({ expression: at.when });
+    }
+    if (resolvedTo !== "__self__" && !compilerState.states.has(resolvedTo)) {
+      compilerState.states.set(resolvedTo, {
+        name: resolvedTo,
+        type: "REGULAR",
+        on_enter: [],
+        during: [],
+        on_exit: []
+      });
+    }
+    if (resolvedTo === "__self__") {
+      for (const from of resolvedFrom) {
+        compilerState.transitions.push({
+          name: at.name,
+          from: [from],
+          to: from,
+          conditions: conditions.length > 0 ? conditions : void 0,
+          actions: [],
+          ...at.require ? { required_fields: at.require } : {}
+        });
+      }
+    } else {
+      compilerState.transitions.push({
+        name: at.name,
+        from: resolvedFrom,
+        to: resolvedTo,
+        conditions: conditions.length > 0 ? conditions : void 0,
+        actions: [],
+        ...at.require ? { required_fields: at.require } : {}
+      });
+    }
+  }
+  for (const [, info] of stateFnInfos) {
+    for (const v of info.validations) {
+      if (v.field === "__cross__") continue;
+      const field = compilerState.fields.find((f) => f.name === v.field);
+      if (field) {
+        if (!field.validation) field.validation = {};
+        Object.assign(field.validation, v.validation);
+        if (v.validation.rules) {
+          if (!field.validation.rules) field.validation.rules = [];
+          field.validation.rules.push(...v.validation.rules);
+        }
+      }
+    }
+  }
+  for (const node of path.node.body) {
+    if (t12.isExportNamedDeclaration(node) && t12.isVariableDeclaration(node.declaration)) {
+      for (const decl of node.declaration.declarations) {
+        if (t12.isIdentifier(decl.id) && decl.id.name === "roles" && decl.init) {
+          let rolesObj = null;
+          if (t12.isCallExpression(decl.init) && t12.isIdentifier(decl.init.callee) && decl.init.callee.name === "defineRoles" && t12.isObjectExpression(decl.init.arguments[0])) {
+            rolesObj = decl.init.arguments[0];
+          } else if (t12.isObjectExpression(decl.init)) {
+            rolesObj = decl.init;
+          }
+          if (rolesObj) {
+            const roles = extractNodeValue2(rolesObj);
+            if (!compilerState.metadata.roles) compilerState.metadata.roles = {};
+            for (const [roleName, roleConfig] of Object.entries(roles)) {
+              compilerState.metadata.roles[roleName] = roleConfig;
+            }
+          }
+        }
+        if (t12.isIdentifier(decl.id) && decl.id.name === "fieldAccess" && t12.isObjectExpression(decl.init)) {
+          const access = extractNodeValue2(decl.init);
+          for (const [fieldName, config] of Object.entries(access)) {
+            const field = compilerState.fields.find((f) => f.name === fieldName);
+            if (field) {
+              if (config.visibleTo) field.visible_to_roles = config.visibleTo;
+              if (config.editableBy) field.editable_by_roles = config.editableBy;
+              if (config.editableIn) field.editable_in_states = config.editableIn;
+            }
+          }
+        }
+        if (t12.isIdentifier(decl.id) && decl.id.name === "config" && decl.init) {
+          if (t12.isCallExpression(decl.init) && t12.isIdentifier(decl.init.callee) && decl.init.callee.name === "orchestration" && t12.isObjectExpression(decl.init.arguments[0])) {
+            compilerState.metadata.orchestration = extractNodeValue2(decl.init.arguments[0]);
+          }
+        }
+      }
+    }
+  }
+  for (const node of path.node.body) {
+    if (t12.isExportNamedDeclaration(node) && t12.isVariableDeclaration(node.declaration)) {
+      for (const decl of node.declaration.declarations) {
+        if (t12.isIdentifier(decl.id) && decl.id.name === "fields" && t12.isObjectExpression(decl.init)) {
+          const fieldsConfig = extractNodeValue2(decl.init);
+          for (const [name, config] of Object.entries(fieldsConfig)) {
+            const field = compilerState.fields.find((f) => f.name === name);
+            if (!field) continue;
+            if (typeof config === "string") {
+              if (config.includes("!")) field.required = true;
+            } else if (typeof config === "object" && config !== null) {
+              const cfg = config;
+              if (cfg.required) field.required = true;
+              if (cfg.min !== void 0 || cfg.max !== void 0 || cfg.minLength !== void 0 || cfg.maxLength !== void 0 || cfg.pattern !== void 0) {
+                if (!field.validation) field.validation = {};
+                if (cfg.min !== void 0) field.validation.min = Number(cfg.min);
+                if (cfg.max !== void 0) field.validation.max = Number(cfg.max);
+                if (cfg.minLength !== void 0) field.validation.minLength = Number(cfg.minLength);
+                if (cfg.maxLength !== void 0) field.validation.maxLength = Number(cfg.maxLength);
+                if (cfg.pattern !== void 0) {
+                  if (!field.validation.rules) field.validation.rules = [];
+                  field.validation.rules.push({
+                    expression: `MATCHES(value, "${String(cfg.pattern)}")`,
+                    message: "Invalid format",
+                    severity: "error"
+                  });
+                }
+              }
+              if (cfg.default !== void 0) field.default_value = cfg.default;
+            }
+          }
+        }
+      }
+    }
+  }
+  compilerState.transitions = compilerState.transitions.filter((t22) => t22.to !== "");
+  for (const trans of compilerState.transitions) {
+    for (const from of trans.from) {
+      if (!compilerState.states.has(from)) {
+        compilerState.states.set(from, {
+          name: from,
+          type: "REGULAR",
+          on_enter: [],
+          during: [],
+          on_exit: []
+        });
+      }
+    }
+    if (!compilerState.states.has(trans.to)) {
+      compilerState.states.set(trans.to, {
+        name: trans.to,
+        type: "REGULAR",
+        on_enter: [],
+        during: [],
+        on_exit: []
+      });
+    }
+  }
+  compilerState.actionCounter = actionCounter.value;
+}
+
+// src/babel/extractors/server-action-extractor.ts
+var t13 = __toESM(require("@babel/types"));
+function isServerActionFile(filename) {
+  if (!filename) return false;
+  return /\.server\.(ts|tsx|js|jsx)$/.test(filename);
+}
+function extractServerActions(path, state) {
+  const compilerState = state;
+  const serverActions = [];
+  for (const node of path.node.body) {
+    if (t13.isExportNamedDeclaration(node)) {
+      const decl = node.declaration;
+      if (t13.isFunctionDeclaration(decl) && decl.id) {
+        const action = extractFunctionAction(decl);
+        if (action) {
+          const comments = node.leadingComments || decl.leadingComments || [];
+          action.description = extractDescription(comments);
+          serverActions.push(action);
+        }
+      }
+      if (t13.isVariableDeclaration(decl)) {
+        for (const varDecl of decl.declarations) {
+          if (!t13.isIdentifier(varDecl.id)) continue;
+          const init = varDecl.init;
+          if (t13.isArrowFunctionExpression(init) || t13.isFunctionExpression(init)) {
+            const action = {
+              name: varDecl.id.name,
+              async: init.async || false,
+              params: init.params.filter((p) => t13.isIdentifier(p)).map((p) => p.name)
+            };
+            if (init.params.length > 0) {
+              const firstParam = init.params[0];
+              if (t13.isIdentifier(firstParam) && firstParam.typeAnnotation) {
+                action.contextType = extractTypeName(firstParam.typeAnnotation);
+              }
+            }
+            serverActions.push(action);
+          }
+        }
+      }
+    }
+  }
+  if (serverActions.length > 0) {
+    if (!compilerState.metadata) compilerState.metadata = {};
+    compilerState.metadata.serverActions = serverActions;
+  }
+}
+function extractFunctionAction(decl) {
+  if (!decl.id) return null;
+  const action = {
+    name: decl.id.name,
+    async: decl.async || false,
+    params: decl.params.filter((p) => t13.isIdentifier(p)).map((p) => p.name)
+  };
+  if (decl.params.length > 0) {
+    const firstParam = decl.params[0];
+    if (t13.isIdentifier(firstParam) && firstParam.typeAnnotation) {
+      action.contextType = extractTypeName(firstParam.typeAnnotation);
+    }
+  }
+  return action;
+}
+function extractTypeName(annotation) {
+  if (t13.isTSTypeAnnotation(annotation)) {
+    const typeNode = annotation.typeAnnotation;
+    if (t13.isTSTypeReference(typeNode) && t13.isIdentifier(typeNode.typeName)) {
+      return typeNode.typeName.name;
+    }
+  }
+  return void 0;
+}
+function extractDescription(comments) {
+  for (const comment of comments) {
+    if (comment.type !== "CommentBlock") continue;
+    const lines = comment.value.split("\n");
+    for (const line of lines) {
+      const trimmed = line.replace(/^\s*\*\s?/, "").trim();
+      if (trimmed && !trimmed.startsWith("@")) {
+        return trimmed;
+      }
+    }
+  }
+  return void 0;
+}
+
+// src/babel/extractors/server-action-hook-extractor.ts
+var t14 = __toESM(require("@babel/types"));
+function extractServerActionHook(path, state) {
+  const args = path.node.arguments;
+  if (args.length < 1) return;
+  const nameArg = args[0];
+  if (!t14.isStringLiteral(nameArg)) return;
+  const compilerState = state;
+  const entry = {
+    name: nameArg.value
+  };
+  if (args.length > 1 && t14.isObjectExpression(args[1])) {
+    for (const prop of args[1].properties) {
+      if (!t14.isObjectProperty(prop) || !t14.isIdentifier(prop.key)) continue;
+      if (prop.key.name === "instanceId" && t14.isStringLiteral(prop.value)) {
+        entry.staticInstanceId = prop.value.value;
+      }
+    }
+  }
+  const parent = path.parentPath;
+  if (parent?.isVariableDeclarator() && t14.isIdentifier(parent.node.id)) {
+    entry.variableName = parent.node.id.name;
+  }
+  if (!compilerState.metadata) compilerState.metadata = {};
+  const meta = compilerState.metadata;
+  if (!meta.serverActionHooks) meta.serverActionHooks = [];
+  meta.serverActionHooks.push(entry);
+}
+
+// src/babel/extractors/server-state-extractor.ts
+var t15 = __toESM(require("@babel/types"));
+function extractServerState(path, state) {
+  const args = path.node.arguments;
+  if (args.length < 1) return;
+  const compilerState = state;
+  const entry = {};
+  const instanceArg = args[0];
+  if (t15.isStringLiteral(instanceArg)) {
+    entry.staticInstanceId = instanceArg.value;
+  }
+  if (args.length > 1 && t15.isObjectExpression(args[1])) {
+    for (const prop of args[1].properties) {
+      if (!t15.isObjectProperty(prop) || !t15.isIdentifier(prop.key)) continue;
+      if (prop.key.name === "enabled" && t15.isBooleanLiteral(prop.value)) {
+        if (!prop.value.value) entry.disabled = true;
+      }
+    }
+  }
+  const parent = path.parentPath;
+  if (parent?.isVariableDeclarator()) {
+    if (t15.isIdentifier(parent.node.id)) {
+      entry.variableName = parent.node.id.name;
+    } else if (t15.isObjectPattern(parent.node.id)) {
+      const props = parent.node.id.properties.filter((p) => t15.isObjectProperty(p) && t15.isIdentifier(p.key)).map((p) => p.key.name);
+      if (props.length > 0) {
+        entry.variableName = props.join(", ");
+      }
+    }
+  }
+  if (!compilerState.metadata) compilerState.metadata = {};
+  const meta = compilerState.metadata;
+  if (!meta.serverStateSubscriptions) meta.serverStateSubscriptions = [];
+  meta.serverStateSubscriptions.push(entry);
+  meta.requiresSSE = true;
+}
+
+// src/babel/extractors/grammar-island-extractor.ts
+var t16 = __toESM(require("@babel/types"));
+var GRAMMAR_TAGS = /* @__PURE__ */ new Set(["cedar", "sql", "cron", "dmn", "graphql", "jsonpath"]);
+function parseCedar(source) {
+  const policies = [];
+  const policyRegex = /(permit|forbid)\s*\(([^)]*)\)(?:\s*when\s*\{([^}]*)\})?/g;
+  let match;
   while ((match = policyRegex.exec(source)) !== null) {
     const [, effect, scope, condition] = match;
     const parts = scope.split(",").map((s) => s.trim());
@@ -3272,7 +5230,7 @@ function parseDmn(source) {
 }
 function extractGrammarIsland(path, state, slug) {
   const tag = path.node.tag;
-  if (!t15.isIdentifier(tag)) return;
+  if (!t16.isIdentifier(tag)) return;
   const tagName = tag.name;
   if (!GRAMMAR_TAGS.has(tagName)) return;
   const compilerState = state;
@@ -3282,7 +5240,7 @@ function extractGrammarIsland(path, state, slug) {
     rawSource += quasi.quasis[i].value.raw;
     if (i < quasi.expressions.length) {
       const expr = quasi.expressions[i];
-      if (t15.isIdentifier(expr)) {
+      if (t16.isIdentifier(expr)) {
         rawSource += `\${${expr.name}}`;
       } else {
         rawSource += `\${expr_${i}}`;
@@ -3326,16 +5284,16 @@ function extractGrammarIslands(path, state) {
   path.traverse({
     TaggedTemplateExpression(templatePath) {
       const tag = templatePath.node.tag;
-      if (!t15.isIdentifier(tag) || !GRAMMAR_TAGS.has(tag.name)) return;
+      if (!t16.isIdentifier(tag) || !GRAMMAR_TAGS.has(tag.name)) return;
       let slug = "unnamed";
       const parent = templatePath.parentPath;
-      if (parent && parent.isVariableDeclarator() && t15.isIdentifier(parent.node.id)) {
+      if (parent && parent.isVariableDeclarator() && t16.isIdentifier(parent.node.id)) {
         slug = parent.node.id.name;
       }
-      if (parent && parent.isObjectProperty() && t15.isIdentifier(parent.node.key)) {
+      if (parent && parent.isObjectProperty() && t16.isIdentifier(parent.node.key)) {
         slug = parent.node.key.name;
       }
-      if (parent && parent.isObjectProperty() && t15.isStringLiteral(parent.node.key)) {
+      if (parent && parent.isObjectProperty() && t16.isStringLiteral(parent.node.key)) {
         slug = parent.node.key.value;
       }
       extractGrammarIsland(templatePath, state, slug);
@@ -3344,12 +5302,12 @@ function extractGrammarIslands(path, state) {
 }
 
 // src/babel/extractors/context-extractor.ts
-var t16 = __toESM(require("@babel/types"));
+var t17 = __toESM(require("@babel/types"));
 function hasContextCreation(path) {
   let found = false;
   path.traverse({
     CallExpression(callPath) {
-      if (t16.isIdentifier(callPath.node.callee, { name: "createContext" })) {
+      if (t17.isIdentifier(callPath.node.callee, { name: "createContext" })) {
         found = true;
         callPath.stop();
       }
@@ -3365,9 +5323,9 @@ function extractContextWorkflows(path, state) {
     // Detect: const XContext = createContext(...)
     VariableDeclarator(declPath) {
       const init = declPath.node.init;
-      if (!init || !t16.isCallExpression(init)) return;
-      if (!t16.isIdentifier(init.callee, { name: "createContext" })) return;
-      if (!t16.isIdentifier(declPath.node.id)) return;
+      if (!init || !t17.isCallExpression(init)) return;
+      if (!t17.isIdentifier(init.callee, { name: "createContext" })) return;
+      if (!t17.isIdentifier(declPath.node.id)) return;
       const contextName = declPath.node.id.name;
       contextNames.set(contextName, contextName);
       const workflow = {
@@ -3376,25 +5334,25 @@ function extractContextWorkflows(path, state) {
         reducerActions: []
       };
       const typeParams = init.typeParameters;
-      if (typeParams && t16.isTSTypeParameterInstantiation(typeParams)) {
+      if (typeParams && t17.isTSTypeParameterInstantiation(typeParams)) {
         const typeArg = typeParams.params[0];
-        if (t16.isTSTypeReference(typeArg) && t16.isIdentifier(typeArg.typeName)) {
+        if (t17.isTSTypeReference(typeArg) && t17.isIdentifier(typeArg.typeName)) {
           const interfaceName = typeArg.typeName.name;
-          extractFieldsFromInterface2(path, interfaceName, workflow);
+          extractFieldsFromInterface3(path, interfaceName, workflow);
         }
       }
-      if (init.arguments.length > 0 && t16.isObjectExpression(init.arguments[0])) {
+      if (init.arguments.length > 0 && t17.isObjectExpression(init.arguments[0])) {
         workflow.initialState = extractObjectLiteral2(init.arguments[0]);
       }
       contextWorkflows.push(workflow);
     },
     // Detect useReducer(reducer, initialState) and extract reducer cases
     CallExpression(callPath) {
-      if (!t16.isIdentifier(callPath.node.callee, { name: "useReducer" })) return;
+      if (!t17.isIdentifier(callPath.node.callee, { name: "useReducer" })) return;
       const args = callPath.node.arguments;
       if (args.length < 1) return;
       const reducerArg = args[0];
-      if (!t16.isIdentifier(reducerArg)) return;
+      if (!t17.isIdentifier(reducerArg)) return;
       const reducerName = reducerArg.name;
       const actions = extractReducerActions(path, reducerName);
       if (contextWorkflows.length > 0) {
@@ -3410,13 +5368,13 @@ function extractContextWorkflows(path, state) {
     meta.contextWorkflows = contextWorkflows;
   }
 }
-function extractFieldsFromInterface2(path, interfaceName, workflow) {
+function extractFieldsFromInterface3(path, interfaceName, workflow) {
   path.traverse({
     TSInterfaceDeclaration(ifacePath) {
-      if (!t16.isIdentifier(ifacePath.node.id, { name: interfaceName })) return;
+      if (!t17.isIdentifier(ifacePath.node.id, { name: interfaceName })) return;
       for (const prop of ifacePath.node.body.body) {
-        if (!t16.isTSPropertySignature(prop)) continue;
-        if (!t16.isIdentifier(prop.key)) continue;
+        if (!t17.isTSPropertySignature(prop)) continue;
+        if (!t17.isIdentifier(prop.key)) continue;
         const field = {
           name: prop.key.name,
           type: extractTSType(prop.typeAnnotation),
@@ -3428,20 +5386,20 @@ function extractFieldsFromInterface2(path, interfaceName, workflow) {
   });
 }
 function extractTSType(annotation) {
-  if (!annotation || !t16.isTSTypeAnnotation(annotation)) return "unknown";
+  if (!annotation || !t17.isTSTypeAnnotation(annotation)) return "unknown";
   const typeNode = annotation.typeAnnotation;
-  if (t16.isTSStringKeyword(typeNode)) return "string";
-  if (t16.isTSNumberKeyword(typeNode)) return "number";
-  if (t16.isTSBooleanKeyword(typeNode)) return "boolean";
-  if (t16.isTSArrayType(typeNode)) return `${extractTSTypeNode(typeNode.elementType)}[]`;
-  if (t16.isTSTypeReference(typeNode) && t16.isIdentifier(typeNode.typeName)) return typeNode.typeName.name;
+  if (t17.isTSStringKeyword(typeNode)) return "string";
+  if (t17.isTSNumberKeyword(typeNode)) return "number";
+  if (t17.isTSBooleanKeyword(typeNode)) return "boolean";
+  if (t17.isTSArrayType(typeNode)) return `${extractTSTypeNode(typeNode.elementType)}[]`;
+  if (t17.isTSTypeReference(typeNode) && t17.isIdentifier(typeNode.typeName)) return typeNode.typeName.name;
   return "unknown";
 }
 function extractTSTypeNode(node) {
-  if (t16.isTSStringKeyword(node)) return "string";
-  if (t16.isTSNumberKeyword(node)) return "number";
-  if (t16.isTSBooleanKeyword(node)) return "boolean";
-  if (t16.isTSTypeReference(node) && t16.isIdentifier(node.typeName)) return node.typeName.name;
+  if (t17.isTSStringKeyword(node)) return "string";
+  if (t17.isTSNumberKeyword(node)) return "number";
+  if (t17.isTSBooleanKeyword(node)) return "boolean";
+  if (t17.isTSTypeReference(node) && t17.isIdentifier(node.typeName)) return node.typeName.name;
   return "unknown";
 }
 function extractReducerActions(path, reducerName) {
@@ -3453,7 +5411,7 @@ function extractReducerActions(path, reducerName) {
         SwitchStatement(switchPath) {
           for (const switchCase of switchPath.node.cases) {
             if (!switchCase.test) continue;
-            if (t16.isStringLiteral(switchCase.test)) {
+            if (t17.isStringLiteral(switchCase.test)) {
               actions.push({
                 type: switchCase.test.value
               });
@@ -3468,24 +5426,576 @@ function extractReducerActions(path, reducerName) {
 function extractObjectLiteral2(obj) {
   const result = {};
   for (const prop of obj.properties) {
-    if (!t16.isObjectProperty(prop) || !t16.isIdentifier(prop.key)) continue;
-    if (t16.isStringLiteral(prop.value)) result[prop.key.name] = prop.value.value;
-    else if (t16.isNumericLiteral(prop.value)) result[prop.key.name] = prop.value.value;
-    else if (t16.isBooleanLiteral(prop.value)) result[prop.key.name] = prop.value.value;
-    else if (t16.isNullLiteral(prop.value)) result[prop.key.name] = null;
-    else if (t16.isArrayExpression(prop.value)) result[prop.key.name] = [];
-    else if (t16.isObjectExpression(prop.value)) result[prop.key.name] = extractObjectLiteral2(prop.value);
+    if (!t17.isObjectProperty(prop) || !t17.isIdentifier(prop.key)) continue;
+    if (t17.isStringLiteral(prop.value)) result[prop.key.name] = prop.value.value;
+    else if (t17.isNumericLiteral(prop.value)) result[prop.key.name] = prop.value.value;
+    else if (t17.isBooleanLiteral(prop.value)) result[prop.key.name] = prop.value.value;
+    else if (t17.isNullLiteral(prop.value)) result[prop.key.name] = null;
+    else if (t17.isArrayExpression(prop.value)) result[prop.key.name] = [];
+    else if (t17.isObjectExpression(prop.value)) result[prop.key.name] = extractObjectLiteral2(prop.value);
+  }
+  return result;
+}
+
+// src/babel/extractors/middleware-extractor.ts
+var t18 = __toESM(require("@babel/types"));
+var BUILTIN_FACTORIES = /* @__PURE__ */ new Set([
+  "withAuth",
+  "withAuditLog",
+  "withRateLimit",
+  "withValidation",
+  "withMetrics"
+]);
+function hasMiddleware(path) {
+  for (const node of path.node.body) {
+    if (t18.isExportDefaultDeclaration(node)) {
+      const decl = node.declaration;
+      if (isDefineMiddlewareCall(decl) || isBuiltinFactoryCall(decl)) {
+        return true;
+      }
+    }
+    if (t18.isExportNamedDeclaration(node) && node.declaration) {
+      if (t18.isVariableDeclaration(node.declaration)) {
+        for (const declarator of node.declaration.declarations) {
+          if (declarator.init && (isDefineMiddlewareCall(declarator.init) || isBuiltinFactoryCall(declarator.init))) {
+            return true;
+          }
+        }
+      }
+    }
+    if (t18.isVariableDeclaration(node)) {
+      for (const declarator of node.declarations) {
+        if (declarator.init && (isDefineMiddlewareCall(declarator.init) || isBuiltinFactoryCall(declarator.init))) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+function isDefineMiddlewareCall(node) {
+  return t18.isCallExpression(node) && t18.isIdentifier(node.callee) && node.callee.name === "defineMiddleware";
+}
+function isBuiltinFactoryCall(node) {
+  return t18.isCallExpression(node) && t18.isIdentifier(node.callee) && BUILTIN_FACTORIES.has(node.callee.name);
+}
+function extractMiddleware(path, state) {
+  const compilerState = state;
+  if (!compilerState.metadata) compilerState.metadata = {};
+  const meta = compilerState.metadata;
+  if (!meta.middleware) meta.middleware = [];
+  const middlewareList = meta.middleware;
+  path.traverse({
+    CallExpression(callPath) {
+      const callee = callPath.node.callee;
+      if (!t18.isIdentifier(callee)) return;
+      if (callee.name === "defineMiddleware") {
+        const extracted = extractDefineMiddleware(callPath);
+        if (extracted) middlewareList.push(extracted);
+      } else if (BUILTIN_FACTORIES.has(callee.name)) {
+        const extracted = extractBuiltinFactory(callee.name, callPath);
+        if (extracted) middlewareList.push(extracted);
+      }
+    }
+  });
+}
+function extractDefineMiddleware(callPath) {
+  const args = callPath.node.arguments;
+  if (args.length < 1 || !t18.isObjectExpression(args[0])) return null;
+  const obj = args[0];
+  let name = "unnamed";
+  let match = [];
+  let priority = 0;
+  const before = [];
+  const after = [];
+  let hasAround = false;
+  let config;
+  for (const prop of obj.properties) {
+    if (!t18.isObjectProperty(prop) && !t18.isObjectMethod(prop)) continue;
+    const key = t18.isObjectProperty(prop) ? prop.key : prop.key;
+    const keyName = t18.isIdentifier(key) ? key.name : t18.isStringLiteral(key) ? key.value : null;
+    if (!keyName) continue;
+    switch (keyName) {
+      case "name":
+        if (t18.isObjectProperty(prop) && t18.isStringLiteral(prop.value)) {
+          name = prop.value.value;
+        }
+        break;
+      case "match":
+        if (t18.isObjectProperty(prop)) {
+          if (t18.isStringLiteral(prop.value)) {
+            match = [prop.value.value];
+          } else if (t18.isArrayExpression(prop.value)) {
+            match = prop.value.elements.filter((el) => t18.isStringLiteral(el)).map((el) => el.value);
+          }
+        }
+        break;
+      case "priority":
+        if (t18.isObjectProperty(prop) && t18.isNumericLiteral(prop.value)) {
+          priority = prop.value.value;
+        }
+        break;
+      case "config":
+        if (t18.isObjectProperty(prop) && t18.isObjectExpression(prop.value)) {
+          config = extractConfigSchema(prop.value);
+        }
+        break;
+      case "before":
+        if (t18.isObjectMethod(prop)) {
+          extractActionsFromBody(prop.body, before);
+        } else if (t18.isObjectProperty(prop)) {
+          const val = prop.value;
+          if (t18.isFunctionExpression(val) || t18.isArrowFunctionExpression(val)) {
+            const body = t18.isBlockStatement(val.body) ? val.body : null;
+            if (body) extractActionsFromBody(body, before);
+          }
+        }
+        break;
+      case "after":
+        if (t18.isObjectMethod(prop)) {
+          extractActionsFromBody(prop.body, after);
+        } else if (t18.isObjectProperty(prop)) {
+          const val = prop.value;
+          if (t18.isFunctionExpression(val) || t18.isArrowFunctionExpression(val)) {
+            const body = t18.isBlockStatement(val.body) ? val.body : null;
+            if (body) extractActionsFromBody(body, after);
+          }
+        }
+        break;
+      case "around":
+        hasAround = true;
+        break;
+    }
+  }
+  return { name, match, priority, before, after, hasAround, config };
+}
+function extractBuiltinFactory(factoryName, callPath) {
+  const args = callPath.node.arguments;
+  const opts = args.length > 0 && t18.isObjectExpression(args[0]) ? args[0] : null;
+  switch (factoryName) {
+    case "withAuth": {
+      let redirectTo;
+      if (opts) {
+        for (const prop of opts.properties) {
+          if (t18.isObjectProperty(prop) && t18.isIdentifier(prop.key) && prop.key.name === "redirectTo" && t18.isStringLiteral(prop.value)) {
+            redirectTo = prop.value.value;
+          }
+        }
+      }
+      return {
+        name: "mm:auth",
+        match: ["*:*:transition.execute"],
+        priority: 90,
+        before: [{ type: "block", args: { condition: "!ctx.actor.id", reason: redirectTo ? `redirect:${redirectTo}` : "Authentication required" } }],
+        after: [],
+        hasAround: false,
+        factory: "withAuth"
+      };
+    }
+    case "withAuditLog": {
+      let level = "info";
+      if (opts) {
+        for (const prop of opts.properties) {
+          if (t18.isObjectProperty(prop) && t18.isIdentifier(prop.key) && prop.key.name === "level" && t18.isStringLiteral(prop.value)) {
+            level = prop.value.value;
+          }
+        }
+      }
+      return {
+        name: "mm:audit-log",
+        match: ["*:*:transition.execute"],
+        priority: 0,
+        before: [],
+        after: [{ type: "modify", args: { __audit: { level } } }],
+        hasAround: false,
+        factory: "withAuditLog"
+      };
+    }
+    case "withRateLimit": {
+      let maxPerMinute = 60;
+      if (opts) {
+        for (const prop of opts.properties) {
+          if (t18.isObjectProperty(prop) && t18.isIdentifier(prop.key) && prop.key.name === "maxPerMinute" && t18.isNumericLiteral(prop.value)) {
+            maxPerMinute = prop.value.value;
+          }
+        }
+      }
+      return {
+        name: "mm:rate-limit",
+        match: ["*:*:transition.execute"],
+        priority: 80,
+        before: [{ type: "block", args: { condition: `counter >= ${maxPerMinute}`, reason: `Rate limit exceeded: ${maxPerMinute} per minute` } }],
+        after: [],
+        hasAround: false,
+        config: { maxPerMinute: { type: "number", default: maxPerMinute } },
+        factory: "withRateLimit"
+      };
+    }
+    case "withValidation": {
+      const rules = [];
+      if (opts) {
+        for (const prop of opts.properties) {
+          if (t18.isObjectProperty(prop) && t18.isIdentifier(prop.key) && prop.key.name === "rules" && t18.isArrayExpression(prop.value)) {
+            for (const el of prop.value.elements) {
+              if (!t18.isObjectExpression(el)) continue;
+              let fields = [];
+              let check = "";
+              let message = "";
+              for (const rp of el.properties) {
+                if (!t18.isObjectProperty(rp) || !t18.isIdentifier(rp.key)) continue;
+                if (rp.key.name === "fields" && t18.isArrayExpression(rp.value)) {
+                  fields = rp.value.elements.filter((e) => t18.isStringLiteral(e)).map((e) => e.value);
+                }
+                if (rp.key.name === "check" && t18.isStringLiteral(rp.value)) {
+                  check = rp.value.value;
+                }
+                if (rp.key.name === "message" && t18.isStringLiteral(rp.value)) {
+                  message = rp.value.value;
+                }
+              }
+              if (fields.length > 0) rules.push({ fields, check, message });
+            }
+          }
+        }
+      }
+      return {
+        name: "mm:validation",
+        match: ["*:*:field.change"],
+        priority: 70,
+        before: rules.map((r) => ({ type: "validate", args: { fields: r.fields, check: r.check, message: r.message } })),
+        after: [],
+        hasAround: false,
+        config: { rules: { type: "json", default: rules } },
+        factory: "withValidation"
+      };
+    }
+    case "withMetrics": {
+      let endpoint;
+      if (opts) {
+        for (const prop of opts.properties) {
+          if (t18.isObjectProperty(prop) && t18.isIdentifier(prop.key) && prop.key.name === "endpoint" && t18.isStringLiteral(prop.value)) {
+            endpoint = prop.value.value;
+          }
+        }
+      }
+      return {
+        name: "mm:metrics",
+        match: ["*:*:*"],
+        priority: 100,
+        before: [],
+        after: [],
+        hasAround: true,
+        config: { endpoint: { type: "string", default: endpoint } },
+        factory: "withMetrics"
+      };
+    }
+    default:
+      return null;
+  }
+}
+function extractActionsFromBody(body, actions) {
+  for (const stmt of body.body) {
+    if (t18.isExpressionStatement(stmt) && t18.isCallExpression(stmt.expression)) {
+      const call = stmt.expression;
+      if (t18.isMemberExpression(call.callee) && t18.isIdentifier(call.callee.property)) {
+        const method = call.callee.property.name;
+        if (method === "block" && call.arguments.length > 0) {
+          const arg = call.arguments[0];
+          actions.push({
+            type: "block",
+            args: { reason: t18.isStringLiteral(arg) ? arg.value : "<expression>" }
+          });
+        } else if (method === "modify" && call.arguments.length > 0) {
+          const arg = call.arguments[0];
+          actions.push({
+            type: "modify",
+            args: t18.isObjectExpression(arg) ? extractStaticObject(arg) : {}
+          });
+        } else if (method === "skip") {
+          actions.push({ type: "skip" });
+        }
+      }
+    }
+    if (t18.isIfStatement(stmt)) {
+      if (t18.isBlockStatement(stmt.consequent)) {
+        extractActionsFromBody(stmt.consequent, actions);
+      } else if (t18.isExpressionStatement(stmt.consequent)) {
+        extractActionsFromBody(
+          t18.blockStatement([stmt.consequent]),
+          actions
+        );
+      }
+    }
+  }
+}
+function extractStaticObject(obj) {
+  const result = {};
+  for (const prop of obj.properties) {
+    if (!t18.isObjectProperty(prop)) continue;
+    const key = t18.isIdentifier(prop.key) ? prop.key.name : t18.isStringLiteral(prop.key) ? prop.key.value : null;
+    if (!key) continue;
+    const val = prop.value;
+    if (t18.isStringLiteral(val)) result[key] = val.value;
+    else if (t18.isNumericLiteral(val)) result[key] = val.value;
+    else if (t18.isBooleanLiteral(val)) result[key] = val.value;
+    else if (t18.isNullLiteral(val)) result[key] = null;
+    else if (t18.isObjectExpression(val)) result[key] = extractStaticObject(val);
+    else if (t18.isMemberExpression(val)) {
+      result[key] = memberExprToString2(val);
+    } else {
+      result[key] = "<expression>";
+    }
   }
   return result;
 }
+function memberExprToString2(expr) {
+  const parts = [];
+  let current = expr;
+  while (t18.isMemberExpression(current)) {
+    if (t18.isIdentifier(current.property)) {
+      parts.unshift(current.property.name);
+    }
+    current = current.object;
+  }
+  if (t18.isIdentifier(current)) {
+    parts.unshift(current.name);
+  }
+  return "$" + parts.join(".");
+}
+function extractConfigSchema(obj) {
+  const schema = {};
+  for (const prop of obj.properties) {
+    if (!t18.isObjectProperty(prop) || !t18.isIdentifier(prop.key)) continue;
+    if (!t18.isObjectExpression(prop.value)) continue;
+    const entry = { type: "string" };
+    for (const inner of prop.value.properties) {
+      if (!t18.isObjectProperty(inner) || !t18.isIdentifier(inner.key)) continue;
+      if (inner.key.name === "type" && t18.isStringLiteral(inner.value)) {
+        entry.type = inner.value.value;
+      }
+      if (inner.key.name === "default") {
+        if (t18.isStringLiteral(inner.value)) entry.default = inner.value.value;
+        else if (t18.isNumericLiteral(inner.value)) entry.default = inner.value.value;
+        else if (t18.isBooleanLiteral(inner.value)) entry.default = inner.value.value;
+      }
+    }
+    schema[prop.key.name] = entry;
+  }
+  return schema;
+}
+
+// src/babel/extractors/constraint-extractor.ts
+var t19 = __toESM(require("@babel/types"));
+var BUILTIN_CONSTRAINTS = /* @__PURE__ */ new Set([
+  "every state is reachable",
+  "no deadlocks",
+  "no unreachable states",
+  "deterministic guards",
+  "terminates",
+  "no guard overlaps",
+  "all roles defined",
+  "all fields validated"
+]);
+function hasConstraints(path) {
+  for (const node of path.node.body) {
+    if (t19.isExportNamedDeclaration(node) && node.declaration) {
+      if (t19.isVariableDeclaration(node.declaration)) {
+        for (const declarator of node.declaration.declarations) {
+          if (declarator.init && isConstraintsCall(declarator.init)) {
+            return true;
+          }
+        }
+      }
+    }
+    if (t19.isVariableDeclaration(node)) {
+      for (const declarator of node.declarations) {
+        if (declarator.init && isConstraintsCall(declarator.init)) {
+          return true;
+        }
+      }
+    }
+    if (t19.isExpressionStatement(node) && isConstraintsCall(node.expression)) {
+      return true;
+    }
+  }
+  return false;
+}
+function isConstraintsCall(node) {
+  return t19.isCallExpression(node) && t19.isIdentifier(node.callee) && node.callee.name === "constraints";
+}
+function extractConstraints(path, state) {
+  const compilerState = state;
+  if (!compilerState.metadata) compilerState.metadata = {};
+  const meta = compilerState.metadata;
+  if (!meta.constraints) meta.constraints = [];
+  const constraintList = meta.constraints;
+  path.traverse({
+    CallExpression(callPath) {
+      const callee = callPath.node.callee;
+      if (!t19.isIdentifier(callee) || callee.name !== "constraints") return;
+      const args = callPath.node.arguments;
+      for (const arg of args) {
+        if (t19.isStringLiteral(arg)) {
+          constraintList.push({
+            rule: arg.value,
+            type: BUILTIN_CONSTRAINTS.has(arg.value) ? "builtin" : "custom"
+          });
+        }
+      }
+    }
+  });
+}
 
-// ../player-core/dist/index.mjs
-function normalizeCategory(primary, ...tags) {
-  const uniqueTags = [...new Set(tags.filter((t18) => t18 !== primary))];
-  uniqueTags.sort();
-  return [primary, ...uniqueTags];
+// src/babel/extractors/actor-extractor.ts
+var t20 = __toESM(require("@babel/types"));
+function hasActorConfig(path) {
+  for (const node of path.node.body) {
+    if (t20.isExportNamedDeclaration(node) && node.declaration) {
+      if (t20.isVariableDeclaration(node.declaration)) {
+        for (const declarator of node.declaration.declarations) {
+          if (declarator.init && isActorCall(declarator.init)) {
+            return true;
+          }
+        }
+      }
+    }
+    if (t20.isVariableDeclaration(node)) {
+      for (const declarator of node.declarations) {
+        if (declarator.init && isActorCall(declarator.init)) {
+          return true;
+        }
+      }
+    }
+    if (t20.isExpressionStatement(node) && isActorCall(node.expression)) {
+      return true;
+    }
+  }
+  return false;
+}
+function isActorCall(node) {
+  return t20.isCallExpression(node) && t20.isIdentifier(node.callee) && (node.callee.name === "configureActor" || node.callee.name === "spawnActor");
+}
+function extractActorConfig(path, state) {
+  const compilerState = state;
+  if (!compilerState.metadata) compilerState.metadata = {};
+  const meta = compilerState.metadata;
+  if (!meta.actor) {
+    meta.actor = {
+      supervision: { strategy: "escalate" },
+      mailbox: {},
+      hierarchy: {},
+      spawns: []
+    };
+  }
+  const actorConfig = meta.actor;
+  path.traverse({
+    CallExpression(callPath) {
+      const callee = callPath.node.callee;
+      if (!t20.isIdentifier(callee)) return;
+      if (callee.name === "configureActor") {
+        extractConfigureActor(callPath, actorConfig);
+      } else if (callee.name === "spawnActor") {
+        extractSpawnActor(callPath, actorConfig);
+      }
+    }
+  });
+}
+function extractConfigureActor(callPath, actorConfig) {
+  const args = callPath.node.arguments;
+  if (args.length < 1 || !t20.isObjectExpression(args[0])) return;
+  const obj = args[0];
+  for (const prop of obj.properties) {
+    if (!t20.isObjectProperty(prop) || !t20.isIdentifier(prop.key)) continue;
+    switch (prop.key.name) {
+      case "supervision":
+        if (t20.isObjectExpression(prop.value)) {
+          actorConfig.supervision = extractSupervision(prop.value);
+        }
+        break;
+      case "mailbox":
+        if (t20.isObjectExpression(prop.value)) {
+          actorConfig.mailbox = extractMailbox(prop.value);
+        }
+        break;
+      case "hierarchy":
+        if (t20.isObjectExpression(prop.value)) {
+          actorConfig.hierarchy = extractStaticObj(prop.value);
+        }
+        break;
+    }
+  }
+}
+function extractSpawnActor(callPath, actorConfig) {
+  const args = callPath.node.arguments;
+  if (args.length < 1 || !t20.isStringLiteral(args[0])) return;
+  const spawn = { slug: args[0].value };
+  if (args.length > 1 && t20.isObjectExpression(args[1])) {
+    for (const prop of args[1].properties) {
+      if (!t20.isObjectProperty(prop) || !t20.isIdentifier(prop.key)) continue;
+      if (prop.key.name === "supervision" && t20.isObjectExpression(prop.value)) {
+        spawn.supervision = extractSupervision(prop.value);
+      } else if (prop.key.name === "blocking" && t20.isBooleanLiteral(prop.value)) {
+        spawn.blocking = prop.value.value;
+      }
+    }
+  }
+  actorConfig.spawns.push(spawn);
+}
+function extractSupervision(obj) {
+  const result = { strategy: "escalate" };
+  for (const prop of obj.properties) {
+    if (!t20.isObjectProperty(prop) || !t20.isIdentifier(prop.key)) continue;
+    switch (prop.key.name) {
+      case "strategy":
+        if (t20.isStringLiteral(prop.value)) result.strategy = prop.value.value;
+        break;
+      case "maxRetries":
+        if (t20.isNumericLiteral(prop.value)) result.maxRetries = prop.value.value;
+        break;
+      case "retryWindow":
+        if (t20.isStringLiteral(prop.value)) result.retryWindow = prop.value.value;
+        break;
+      case "backoff":
+        if (t20.isStringLiteral(prop.value)) result.backoff = prop.value.value;
+        break;
+    }
+  }
+  return result;
+}
+function extractMailbox(obj) {
+  const result = {};
+  for (const prop of obj.properties) {
+    if (!t20.isObjectProperty(prop) || !t20.isIdentifier(prop.key)) continue;
+    switch (prop.key.name) {
+      case "capacity":
+        if (t20.isNumericLiteral(prop.value)) result.capacity = prop.value.value;
+        break;
+      case "overflow":
+        if (t20.isStringLiteral(prop.value)) result.overflow = prop.value.value;
+        break;
+      case "priority":
+        if (t20.isStringLiteral(prop.value)) result.priority = prop.value.value;
+        break;
+    }
+  }
+  return result;
+}
+function extractStaticObj(obj) {
+  const result = {};
+  for (const prop of obj.properties) {
+    if (!t20.isObjectProperty(prop) || !t20.isIdentifier(prop.key)) continue;
+    const val = prop.value;
+    if (t20.isStringLiteral(val)) result[prop.key.name] = val.value;
+    else if (t20.isNumericLiteral(val)) result[prop.key.name] = val.value;
+    else if (t20.isBooleanLiteral(val)) result[prop.key.name] = val.value;
+    else if (t20.isNullLiteral(val)) result[prop.key.name] = null;
+  }
+  return result;
 }
 
+// src/babel/emitters/pure-form-emitter.ts
+var import_player_core = require("@mindmatrix/player-core");
+
 // src/babel/emitters/experience-transform.ts
 function transformToFrontend(node) {
   const result = {
@@ -3703,7 +6213,7 @@ function normalizeViewNode(node, fieldNames) {
   }
   return node;
 }
-function toSnakeCase2(str) {
+function toSnakeCase3(str) {
   return str.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
 }
 function convertAction(action) {
@@ -3771,6 +6281,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;
@@ -3786,7 +6308,7 @@ function emitIR(extracted) {
     if (fields.length > 0) {
       const localDefaults = {};
       for (const f of fields) {
-        localDefaults[toSnakeCase2(f.name)] = f.default_value ?? null;
+        localDefaults[toSnakeCase3(f.name)] = f.default_value ?? null;
       }
       if (!normalizedView.config) normalizedView.config = {};
       normalizedView.config.localDefaults = localDefaults;
@@ -3865,7 +6387,7 @@ function liftAction(action) {
   }
   return {
     slug: action.id,
-    category: normalizeCategory("expression", "mutation", action.type),
+    category: (0, import_player_core.normalizeCategory)("expression", "mutation", action.type),
     parts: parts.length > 0 ? parts : void 0
   };
 }
@@ -3895,7 +6417,7 @@ function liftSchedule(during) {
   for (const action of during.actions) {
     parts.push({
       slug: "do",
-      category: normalizeCategory("expression", "mutation", action.type),
+      category: (0, import_player_core.normalizeCategory)("expression", "mutation", action.type),
       parts: Object.entries(action.config || {}).map(([key, value]) => ({
         slug: key,
         category: ["atom"],
@@ -3905,7 +6427,7 @@ function liftSchedule(during) {
   }
   return {
     slug: during.id,
-    category: normalizeCategory("schedule", during.type),
+    category: (0, import_player_core.normalizeCategory)("schedule", during.type),
     parts
   };
 }
@@ -3918,14 +6440,14 @@ function liftState(state) {
   if (state.on_enter && state.on_enter.length > 0) {
     parts.push({
       slug: "on_enter",
-      category: normalizeCategory("expression", "sequence"),
+      category: (0, import_player_core.normalizeCategory)("expression", "sequence"),
       parts: state.on_enter.map(liftAction)
     });
   }
   if (state.on_exit && state.on_exit.length > 0) {
     parts.push({
       slug: "on_exit",
-      category: normalizeCategory("expression", "sequence"),
+      category: (0, import_player_core.normalizeCategory)("expression", "sequence"),
       parts: state.on_exit.map(liftAction)
     });
   }
@@ -3936,7 +6458,7 @@ function liftState(state) {
   }
   return {
     slug: state.name,
-    category: normalizeCategory("state", ...tags),
+    category: (0, import_player_core.normalizeCategory)("state", ...tags),
     parts: parts.length > 0 ? parts : void 0
   };
 }
@@ -3959,17 +6481,17 @@ function liftTransition(transition) {
   if (transition.actions && transition.actions.length > 0) {
     parts.push({
       slug: "actions",
-      category: normalizeCategory("expression", "sequence"),
+      category: (0, import_player_core.normalizeCategory)("expression", "sequence"),
       parts: transition.actions.map(liftAction)
     });
   }
   if (transition.conditions && transition.conditions.length > 0) {
     parts.push({
       slug: "conditions",
-      category: normalizeCategory("expression", "guard"),
+      category: (0, import_player_core.normalizeCategory)("expression", "guard"),
       parts: transition.conditions.map((c, i) => ({
         slug: `condition_${i}`,
-        category: normalizeCategory("expression", c.type || "condition"),
+        category: (0, import_player_core.normalizeCategory)("expression", c.type || "condition"),
         parts: c.expression ? [{ slug: c.expression, category: ["binding"] }] : void 0
       }))
     });
@@ -4008,7 +6530,7 @@ function liftField(field) {
   }
   return {
     slug: field.name,
-    category: normalizeCategory("field", field.type),
+    category: (0, import_player_core.normalizeCategory)("field", field.type),
     parts: parts.length > 0 ? parts : void 0
   };
 }
@@ -4031,20 +6553,20 @@ function liftView(node) {
         if (match) {
           parts.push({
             slug: key,
-            category: normalizeCategory("expression", "effect", "transition"),
+            category: (0, import_player_core.normalizeCategory)("expression", "effect", "transition"),
             parts: [{ slug: match[1], category: ["ref"] }]
           });
         } else {
           parts.push({
             slug: key,
-            category: normalizeCategory("expression", "binding"),
+            category: (0, import_player_core.normalizeCategory)("expression", "binding"),
             parts: [{ slug: String(expr), category: ["binding"] }]
           });
         }
       } else {
         parts.push({
           slug: key,
-          category: normalizeCategory("expression", "binding"),
+          category: (0, import_player_core.normalizeCategory)("expression", "binding"),
           parts: [{ slug: String(expr), category: ["binding"] }]
         });
       }
@@ -4055,20 +6577,20 @@ function liftView(node) {
     if (eqMatch) {
       parts.push({
         slug: "visible_when",
-        category: normalizeCategory("expression", "guard"),
+        category: (0, import_player_core.normalizeCategory)("expression", "guard"),
         parts: [{
           slug: "body",
-          category: normalizeCategory("expression", "eq"),
+          category: (0, import_player_core.normalizeCategory)("expression", "eq"),
           parts: [
-            { slug: "lhs", category: normalizeCategory("expression", "path"), parts: [{ slug: eqMatch[1], category: ["binding"] }] },
-            { slug: "rhs", category: normalizeCategory("expression", "literal"), parts: [{ slug: eqMatch[2], category: ["literal"] }] }
+            { slug: "lhs", category: (0, import_player_core.normalizeCategory)("expression", "path"), parts: [{ slug: eqMatch[1], category: ["binding"] }] },
+            { slug: "rhs", category: (0, import_player_core.normalizeCategory)("expression", "literal"), parts: [{ slug: eqMatch[2], category: ["literal"] }] }
           ]
         }]
       });
     } else {
       parts.push({
         slug: "visible_when",
-        category: normalizeCategory("expression", "guard"),
+        category: (0, import_player_core.normalizeCategory)("expression", "guard"),
         parts: [{ slug: node.visible_when, category: ["binding"] }]
       });
     }
@@ -4080,7 +6602,7 @@ function liftView(node) {
   }
   return {
     slug: node.id,
-    category: normalizeCategory("view", componentTag),
+    category: (0, import_player_core.normalizeCategory)("view", componentTag),
     parts: parts.length > 0 ? parts : void 0
   };
 }
@@ -4101,7 +6623,7 @@ function emitCanonical(extracted, sourceFilename) {
   }
   parts.push({
     slug: "manifest",
-    category: normalizeCategory("meta", "manifest"),
+    category: (0, import_player_core.normalizeCategory)("meta", "manifest"),
     parts: [
       {
         slug: "workflows",
@@ -4122,7 +6644,7 @@ function emitCanonical(extracted, sourceFilename) {
   let categoryArray;
   if (category.includes("/")) {
     const [primary, ...tags] = category.split("/");
-    categoryArray = normalizeCategory(primary, ...tags);
+    categoryArray = (0, import_player_core.normalizeCategory)(primary, ...tags);
   } else {
     categoryArray = [category];
   }
@@ -4184,7 +6706,7 @@ function emitWorkflowDefinition(extracted) {
     on_event: (s.on_event || []).map(convertOnEvent)
   }));
   const fields = ir.fields.map((f) => ({
-    name: toSnakeCase2(f.name),
+    name: toSnakeCase3(f.name),
     field_type: f.type,
     label: f.label || f.name.replace(/([A-Z])/g, " $1").replace(/^./, (c) => c.toUpperCase()),
     required: f.required || false,
@@ -4200,16 +6722,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((t18) => ({
-    name: t18.name,
-    from: t18.from,
-    to: t18.to,
-    description: t18.description || "",
-    roles: t18.roles || [],
-    auto: t18.auto || false,
-    conditions: t18.conditions || [],
-    actions: (t18.actions || []).map(convertAction),
-    required_fields: t18.required_fields || [],
+  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 || [],
     priority: 0
   }));
   const state_data = {};
@@ -4227,7 +6749,7 @@ function emitWorkflowDefinition(extracted) {
     if (extracted.fields.length > 0) {
       const localDefaults = {};
       for (const f of extracted.fields) {
-        localDefaults[toSnakeCase2(f.name)] = f.default_value ?? null;
+        localDefaults[toSnakeCase3(f.name)] = f.default_value ?? null;
       }
       if (!viewRoot.config) viewRoot.config = {};
       viewRoot.config.localDefaults = localDefaults;
@@ -4290,8 +6812,8 @@ function compilerStateToWorkflow(state, metadata) {
 function resolveSlugArg(args, state) {
   if (args.length < 1) return null;
   const slugArg = args[0];
-  if (t17.isStringLiteral(slugArg)) return slugArg.value;
-  if (t17.isIdentifier(slugArg)) {
+  if (t21.isStringLiteral(slugArg)) return slugArg.value;
+  if (t21.isIdentifier(slugArg)) {
     const compilerState = state;
     const meta = compilerState.metadata;
     const resolvedSlugs = meta.__modelImportSlugs;
@@ -4317,43 +6839,43 @@ function extractQueryDataSource(path, state) {
     slug,
     query: "list"
   };
-  if (args.length > 1 && t17.isObjectExpression(args[1])) {
+  if (args.length > 1 && t21.isObjectExpression(args[1])) {
     for (const prop of args[1].properties) {
-      if (!t17.isObjectProperty(prop) || !t17.isIdentifier(prop.key)) continue;
+      if (!t21.isObjectProperty(prop) || !t21.isIdentifier(prop.key)) continue;
       const key = prop.key.name;
       const val = prop.value;
       switch (key) {
         case "limit":
-          if (t17.isNumericLiteral(val)) {
+          if (t21.isNumericLiteral(val)) {
             dataSource.pageSize = val.value;
             dataSource.paginated = true;
           }
           break;
         case "orderBy":
-          if (t17.isStringLiteral(val)) {
+          if (t21.isStringLiteral(val)) {
             dataSource.sort = val.value;
           }
           break;
         case "order":
-          if (t17.isStringLiteral(val) && dataSource.sort) {
+          if (t21.isStringLiteral(val) && dataSource.sort) {
             dataSource.sort = `${dataSource.sort}:${val.value}`;
           }
           break;
         case "search":
-          if (t17.isStringLiteral(val)) {
+          if (t21.isStringLiteral(val)) {
             dataSource.search = val.value;
           }
           break;
         case "searchFields":
-          if (t17.isArrayExpression(val)) {
-            dataSource.searchFields = val.elements.filter((el) => t17.isStringLiteral(el)).map((el) => el.value);
+          if (t21.isArrayExpression(val)) {
+            dataSource.searchFields = val.elements.filter((el) => t21.isStringLiteral(el)).map((el) => el.value);
           }
           break;
         case "filter":
-          if (t17.isObjectExpression(val)) {
+          if (t21.isObjectExpression(val)) {
             const filter = {};
             for (const fp of val.properties) {
-              if (t17.isObjectProperty(fp) && t17.isIdentifier(fp.key) && t17.isStringLiteral(fp.value)) {
+              if (t21.isObjectProperty(fp) && t21.isIdentifier(fp.key) && t21.isStringLiteral(fp.value)) {
                 filter[fp.key.name] = fp.value.value;
               }
             }
@@ -4363,19 +6885,19 @@ function extractQueryDataSource(path, state) {
           }
           break;
         case "state":
-          if (t17.isStringLiteral(val)) {
+          if (t21.isStringLiteral(val)) {
             if (!dataSource.filter) dataSource.filter = {};
             dataSource.filter.current_state = val.value;
           }
           break;
         case "groupBy":
-          if (t17.isStringLiteral(val)) {
+          if (t21.isStringLiteral(val)) {
             dataSource.groupBy = val.value;
           }
           break;
         case "facets":
-          if (t17.isArrayExpression(val)) {
-            dataSource.facets = val.elements.filter((el) => t17.isStringLiteral(el)).map((el) => el.value);
+          if (t21.isArrayExpression(val)) {
+            dataSource.facets = val.elements.filter((el) => t21.isStringLiteral(el)).map((el) => el.value);
           }
           break;
       }
@@ -4399,17 +6921,17 @@ function extractMutationDataSource(path, state) {
 }
 function extractDuringAction(path, state) {
   const args = path.node.arguments;
-  if (args.length < 1 || !t17.isObjectExpression(args[0])) return;
+  if (args.length < 1 || !t21.isObjectExpression(args[0])) return;
   const compilerState = state;
   const config = args[0];
   let stateName;
   let intervalMs = 1e3;
   for (const prop of config.properties) {
-    if (!t17.isObjectProperty(prop) || !t17.isIdentifier(prop.key)) continue;
-    if (prop.key.name === "state" && t17.isStringLiteral(prop.value)) {
+    if (!t21.isObjectProperty(prop) || !t21.isIdentifier(prop.key)) continue;
+    if (prop.key.name === "state" && t21.isStringLiteral(prop.value)) {
       stateName = prop.value.value;
     }
-    if (prop.key.name === "intervalMs" && t17.isNumericLiteral(prop.value)) {
+    if (prop.key.name === "intervalMs" && t21.isNumericLiteral(prop.value)) {
       intervalMs = prop.value.value;
     }
   }
@@ -4435,7 +6957,7 @@ function extractDuringAction(path, state) {
 }
 function extractRoleDependency(path, state) {
   const args = path.node.arguments;
-  if (args.length < 1 || !t17.isStringLiteral(args[0])) return;
+  if (args.length < 1 || !t21.isStringLiteral(args[0])) return;
   const compilerState = state;
   if (!compilerState.metadata) compilerState.metadata = {};
   const meta = compilerState.metadata;
@@ -4446,7 +6968,7 @@ function extractRoleDependency(path, state) {
 }
 function extractViewDependency(path, state) {
   const args = path.node.arguments;
-  if (args.length < 1 || !t17.isStringLiteral(args[0])) return;
+  if (args.length < 1 || !t21.isStringLiteral(args[0])) return;
   const compilerState = state;
   if (!compilerState.metadata) compilerState.metadata = {};
   const meta = compilerState.metadata;
@@ -4463,7 +6985,7 @@ function extractParamsUsage(_path, state) {
 }
 function extractLibraryDependency(path, state) {
   const args = path.node.arguments;
-  if (args.length < 1 || !t17.isStringLiteral(args[0])) return;
+  if (args.length < 1 || !t21.isStringLiteral(args[0])) return;
   const compilerState = state;
   if (!compilerState.metadata) compilerState.metadata = {};
   const meta = compilerState.metadata;
@@ -4543,15 +7065,15 @@ function createVisitor(options = {}) {
           }
         }
         const exportDeclaration = program.body.find(
-          (node) => t17.isExportNamedDeclaration(node) || t17.isExportDefaultDeclaration(node)
+          (node) => t21.isExportNamedDeclaration(node) || t21.isExportDefaultDeclaration(node)
         );
         if (exportDeclaration) {
           if (exportDeclaration.leadingComments) {
             extractMetadataFromComments(exportDeclaration.leadingComments, compilerState.metadata);
           }
-          if (t17.isExportNamedDeclaration(exportDeclaration)) {
+          if (t21.isExportNamedDeclaration(exportDeclaration)) {
             const declaration = exportDeclaration.declaration;
-            if (t17.isFunctionDeclaration(declaration)) {
+            if (t21.isFunctionDeclaration(declaration)) {
               if (declaration.id) {
                 compilerState.metadata.name = declaration.id.name;
               }
@@ -4559,16 +7081,16 @@ function createVisitor(options = {}) {
                 extractMetadataFromComments(declaration.leadingComments, compilerState.metadata);
               }
             }
-          } else if (t17.isExportDefaultDeclaration(exportDeclaration)) {
+          } else if (t21.isExportDefaultDeclaration(exportDeclaration)) {
             const declaration = exportDeclaration.declaration;
-            if (t17.isFunctionDeclaration(declaration)) {
+            if (t21.isFunctionDeclaration(declaration)) {
               if (declaration.id) {
                 compilerState.metadata.name = declaration.id.name;
               }
               if (declaration.leadingComments) {
                 extractMetadataFromComments(declaration.leadingComments, compilerState.metadata);
               }
-            } else if (t17.isIdentifier(declaration)) {
+            } else if (t21.isIdentifier(declaration)) {
               compilerState.metadata.name = declaration.name;
             }
           }
@@ -4579,7 +7101,13 @@ function createVisitor(options = {}) {
           compilerState.metadata.__slugAutoFallback = true;
         }
         Object.assign(state, compilerState);
-        if (isModelFile(_path, state.filename)) {
+        if (isImperativeWorkflowFile(_path, state.filename)) {
+          extractImperativeWorkflow(_path, state);
+          state.__isModelFile = true;
+          if (!compilerState.metadata.category) {
+            compilerState.metadata.category = "workflow";
+          }
+        } else if (isModelFile(_path, state.filename)) {
           extractModelFile(_path, state);
           state.__isModelFile = true;
           if (!compilerState.metadata.category) {
@@ -4590,6 +7118,15 @@ function createVisitor(options = {}) {
         if (hasContextCreation(_path)) {
           extractContextWorkflows(_path, state);
         }
+        if (hasMiddleware(_path)) {
+          extractMiddleware(_path, state);
+        }
+        if (hasConstraints(_path)) {
+          extractConstraints(_path, state);
+        }
+        if (hasActorConfig(_path)) {
+          extractActorConfig(_path, state);
+        }
         if (isServerActionFile(state.filename)) {
           extractServerActions(_path, state);
           state.__isServerActionFile = true;
@@ -4625,7 +7162,7 @@ function createVisitor(options = {}) {
     // Main hook extraction dispatcher
     CallExpression(path, state) {
       const callee = path.node.callee;
-      if (!t17.isIdentifier(callee)) return;
+      if (!t21.isIdentifier(callee)) return;
       const compilerState = state;
       const hookName = callee.name;
       if (mode === "strict" && STRICT_BANNED_HOOKS[hookName]) {
@@ -4717,13 +7254,13 @@ function createVisitor(options = {}) {
         if (!meta.__modelImports) meta.__modelImports = {};
         const imports = meta.__modelImports;
         for (const specifier of path.node.specifiers) {
-          if (t17.isImportDefaultSpecifier(specifier) || t17.isImportSpecifier(specifier)) {
+          if (t21.isImportDefaultSpecifier(specifier) || t21.isImportSpecifier(specifier)) {
             imports[specifier.local.name] = source;
           }
         }
       }
       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 = {
@@ -4750,8 +7287,8 @@ function createVisitor(options = {}) {
       if (!compilerState.metadata) return;
       const id = path.node.id;
       const init = path.node.init;
-      if (t17.isArrayPattern(id)) return;
-      if (!t17.isIdentifier(id) || !init || !t17.isExpression(init)) return;
+      if (t21.isArrayPattern(id)) return;
+      if (!t21.isIdentifier(id) || !init || !t21.isExpression(init)) return;
       const parentFn = path.getFunctionParent();
       if (!parentFn) return;
       const parentNode = parentFn.parentPath;
@@ -4759,17 +7296,17 @@ function createVisitor(options = {}) {
       let isExportedByName = false;
       if (!isExportedDirectly && parentNode?.isVariableDeclarator()) {
         const varId = parentNode.node.id;
-        if (t17.isIdentifier(varId)) {
+        if (t21.isIdentifier(varId)) {
           isExportedByName = varId.name === compilerState.metadata?.name;
         }
       }
       if (!isExportedDirectly && !isExportedByName) return;
-      if (t17.isCallExpression(init) && t17.isIdentifier(init.callee)) {
+      if (t21.isCallExpression(init) && t21.isIdentifier(init.callee)) {
         const callee = init.callee.name;
         if (callee === "useQuery") {
-          registerDerivedVar(id.name, t17.optionalMemberExpression(
-            t17.identifier("$instance"),
-            t17.identifier(id.name),
+          registerDerivedVar(id.name, t21.optionalMemberExpression(
+            t21.identifier("$instance"),
+            t21.identifier(id.name),
             false,
             // computed
             true
@@ -4778,23 +7315,23 @@ function createVisitor(options = {}) {
           return;
         }
         if (callee === "useMutation") {
-          registerDerivedVar(id.name, t17.memberExpression(
-            t17.identifier("$action"),
-            t17.identifier("transition")
+          registerDerivedVar(id.name, t21.memberExpression(
+            t21.identifier("$action"),
+            t21.identifier("transition")
           ));
           return;
         }
         if (callee === "useServerAction") {
-          registerDerivedVar(id.name, t17.memberExpression(
-            t17.identifier("$action"),
-            t17.identifier("serverAction")
+          registerDerivedVar(id.name, t21.memberExpression(
+            t21.identifier("$action"),
+            t21.identifier("serverAction")
           ));
           return;
         }
         if (callee === "useServerState") {
-          registerDerivedVar(id.name, t17.optionalMemberExpression(
-            t17.identifier("$instance"),
-            t17.identifier("serverState"),
+          registerDerivedVar(id.name, t21.optionalMemberExpression(
+            t21.identifier("$instance"),
+            t21.identifier("serverState"),
             false,
             true
           ));
@@ -4802,12 +7339,12 @@ function createVisitor(options = {}) {
         }
         if (callee === "useMemo" && init.arguments.length >= 1) {
           const callback = init.arguments[0];
-          if (t17.isArrowFunctionExpression(callback)) {
-            if (t17.isExpression(callback.body)) {
+          if (t21.isArrowFunctionExpression(callback)) {
+            if (t21.isExpression(callback.body)) {
               registerDerivedVar(id.name, callback.body);
-            } else if (t17.isBlockStatement(callback.body)) {
-              const retStmt = callback.body.body.find((s) => t17.isReturnStatement(s));
-              if (retStmt?.argument && t17.isExpression(retStmt.argument)) {
+            } else if (t21.isBlockStatement(callback.body)) {
+              const retStmt = callback.body.body.find((s) => t21.isReturnStatement(s));
+              if (retStmt?.argument && t21.isExpression(retStmt.argument)) {
                 registerDerivedVar(id.name, retStmt.argument);
               }
             }
@@ -4822,7 +7359,7 @@ function createVisitor(options = {}) {
     // Only extract from the exported component function's direct return,
     // not from nested callbacks (Each render functions, helper components, etc.).
     ReturnStatement(path, state) {
-      if (!t17.isJSXElement(path.node.argument) && !t17.isJSXFragment(path.node.argument)) return;
+      if (!t21.isJSXElement(path.node.argument) && !t21.isJSXFragment(path.node.argument)) return;
       const parentFn = path.getFunctionParent();
       if (!parentFn) return;
       const parentNode = parentFn.parentPath;
@@ -4830,7 +7367,7 @@ function createVisitor(options = {}) {
       let isExportedByName = false;
       if (!isExportedDirectly && parentNode?.isVariableDeclarator()) {
         const varId = parentNode.node.id;
-        if (t17.isIdentifier(varId)) {
+        if (t21.isIdentifier(varId)) {
           isExportedByName = varId.name === state.metadata?.name;
         }
       }