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

package/dist/dev-server.js

@@ -445,25 +445,25 @@ function inferTransitionStates(transitions, states) {
   const stateArray = Array.from(states.values());
   const startStates = stateArray.filter((s) => s.type === "START");
   const regularStates = stateArray.filter((s) => s.type === "REGULAR");
-  const needsInference = transitions.filter((t19) => t19.from.length === 0 || !t19.to);
+  const needsInference = transitions.filter((t23) => t23.from.length === 0 || !t23.to);
   if (needsInference.length === 0) return;
   if (startStates.length === 1 && regularStates.length > 0) {
-    needsInference.forEach((t19, idx) => {
-      if (t19.from.length === 0) {
-        t19.from = [startStates[0].name];
+    needsInference.forEach((t23, idx) => {
+      if (t23.from.length === 0) {
+        t23.from = [startStates[0].name];
       }
-      if (!t19.to) {
-        t19.to = regularStates[idx % regularStates.length]?.name || startStates[0].name;
+      if (!t23.to) {
+        t23.to = regularStates[idx % regularStates.length]?.name || startStates[0].name;
       }
     });
   } else {
     const allStateNames = stateArray.map((s) => s.name);
-    needsInference.forEach((t19, idx) => {
-      if (t19.from.length === 0 && allStateNames.length > 0) {
-        t19.from = [allStateNames[0]];
+    needsInference.forEach((t23, idx) => {
+      if (t23.from.length === 0 && allStateNames.length > 0) {
+        t23.from = [allStateNames[0]];
       }
-      if (!t19.to && allStateNames.length > 1) {
-        t19.to = allStateNames[Math.min(idx + 1, allStateNames.length - 1)];
+      if (!t23.to && allStateNames.length > 1) {
+        t23.to = allStateNames[Math.min(idx + 1, allStateNames.length - 1)];
       }
     });
   }
@@ -2551,7 +2551,7 @@ function resolveType(annotation) {
   }
   if (t11.isTSUnionType(annotation)) {
     const allLiterals = annotation.types.every(
-      (t22) => t11.isTSLiteralType(t22) && (t11.isStringLiteral(t22.literal) || t11.isNumericLiteral(t22.literal))
+      (t23) => t11.isTSLiteralType(t23) && (t11.isStringLiteral(t23.literal) || t11.isNumericLiteral(t23.literal))
     );
     if (allLiterals) return "select";
     return "text";
@@ -3033,6 +3033,7 @@ function extractDefineModelCall(programPath, compilerState, 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,
@@ -3041,7 +3042,8 @@ function extractDefineModelCall(programPath, compilerState, actionCounter) {
             on_enter,
             during,
             on_exit,
-            ...on_event.length > 0 ? { on_event } : {}
+            ...on_event.length > 0 ? { on_event } : {},
+            ...stateRuntime ? { runtime: stateRuntime } : {}
           });
         } else {
           const existing = compilerState.states.get(name);
@@ -3095,6 +3097,7 @@ function extractDefineModelCall(programPath, compilerState, actionCounter) {
           }
         }
         const actions = parseActionArray(transConfig.actions, actionCounter);
+        const transRuntime = transConfig.runtime;
         compilerState.transitions.push({
           name,
           from,
@@ -3104,7 +3107,8 @@ function extractDefineModelCall(programPath, compilerState, actionCounter) {
           actions,
           roles: transConfig.roles,
           auto: transConfig.auto,
-          required_fields: transConfig.required_fields
+          required_fields: transConfig.required_fields,
+          ...transRuntime ? { runtime: transRuntime } : {}
         });
       }
     }
@@ -3121,6 +3125,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;
@@ -3309,6 +3316,1873 @@ var init_model_extractor = __esm({
   }
 });
 
+// src/babel/extractors/workflow-shorthand.ts
+function makeState(name, type) {
+  return {
+    name,
+    type,
+    on_enter: [],
+    during: [],
+    on_exit: []
+  };
+}
+function makeTransition(name, from, to) {
+  return {
+    name,
+    from: [from],
+    to,
+    actions: []
+  };
+}
+function dedupeTransitions(ts) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const t23 of ts) {
+    const key = `${t23.name}::${t23.from.join(",")}::${t23.to}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      out.push(t23);
+    }
+  }
+  return out;
+}
+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 (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((t23) => t23.kind === "state");
+    const hasForwardArrows = tokens.some(
+      (t23) => t23.kind === "arrow" && (t23.direction === "forward" || t23.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((t23) => t23.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);
+            }
+          }
+          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);
+        }
+      }
+    }
+  }
+  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 t23 of transitions) {
+    for (const from of t23.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 };
+}
+var TOKEN_RE;
+var init_workflow_shorthand = __esm({
+  "src/babel/extractors/workflow-shorthand.ts"() {
+    "use strict";
+    TOKEN_RE = /(<->)|<-(\w+)-|(<-)|(?:-(\w+)->)|(->)|(\|)|([a-zA-Z_]\w*)/g;
+  }
+});
+
+// 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 false;
+}
+function roleCondition(role) {
+  return { type: "role", field: role, operator: "eq", value: true };
+}
+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(
+      (t23) => t12.isTSLiteralType(t23) && (t12.isStringLiteral(t23.literal) || t12.isNumericLiteral(t23.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 options.length > 0 ? options : void 0;
+}
+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 fields;
+}
+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;
+  }
+  if (t12.isTemplateLiteral(node)) {
+    return node.quasis.map((q) => q.value.raw).join("${}");
+  }
+  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]";
+}
+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: (t23) => {
+        timeout = t23;
+      },
+      setRuntime: (r) => {
+        runtime = r;
+      }
+    });
+  }
+  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;
+  }
+  if (t12.isVariableDeclaration(stmt)) {
+    for (const decl of stmt.declarations) {
+      if (decl.init && t12.isAwaitExpression(decl.init)) {
+        processExpression(decl.init, paramName, actionCounter, ctx);
+      }
+    }
+  }
+}
+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((t23) => t23.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((t23) => t23.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;
+}
+var t12, VALIDATION_FNS, TS_TYPE_MAP, NAME_TYPE_MAP;
+var init_flow_extractor = __esm({
+  "src/babel/extractors/flow-extractor.ts"() {
+    "use strict";
+    t12 = __toESM(require("@babel/types"));
+    init_workflow_shorthand();
+    VALIDATION_FNS = /* @__PURE__ */ new Set(["validate", "assert"]);
+    TS_TYPE_MAP = {
+      Date: "datetime",
+      Record: "json",
+      Map: "json",
+      Set: "json",
+      URL: "url"
+    };
+    NAME_TYPE_MAP = {
+      email: "email",
+      url: "url",
+      website: "url",
+      phone: "phone"
+    };
+  }
+});
+
 // src/babel/extractors/server-action-extractor.ts
 function isServerActionFile(filename) {
   if (!filename) return false;
@@ -3318,9 +5192,9 @@ function extractServerActions(path, state) {
   const compilerState = state;
   const serverActions = [];
   for (const node of path.node.body) {
-    if (t12.isExportNamedDeclaration(node)) {
+    if (t13.isExportNamedDeclaration(node)) {
       const decl = node.declaration;
-      if (t12.isFunctionDeclaration(decl) && decl.id) {
+      if (t13.isFunctionDeclaration(decl) && decl.id) {
         const action = extractFunctionAction(decl);
         if (action) {
           const comments = node.leadingComments || decl.leadingComments || [];
@@ -3328,19 +5202,19 @@ function extractServerActions(path, state) {
           serverActions.push(action);
         }
       }
-      if (t12.isVariableDeclaration(decl)) {
+      if (t13.isVariableDeclaration(decl)) {
         for (const varDecl of decl.declarations) {
-          if (!t12.isIdentifier(varDecl.id)) continue;
+          if (!t13.isIdentifier(varDecl.id)) continue;
           const init = varDecl.init;
-          if (t12.isArrowFunctionExpression(init) || t12.isFunctionExpression(init)) {
+          if (t13.isArrowFunctionExpression(init) || t13.isFunctionExpression(init)) {
             const action = {
               name: varDecl.id.name,
               async: init.async || false,
-              params: init.params.filter((p) => t12.isIdentifier(p)).map((p) => p.name)
+              params: init.params.filter((p) => t13.isIdentifier(p)).map((p) => p.name)
             };
             if (init.params.length > 0) {
               const firstParam = init.params[0];
-              if (t12.isIdentifier(firstParam) && firstParam.typeAnnotation) {
+              if (t13.isIdentifier(firstParam) && firstParam.typeAnnotation) {
                 action.contextType = extractTypeName(firstParam.typeAnnotation);
               }
             }
@@ -3360,20 +5234,20 @@ function extractFunctionAction(decl) {
   const action = {
     name: decl.id.name,
     async: decl.async || false,
-    params: decl.params.filter((p) => t12.isIdentifier(p)).map((p) => p.name)
+    params: decl.params.filter((p) => t13.isIdentifier(p)).map((p) => p.name)
   };
   if (decl.params.length > 0) {
     const firstParam = decl.params[0];
-    if (t12.isIdentifier(firstParam) && firstParam.typeAnnotation) {
+    if (t13.isIdentifier(firstParam) && firstParam.typeAnnotation) {
       action.contextType = extractTypeName(firstParam.typeAnnotation);
     }
   }
   return action;
 }
 function extractTypeName(annotation) {
-  if (t12.isTSTypeAnnotation(annotation)) {
+  if (t13.isTSTypeAnnotation(annotation)) {
     const typeNode = annotation.typeAnnotation;
-    if (t12.isTSTypeReference(typeNode) && t12.isIdentifier(typeNode.typeName)) {
+    if (t13.isTSTypeReference(typeNode) && t13.isIdentifier(typeNode.typeName)) {
       return typeNode.typeName.name;
     }
   }
@@ -3392,11 +5266,11 @@ function extractDescription(comments) {
   }
   return void 0;
 }
-var t12;
+var t13;
 var init_server_action_extractor = __esm({
   "src/babel/extractors/server-action-extractor.ts"() {
     "use strict";
-    t12 = __toESM(require("@babel/types"));
+    t13 = __toESM(require("@babel/types"));
   }
 });
 
@@ -3405,21 +5279,21 @@ function extractServerActionHook(path, state) {
   const args = path.node.arguments;
   if (args.length < 1) return;
   const nameArg = args[0];
-  if (!t13.isStringLiteral(nameArg)) return;
+  if (!t14.isStringLiteral(nameArg)) return;
   const compilerState = state;
   const entry = {
     name: nameArg.value
   };
-  if (args.length > 1 && t13.isObjectExpression(args[1])) {
+  if (args.length > 1 && t14.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)) {
+      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() && t13.isIdentifier(parent.node.id)) {
+  if (parent?.isVariableDeclarator() && t14.isIdentifier(parent.node.id)) {
     entry.variableName = parent.node.id.name;
   }
   if (!compilerState.metadata) compilerState.metadata = {};
@@ -3427,11 +5301,11 @@ function extractServerActionHook(path, state) {
   if (!meta.serverActionHooks) meta.serverActionHooks = [];
   meta.serverActionHooks.push(entry);
 }
-var t13;
+var t14;
 var init_server_action_hook_extractor = __esm({
   "src/babel/extractors/server-action-hook-extractor.ts"() {
     "use strict";
-    t13 = __toESM(require("@babel/types"));
+    t14 = __toESM(require("@babel/types"));
   }
 });
 
@@ -3442,23 +5316,23 @@ function extractServerState(path, state) {
   const compilerState = state;
   const entry = {};
   const instanceArg = args[0];
-  if (t14.isStringLiteral(instanceArg)) {
+  if (t15.isStringLiteral(instanceArg)) {
     entry.staticInstanceId = instanceArg.value;
   }
-  if (args.length > 1 && t14.isObjectExpression(args[1])) {
+  if (args.length > 1 && t15.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 (!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 (t14.isIdentifier(parent.node.id)) {
+    if (t15.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);
+    } 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(", ");
       }
@@ -3470,11 +5344,11 @@ function extractServerState(path, state) {
   meta.serverStateSubscriptions.push(entry);
   meta.requiresSSE = true;
 }
-var t14;
+var t15;
 var init_server_state_extractor = __esm({
   "src/babel/extractors/server-state-extractor.ts"() {
     "use strict";
-    t14 = __toESM(require("@babel/types"));
+    t15 = __toESM(require("@babel/types"));
   }
 });
 
@@ -3558,7 +5432,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;
@@ -3568,7 +5442,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}}`;
@@ -3608,186 +5482,748 @@ function extractGrammarIsland(path, state, slug) {
   if (!meta.grammarIslands) meta.grammarIslands = [];
   meta.grammarIslands.push(island);
 }
-function extractGrammarIslands(path, state) {
-  path.traverse({
-    TaggedTemplateExpression(templatePath) {
-      const tag = templatePath.node.tag;
-      if (!t15.isIdentifier(tag) || !GRAMMAR_TAGS.has(tag.name)) return;
-      let slug = "unnamed";
-      const parent = templatePath.parentPath;
-      if (parent && parent.isVariableDeclarator() && t15.isIdentifier(parent.node.id)) {
-        slug = parent.node.id.name;
-      }
-      if (parent && parent.isObjectProperty() && t15.isIdentifier(parent.node.key)) {
-        slug = parent.node.key.name;
+function extractGrammarIslands(path, state) {
+  path.traverse({
+    TaggedTemplateExpression(templatePath) {
+      const tag = templatePath.node.tag;
+      if (!t16.isIdentifier(tag) || !GRAMMAR_TAGS.has(tag.name)) return;
+      let slug = "unnamed";
+      const parent = templatePath.parentPath;
+      if (parent && parent.isVariableDeclarator() && t16.isIdentifier(parent.node.id)) {
+        slug = parent.node.id.name;
+      }
+      if (parent && parent.isObjectProperty() && t16.isIdentifier(parent.node.key)) {
+        slug = parent.node.key.name;
+      }
+      if (parent && parent.isObjectProperty() && t16.isStringLiteral(parent.node.key)) {
+        slug = parent.node.key.value;
+      }
+      extractGrammarIsland(templatePath, state, slug);
+    }
+  });
+}
+var t16, GRAMMAR_TAGS;
+var init_grammar_island_extractor = __esm({
+  "src/babel/extractors/grammar-island-extractor.ts"() {
+    "use strict";
+    t16 = __toESM(require("@babel/types"));
+    GRAMMAR_TAGS = /* @__PURE__ */ new Set(["cedar", "sql", "cron", "dmn", "graphql", "jsonpath"]);
+  }
+});
+
+// src/babel/extractors/context-extractor.ts
+function hasContextCreation(path) {
+  let found = false;
+  path.traverse({
+    CallExpression(callPath) {
+      if (t17.isIdentifier(callPath.node.callee, { name: "createContext" })) {
+        found = true;
+        callPath.stop();
+      }
+    }
+  });
+  return found;
+}
+function extractContextWorkflows(path, state) {
+  const compilerState = state;
+  const contextWorkflows = [];
+  const contextNames = /* @__PURE__ */ new Map();
+  path.traverse({
+    // Detect: const XContext = createContext(...)
+    VariableDeclarator(declPath) {
+      const init = declPath.node.init;
+      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 = {
+        name: contextName,
+        fields: [],
+        reducerActions: []
+      };
+      const typeParams = init.typeParameters;
+      if (typeParams && t17.isTSTypeParameterInstantiation(typeParams)) {
+        const typeArg = typeParams.params[0];
+        if (t17.isTSTypeReference(typeArg) && t17.isIdentifier(typeArg.typeName)) {
+          const interfaceName = typeArg.typeName.name;
+          extractFieldsFromInterface3(path, interfaceName, workflow);
+        }
+      }
+      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 (!t17.isIdentifier(callPath.node.callee, { name: "useReducer" })) return;
+      const args = callPath.node.arguments;
+      if (args.length < 1) return;
+      const reducerArg = args[0];
+      if (!t17.isIdentifier(reducerArg)) return;
+      const reducerName = reducerArg.name;
+      const actions = extractReducerActions(path, reducerName);
+      if (contextWorkflows.length > 0) {
+        const lastWorkflow = contextWorkflows[contextWorkflows.length - 1];
+        lastWorkflow.reducerActions = actions;
+        lastWorkflow.reducerName = reducerName;
+      }
+    }
+  });
+  if (contextWorkflows.length > 0) {
+    if (!compilerState.metadata) compilerState.metadata = {};
+    const meta = compilerState.metadata;
+    meta.contextWorkflows = contextWorkflows;
+  }
+}
+function extractFieldsFromInterface3(path, interfaceName, workflow) {
+  path.traverse({
+    TSInterfaceDeclaration(ifacePath) {
+      if (!t17.isIdentifier(ifacePath.node.id, { name: interfaceName })) return;
+      for (const prop of ifacePath.node.body.body) {
+        if (!t17.isTSPropertySignature(prop)) continue;
+        if (!t17.isIdentifier(prop.key)) continue;
+        const field = {
+          name: prop.key.name,
+          type: extractTSType(prop.typeAnnotation),
+          optional: prop.optional || false
+        };
+        workflow.fields.push(field);
+      }
+    }
+  });
+}
+function extractTSType(annotation) {
+  if (!annotation || !t17.isTSTypeAnnotation(annotation)) return "unknown";
+  const typeNode = annotation.typeAnnotation;
+  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 (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) {
+  const actions = [];
+  path.traverse({
+    FunctionDeclaration(funcPath) {
+      if (!funcPath.node.id || funcPath.node.id.name !== reducerName) return;
+      funcPath.traverse({
+        SwitchStatement(switchPath) {
+          for (const switchCase of switchPath.node.cases) {
+            if (!switchCase.test) continue;
+            if (t17.isStringLiteral(switchCase.test)) {
+              actions.push({
+                type: switchCase.test.value
+              });
+            }
+          }
+        }
+      });
+    }
+  });
+  return actions;
+}
+function extractObjectLiteral2(obj) {
+  const result = {};
+  for (const prop of obj.properties) {
+    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;
+}
+var t17;
+var init_context_extractor = __esm({
+  "src/babel/extractors/context-extractor.ts"() {
+    "use strict";
+    t17 = __toESM(require("@babel/types"));
+  }
+});
+
+// src/babel/extractors/middleware-extractor.ts
+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 (parent && parent.isObjectProperty() && t15.isStringLiteral(parent.node.key)) {
-        slug = parent.node.key.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;
       }
-      extractGrammarIsland(templatePath, state, slug);
     }
-  });
+    schema[prop.key.name] = entry;
+  }
+  return schema;
 }
-var t15, GRAMMAR_TAGS;
-var init_grammar_island_extractor = __esm({
-  "src/babel/extractors/grammar-island-extractor.ts"() {
+var t18, BUILTIN_FACTORIES;
+var init_middleware_extractor = __esm({
+  "src/babel/extractors/middleware-extractor.ts"() {
     "use strict";
-    t15 = __toESM(require("@babel/types"));
-    GRAMMAR_TAGS = /* @__PURE__ */ new Set(["cedar", "sql", "cron", "dmn", "graphql", "jsonpath"]);
+    t18 = __toESM(require("@babel/types"));
+    BUILTIN_FACTORIES = /* @__PURE__ */ new Set([
+      "withAuth",
+      "withAuditLog",
+      "withRateLimit",
+      "withValidation",
+      "withMetrics"
+    ]);
   }
 });
 
-// src/babel/extractors/context-extractor.ts
-function hasContextCreation(path) {
-  let found = false;
-  path.traverse({
-    CallExpression(callPath) {
-      if (t16.isIdentifier(callPath.node.callee, { name: "createContext" })) {
-        found = true;
-        callPath.stop();
+// src/babel/extractors/constraint-extractor.ts
+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;
+          }
+        }
       }
     }
-  });
-  return found;
+    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 extractContextWorkflows(path, state) {
+function isConstraintsCall(node) {
+  return t19.isCallExpression(node) && t19.isIdentifier(node.callee) && node.callee.name === "constraints";
+}
+function extractConstraints(path, state) {
   const compilerState = state;
-  const contextWorkflows = [];
-  const contextNames = /* @__PURE__ */ new Map();
+  if (!compilerState.metadata) compilerState.metadata = {};
+  const meta = compilerState.metadata;
+  if (!meta.constraints) meta.constraints = [];
+  const constraintList = meta.constraints;
   path.traverse({
-    // 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;
-      const contextName = declPath.node.id.name;
-      contextNames.set(contextName, contextName);
-      const workflow = {
-        name: contextName,
-        fields: [],
-        reducerActions: []
-      };
-      const typeParams = init.typeParameters;
-      if (typeParams && t16.isTSTypeParameterInstantiation(typeParams)) {
-        const typeArg = typeParams.params[0];
-        if (t16.isTSTypeReference(typeArg) && t16.isIdentifier(typeArg.typeName)) {
-          const interfaceName = typeArg.typeName.name;
-          extractFieldsFromInterface2(path, interfaceName, workflow);
-        }
-      }
-      if (init.arguments.length > 0 && t16.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;
+      const callee = callPath.node.callee;
+      if (!t19.isIdentifier(callee) || callee.name !== "constraints") return;
       const args = callPath.node.arguments;
-      if (args.length < 1) return;
-      const reducerArg = args[0];
-      if (!t16.isIdentifier(reducerArg)) return;
-      const reducerName = reducerArg.name;
-      const actions = extractReducerActions(path, reducerName);
-      if (contextWorkflows.length > 0) {
-        const lastWorkflow = contextWorkflows[contextWorkflows.length - 1];
-        lastWorkflow.reducerActions = actions;
-        lastWorkflow.reducerName = reducerName;
+      for (const arg of args) {
+        if (t19.isStringLiteral(arg)) {
+          constraintList.push({
+            rule: arg.value,
+            type: BUILTIN_CONSTRAINTS.has(arg.value) ? "builtin" : "custom"
+          });
+        }
       }
     }
   });
-  if (contextWorkflows.length > 0) {
-    if (!compilerState.metadata) compilerState.metadata = {};
-    const meta = compilerState.metadata;
-    meta.contextWorkflows = contextWorkflows;
+}
+var t19, BUILTIN_CONSTRAINTS;
+var init_constraint_extractor = __esm({
+  "src/babel/extractors/constraint-extractor.ts"() {
+    "use strict";
+    t19 = __toESM(require("@babel/types"));
+    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"
+    ]);
+  }
+});
+
+// src/babel/extractors/actor-extractor.ts
+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 extractFieldsFromInterface2(path, interfaceName, workflow) {
+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({
-    TSInterfaceDeclaration(ifacePath) {
-      if (!t16.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;
-        const field = {
-          name: prop.key.name,
-          type: extractTSType(prop.typeAnnotation),
-          optional: prop.optional || false
-        };
-        workflow.fields.push(field);
+    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 extractTSType(annotation) {
-  if (!annotation || !t16.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;
-  return "unknown";
+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 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;
-  return "unknown";
+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 extractReducerActions(path, reducerName) {
-  const actions = [];
-  path.traverse({
-    FunctionDeclaration(funcPath) {
-      if (!funcPath.node.id || funcPath.node.id.name !== reducerName) return;
-      funcPath.traverse({
-        SwitchStatement(switchPath) {
-          for (const switchCase of switchPath.node.cases) {
-            if (!switchCase.test) continue;
-            if (t16.isStringLiteral(switchCase.test)) {
-              actions.push({
-                type: switchCase.test.value
-              });
-            }
-          }
-        }
-      });
+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 actions;
+  }
+  return result;
 }
-function extractObjectLiteral2(obj) {
+function extractMailbox(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 (!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;
 }
-var t16;
-var init_context_extractor = __esm({
-  "src/babel/extractors/context-extractor.ts"() {
-    "use strict";
-    t16 = __toESM(require("@babel/types"));
+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;
   }
-});
-
-// ../player-core/dist/index.mjs
-function normalizeCategory(primary, ...tags) {
-  const uniqueTags = [...new Set(tags.filter((t19) => t19 !== primary))];
-  uniqueTags.sort();
-  return [primary, ...uniqueTags];
-}
-var init_dist = __esm({
-  "../player-core/dist/index.mjs"() {
+  return result;
+}
+var t20;
+var init_actor_extractor = __esm({
+  "src/babel/extractors/actor-extractor.ts"() {
     "use strict";
+    t20 = __toESM(require("@babel/types"));
   }
 });
 
@@ -3993,7 +6429,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) {
@@ -4088,7 +6524,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;
@@ -4167,7 +6603,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
   };
 }
@@ -4197,7 +6633,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"],
@@ -4207,7 +6643,7 @@ function liftSchedule(during) {
   }
   return {
     slug: during.id,
-    category: normalizeCategory("schedule", during.type),
+    category: (0, import_player_core.normalizeCategory)("schedule", during.type),
     parts
   };
 }
@@ -4220,14 +6656,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)
     });
   }
@@ -4238,7 +6674,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
   };
 }
@@ -4261,17 +6697,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
       }))
     });
@@ -4310,7 +6746,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
   };
 }
@@ -4333,20 +6769,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"] }]
         });
       }
@@ -4357,20 +6793,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"] }]
       });
     }
@@ -4382,7 +6818,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
   };
 }
@@ -4403,7 +6839,7 @@ function emitCanonical(extracted, sourceFilename) {
   }
   parts.push({
     slug: "manifest",
-    category: normalizeCategory("meta", "manifest"),
+    category: (0, import_player_core.normalizeCategory)("meta", "manifest"),
     parts: [
       {
         slug: "workflows",
@@ -4424,7 +6860,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];
   }
@@ -4486,7 +6922,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,
@@ -4502,16 +6938,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((t19) => ({
-    name: t19.name,
-    from: t19.from,
-    to: t19.to,
-    description: t19.description || "",
-    roles: t19.roles || [],
-    auto: t19.auto || false,
-    conditions: t19.conditions || [],
-    actions: (t19.actions || []).map(convertAction),
-    required_fields: t19.required_fields || [],
+  const transitions = ir.transitions.map((t23) => ({
+    name: t23.name,
+    from: t23.from,
+    to: t23.to,
+    description: t23.description || "",
+    roles: t23.roles || [],
+    auto: t23.auto || false,
+    conditions: t23.conditions || [],
+    actions: (t23.actions || []).map(convertAction),
+    required_fields: t23.required_fields || [],
     priority: 0
   }));
   const state_data = {};
@@ -4529,7 +6965,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;
@@ -4587,11 +7023,11 @@ function compilerStateToWorkflow(state, metadata) {
     extraMetadata: Object.keys(extraMetadata).length > 0 ? extraMetadata : void 0
   };
 }
-var PROP_RULES, COMPONENT_RENAMES, RENAME_EXTRA_CONFIG;
+var import_player_core, PROP_RULES, COMPONENT_RENAMES, RENAME_EXTRA_CONFIG;
 var init_pure_form_emitter = __esm({
   "src/babel/emitters/pure-form-emitter.ts"() {
     "use strict";
-    init_dist();
+    import_player_core = require("@mindmatrix/player-core");
     init_transition_extractor();
     init_experience_transform();
     PROP_RULES = {
@@ -4621,8 +7057,8 @@ var init_pure_form_emitter = __esm({
 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;
@@ -4648,43 +7084,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;
               }
             }
@@ -4694,19 +7130,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;
       }
@@ -4730,17 +7166,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;
     }
   }
@@ -4766,7 +7202,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;
@@ -4777,7 +7213,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;
@@ -4794,7 +7230,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;
@@ -4867,15 +7303,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;
               }
@@ -4883,16 +7319,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;
             }
           }
@@ -4903,7 +7339,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) {
@@ -4914,6 +7356,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;
@@ -4949,7 +7400,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]) {
@@ -5041,7 +7492,7 @@ 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;
           }
         }
@@ -5074,8 +7525,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;
@@ -5083,17 +7534,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
@@ -5102,23 +7553,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
           ));
@@ -5126,12 +7577,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);
               }
             }
@@ -5146,7 +7597,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;
@@ -5154,7 +7605,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;
         }
       }
@@ -5164,11 +7615,11 @@ function createVisitor(options = {}) {
     }
   };
 }
-var t17, STRICT_BANNED_HOOKS;
+var t21, STRICT_BANNED_HOOKS;
 var init_visitor = __esm({
   "src/babel/visitor.ts"() {
     "use strict";
-    t17 = __toESM(require("@babel/types"));
+    t21 = __toESM(require("@babel/types"));
     init_state_extractor();
     init_effect_extractor();
     init_transition_extractor();
@@ -5179,11 +7630,15 @@ var init_visitor = __esm({
     init_computed_extractor();
     init_transition_effect_extractor();
     init_model_extractor();
+    init_flow_extractor();
     init_server_action_extractor();
     init_server_action_hook_extractor();
     init_server_state_extractor();
     init_grammar_island_extractor();
     init_context_extractor();
+    init_middleware_extractor();
+    init_constraint_extractor();
+    init_actor_extractor();
     init_pure_form_emitter();
     STRICT_BANNED_HOOKS = {
       useEffect: "STRICT_USE_EFFECT",
@@ -5461,7 +7916,7 @@ function compileModel(filename, source, options = {}) {
     ir,
     interfaceName,
     fieldNames: ir.fields.map((f) => f.name),
-    transitionNames: ir.transitions.map((t19) => t19.name),
+    transitionNames: ir.transitions.map((t23) => t23.name),
     stateNames: ir.states.map((s) => s.name),
     hasFieldOptions: Object.keys(rawFieldOptions).length > 0,
     fieldOptions: rawFieldOptions
@@ -5881,7 +8336,7 @@ function extractAction(source, filename) {
   const fields = params.map((p) => paramToField(p));
   const parameterMap = /* @__PURE__ */ new Map();
   for (const p of params) {
-    const snakeName = toSnakeCase3(p.name);
+    const snakeName = toSnakeCase4(p.name);
     if (snakeName !== p.name) {
       parameterMap.set(p.name, snakeName);
     }
@@ -5901,7 +8356,7 @@ function extractAction(source, filename) {
   }
   if (isAsync) {
     const segments = splitAtAwaits(body.body);
-    const hasAwaits = segments.some((s) => s.kind === "await");
+    const hasAwaits = segments.some((s) => s.kind !== "sync");
     if (hasAwaits) {
       const rewritten = rewriteAwaitReferences(segments);
       const { states: states2, transitions: transitions2, bodyIsPure } = generateMultiStateIR(rewritten, warnings, parameterMap);
@@ -5976,10 +8431,10 @@ function extractAction(source, filename) {
 function findDefaultExportedFunction(ast) {
   const topLevelVars = /* @__PURE__ */ new Map();
   for (const node of ast.program.body) {
-    if (t18.isVariableDeclaration(node)) {
+    if (t22.isVariableDeclaration(node)) {
       for (const decl of node.declarations) {
-        if (t18.isIdentifier(decl.id) && decl.init) {
-          if (t18.isArrowFunctionExpression(decl.init) || t18.isFunctionExpression(decl.init)) {
+        if (t22.isIdentifier(decl.id) && decl.init) {
+          if (t22.isArrowFunctionExpression(decl.init) || t22.isFunctionExpression(decl.init)) {
             topLevelVars.set(decl.id.name, decl.init);
           }
         }
@@ -5987,19 +8442,19 @@ function findDefaultExportedFunction(ast) {
     }
   }
   for (const node of ast.program.body) {
-    if (t18.isExportDefaultDeclaration(node)) {
+    if (t22.isExportDefaultDeclaration(node)) {
       const decl = node.declaration;
-      if (t18.isFunctionDeclaration(decl) && decl.body) {
+      if (t22.isFunctionDeclaration(decl) && decl.body) {
         const name = decl.id?.name ?? inferNameFromFile(decl) ?? "action";
         return extractFromFunction(name, decl.params, decl.body, decl.returnType, decl.async);
       }
-      if (t18.isArrowFunctionExpression(decl) || t18.isFunctionExpression(decl)) {
-        const name = t18.isFunctionExpression(decl) && decl.id ? decl.id.name : "action";
+      if (t22.isArrowFunctionExpression(decl) || t22.isFunctionExpression(decl)) {
+        const name = t22.isFunctionExpression(decl) && decl.id ? decl.id.name : "action";
         const body = ensureBlock(decl.body);
         if (!body) return null;
         return extractFromFunction(name, decl.params, body, decl.returnType, decl.async);
       }
-      if (t18.isIdentifier(decl)) {
+      if (t22.isIdentifier(decl)) {
         const fn = topLevelVars.get(decl.name);
         if (fn) {
           const body = ensureBlock(fn.body);
@@ -6013,28 +8468,28 @@ function findDefaultExportedFunction(ast) {
 }
 function extractFromFunction(name, params, body, returnType, isAsync = false) {
   const extracted = params.map((p) => extractParam(p));
-  const returnTypeAnnotation = returnType && t18.isTSTypeAnnotation(returnType) ? serializeTSType(returnType.typeAnnotation) : void 0;
+  const returnTypeAnnotation = returnType && t22.isTSTypeAnnotation(returnType) ? serializeTSType(returnType.typeAnnotation) : void 0;
   return { name, params: extracted, body, returnTypeAnnotation, isAsync };
 }
 function ensureBlock(body) {
-  if (t18.isBlockStatement(body)) return body;
-  const ret = t18.returnStatement(body);
-  return t18.blockStatement([ret]);
+  if (t22.isBlockStatement(body)) return body;
+  const ret = t22.returnStatement(body);
+  return t22.blockStatement([ret]);
 }
 function inferNameFromFile(_node) {
   return null;
 }
 function extractParam(param) {
-  if (t18.isIdentifier(param)) {
+  if (t22.isIdentifier(param)) {
     return {
       name: param.name,
       typeAnnotation: param.typeAnnotation ? param.typeAnnotation.typeAnnotation : null,
       optional: param.optional ?? false
     };
   }
-  if (t18.isAssignmentPattern(param)) {
+  if (t22.isAssignmentPattern(param)) {
     const inner = param.left;
-    if (t18.isIdentifier(inner)) {
+    if (t22.isIdentifier(inner)) {
       return {
         name: inner.name,
         typeAnnotation: inner.typeAnnotation ? inner.typeAnnotation.typeAnnotation : null,
@@ -6043,10 +8498,10 @@ function extractParam(param) {
       };
     }
   }
-  if (t18.isRestElement(param)) {
+  if (t22.isRestElement(param)) {
     const arg = param.argument;
     return {
-      name: t18.isIdentifier(arg) ? arg.name : "rest",
+      name: t22.isIdentifier(arg) ? arg.name : "rest",
       typeAnnotation: null,
       optional: true
     };
@@ -6056,7 +8511,7 @@ function extractParam(param) {
 function paramToField(param) {
   const fieldType = param.typeAnnotation ? tsTypeToFieldType2(param.typeAnnotation) : "text";
   const field = {
-    name: toSnakeCase3(param.name),
+    name: toSnakeCase4(param.name),
     type: fieldType,
     required: !param.optional
   };
@@ -6067,34 +8522,34 @@ function paramToField(param) {
 }
 function extractLiteralDefault(expr) {
   if (!expr) return void 0;
-  if (t18.isStringLiteral(expr)) return expr.value;
-  if (t18.isNumericLiteral(expr)) return expr.value;
-  if (t18.isBooleanLiteral(expr)) return expr.value;
-  if (t18.isNullLiteral(expr)) return null;
-  if (t18.isArrayExpression(expr) && expr.elements.length === 0) return [];
-  if (t18.isObjectExpression(expr) && expr.properties.length === 0) return {};
+  if (t22.isStringLiteral(expr)) return expr.value;
+  if (t22.isNumericLiteral(expr)) return expr.value;
+  if (t22.isBooleanLiteral(expr)) return expr.value;
+  if (t22.isNullLiteral(expr)) return null;
+  if (t22.isArrayExpression(expr) && expr.elements.length === 0) return [];
+  if (t22.isObjectExpression(expr) && expr.properties.length === 0) return {};
   return void 0;
 }
 function tsTypeToFieldType2(tsType) {
-  if (t18.isTSStringKeyword(tsType)) return "text";
-  if (t18.isTSNumberKeyword(tsType)) return "number";
-  if (t18.isTSBooleanKeyword(tsType)) return "boolean";
-  if (t18.isTSObjectKeyword(tsType)) return "json";
-  if (t18.isTSAnyKeyword(tsType) || t18.isTSUnknownKeyword(tsType)) return "json";
-  if (t18.isTSArrayType(tsType)) return "json";
-  if (t18.isTSUnionType(tsType)) {
+  if (t22.isTSStringKeyword(tsType)) return "text";
+  if (t22.isTSNumberKeyword(tsType)) return "number";
+  if (t22.isTSBooleanKeyword(tsType)) return "boolean";
+  if (t22.isTSObjectKeyword(tsType)) return "json";
+  if (t22.isTSAnyKeyword(tsType) || t22.isTSUnknownKeyword(tsType)) return "json";
+  if (t22.isTSArrayType(tsType)) return "json";
+  if (t22.isTSUnionType(tsType)) {
     const nonNullable = tsType.types.filter(
-      (t22) => !t18.isTSNullKeyword(t22) && !t18.isTSUndefinedKeyword(t22)
+      (t23) => !t22.isTSNullKeyword(t23) && !t22.isTSUndefinedKeyword(t23)
     );
     if (nonNullable.length === 1) {
       return tsTypeToFieldType2(nonNullable[0]);
     }
-    if (nonNullable.every((t22) => t18.isTSLiteralType(t22) && t18.isStringLiteral(t22.literal))) {
+    if (nonNullable.every((t23) => t22.isTSLiteralType(t23) && t22.isStringLiteral(t23.literal))) {
       return "select";
     }
     return "text";
   }
-  if (t18.isTSTypeReference(tsType) && t18.isIdentifier(tsType.typeName)) {
+  if (t22.isTSTypeReference(tsType) && t22.isIdentifier(tsType.typeName)) {
     const name = tsType.typeName.name;
     if (name === "Date") return "datetime";
     if (name === "string") return "text";
@@ -6104,16 +8559,16 @@ function tsTypeToFieldType2(tsType) {
   return "text";
 }
 function serializeTSType(tsType) {
-  if (t18.isTSStringKeyword(tsType)) return "string";
-  if (t18.isTSNumberKeyword(tsType)) return "number";
-  if (t18.isTSBooleanKeyword(tsType)) return "boolean";
-  if (t18.isTSVoidKeyword(tsType)) return "void";
-  if (t18.isTSAnyKeyword(tsType)) return "any";
-  if (t18.isTSTypeReference(tsType) && t18.isIdentifier(tsType.typeName)) {
+  if (t22.isTSStringKeyword(tsType)) return "string";
+  if (t22.isTSNumberKeyword(tsType)) return "number";
+  if (t22.isTSBooleanKeyword(tsType)) return "boolean";
+  if (t22.isTSVoidKeyword(tsType)) return "void";
+  if (t22.isTSAnyKeyword(tsType)) return "any";
+  if (t22.isTSTypeReference(tsType) && t22.isIdentifier(tsType.typeName)) {
     return tsType.typeName.name;
   }
-  if (t18.isTSArrayType(tsType)) return `${serializeTSType(tsType.elementType)}[]`;
-  if (t18.isTSPromiseType(tsType)) {
+  if (t22.isTSArrayType(tsType)) return `${serializeTSType(tsType.elementType)}[]`;
+  if (t22.isTSPromiseType(tsType)) {
     return `Promise<${tsType.typeParameter ? serializeTSType(tsType.typeParameter.params[0]) : "unknown"}>`;
   }
   return "unknown";
@@ -6123,6 +8578,56 @@ function splitAtAwaits(body) {
   let current = [];
   let index = 0;
   for (const stmt of body) {
+    if (t22.isTryStatement(stmt) && containsAwait(stmt.block)) {
+      if (current.length > 0) {
+        segments.push({ index: index++, kind: "sync", statements: current });
+        current = [];
+      }
+      const trySegs = splitAtAwaits(stmt.block.body);
+      const catchStmts = stmt.handler?.body.body ?? [];
+      const catchParam = stmt.handler?.param && t22.isIdentifier(stmt.handler.param) ? stmt.handler.param.name : "error";
+      segments.push({
+        index: index++,
+        kind: "try_catch",
+        statements: [stmt],
+        trySegments: trySegs,
+        catchStatements: catchStmts,
+        catchParam
+      });
+      continue;
+    }
+    if (t22.isForOfStatement(stmt) && containsAwait(stmt.body)) {
+      if (current.length > 0) {
+        segments.push({ index: index++, kind: "sync", statements: current });
+        current = [];
+      }
+      const loopBody = t22.isBlockStatement(stmt.body) ? stmt.body.body : [stmt.body];
+      const loopBinding = t22.isVariableDeclaration(stmt.left) && t22.isIdentifier(stmt.left.declarations[0]?.id) ? stmt.left.declarations[0].id.name : "item";
+      segments.push({
+        index: index++,
+        kind: "loop",
+        statements: [stmt],
+        loopBinding,
+        loopIterable: stmt.right,
+        loopBodySegments: splitAtAwaits(loopBody)
+      });
+      continue;
+    }
+    const promiseInfo = extractPromiseAllOrRace(stmt);
+    if (promiseInfo) {
+      if (current.length > 0) {
+        segments.push({ index: index++, kind: "sync", statements: current });
+        current = [];
+      }
+      segments.push({
+        index: index++,
+        kind: promiseInfo.type === "all" ? "parallel" : "race",
+        statements: [stmt],
+        parallelCallees: promiseInfo.callees,
+        resultBinding: promiseInfo.binding
+      });
+      continue;
+    }
     const awaitInfo = extractAwait(stmt);
     if (!awaitInfo) {
       current.push(stmt);
@@ -6147,22 +8652,22 @@ function splitAtAwaits(body) {
   return segments;
 }
 function extractAwait(stmt) {
-  if (t18.isVariableDeclaration(stmt)) {
+  if (t22.isVariableDeclaration(stmt)) {
     const decl = stmt.declarations[0];
-    if (decl?.init && t18.isAwaitExpression(decl.init)) {
+    if (decl?.init && t22.isAwaitExpression(decl.init)) {
       const arg = decl.init.argument;
-      if (t18.isCallExpression(arg)) {
+      if (t22.isCallExpression(arg)) {
         return {
           callee: getCalleeName(arg.callee),
           args: arg.arguments,
-          binding: t18.isIdentifier(decl.id) ? decl.id.name : void 0
+          binding: t22.isIdentifier(decl.id) ? decl.id.name : void 0
         };
       }
     }
   }
-  if (t18.isExpressionStatement(stmt) && t18.isAwaitExpression(stmt.expression)) {
+  if (t22.isExpressionStatement(stmt) && t22.isAwaitExpression(stmt.expression)) {
     const arg = stmt.expression.argument;
-    if (t18.isCallExpression(arg)) {
+    if (t22.isCallExpression(arg)) {
       return {
         callee: getCalleeName(arg.callee),
         args: arg.arguments,
@@ -6170,9 +8675,9 @@ function extractAwait(stmt) {
       };
     }
   }
-  if (t18.isReturnStatement(stmt) && stmt.argument && t18.isAwaitExpression(stmt.argument)) {
+  if (t22.isReturnStatement(stmt) && stmt.argument && t22.isAwaitExpression(stmt.argument)) {
     const arg = stmt.argument.argument;
-    if (t18.isCallExpression(arg)) {
+    if (t22.isCallExpression(arg)) {
       return {
         callee: getCalleeName(arg.callee),
         args: arg.arguments,
@@ -6182,9 +8687,89 @@ function extractAwait(stmt) {
   }
   return null;
 }
+function containsAwait(node) {
+  if (t22.isAwaitExpression(node)) return true;
+  if (t22.isBlockStatement(node)) {
+    return node.body.some((s) => containsAwait(s));
+  }
+  if (t22.isExpressionStatement(node)) {
+    return containsAwait(node.expression);
+  }
+  if (t22.isVariableDeclaration(node)) {
+    return node.declarations.some((d) => d.init ? containsAwait(d.init) : false);
+  }
+  if (t22.isReturnStatement(node) && node.argument) {
+    return containsAwait(node.argument);
+  }
+  if (t22.isCallExpression(node)) {
+    return node.arguments.some((a) => t22.isNode(a) && containsAwait(a));
+  }
+  if (t22.isForOfStatement(node)) {
+    return containsAwait(node.body);
+  }
+  if (t22.isForStatement(node)) {
+    return containsAwait(node.body);
+  }
+  if (t22.isIfStatement(node)) {
+    return containsAwait(node.consequent) || (node.alternate ? containsAwait(node.alternate) : false);
+  }
+  if (t22.isTryStatement(node)) {
+    return containsAwait(node.block) || (node.handler ? containsAwait(node.handler.body) : false);
+  }
+  if (t22.isArrayExpression(node)) {
+    return node.elements.some((e) => e && !t22.isSpreadElement(e) && containsAwait(e));
+  }
+  return false;
+}
+function extractPromiseAllOrRace(stmt) {
+  let awaitExpr = null;
+  let binding;
+  if (t22.isVariableDeclaration(stmt)) {
+    const decl = stmt.declarations[0];
+    if (decl?.init && t22.isAwaitExpression(decl.init)) {
+      awaitExpr = decl.init;
+      binding = t22.isIdentifier(decl.id) ? decl.id.name : t22.isArrayPattern(decl.id) ? "__destructured__" : void 0;
+    }
+  } else if (t22.isExpressionStatement(stmt) && t22.isAwaitExpression(stmt.expression)) {
+    awaitExpr = stmt.expression;
+  }
+  if (!awaitExpr) return null;
+  const arg = awaitExpr.argument;
+  if (!t22.isCallExpression(arg)) return null;
+  if (!t22.isMemberExpression(arg.callee)) return null;
+  if (!t22.isIdentifier(arg.callee.object) || arg.callee.object.name !== "Promise") return null;
+  if (!t22.isIdentifier(arg.callee.property)) return null;
+  const method = arg.callee.property.name;
+  if (method !== "all" && method !== "race") return null;
+  const firstArg = arg.arguments[0];
+  if (!t22.isArrayExpression(firstArg)) return null;
+  const callees = [];
+  for (const elem of firstArg.elements) {
+    if (!elem || t22.isSpreadElement(elem)) continue;
+    if (t22.isCallExpression(elem)) {
+      callees.push({
+        callee: getCalleeName(elem.callee),
+        args: elem.arguments
+      });
+    }
+  }
+  if (callees.length === 0) return null;
+  if (binding === "__destructured__" && t22.isVariableDeclaration(stmt)) {
+    const decl = stmt.declarations[0];
+    if (t22.isArrayPattern(decl.id)) {
+      for (let i = 0; i < decl.id.elements.length && i < callees.length; i++) {
+        const elem = decl.id.elements[i];
+        if (t22.isIdentifier(elem)) {
+          callees[i].binding = elem.name;
+        }
+      }
+    }
+  }
+  return { type: method, callees, binding };
+}
 function getCalleeName(callee) {
-  if (t18.isIdentifier(callee)) return callee.name;
-  if (t18.isMemberExpression(callee) && t18.isIdentifier(callee.object) && t18.isIdentifier(callee.property)) {
+  if (t22.isIdentifier(callee)) return callee.name;
+  if (t22.isMemberExpression(callee) && t22.isIdentifier(callee.object) && t22.isIdentifier(callee.property)) {
     return `${callee.object.name}_${callee.property.name}`;
   }
   return "unknown_action";
@@ -6194,7 +8779,7 @@ function rewriteAwaitReferences(segments) {
   const slugCounts = /* @__PURE__ */ new Map();
   return segments.map((seg) => {
     if (seg.kind === "await" && seg.resultBinding) {
-      const slug = toSnakeCase3(seg.awaitTarget ?? "unknown");
+      const slug = toSnakeCase4(seg.awaitTarget ?? "unknown");
       const count = (slugCounts.get(slug) ?? 0) + 1;
       slugCounts.set(slug, count);
       const key = count > 1 ? `${slug}_${count}` : slug;
@@ -6222,7 +8807,7 @@ function generateMultiStateIR(segments, _warnings, parameterMap) {
   const slugCounts = /* @__PURE__ */ new Map();
   for (const seg of segments) {
     if (seg.kind === "await" && seg.resultBinding) {
-      const slug = toSnakeCase3(seg.awaitTarget ?? "unknown");
+      const slug = toSnakeCase4(seg.awaitTarget ?? "unknown");
       const count = (slugCounts.get(slug) ?? 0) + 1;
       slugCounts.set(slug, count);
       const key = count > 1 ? `${slug}_${count}` : slug;
@@ -6239,7 +8824,177 @@ function generateMultiStateIR(segments, _warnings, parameterMap) {
       pendingSyncStmts.push(...seg.statements);
       continue;
     }
-    const targetSlug = toSnakeCase3(seg.awaitTarget ?? "unknown");
+    if (seg.kind === "try_catch" && seg.trySegments) {
+      if (pendingSyncStmts.length > 0) {
+        const block = t22.blockStatement(pendingSyncStmts);
+        const transpiled = transpileBlock(block, { allMutable: true, derivedVarMap: buildDerivedVarMap(awaitBindings), parameterMap });
+        if (!transpiled.pure) bodyIsPure = false;
+        const preState = uniqueState("pre_try", usedStateNames);
+        states.push({ name: preState, type: "REGULAR", on_enter: [], during: [], on_exit: [] });
+        transitions.push({
+          name: transitionCount === 0 ? "execute" : `on_${getStateSuffix(prevState)}_complete`,
+          from: [prevState],
+          to: preState,
+          actions: [{ id: `pre_try_${transitionCount}`, type: "eval", mode: "auto", config: { expression: transpiled.expression } }]
+        });
+        prevState = preState;
+        transitionCount++;
+        pendingSyncStmts = [];
+      }
+      const tryResult = generateMultiStateIR(seg.trySegments, _warnings, parameterMap);
+      if (!tryResult.bodyIsPure) bodyIsPure = false;
+      const successState = uniqueState("try_success", usedStateNames);
+      const errorState = uniqueState("try_error", usedStateNames);
+      states.push({ name: errorState, type: "REGULAR", on_enter: [], during: [], on_exit: [] });
+      states.push({ name: successState, type: "REGULAR", on_enter: [], during: [], on_exit: [] });
+      for (const s of tryResult.states) {
+        if (s.name === "ready" || s.name === "done") continue;
+        states.push(s);
+      }
+      for (const tr of tryResult.transitions) {
+        const remappedFrom = tr.from.map((f) => f === "ready" ? prevState : f);
+        const remappedTo = tr.to === "done" ? successState : tr.to;
+        transitions.push({ ...tr, from: remappedFrom, to: remappedTo });
+        if (tr.actions.some((a) => a.type === "call_workflow")) {
+          const awaitState = tr.to === successState ? successState : tr.to;
+          if (awaitState !== successState) {
+            transitions.push({
+              name: `on_${getStateSuffix(awaitState)}_error`,
+              from: [awaitState],
+              to: errorState,
+              actions: [],
+              conditions: [{ expression: "action_error != null", type: "expression" }]
+            });
+          }
+        }
+      }
+      if (tryResult.transitions.length > 0 && transitionCount === 0) {
+        transitions[transitions.length - tryResult.transitions.length].name = "execute";
+      }
+      if (seg.catchStatements && seg.catchStatements.length > 0) {
+        const catchBlock = t22.blockStatement(seg.catchStatements);
+        const catchBindings = new Map(awaitBindings);
+        if (seg.catchParam) {
+          catchBindings.set(seg.catchParam, "action_error");
+        }
+        const catchTranspiled = transpileBlock(catchBlock, {
+          allMutable: true,
+          derivedVarMap: buildDerivedVarMap(catchBindings),
+          parameterMap
+        });
+        if (!catchTranspiled.pure) bodyIsPure = false;
+        const postCatch = uniqueState("post_catch", usedStateNames);
+        states.push({ name: postCatch, type: "REGULAR", on_enter: [], during: [], on_exit: [] });
+        transitions.push({
+          name: `catch_${transitionCount}`,
+          from: [errorState],
+          to: postCatch,
+          actions: [{ id: `catch_eval_${transitionCount}`, type: "eval", mode: "auto", config: { expression: catchTranspiled.expression } }]
+        });
+        prevState = postCatch;
+        transitions.push({
+          name: `try_success_${transitionCount}`,
+          from: [successState],
+          to: postCatch,
+          actions: []
+        });
+      } else {
+        prevState = successState;
+      }
+      transitionCount++;
+      continue;
+    }
+    if ((seg.kind === "parallel" || seg.kind === "race") && seg.parallelCallees) {
+      if (pendingSyncStmts.length > 0) {
+        const block = t22.blockStatement(pendingSyncStmts);
+        const transpiled = transpileBlock(block, { allMutable: true, derivedVarMap: buildDerivedVarMap(awaitBindings), parameterMap });
+        if (!transpiled.pure) bodyIsPure = false;
+        pendingSyncStmts = [];
+      }
+      const groupId = `p${transitionCount}`;
+      const dispatchKind = seg.kind === "parallel" ? "parallel" : "race";
+      const stateName2 = uniqueState(`awaiting_${dispatchKind}_${transitionCount}`, usedStateNames);
+      states.push({ name: stateName2, type: "REGULAR", on_enter: [], during: [], on_exit: [] });
+      const actions2 = [];
+      for (let ci = 0; ci < seg.parallelCallees.length; ci++) {
+        const callee = seg.parallelCallees[ci];
+        const slug = toSnakeCase4(callee.callee);
+        actions2.push({
+          id: `call_${slug}_${ci}`,
+          type: "call_workflow",
+          mode: "auto",
+          config: {
+            definition_slug: callee.callee,
+            result_key: slug,
+            [`${dispatchKind}_group`]: groupId
+          }
+        });
+        if (callee.binding) {
+          awaitBindings.set(callee.binding, `action_results.${slug}`);
+        }
+      }
+      const transName2 = transitionCount === 0 ? "execute" : `on_${getStateSuffix(prevState)}_complete`;
+      transitions.push({ name: transName2, from: [prevState], to: stateName2, actions: actions2 });
+      prevState = stateName2;
+      transitionCount++;
+      continue;
+    }
+    if (seg.kind === "loop" && seg.loopBodySegments) {
+      if (pendingSyncStmts.length > 0) {
+        const block = t22.blockStatement(pendingSyncStmts);
+        const transpiled = transpileBlock(block, { allMutable: true, derivedVarMap: buildDerivedVarMap(awaitBindings), parameterMap });
+        if (!transpiled.pure) bodyIsPure = false;
+        pendingSyncStmts = [];
+      }
+      const loopState = uniqueState(`loop_${toSnakeCase4(seg.loopBinding ?? "item")}`, usedStateNames);
+      const postLoop = uniqueState("post_loop", usedStateNames);
+      states.push({ name: loopState, type: "REGULAR", on_enter: [], during: [], on_exit: [] });
+      states.push({ name: postLoop, type: "REGULAR", on_enter: [], during: [], on_exit: [] });
+      const initTransName = transitionCount === 0 ? "execute" : `on_${getStateSuffix(prevState)}_complete`;
+      transitions.push({
+        name: initTransName,
+        from: [prevState],
+        to: loopState,
+        actions: [{
+          id: `loop_init_${transitionCount}`,
+          type: "eval",
+          mode: "auto",
+          config: { expression: `let __loop_idx = 0; let __loop_items = ${seg.loopIterable ? toSnakeCase4(seg.loopBinding ?? "items") : "[]"}` }
+        }]
+      });
+      const awaitSegs = seg.loopBodySegments.filter((s) => s.kind === "await");
+      if (awaitSegs.length > 0) {
+        const firstAwait = awaitSegs[0];
+        const slug = toSnakeCase4(firstAwait.awaitTarget ?? "action");
+        transitions.push({
+          name: `loop_body_${transitionCount}`,
+          from: [loopState],
+          to: loopState,
+          actions: [{
+            id: `loop_call_${slug}`,
+            type: "call_workflow",
+            mode: "auto",
+            config: {
+              definition_slug: firstAwait.awaitTarget,
+              result_key: slug,
+              loop_iteration: true
+            }
+          }],
+          conditions: [{ expression: "__loop_idx < length(__loop_items)", type: "expression" }]
+        });
+      }
+      transitions.push({
+        name: `loop_done_${transitionCount}`,
+        from: [loopState],
+        to: postLoop,
+        actions: [],
+        conditions: [{ expression: "__loop_idx >= length(__loop_items)", type: "expression" }]
+      });
+      prevState = postLoop;
+      transitionCount++;
+      continue;
+    }
+    const targetSlug = toSnakeCase4(seg.awaitTarget ?? "unknown");
     let stateName = `awaiting_${targetSlug}`;
     if (usedStateNames.has(stateName)) {
       let suffix = 2;
@@ -6250,7 +9005,7 @@ function generateMultiStateIR(segments, _warnings, parameterMap) {
     states.push({ name: stateName, type: "REGULAR", on_enter: [], during: [], on_exit: [] });
     const actions = [];
     if (pendingSyncStmts.length > 0) {
-      const block = t18.blockStatement(pendingSyncStmts);
+      const block = t22.blockStatement(pendingSyncStmts);
       const transpiled = transpileBlock(block, {
         allMutable: true,
         derivedVarMap: buildDerivedVarMap(awaitBindings),
@@ -6273,9 +9028,9 @@ function generateMultiStateIR(segments, _warnings, parameterMap) {
       const params = {};
       for (let i = 0; i < seg.awaitArgs.length; i++) {
         const arg = seg.awaitArgs[i];
-        if (t18.isObjectExpression(arg)) {
+        if (t22.isObjectExpression(arg)) {
           for (const prop of arg.properties) {
-            if (t18.isObjectProperty(prop) && t18.isIdentifier(prop.key)) {
+            if (t22.isObjectProperty(prop) && t22.isIdentifier(prop.key)) {
               const { expression: valExpr } = transpileArgExpression(prop.value, awaitBindings);
               params[prop.key.name] = valExpr;
             }
@@ -6308,7 +9063,7 @@ function generateMultiStateIR(segments, _warnings, parameterMap) {
   states.push({ name: "done", type: "END", on_enter: [], during: [], on_exit: [] });
   const finalActions = [];
   if (pendingSyncStmts.length > 0) {
-    const block = t18.blockStatement(pendingSyncStmts);
+    const block = t22.blockStatement(pendingSyncStmts);
     const transpiled = transpileBlock(block, {
       allMutable: true,
       derivedVarMap: buildDerivedVarMap(awaitBindings),
@@ -6331,46 +9086,57 @@ function generateMultiStateIR(segments, _warnings, parameterMap) {
   });
   return { states, transitions, bodyIsPure };
 }
+function uniqueState(base, used) {
+  if (!used.has(base)) {
+    used.add(base);
+    return base;
+  }
+  let suffix = 2;
+  while (used.has(`${base}_${suffix}`)) suffix++;
+  const name = `${base}_${suffix}`;
+  used.add(name);
+  return name;
+}
 function getStateSuffix(stateName) {
   return stateName.replace(/^awaiting_/, "");
 }
 function transpileArgExpression(expr, bindings) {
-  if (t18.isIdentifier(expr)) {
+  if (t22.isIdentifier(expr)) {
     const replacement = bindings.get(expr.name);
     if (replacement) return { expression: replacement };
-    return { expression: `state_data.${toSnakeCase3(expr.name)}` };
+    return { expression: `state_data.${toSnakeCase4(expr.name)}` };
   }
-  if (t18.isMemberExpression(expr) && t18.isIdentifier(expr.object)) {
+  if (t22.isMemberExpression(expr) && t22.isIdentifier(expr.object)) {
     const replacement = bindings.get(expr.object.name);
-    if (replacement && t18.isIdentifier(expr.property)) {
+    if (replacement && t22.isIdentifier(expr.property)) {
       return { expression: `${replacement}.${expr.property.name}` };
     }
   }
-  if (t18.isStringLiteral(expr)) return { expression: `'${expr.value}'` };
-  if (t18.isNumericLiteral(expr)) return { expression: String(expr.value) };
-  if (t18.isBooleanLiteral(expr)) return { expression: String(expr.value) };
+  if (t22.isStringLiteral(expr)) return { expression: `'${expr.value}'` };
+  if (t22.isNumericLiteral(expr)) return { expression: String(expr.value) };
+  if (t22.isBooleanLiteral(expr)) return { expression: String(expr.value) };
   const { transpile: transpile2 } = (init_ts_to_expression(), __toCommonJS(ts_to_expression_exports));
   return { expression: transpile2(expr, { derivedVarMap: buildDerivedVarMap(bindings) }) };
 }
 function buildDerivedVarMap(bindings) {
   const map = /* @__PURE__ */ new Map();
   for (const [varName, path] of bindings) {
-    map.set(varName, t18.identifier(path));
+    map.set(varName, t22.identifier(path));
   }
   return map;
 }
 function toKebabCase(name) {
   return name.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "");
 }
-function toSnakeCase3(name) {
+function toSnakeCase4(name) {
   return name.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
 }
-var import_parser, t18;
+var import_parser, t22;
 var init_action_extractor = __esm({
   "src/babel/extractors/action-extractor.ts"() {
     "use strict";
     import_parser = require("@babel/parser");
-    t18 = __toESM(require("@babel/types"));
+    t22 = __toESM(require("@babel/types"));
     init_ts_to_expression();
   }
 });