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

package/dist/chunk-2FBDFAX6.mjs

@@ -0,0 +1,2362 @@
+// src/babel/visitor.ts
+import * as t13 from "@babel/types";
+
+// src/babel/extractors/state-extractor.ts
+import * as t from "@babel/types";
+function inferFieldType(typeAnnotation, defaultValue) {
+  if (typeAnnotation) {
+    if (t.isTSNumberKeyword(typeAnnotation)) return "number";
+    if (t.isTSStringKeyword(typeAnnotation)) return "text";
+    if (t.isTSBooleanKeyword(typeAnnotation)) return "boolean";
+    if (t.isTSTypeReference(typeAnnotation)) {
+      const typeName = t.isIdentifier(typeAnnotation.typeName) ? typeAnnotation.typeName.name : "";
+      if (typeName === "Date") return "date";
+    }
+    if (t.isTSArrayType(typeAnnotation) || t.isTSTypeLiteral(typeAnnotation) || t.isTSTupleType(typeAnnotation)) {
+      return "json";
+    }
+  }
+  if (defaultValue) {
+    if (t.isNumericLiteral(defaultValue)) return "number";
+    if (t.isStringLiteral(defaultValue)) return "text";
+    if (t.isBooleanLiteral(defaultValue)) return "boolean";
+    if (t.isArrayExpression(defaultValue) || t.isObjectExpression(defaultValue)) {
+      return "json";
+    }
+    if (t.isNewExpression(defaultValue) && t.isIdentifier(defaultValue.callee)) {
+      if (defaultValue.callee.name === "Date") return "date";
+    }
+  }
+  return "text";
+}
+function extractDefaultValue(arg) {
+  if (t.isNumericLiteral(arg)) return arg.value;
+  if (t.isStringLiteral(arg)) return arg.value;
+  if (t.isBooleanLiteral(arg)) return arg.value;
+  if (t.isNullLiteral(arg)) return null;
+  if (t.isArrayExpression(arg)) {
+    return arg.elements.map(
+      (el) => el && t.isExpression(el) ? extractDefaultValue(el) : null
+    );
+  }
+  if (t.isObjectExpression(arg)) {
+    const obj = {};
+    arg.properties.forEach((prop) => {
+      if (t.isObjectProperty(prop) && t.isIdentifier(prop.key) && t.isExpression(prop.value)) {
+        obj[prop.key.name] = extractDefaultValue(prop.value);
+      }
+    });
+    return obj;
+  }
+  return void 0;
+}
+function extractStates(path, state) {
+  const parent = path.parentPath;
+  if (!parent.isVariableDeclarator()) return;
+  const id = parent.node.id;
+  if (!t.isArrayPattern(id) || id.elements.length < 1) return;
+  const firstElement = id.elements[0];
+  if (!t.isIdentifier(firstElement)) return;
+  const fieldName = firstElement.name;
+  const args = path.node.arguments;
+  const defaultValue = args.length > 0 && t.isExpression(args[0]) ? args[0] : null;
+  let typeAnnotation = null;
+  if (path.node.typeParameters && t.isTSTypeParameterInstantiation(path.node.typeParameters)) {
+    const params = path.node.typeParameters.params;
+    if (params.length > 0) {
+      typeAnnotation = params[0];
+    }
+  }
+  const fieldType = inferFieldType(typeAnnotation, defaultValue);
+  const fieldDefaultValue = defaultValue ? extractDefaultValue(defaultValue) : void 0;
+  const field = {
+    name: fieldName,
+    type: fieldType,
+    default_value: fieldDefaultValue
+  };
+  const compilerState = state;
+  if (!compilerState.fields) compilerState.fields = [];
+  if (!compilerState.fields.some((f) => f.name === fieldName)) {
+    compilerState.fields.push(field);
+  }
+}
+
+// src/babel/extractors/effect-extractor.ts
+import * as t2 from "@babel/types";
+function analyzeCallbackBody(body, actionCounter) {
+  const actions = [];
+  for (const statement of body) {
+    if (t2.isExpressionStatement(statement)) {
+      const expr = statement.expression;
+      if (t2.isCallExpression(expr) && t2.isIdentifier(expr.callee)) {
+        const calleeName = expr.callee.name;
+        const args = expr.arguments;
+        if (calleeName === "setField" && args.length >= 2) {
+          const field = t2.isStringLiteral(args[0]) ? args[0].value : void 0;
+          const arg1 = args[1];
+          if (field !== void 0 && !t2.isArgumentPlaceholder(arg1)) {
+            const value = extractValue(arg1);
+            actions.push({
+              id: `auto_${++actionCounter.value}`,
+              type: "set_field",
+              mode: "auto",
+              config: { field, value }
+            });
+          }
+        } else if (calleeName === "setMemory" && args.length >= 2) {
+          const key = t2.isStringLiteral(args[0]) ? args[0].value : void 0;
+          const arg1 = args[1];
+          if (key !== void 0 && !t2.isArgumentPlaceholder(arg1)) {
+            const value = extractValue(arg1);
+            actions.push({
+              id: `auto_${++actionCounter.value}`,
+              type: "set_memory",
+              mode: "auto",
+              config: { key, value }
+            });
+          }
+        } else if (calleeName.startsWith("set") && args.length >= 1) {
+          const fieldName = calleeName.slice(3).charAt(0).toLowerCase() + calleeName.slice(4);
+          const arg0 = args[0];
+          if (!t2.isArgumentPlaceholder(arg0)) {
+            const value = extractValue(arg0);
+            actions.push({
+              id: `auto_${++actionCounter.value}`,
+              type: "set_field",
+              mode: "auto",
+              config: { field: fieldName, value }
+            });
+          }
+        }
+      } else if (t2.isCallExpression(expr)) {
+        const callee = expr.callee;
+        const args = expr.arguments;
+        if (t2.isMemberExpression(callee) && t2.isIdentifier(callee.object) && callee.object.name === "console" && t2.isIdentifier(callee.property) && callee.property.name === "log" && args.length > 0) {
+          const arg0 = args[0];
+          if (!t2.isArgumentPlaceholder(arg0)) {
+            const message = extractValue(arg0);
+            actions.push({
+              id: `auto_${++actionCounter.value}`,
+              type: "log_event",
+              mode: "auto",
+              config: { message }
+            });
+          }
+        } else {
+          actions.push({
+            id: `auto_${++actionCounter.value}`,
+            type: "custom",
+            mode: "auto",
+            config: { expression: generateCode(expr) }
+          });
+        }
+      }
+    }
+  }
+  return actions;
+}
+function extractValue(node) {
+  if (t2.isNumericLiteral(node)) return node.value;
+  if (t2.isStringLiteral(node)) return node.value;
+  if (t2.isBooleanLiteral(node)) return node.value;
+  if (t2.isNullLiteral(node)) return null;
+  if (t2.isArrayExpression(node)) {
+    return node.elements.map((el) => el && t2.isExpression(el) ? extractValue(el) : null);
+  }
+  if (t2.isObjectExpression(node)) {
+    const obj = {};
+    node.properties.forEach((prop) => {
+      if (t2.isObjectProperty(prop) && t2.isIdentifier(prop.key) && t2.isExpression(prop.value)) {
+        obj[prop.key.name] = extractValue(prop.value);
+      }
+    });
+    return obj;
+  }
+  return generateCode(node);
+}
+function generateCode(node) {
+  if (t2.isIdentifier(node)) return node.name;
+  if (t2.isNumericLiteral(node)) return String(node.value);
+  if (t2.isStringLiteral(node)) return `"${node.value}"`;
+  if (t2.isBooleanLiteral(node)) return String(node.value);
+  if (t2.isNullLiteral(node)) return "null";
+  if (t2.isCallExpression(node) && t2.isMemberExpression(node.callee) && t2.isIdentifier(node.callee.object) && node.callee.object.name === "Date" && t2.isIdentifier(node.callee.property) && node.callee.property.name === "now") {
+    return "now()";
+  }
+  if (t2.isCallExpression(node) && t2.isMemberExpression(node.callee) && t2.isNewExpression(node.callee.object) && t2.isIdentifier(node.callee.object.callee) && node.callee.object.callee.name === "Date" && t2.isIdentifier(node.callee.property) && node.callee.property.name === "toISOString") {
+    return "now()";
+  }
+  if (t2.isTemplateLiteral(node)) {
+    return node.quasis.map((q) => q.value.raw).join("${}");
+  }
+  if (t2.isMemberExpression(node) && t2.isIdentifier(node.object) && t2.isIdentifier(node.property)) {
+    return `${node.object.name}.${node.property.name}`;
+  }
+  return "[Expression]";
+}
+function ensureState(states, stateName) {
+  if (!states.has(stateName)) {
+    states.set(stateName, {
+      name: stateName,
+      type: "REGULAR",
+      on_enter: [],
+      during: [],
+      on_exit: []
+    });
+  }
+  return states.get(stateName);
+}
+function extractEffects(path, state) {
+  const callee = path.node.callee;
+  if (!t2.isIdentifier(callee)) return;
+  const hookName = callee.name;
+  const args = path.node.arguments;
+  if ((hookName === "useOnEnter" || hookName === "useOnExit") && args.length >= 2) {
+    const stateArg = args[0];
+    const callbackArg = args[1];
+    if (!t2.isStringLiteral(stateArg)) return;
+    const stateName = stateArg.value;
+    let callbackBody = [];
+    if (t2.isArrowFunctionExpression(callbackArg) || t2.isFunctionExpression(callbackArg)) {
+      const body = callbackArg.body;
+      if (t2.isBlockStatement(body)) {
+        callbackBody = body.body;
+      } else if (t2.isExpression(body)) {
+        callbackBody = [t2.expressionStatement(body)];
+      }
+    }
+    const compilerState = state;
+    if (!compilerState.states) compilerState.states = /* @__PURE__ */ new Map();
+    if (!compilerState.actionCounter) compilerState.actionCounter = 0;
+    const stateDefinition = ensureState(compilerState.states, stateName);
+    const actions = analyzeCallbackBody(callbackBody, { value: compilerState.actionCounter });
+    compilerState.actionCounter += actions.length;
+    if (hookName === "useOnEnter") {
+      stateDefinition.on_enter.push(...actions);
+    } else if (hookName === "useOnExit") {
+      stateDefinition.on_exit.push(...actions);
+    }
+  }
+}
+
+// src/babel/extractors/transition-extractor.ts
+import * as t3 from "@babel/types";
+function extractTransitions(path, state) {
+  const callee = path.node.callee;
+  if (!t3.isIdentifier(callee) || callee.name !== "useTransition") return;
+  const args = path.node.arguments;
+  if (args.length < 1) return;
+  const nameArg = args[0];
+  if (!t3.isStringLiteral(nameArg)) return;
+  const transitionName = nameArg.value;
+  const compilerState = state;
+  if (!compilerState.transitions) compilerState.transitions = [];
+  const existing = compilerState.transitions.find((tr) => tr.name === transitionName);
+  if (existing) return;
+  let from = [];
+  let to = "";
+  if (args.length >= 2 && t3.isObjectExpression(args[1])) {
+    const opts = args[1];
+    for (const prop of opts.properties) {
+      if (!t3.isObjectProperty(prop) || !t3.isIdentifier(prop.key)) continue;
+      if (prop.key.name === "from") {
+        if (t3.isArrayExpression(prop.value)) {
+          from = prop.value.elements.filter((el) => t3.isStringLiteral(el)).map((el) => el.value);
+        } else if (t3.isStringLiteral(prop.value)) {
+          from = [prop.value.value];
+        }
+      } else if (prop.key.name === "to") {
+        if (t3.isStringLiteral(prop.value)) {
+          to = prop.value.value;
+        }
+      }
+    }
+  }
+  const transition = {
+    name: transitionName,
+    from,
+    to,
+    actions: [],
+    conditions: []
+  };
+  compilerState.transitions.push(transition);
+}
+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((t14) => t14.from.length === 0 || !t14.to);
+  if (needsInference.length === 0) return;
+  if (startStates.length === 1 && regularStates.length > 0) {
+    needsInference.forEach((t14, idx) => {
+      if (t14.from.length === 0) {
+        t14.from = [startStates[0].name];
+      }
+      if (!t14.to) {
+        t14.to = regularStates[idx % regularStates.length]?.name || startStates[0].name;
+      }
+    });
+  } else {
+    const allStateNames = stateArray.map((s) => s.name);
+    needsInference.forEach((t14, idx) => {
+      if (t14.from.length === 0 && allStateNames.length > 0) {
+        t14.from = [allStateNames[0]];
+      }
+      if (!t14.to && allStateNames.length > 1) {
+        t14.to = allStateNames[Math.min(idx + 1, allStateNames.length - 1)];
+      }
+    });
+  }
+}
+
+// src/babel/extractors/event-extractor.ts
+import * as t4 from "@babel/types";
+function analyzeEventCallback(body) {
+  const actions = [];
+  for (const statement of body) {
+    if (t4.isExpressionStatement(statement)) {
+      const expr = statement.expression;
+      if (t4.isCallExpression(expr) && t4.isIdentifier(expr.callee)) {
+        const calleeName = expr.callee.name;
+        const args = expr.arguments;
+        if (calleeName === "setField" && args.length >= 2) {
+          const field = t4.isStringLiteral(args[0]) ? args[0].value : void 0;
+          const expression = generateExpression(args[1]);
+          if (field) {
+            actions.push({
+              type: "set_field",
+              field,
+              expression
+            });
+          }
+        } else if (calleeName === "setMemory" && args.length >= 2) {
+          const key = t4.isStringLiteral(args[0]) ? args[0].value : void 0;
+          const expression = generateExpression(args[1]);
+          if (key) {
+            actions.push({
+              type: "set_memory",
+              key,
+              expression
+            });
+          }
+        }
+      } else if (t4.isCallExpression(expr)) {
+        const callee = expr.callee;
+        const args = expr.arguments;
+        if (t4.isMemberExpression(callee) && t4.isIdentifier(callee.object) && callee.object.name === "console" && t4.isIdentifier(callee.property) && callee.property.name === "log") {
+          const message = args.length > 0 ? generateExpression(args[0]) : "";
+          actions.push({
+            type: "log_event",
+            message
+          });
+        }
+      }
+    }
+  }
+  return actions;
+}
+function generateExpression(node) {
+  if (t4.isStringLiteral(node)) return node.value;
+  if (t4.isNumericLiteral(node)) return String(node.value);
+  if (t4.isBooleanLiteral(node)) return String(node.value);
+  if (t4.isIdentifier(node)) return node.name;
+  if (t4.isBinaryExpression(node)) {
+    return `${generateExpression(node.left)} ${node.operator} ${generateExpression(node.right)}`;
+  }
+  if (t4.isCallExpression(node) && t4.isIdentifier(node.callee)) {
+    const args = node.arguments.map((arg) => generateExpression(arg)).join(", ");
+    return `${node.callee.name}(${args})`;
+  }
+  return "[Expression]";
+}
+function ensureState2(states, stateName) {
+  if (!states.has(stateName)) {
+    states.set(stateName, {
+      name: stateName,
+      type: "REGULAR",
+      on_enter: [],
+      during: [],
+      on_exit: []
+    });
+  }
+  return states.get(stateName);
+}
+function extractEvents(path, state) {
+  const callee = path.node.callee;
+  if (!t4.isIdentifier(callee) || callee.name !== "useOnEvent") return;
+  const args = path.node.arguments;
+  if (args.length < 2) return;
+  const patternArg = args[0];
+  const callbackArg = args[1];
+  const optionsArg = args.length > 2 ? args[2] : null;
+  if (!t4.isStringLiteral(patternArg)) return;
+  const pattern = patternArg.value;
+  let callbackBody = [];
+  if (t4.isArrowFunctionExpression(callbackArg) || t4.isFunctionExpression(callbackArg)) {
+    const body = callbackArg.body;
+    if (t4.isBlockStatement(body)) {
+      callbackBody = body.body;
+    } else if (t4.isExpression(body)) {
+      callbackBody = [t4.expressionStatement(body)];
+    }
+  }
+  let stateName = null;
+  if (optionsArg && t4.isObjectExpression(optionsArg)) {
+    const whileProp = optionsArg.properties.find(
+      (prop) => t4.isObjectProperty(prop) && t4.isIdentifier(prop.key) && prop.key.name === "while"
+    );
+    if (whileProp && t4.isObjectProperty(whileProp) && t4.isStringLiteral(whileProp.value)) {
+      stateName = whileProp.value.value;
+    }
+  }
+  const actions = analyzeEventCallback(callbackBody);
+  const subscription = {
+    match: pattern,
+    conditions: [],
+    actions
+  };
+  const compilerState = state;
+  if (!compilerState.states) compilerState.states = /* @__PURE__ */ new Map();
+  if (stateName) {
+    const stateDefinition = ensureState2(compilerState.states, stateName);
+    if (!stateDefinition.on_event) stateDefinition.on_event = [];
+    stateDefinition.on_event.push(subscription);
+  } else {
+    if (!compilerState.events) compilerState.events = [];
+    compilerState.events.push(subscription);
+  }
+}
+
+// src/babel/extractors/component-extractor.ts
+import * as t5 from "@babel/types";
+var nodeIdCounter = 0;
+function resetNodeIdCounter() {
+  nodeIdCounter = 0;
+}
+function jsxToExperienceNode(node) {
+  if (t5.isJSXFragment(node)) {
+    return {
+      id: `fragment_${++nodeIdCounter}`,
+      children: extractChildren(node.children)
+    };
+  }
+  const element = node.openingElement;
+  const componentName = resolveComponentName(element.name);
+  const id = generateNodeId(componentName);
+  const config = {};
+  const bindings = {};
+  let visibleWhen;
+  let layout;
+  const layoutMap = {
+    Stack: "stack",
+    Row: "row",
+    Grid: "grid",
+    Tabs: "tabs",
+    Column: "column"
+  };
+  if (layoutMap[componentName]) {
+    layout = layoutMap[componentName];
+  }
+  for (const attr of element.attributes) {
+    if (t5.isJSXAttribute(attr) && t5.isJSXIdentifier(attr.name)) {
+      const attrName = attr.name.name;
+      const attrValue = attr.value;
+      if (attrName === "visible_when" && t5.isStringLiteral(attrValue)) {
+        visibleWhen = attrValue.value;
+      } else if (attrName === "data-slot" && t5.isStringLiteral(attrValue)) {
+        config.slot = attrValue.value;
+      } else if (t5.isJSXExpressionContainer(attrValue)) {
+        const expr = attrValue.expression;
+        if (t5.isJSXEmptyExpression(expr)) continue;
+        if (t5.isIdentifier(expr)) {
+          bindings[attrName] = `$instance.${expr.name}`;
+        } else if (t5.isExpression(expr)) {
+          bindings[attrName] = generateExpression2(expr);
+        }
+      } else if (t5.isStringLiteral(attrValue)) {
+        config[attrName] = attrValue.value;
+      } else if (attrValue === null) {
+        config[attrName] = true;
+      }
+    } else if (t5.isJSXSpreadAttribute(attr)) {
+      if (t5.isIdentifier(attr.argument)) {
+        bindings["..." + attr.argument.name] = `$instance.${attr.argument.name}`;
+      }
+    }
+  }
+  const children = extractChildren(node.children);
+  const experienceNode = {
+    id,
+    component: componentName,
+    ...layout && { layout },
+    ...Object.keys(bindings).length > 0 && { bindings },
+    ...Object.keys(config).length > 0 && { config },
+    ...visibleWhen && { visible_when: visibleWhen },
+    ...children.length > 0 && { children }
+  };
+  return experienceNode;
+}
+function resolveComponentName(name) {
+  if (t5.isJSXIdentifier(name)) return name.name;
+  if (t5.isJSXMemberExpression(name)) {
+    const obj = resolveComponentName(name.object);
+    return `${obj}.${name.property.name}`;
+  }
+  if (t5.isJSXNamespacedName(name)) {
+    return `${name.namespace.name}:${name.name.name}`;
+  }
+  return "div";
+}
+function extractChildren(children) {
+  const nodes = [];
+  for (const child of children) {
+    if (t5.isJSXElement(child)) {
+      nodes.push(jsxToExperienceNode(child));
+    } else if (t5.isJSXFragment(child)) {
+      nodes.push(jsxToExperienceNode(child));
+    } else if (t5.isJSXText(child)) {
+      const text = child.value.trim();
+      if (text) {
+        nodes.push({
+          id: `text_${++nodeIdCounter}`,
+          component: "Text",
+          config: { value: text }
+        });
+      }
+    } else if (t5.isJSXExpressionContainer(child)) {
+      const expr = child.expression;
+      if (t5.isJSXEmptyExpression(expr)) continue;
+      if (t5.isConditionalExpression(expr)) {
+        const condExpr = generateExpression2(expr.test);
+        if (t5.isJSXElement(expr.consequent) || t5.isJSXFragment(expr.consequent)) {
+          const consequent = jsxToExperienceNode(expr.consequent);
+          consequent.visible_when = condExpr;
+          nodes.push(consequent);
+        }
+        if (t5.isJSXElement(expr.alternate) || t5.isJSXFragment(expr.alternate)) {
+          const alternate = jsxToExperienceNode(expr.alternate);
+          alternate.visible_when = `not(${condExpr})`;
+          nodes.push(alternate);
+        }
+      } else if (t5.isLogicalExpression(expr) && expr.operator === "&&") {
+        const condExpr = generateExpression2(expr.left);
+        if (t5.isJSXElement(expr.right) || t5.isJSXFragment(expr.right)) {
+          const element = jsxToExperienceNode(expr.right);
+          element.visible_when = condExpr;
+          nodes.push(element);
+        }
+      } else if (t5.isCallExpression(expr) && t5.isMemberExpression(expr.callee) && t5.isIdentifier(expr.callee.property) && expr.callee.property.name === "map" && expr.arguments.length > 0) {
+        const listSource = generateExpression2(expr.callee.object);
+        const mapFn = expr.arguments[0];
+        let itemTemplate = null;
+        let itemAlias = "item";
+        if (t5.isArrowFunctionExpression(mapFn) || t5.isFunctionExpression(mapFn)) {
+          if (mapFn.params.length > 0 && t5.isIdentifier(mapFn.params[0])) {
+            itemAlias = mapFn.params[0].name;
+          }
+          const body = mapFn.body;
+          if (t5.isJSXElement(body) || t5.isJSXFragment(body)) {
+            itemTemplate = jsxToExperienceNode(body);
+          } else if (t5.isBlockStatement(body)) {
+            for (const stmt of body.body) {
+              if (t5.isReturnStatement(stmt) && stmt.argument) {
+                if (t5.isJSXElement(stmt.argument) || t5.isJSXFragment(stmt.argument)) {
+                  itemTemplate = jsxToExperienceNode(stmt.argument);
+                }
+                break;
+              }
+            }
+          }
+        }
+        nodes.push({
+          id: `each_${++nodeIdCounter}`,
+          component: "Each",
+          bindings: { items: `$instance.${listSource}` },
+          config: { as: itemAlias },
+          ...itemTemplate ? { children: [itemTemplate] } : {}
+        });
+      } else if (t5.isIdentifier(expr)) {
+        nodes.push({
+          id: `text_${++nodeIdCounter}`,
+          component: "Text",
+          bindings: { value: `$instance.${expr.name}` }
+        });
+      } else if (t5.isExpression(expr)) {
+        const exprStr = generateExpression2(expr);
+        if (exprStr !== "[Expression]") {
+          nodes.push({
+            id: `text_${++nodeIdCounter}`,
+            component: "Text",
+            bindings: { value: exprStr }
+          });
+        }
+      }
+    }
+  }
+  return nodes;
+}
+function generateNodeId(componentName) {
+  const id = componentName.replace(/\./g, "-").replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "");
+  return `${id}_${++nodeIdCounter}`;
+}
+function generateExpression2(node) {
+  if (t5.isIdentifier(node)) return node.name;
+  if (t5.isStringLiteral(node)) return `"${node.value}"`;
+  if (t5.isNumericLiteral(node)) return String(node.value);
+  if (t5.isBooleanLiteral(node)) return String(node.value);
+  if (t5.isNullLiteral(node)) return "null";
+  if (t5.isMemberExpression(node)) {
+    const obj = t5.isExpression(node.object) ? generateExpression2(node.object) : "[object]";
+    const prop = t5.isIdentifier(node.property) ? node.property.name : "[property]";
+    return `${obj}.${prop}`;
+  }
+  if (t5.isBinaryExpression(node)) {
+    return `${generateExpression2(node.left)} ${node.operator} ${generateExpression2(node.right)}`;
+  }
+  if (t5.isUnaryExpression(node) && node.prefix) {
+    return `${node.operator}${generateExpression2(node.argument)}`;
+  }
+  if (t5.isCallExpression(node) && t5.isIdentifier(node.callee)) {
+    const args = node.arguments.map((a) => t5.isExpression(a) ? generateExpression2(a) : "[arg]").join(", ");
+    return `${node.callee.name}(${args})`;
+  }
+  if (t5.isCallExpression(node) && t5.isMemberExpression(node.callee)) {
+    const obj = generateExpression2(node.callee.object);
+    const prop = t5.isIdentifier(node.callee.property) ? node.callee.property.name : "[method]";
+    const args = node.arguments.map((a) => t5.isExpression(a) ? generateExpression2(a) : "[arg]").join(", ");
+    return `${obj}.${prop}(${args})`;
+  }
+  if (t5.isTemplateLiteral(node)) {
+    return node.quasis.map((q, i) => {
+      const raw = q.value.raw;
+      if (i < node.expressions.length) {
+        return raw + "${" + generateExpression2(node.expressions[i]) + "}";
+      }
+      return raw;
+    }).join("");
+  }
+  return "[Expression]";
+}
+function extractComponents(path, state) {
+  const arg = path.node.argument;
+  if (!arg) return;
+  let experienceNode = null;
+  if (t5.isJSXElement(arg)) {
+    experienceNode = jsxToExperienceNode(arg);
+  } else if (t5.isJSXFragment(arg)) {
+    experienceNode = jsxToExperienceNode(arg);
+  }
+  if (experienceNode) {
+    const compilerState = state;
+    compilerState.experience = experienceNode;
+  }
+}
+
+// src/babel/extractors/during-extractor.ts
+import * as t6 from "@babel/types";
+var duringIdCounter = 0;
+function resetDuringIdCounter() {
+  duringIdCounter = 0;
+}
+function analyzeCallbackBody2(body, actionCounter) {
+  const actions = [];
+  for (const statement of body) {
+    if (!t6.isExpressionStatement(statement)) continue;
+    const expr = statement.expression;
+    if (t6.isCallExpression(expr) && t6.isIdentifier(expr.callee)) {
+      const calleeName = expr.callee.name;
+      const args = expr.arguments;
+      if (calleeName === "setField" && args.length >= 2) {
+        const field = t6.isStringLiteral(args[0]) ? args[0].value : void 0;
+        const arg1 = args[1];
+        if (field !== void 0 && !t6.isArgumentPlaceholder(arg1)) {
+          actions.push({
+            id: `auto_${++actionCounter.value}`,
+            type: "set_field",
+            mode: "auto",
+            config: { field, value: extractValue2(arg1) }
+          });
+        }
+      } else if (calleeName === "setMemory" && args.length >= 2) {
+        const key = t6.isStringLiteral(args[0]) ? args[0].value : void 0;
+        const arg1 = args[1];
+        if (key !== void 0 && !t6.isArgumentPlaceholder(arg1)) {
+          actions.push({
+            id: `auto_${++actionCounter.value}`,
+            type: "set_memory",
+            mode: "auto",
+            config: { key, value: extractValue2(arg1) }
+          });
+        }
+      } else if (calleeName.startsWith("set") && calleeName.length > 3 && args.length >= 1) {
+        const fieldName = calleeName.slice(3, 4).toLowerCase() + calleeName.slice(4);
+        const arg0 = args[0];
+        if (!t6.isArgumentPlaceholder(arg0)) {
+          actions.push({
+            id: `auto_${++actionCounter.value}`,
+            type: "set_field",
+            mode: "auto",
+            config: { field: fieldName, value: extractValue2(arg0) }
+          });
+        }
+      }
+    } else if (t6.isCallExpression(expr)) {
+      const callee = expr.callee;
+      if (t6.isMemberExpression(callee) && t6.isIdentifier(callee.object) && callee.object.name === "console" && t6.isIdentifier(callee.property) && callee.property.name === "log" && expr.arguments.length > 0) {
+        const arg0 = expr.arguments[0];
+        if (!t6.isArgumentPlaceholder(arg0)) {
+          actions.push({
+            id: `auto_${++actionCounter.value}`,
+            type: "log_event",
+            mode: "auto",
+            config: { message: extractValue2(arg0) }
+          });
+        }
+      } else {
+        actions.push({
+          id: `auto_${++actionCounter.value}`,
+          type: "custom",
+          mode: "auto",
+          config: { expression: generateCode2(expr) }
+        });
+      }
+    }
+  }
+  return actions;
+}
+function extractValue2(node) {
+  if (t6.isNumericLiteral(node)) return node.value;
+  if (t6.isStringLiteral(node)) return node.value;
+  if (t6.isBooleanLiteral(node)) return node.value;
+  if (t6.isNullLiteral(node)) return null;
+  if (t6.isArrayExpression(node)) {
+    return node.elements.map((el) => el && t6.isExpression(el) ? extractValue2(el) : null);
+  }
+  if (t6.isObjectExpression(node)) {
+    const obj = {};
+    node.properties.forEach((prop) => {
+      if (t6.isObjectProperty(prop) && t6.isIdentifier(prop.key) && t6.isExpression(prop.value)) {
+        obj[prop.key.name] = extractValue2(prop.value);
+      }
+    });
+    return obj;
+  }
+  return generateCode2(node);
+}
+function generateCode2(node) {
+  if (t6.isIdentifier(node)) return node.name;
+  if (t6.isNumericLiteral(node)) return String(node.value);
+  if (t6.isStringLiteral(node)) return `"${node.value}"`;
+  if (t6.isBooleanLiteral(node)) return String(node.value);
+  if (t6.isNullLiteral(node)) return "null";
+  if (t6.isBinaryExpression(node)) {
+    return `${generateCode2(node.left)} ${node.operator} ${generateCode2(node.right)}`;
+  }
+  if (t6.isCallExpression(node) && t6.isMemberExpression(node.callee) && t6.isIdentifier(node.callee.object) && node.callee.object.name === "Date" && t6.isIdentifier(node.callee.property) && node.callee.property.name === "now") {
+    return "now()";
+  }
+  if (t6.isMemberExpression(node) && t6.isIdentifier(node.object) && t6.isIdentifier(node.property)) {
+    return `${node.object.name}.${node.property.name}`;
+  }
+  if (t6.isArrowFunctionExpression(node) || t6.isFunctionExpression(node)) {
+    if (t6.isArrowFunctionExpression(node) && t6.isExpression(node.body)) {
+      const params = node.params;
+      if (params.length === 1 && t6.isIdentifier(params[0])) {
+        const paramName = params[0].name;
+        const bodyCode = generateCode2(node.body);
+        return bodyCode.replace(new RegExp(`\\b${paramName}\\b`, "g"), "$prev");
+      }
+    }
+    return "[Function]";
+  }
+  return "[Expression]";
+}
+function ensureState3(states, stateName) {
+  if (!states.has(stateName)) {
+    states.set(stateName, {
+      name: stateName,
+      type: "REGULAR",
+      on_enter: [],
+      during: [],
+      on_exit: []
+    });
+  }
+  return states.get(stateName);
+}
+function extractDuring(path, state) {
+  const callee = path.node.callee;
+  if (!t6.isIdentifier(callee) || callee.name !== "useWhileIn") return;
+  const args = path.node.arguments;
+  if (args.length < 3) return;
+  const stateArg = args[0];
+  const intervalArg = args[1];
+  const callbackArg = args[2];
+  if (!t6.isStringLiteral(stateArg)) return;
+  const stateName = stateArg.value;
+  let intervalMs = 1e3;
+  if (t6.isNumericLiteral(intervalArg)) {
+    intervalMs = intervalArg.value;
+  }
+  let callbackBody = [];
+  if (t6.isArrowFunctionExpression(callbackArg) || t6.isFunctionExpression(callbackArg)) {
+    const body = callbackArg.body;
+    if (t6.isBlockStatement(body)) {
+      callbackBody = body.body;
+    } else if (t6.isExpression(body)) {
+      callbackBody = [t6.expressionStatement(body)];
+    }
+  }
+  const compilerState = state;
+  if (!compilerState.states) compilerState.states = /* @__PURE__ */ new Map();
+  if (!compilerState.actionCounter) compilerState.actionCounter = 0;
+  const stateDefinition = ensureState3(compilerState.states, stateName);
+  const actions = analyzeCallbackBody2(callbackBody, { value: compilerState.actionCounter });
+  compilerState.actionCounter += actions.length;
+  const duringAction = {
+    id: `during_${++duringIdCounter}`,
+    type: "interval",
+    interval_ms: intervalMs,
+    actions
+  };
+  stateDefinition.during.push(duringAction);
+}
+
+// src/babel/extractors/change-extractor.ts
+import * as t7 from "@babel/types";
+var watcherIdCounter = 0;
+function resetWatcherIdCounter() {
+  watcherIdCounter = 0;
+}
+function analyzeCallbackBody3(body, actionCounter) {
+  const actions = [];
+  for (const statement of body) {
+    if (!t7.isExpressionStatement(statement)) continue;
+    const expr = statement.expression;
+    if (t7.isCallExpression(expr) && t7.isIdentifier(expr.callee)) {
+      const calleeName = expr.callee.name;
+      const args = expr.arguments;
+      if (calleeName === "setField" && args.length >= 2) {
+        const field = t7.isStringLiteral(args[0]) ? args[0].value : void 0;
+        if (field !== void 0) {
+          actions.push({
+            id: `auto_${++actionCounter.value}`,
+            type: "set_field",
+            mode: "auto",
+            config: { field, value: extractValue3(args[1]) }
+          });
+        }
+      } else if (calleeName === "setMemory" && args.length >= 2) {
+        const key = t7.isStringLiteral(args[0]) ? args[0].value : void 0;
+        if (key !== void 0) {
+          actions.push({
+            id: `auto_${++actionCounter.value}`,
+            type: "set_memory",
+            mode: "auto",
+            config: { key, value: extractValue3(args[1]) }
+          });
+        }
+      } else if (calleeName.startsWith("set") && calleeName.length > 3 && args.length >= 1) {
+        const fieldName = calleeName.slice(3, 4).toLowerCase() + calleeName.slice(4);
+        actions.push({
+          id: `auto_${++actionCounter.value}`,
+          type: "set_field",
+          mode: "auto",
+          config: { field: fieldName, value: extractValue3(args[0]) }
+        });
+      }
+    } else if (t7.isCallExpression(expr)) {
+      const callee = expr.callee;
+      if (t7.isMemberExpression(callee) && t7.isIdentifier(callee.object) && callee.object.name === "console" && t7.isIdentifier(callee.property) && callee.property.name === "log" && expr.arguments.length > 0) {
+        actions.push({
+          id: `auto_${++actionCounter.value}`,
+          type: "log_event",
+          mode: "auto",
+          config: { message: extractValue3(expr.arguments[0]) }
+        });
+      }
+    }
+  }
+  return actions;
+}
+function extractValue3(node) {
+  if (t7.isNumericLiteral(node)) return node.value;
+  if (t7.isStringLiteral(node)) return node.value;
+  if (t7.isBooleanLiteral(node)) return node.value;
+  if (t7.isNullLiteral(node)) return null;
+  if (t7.isIdentifier(node)) return node.name;
+  if (t7.isTemplateLiteral(node)) {
+    return node.quasis.map((q) => q.value.raw).join("${}");
+  }
+  return "[Expression]";
+}
+function extractChangeWatcher(path, state) {
+  const callee = path.node.callee;
+  if (!t7.isIdentifier(callee) || callee.name !== "useOnChange") return;
+  const args = path.node.arguments;
+  if (args.length < 2) return;
+  const fieldArg = args[0];
+  const callbackArg = args[1];
+  if (!t7.isStringLiteral(fieldArg)) return;
+  const field = fieldArg.value;
+  let callbackBody = [];
+  if (t7.isArrowFunctionExpression(callbackArg) || t7.isFunctionExpression(callbackArg)) {
+    const body = callbackArg.body;
+    if (t7.isBlockStatement(body)) {
+      callbackBody = body.body;
+    } else if (t7.isExpression(body)) {
+      callbackBody = [t7.expressionStatement(body)];
+    }
+  }
+  const compilerState = state;
+  if (!compilerState.actionCounter) compilerState.actionCounter = 0;
+  const actions = analyzeCallbackBody3(callbackBody, { value: compilerState.actionCounter });
+  compilerState.actionCounter += actions.length;
+  const watcher = {
+    id: `watcher_${++watcherIdCounter}`,
+    field,
+    actions
+  };
+  if (!compilerState.metadata) compilerState.metadata = {};
+  const meta = compilerState.metadata;
+  if (!meta.fieldWatchers) meta.fieldWatchers = [];
+  meta.fieldWatchers.push(watcher);
+}
+
+// src/babel/extractors/transition-effect-extractor.ts
+import * as t8 from "@babel/types";
+var transitionEffectIdCounter = 0;
+function resetTransitionEffectIdCounter() {
+  transitionEffectIdCounter = 0;
+}
+function analyzeCallbackBody4(body, actionCounter) {
+  const actions = [];
+  for (const statement of body) {
+    if (!t8.isExpressionStatement(statement)) continue;
+    const expr = statement.expression;
+    if (t8.isCallExpression(expr) && t8.isIdentifier(expr.callee)) {
+      const calleeName = expr.callee.name;
+      const args = expr.arguments;
+      if (calleeName === "setField" && args.length >= 2) {
+        const field = t8.isStringLiteral(args[0]) ? args[0].value : void 0;
+        if (field !== void 0) {
+          actions.push({
+            id: `auto_${++actionCounter.value}`,
+            type: "set_field",
+            mode: "auto",
+            config: { field, value: extractValue4(args[1]) }
+          });
+        }
+      } else if (calleeName === "setMemory" && args.length >= 2) {
+        const key = t8.isStringLiteral(args[0]) ? args[0].value : void 0;
+        if (key !== void 0) {
+          actions.push({
+            id: `auto_${++actionCounter.value}`,
+            type: "set_memory",
+            mode: "auto",
+            config: { key, value: extractValue4(args[1]) }
+          });
+        }
+      } else if (calleeName.startsWith("set") && calleeName.length > 3 && args.length >= 1) {
+        const fieldName = calleeName.slice(3, 4).toLowerCase() + calleeName.slice(4);
+        actions.push({
+          id: `auto_${++actionCounter.value}`,
+          type: "set_field",
+          mode: "auto",
+          config: { field: fieldName, value: extractValue4(args[0]) }
+        });
+      }
+    } else if (t8.isCallExpression(expr)) {
+      const callee = expr.callee;
+      if (t8.isMemberExpression(callee) && t8.isIdentifier(callee.object) && callee.object.name === "console" && t8.isIdentifier(callee.property) && callee.property.name === "log" && expr.arguments.length > 0) {
+        actions.push({
+          id: `auto_${++actionCounter.value}`,
+          type: "log_event",
+          mode: "auto",
+          config: { message: extractValue4(expr.arguments[0]) }
+        });
+      }
+    }
+  }
+  return actions;
+}
+function extractValue4(node) {
+  if (t8.isNumericLiteral(node)) return node.value;
+  if (t8.isStringLiteral(node)) return node.value;
+  if (t8.isBooleanLiteral(node)) return node.value;
+  if (t8.isNullLiteral(node)) return null;
+  if (t8.isIdentifier(node)) return node.name;
+  return "[Expression]";
+}
+function extractTransitionEffect(path, state) {
+  const callee = path.node.callee;
+  if (!t8.isIdentifier(callee) || callee.name !== "useOnTransition") return;
+  const args = path.node.arguments;
+  if (args.length < 1) return;
+  const callbackArg = args[0];
+  let callbackBody = [];
+  if (t8.isArrowFunctionExpression(callbackArg) || t8.isFunctionExpression(callbackArg)) {
+    const body = callbackArg.body;
+    if (t8.isBlockStatement(body)) {
+      callbackBody = body.body;
+    } else if (t8.isExpression(body)) {
+      callbackBody = [t8.expressionStatement(body)];
+    }
+  }
+  const compilerState = state;
+  if (!compilerState.actionCounter) compilerState.actionCounter = 0;
+  const actions = analyzeCallbackBody4(callbackBody, { value: compilerState.actionCounter });
+  compilerState.actionCounter += actions.length;
+  const effect = {
+    id: `transition_effect_${++transitionEffectIdCounter}`,
+    actions
+  };
+  if (!compilerState.metadata) compilerState.metadata = {};
+  const meta = compilerState.metadata;
+  if (!meta.transitionEffects) meta.transitionEffects = [];
+  meta.transitionEffects.push(effect);
+}
+
+// src/babel/extractors/model-extractor.ts
+import * as t9 from "@babel/types";
+function tsTypeToFieldType(typeAnnotation) {
+  if (!typeAnnotation) return "text";
+  const annotation = typeAnnotation.typeAnnotation;
+  return resolveType(annotation);
+}
+function resolveType(annotation) {
+  if (t9.isTSStringKeyword(annotation)) return "text";
+  if (t9.isTSNumberKeyword(annotation)) return "number";
+  if (t9.isTSBooleanKeyword(annotation)) return "boolean";
+  if (t9.isTSTypeReference(annotation) && t9.isIdentifier(annotation.typeName) && annotation.typeName.name === "Date") {
+    return "datetime";
+  }
+  if (t9.isTSTypeReference(annotation) && t9.isIdentifier(annotation.typeName) && annotation.typeName.name === "Record") {
+    return "json";
+  }
+  if (t9.isTSArrayType(annotation)) {
+    return "multi_select";
+  }
+  if (t9.isTSTypeReference(annotation) && t9.isIdentifier(annotation.typeName) && annotation.typeName.name === "Array") {
+    return "multi_select";
+  }
+  if (t9.isTSUnionType(annotation)) {
+    const allLiterals = annotation.types.every(
+      (t22) => t9.isTSLiteralType(t22) && (t9.isStringLiteral(t22.literal) || t9.isNumericLiteral(t22.literal))
+    );
+    if (allLiterals) return "select";
+    return "text";
+  }
+  if (t9.isTSLiteralType(annotation) && t9.isStringLiteral(annotation.literal)) return "text";
+  if (t9.isTSLiteralType(annotation) && t9.isNumericLiteral(annotation.literal)) return "number";
+  return "text";
+}
+function extractUnionOptions(annotation) {
+  if (!t9.isTSUnionType(annotation)) return void 0;
+  const options = [];
+  for (const member of annotation.types) {
+    if (t9.isTSLiteralType(member) && t9.isStringLiteral(member.literal)) {
+      options.push(member.literal.value);
+    }
+  }
+  return options.length > 0 ? options : void 0;
+}
+function extractDefaultValue2(fieldType) {
+  switch (fieldType) {
+    case "text":
+      return "";
+    case "rich_text":
+      return "";
+    case "number":
+      return 0;
+    case "boolean":
+      return false;
+    case "date":
+      return null;
+    case "datetime":
+      return null;
+    case "select":
+      return "";
+    case "multi_select":
+      return [];
+    case "url":
+      return "";
+    case "json":
+      return {};
+    default:
+      return null;
+  }
+}
+function extractFieldsFromInterface(declaration) {
+  const fields = [];
+  for (const member of declaration.body.body) {
+    if (!t9.isTSPropertySignature(member)) continue;
+    if (!t9.isIdentifier(member.key)) continue;
+    const name = member.key.name;
+    const required = !member.optional;
+    const typeAnno = member.typeAnnotation;
+    const fieldType = tsTypeToFieldType(typeAnno);
+    const field = {
+      name,
+      type: fieldType,
+      label: name.replace(/([A-Z])/g, " $1").replace(/^./, (c) => c.toUpperCase()),
+      required,
+      default_value: extractDefaultValue2(fieldType)
+    };
+    if (typeAnno) {
+      const options = extractUnionOptions(typeAnno.typeAnnotation);
+      if (options) {
+        field.validation = { options };
+      }
+    }
+    fields.push(field);
+  }
+  return fields;
+}
+function extractTransitionsFromObject(init, actionCounter) {
+  const transitions = [];
+  for (const prop of init.properties) {
+    if (!t9.isObjectProperty(prop)) continue;
+    if (!t9.isIdentifier(prop.key) && !t9.isStringLiteral(prop.key)) continue;
+    if (!t9.isObjectExpression(prop.value)) continue;
+    const name = t9.isIdentifier(prop.key) ? prop.key.name : prop.key.value;
+    const config = extractObjectLiteral(prop.value);
+    let from = [];
+    if (typeof config.from === "string") {
+      from = [config.from];
+    } else if (Array.isArray(config.from)) {
+      from = config.from.map(String);
+    }
+    const to = String(config.to || "");
+    const conditions = [];
+    if (config.guard) {
+      conditions.push(parseGuardExpression(config.guard));
+    }
+    if (config.conditions && Array.isArray(config.conditions)) {
+      for (const cond of config.conditions) {
+        conditions.push(cond);
+      }
+    }
+    const actions = [];
+    if (config.actions && Array.isArray(config.actions)) {
+      for (const action of config.actions) {
+        if (typeof action === "object" && action !== null) {
+          actions.push({
+            id: `auto_${++actionCounter.value}`,
+            type: action.type || "custom",
+            mode: "auto",
+            config: action
+          });
+        }
+      }
+    }
+    transitions.push({
+      name,
+      from,
+      to,
+      description: config.description,
+      conditions: conditions.length > 0 ? conditions : void 0,
+      actions,
+      roles: config.roles,
+      auto: config.auto,
+      required_fields: config.required_fields
+    });
+  }
+  return transitions;
+}
+function parseGuardExpression(guard) {
+  const simpleMatch = guard.match(
+    /^(\$?\w+(?:\.\w+)*)\s*(not_in|is_set|is_empty|contains|>=|<=|!=|==|>|<|in)\s*(.+)?$/
+  );
+  if (simpleMatch) {
+    const [, field, op, rawValue] = simpleMatch;
+    const operatorMap = {
+      "==": "eq",
+      "!=": "ne",
+      ">": "gt",
+      ">=": "gte",
+      "<": "lt",
+      "<=": "lte",
+      "in": "in",
+      "not_in": "not_in",
+      "contains": "contains",
+      "is_set": "is_set",
+      "is_empty": "is_empty"
+    };
+    const operator = operatorMap[op];
+    if (operator) {
+      let value = rawValue?.trim();
+      if (value === void 0 || value === "") {
+        return { field, operator };
+      }
+      if (typeof value === "string") {
+        if (value.startsWith('"') && value.endsWith('"')) {
+          value = value.slice(1, -1);
+        } else if (value.startsWith("'") && value.endsWith("'")) {
+          value = value.slice(1, -1);
+        } else if (value === "true") {
+          value = true;
+        } else if (value === "false") {
+          value = false;
+        } else if (value === "null") {
+          value = null;
+        } else if (!isNaN(Number(value))) {
+          value = Number(value);
+        }
+      }
+      return { field, operator, value };
+    }
+  }
+  return { expression: guard };
+}
+function extractHooksFromObject(init, states, actionCounter) {
+  for (const prop of init.properties) {
+    if (!t9.isObjectProperty(prop)) continue;
+    if (!t9.isIdentifier(prop.key) && !t9.isStringLiteral(prop.key)) continue;
+    const hookName = t9.isIdentifier(prop.key) ? prop.key.name : prop.key.value;
+    const hookConfig = t9.isObjectExpression(prop.value) ? extractObjectLiteral(prop.value) : {};
+    const enterMatch = hookName.match(/^on_enter_(.+)$/);
+    const exitMatch = hookName.match(/^on_exit_(.+)$/);
+    if (!enterMatch && !exitMatch) continue;
+    const stateName = enterMatch ? enterMatch[1] : exitMatch[1];
+    const phase = enterMatch ? "on_enter" : "on_exit";
+    if (!states.has(stateName)) {
+      states.set(stateName, {
+        name: stateName,
+        type: "REGULAR",
+        on_enter: [],
+        during: [],
+        on_exit: []
+      });
+    }
+    const state = states.get(stateName);
+    if (hookConfig.emit && typeof hookConfig.emit === "string") {
+      const action = {
+        id: `auto_${++actionCounter.value}`,
+        type: "emit_event",
+        mode: "auto",
+        config: { event: hookConfig.emit }
+      };
+      state[phase].push(action);
+    }
+    if (hookConfig.actions && Array.isArray(hookConfig.actions)) {
+      for (const handler of hookConfig.actions) {
+        if (typeof handler === "string") {
+          const action = {
+            id: `auto_${++actionCounter.value}`,
+            type: "server_action",
+            mode: "auto",
+            config: { handler }
+          };
+          state[phase].push(action);
+        }
+      }
+    }
+  }
+}
+function applyFieldOptions(fields, init) {
+  const options = extractObjectLiteral(init);
+  for (const [fieldName, opts] of Object.entries(options)) {
+    const field = fields.find((f) => f.name === fieldName);
+    if (!field) continue;
+    if (opts.scope || opts.persistence || opts.sync) {
+      field.state_home = {
+        scope: opts.scope || "instance",
+        persistence: opts.persistence || "durable",
+        sync: opts.sync || "none"
+      };
+    }
+    if (opts.computed && typeof opts.computed === "string") {
+      field.computed = opts.computed;
+    }
+    if (opts.computed_deps && Array.isArray(opts.computed_deps)) {
+      field.computed_deps = opts.computed_deps.map(String);
+    }
+    if (opts.visible_in_states && Array.isArray(opts.visible_in_states)) {
+      field.visible_in_states = opts.visible_in_states.map(String);
+    }
+    if (opts.editable_in_states && Array.isArray(opts.editable_in_states)) {
+      field.editable_in_states = opts.editable_in_states.map(String);
+    }
+    if (opts.visible_to_roles && Array.isArray(opts.visible_to_roles)) {
+      field.visible_to_roles = opts.visible_to_roles.map(String);
+    }
+    if (opts.editable_by_roles && Array.isArray(opts.editable_by_roles)) {
+      field.editable_by_roles = opts.editable_by_roles.map(String);
+    }
+    if (opts.visible_when && typeof opts.visible_when === "string") {
+      field.visible_when = opts.visible_when;
+    }
+    if (opts.editable_when && typeof opts.editable_when === "string") {
+      field.editable_when = opts.editable_when;
+    }
+    if (opts.validation && typeof opts.validation === "object") {
+      const val = opts.validation;
+      const validation = field.validation || {};
+      if (val.min !== void 0) validation.min = Number(val.min);
+      if (val.max !== void 0) validation.max = Number(val.max);
+      if (val.minLength !== void 0) validation.minLength = Number(val.minLength);
+      if (val.maxLength !== void 0) validation.maxLength = Number(val.maxLength);
+      if (val.options && Array.isArray(val.options)) {
+        validation.options = val.options.map(String);
+      }
+      if (val.rules && Array.isArray(val.rules)) {
+        validation.rules = val.rules.map((r) => ({
+          expression: String(r.expression || ""),
+          message: String(r.message || ""),
+          severity: r.severity === "warning" ? "warning" : "error"
+        }));
+      }
+      field.validation = validation;
+    }
+  }
+}
+function extractObjectLiteral(node) {
+  const obj = {};
+  for (const prop of node.properties) {
+    if (!t9.isObjectProperty(prop)) continue;
+    const key = t9.isIdentifier(prop.key) ? prop.key.name : t9.isStringLiteral(prop.key) ? prop.key.value : null;
+    if (!key) continue;
+    obj[key] = extractNodeValue(prop.value);
+  }
+  return obj;
+}
+function extractNodeValue(node) {
+  if (t9.isStringLiteral(node)) return node.value;
+  if (t9.isNumericLiteral(node)) return node.value;
+  if (t9.isBooleanLiteral(node)) return node.value;
+  if (t9.isNullLiteral(node)) return null;
+  if (t9.isArrayExpression(node)) {
+    return node.elements.map((el) => {
+      if (!el) return null;
+      if (t9.isSpreadElement(el)) return "[Spread]";
+      return extractNodeValue(el);
+    });
+  }
+  if (t9.isObjectExpression(node)) {
+    return extractObjectLiteral(node);
+  }
+  if (t9.isTemplateLiteral(node)) {
+    return node.quasis.map((q) => q.value.raw).join("${}");
+  }
+  if (t9.isIdentifier(node)) {
+    if (node.name === "undefined") return void 0;
+    return node.name;
+  }
+  return "[Expression]";
+}
+function isModelFile(path, filename) {
+  if (filename && /\/models\//.test(filename)) return true;
+  let hasInterface = false;
+  let hasTransitions = false;
+  for (const node of path.node.body) {
+    if (t9.isExportNamedDeclaration(node)) {
+      if (t9.isTSInterfaceDeclaration(node.declaration)) {
+        hasInterface = true;
+      }
+      if (t9.isVariableDeclaration(node.declaration)) {
+        for (const decl of node.declaration.declarations) {
+          if (t9.isIdentifier(decl.id) && decl.id.name === "transitions") {
+            hasTransitions = true;
+          }
+        }
+      }
+    }
+  }
+  return hasInterface && hasTransitions;
+}
+function extractModelFile(path, state) {
+  const compilerState = state;
+  if (!compilerState.actionCounter) compilerState.actionCounter = 0;
+  const actionCounter = { value: compilerState.actionCounter };
+  let interfaceName = "";
+  for (const node of path.node.body) {
+    if (!t9.isExportNamedDeclaration(node)) continue;
+    const declaration = node.declaration;
+    if (t9.isTSInterfaceDeclaration(declaration)) {
+      interfaceName = declaration.id.name;
+      const fields = extractFieldsFromInterface(declaration);
+      compilerState.fields.push(...fields);
+      for (const field of fields) {
+        if (field.validation?.options && field.validation.options.length > 0) {
+          for (const option of field.validation.options) {
+            if (!compilerState.states.has(option)) {
+              compilerState.states.set(option, {
+                name: option,
+                type: "REGULAR",
+                on_enter: [],
+                during: [],
+                on_exit: []
+              });
+            }
+          }
+          const firstState = compilerState.states.get(field.validation.options[0]);
+          if (firstState) firstState.type = "START";
+          break;
+        }
+      }
+      if (!compilerState.metadata.name) {
+        compilerState.metadata.name = interfaceName;
+      }
+    }
+    if (t9.isVariableDeclaration(declaration)) {
+      for (const decl of declaration.declarations) {
+        if (!t9.isIdentifier(decl.id) || !decl.init) continue;
+        const varName = decl.id.name;
+        if (varName === "transitions" && t9.isObjectExpression(decl.init)) {
+          const transitions = extractTransitionsFromObject(decl.init, actionCounter);
+          compilerState.transitions.push(...transitions);
+          for (const trans of transitions) {
+            for (const fromState of trans.from) {
+              if (!compilerState.states.has(fromState)) {
+                compilerState.states.set(fromState, {
+                  name: fromState,
+                  type: "REGULAR",
+                  on_enter: [],
+                  during: [],
+                  on_exit: []
+                });
+              }
+            }
+            if (trans.to && !compilerState.states.has(trans.to)) {
+              compilerState.states.set(trans.to, {
+                name: trans.to,
+                type: "REGULAR",
+                on_enter: [],
+                during: [],
+                on_exit: []
+              });
+            }
+          }
+        }
+        if (varName === "endStates" && t9.isArrayExpression(decl.init)) {
+          for (const el of decl.init.elements) {
+            if (t9.isStringLiteral(el)) {
+              if (!compilerState.states.has(el.value)) {
+                compilerState.states.set(el.value, {
+                  name: el.value,
+                  type: "END",
+                  on_enter: [],
+                  during: [],
+                  on_exit: []
+                });
+              } else {
+                compilerState.states.get(el.value).type = "END";
+              }
+            }
+          }
+        }
+        if (varName === "cancelledStates" && t9.isArrayExpression(decl.init)) {
+          for (const el of decl.init.elements) {
+            if (t9.isStringLiteral(el)) {
+              if (!compilerState.states.has(el.value)) {
+                compilerState.states.set(el.value, {
+                  name: el.value,
+                  type: "CANCELLED",
+                  on_enter: [],
+                  during: [],
+                  on_exit: []
+                });
+              } else {
+                compilerState.states.get(el.value).type = "CANCELLED";
+              }
+            }
+          }
+        }
+        if (varName === "hooks" && t9.isObjectExpression(decl.init)) {
+          extractHooksFromObject(decl.init, compilerState.states, actionCounter);
+        }
+        if (varName === "runtime" && t9.isStringLiteral(decl.init)) {
+          compilerState.metadata.runtime = decl.init.value;
+        }
+        if (varName === "fieldOptions" && t9.isObjectExpression(decl.init)) {
+          applyFieldOptions(compilerState.fields, decl.init);
+        }
+      }
+    }
+  }
+  compilerState.actionCounter = actionCounter.value;
+  if (interfaceName && compilerState.metadata.__slugAutoFallback) {
+    compilerState.metadata.slug = interfaceName.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "");
+    delete compilerState.metadata.__slugAutoFallback;
+  }
+}
+
+// src/babel/extractors/server-action-extractor.ts
+import * as t10 from "@babel/types";
+function isServerActionFile(filename) {
+  if (!filename) return false;
+  return /\.server\.(ts|tsx|js|jsx)$/.test(filename);
+}
+function extractServerActions(path, state) {
+  const compilerState = state;
+  const serverActions = [];
+  for (const node of path.node.body) {
+    if (t10.isExportNamedDeclaration(node)) {
+      const decl = node.declaration;
+      if (t10.isFunctionDeclaration(decl) && decl.id) {
+        const action = extractFunctionAction(decl);
+        if (action) {
+          const comments = node.leadingComments || decl.leadingComments || [];
+          action.description = extractDescription(comments);
+          serverActions.push(action);
+        }
+      }
+      if (t10.isVariableDeclaration(decl)) {
+        for (const varDecl of decl.declarations) {
+          if (!t10.isIdentifier(varDecl.id)) continue;
+          const init = varDecl.init;
+          if (t10.isArrowFunctionExpression(init) || t10.isFunctionExpression(init)) {
+            const action = {
+              name: varDecl.id.name,
+              async: init.async || false,
+              params: init.params.filter((p) => t10.isIdentifier(p)).map((p) => p.name)
+            };
+            if (init.params.length > 0) {
+              const firstParam = init.params[0];
+              if (t10.isIdentifier(firstParam) && firstParam.typeAnnotation) {
+                action.contextType = extractTypeName(firstParam.typeAnnotation);
+              }
+            }
+            serverActions.push(action);
+          }
+        }
+      }
+    }
+  }
+  if (serverActions.length > 0) {
+    if (!compilerState.metadata) compilerState.metadata = {};
+    compilerState.metadata.serverActions = serverActions;
+  }
+}
+function extractFunctionAction(decl) {
+  if (!decl.id) return null;
+  const action = {
+    name: decl.id.name,
+    async: decl.async || false,
+    params: decl.params.filter((p) => t10.isIdentifier(p)).map((p) => p.name)
+  };
+  if (decl.params.length > 0) {
+    const firstParam = decl.params[0];
+    if (t10.isIdentifier(firstParam) && firstParam.typeAnnotation) {
+      action.contextType = extractTypeName(firstParam.typeAnnotation);
+    }
+  }
+  return action;
+}
+function extractTypeName(annotation) {
+  if (t10.isTSTypeAnnotation(annotation)) {
+    const typeNode = annotation.typeAnnotation;
+    if (t10.isTSTypeReference(typeNode) && t10.isIdentifier(typeNode.typeName)) {
+      return typeNode.typeName.name;
+    }
+  }
+  return void 0;
+}
+function extractDescription(comments) {
+  for (const comment of comments) {
+    if (comment.type !== "CommentBlock") continue;
+    const lines = comment.value.split("\n");
+    for (const line of lines) {
+      const trimmed = line.replace(/^\s*\*\s?/, "").trim();
+      if (trimmed && !trimmed.startsWith("@")) {
+        return trimmed;
+      }
+    }
+  }
+  return void 0;
+}
+
+// src/babel/extractors/grammar-island-extractor.ts
+import * as t11 from "@babel/types";
+var GRAMMAR_TAGS = /* @__PURE__ */ new Set(["cedar", "sql", "cron", "dmn", "graphql", "jsonpath"]);
+function parseCedar(source) {
+  const policies = [];
+  const policyRegex = /(permit|forbid)\s*\(([^)]*)\)(?:\s*when\s*\{([^}]*)\})?/g;
+  let match;
+  while ((match = policyRegex.exec(source)) !== null) {
+    const [, effect, scope, condition] = match;
+    const parts = scope.split(",").map((s) => s.trim());
+    const policy = {
+      effect,
+      conditions: []
+    };
+    for (const part of parts) {
+      if (part.startsWith("principal")) {
+        policy.principal = part;
+      } else if (part.startsWith("action")) {
+        policy.action = part;
+      } else if (part.startsWith("resource")) {
+        policy.resource = part;
+      }
+    }
+    if (condition) {
+      policy.conditions.push(condition.trim());
+    }
+    policies.push(policy);
+  }
+  return { policies };
+}
+function parseCron(source) {
+  const trimmed = source.trim();
+  const parts = trimmed.split(/\s+/);
+  const valid = parts.length === 5;
+  return {
+    expression: trimmed,
+    fields: {
+      minute: parts[0] || "*",
+      hour: parts[1] || "*",
+      dayOfMonth: parts[2] || "*",
+      month: parts[3] || "*",
+      dayOfWeek: parts[4] || "*"
+    },
+    valid
+  };
+}
+function parseDmn(source) {
+  const lines = source.split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
+  const rules = [];
+  const headers = [];
+  let hitPolicy = "first";
+  if (lines.length === 0) return { hitPolicy, rules, headers };
+  const headerLine = lines[0];
+  const headerCells = headerLine.split("|").map((c) => c.trim()).filter((c) => c.length > 0);
+  headers.push(...headerCells);
+  const outputStartIndex = headers.length - 1;
+  let dataStart = 1;
+  if (lines.length > 1 && /^[|\s-]+$/.test(lines[1])) {
+    dataStart = 2;
+  }
+  const hitPolicyMatch = source.match(/@hitPolicy\s*=\s*"?(\w+)"?/);
+  if (hitPolicyMatch) {
+    hitPolicy = hitPolicyMatch[1];
+  }
+  for (let i = dataStart; i < lines.length; i++) {
+    const cells = lines[i].split("|").map((c) => c.trim()).filter((c) => c.length > 0);
+    if (cells.length < headers.length) continue;
+    const inputs = {};
+    const output = {};
+    for (let j = 0; j < headers.length; j++) {
+      if (j >= outputStartIndex) {
+        output[headers[j]] = cells[j];
+      } else {
+        inputs[headers[j]] = cells[j];
+      }
+    }
+    rules.push({ inputs, output });
+  }
+  return { hitPolicy, rules, headers };
+}
+function extractGrammarIsland(path, state, slug) {
+  const tag = path.node.tag;
+  if (!t11.isIdentifier(tag)) return;
+  const tagName = tag.name;
+  if (!GRAMMAR_TAGS.has(tagName)) return;
+  const compilerState = state;
+  const quasi = path.node.quasi;
+  let rawSource = "";
+  for (let i = 0; i < quasi.quasis.length; i++) {
+    rawSource += quasi.quasis[i].value.raw;
+    if (i < quasi.expressions.length) {
+      const expr = quasi.expressions[i];
+      if (t11.isIdentifier(expr)) {
+        rawSource += `\${${expr.name}}`;
+      } else {
+        rawSource += `\${expr_${i}}`;
+      }
+    }
+  }
+  rawSource = rawSource.trim();
+  let parsed = void 0;
+  switch (tagName) {
+    case "cedar":
+      parsed = parseCedar(rawSource);
+      break;
+    case "cron":
+      parsed = parseCron(rawSource);
+      break;
+    case "dmn":
+      parsed = parseDmn(rawSource);
+      break;
+    case "sql":
+      parsed = { query: rawSource };
+      break;
+    case "graphql":
+      parsed = { query: rawSource };
+      break;
+    case "jsonpath":
+      parsed = { expression: rawSource };
+      break;
+  }
+  const island = {
+    slug,
+    contextTag: tagName,
+    rawSource,
+    parsed
+  };
+  if (!compilerState.metadata) compilerState.metadata = {};
+  const meta = compilerState.metadata;
+  if (!meta.grammarIslands) meta.grammarIslands = [];
+  meta.grammarIslands.push(island);
+}
+function extractGrammarIslands(path, state) {
+  path.traverse({
+    TaggedTemplateExpression(templatePath) {
+      const tag = templatePath.node.tag;
+      if (!t11.isIdentifier(tag) || !GRAMMAR_TAGS.has(tag.name)) return;
+      let slug = "unnamed";
+      const parent = templatePath.parentPath;
+      if (parent && parent.isVariableDeclarator() && t11.isIdentifier(parent.node.id)) {
+        slug = parent.node.id.name;
+      }
+      if (parent && parent.isObjectProperty() && t11.isIdentifier(parent.node.key)) {
+        slug = parent.node.key.name;
+      }
+      if (parent && parent.isObjectProperty() && t11.isStringLiteral(parent.node.key)) {
+        slug = parent.node.key.value;
+      }
+      extractGrammarIsland(templatePath, state, slug);
+    }
+  });
+}
+
+// src/babel/extractors/context-extractor.ts
+import * as t12 from "@babel/types";
+function hasContextCreation(path) {
+  let found = false;
+  path.traverse({
+    CallExpression(callPath) {
+      if (t12.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 || !t12.isCallExpression(init)) return;
+      if (!t12.isIdentifier(init.callee, { name: "createContext" })) return;
+      if (!t12.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 && t12.isTSTypeParameterInstantiation(typeParams)) {
+        const typeArg = typeParams.params[0];
+        if (t12.isTSTypeReference(typeArg) && t12.isIdentifier(typeArg.typeName)) {
+          const interfaceName = typeArg.typeName.name;
+          extractFieldsFromInterface2(path, interfaceName, workflow);
+        }
+      }
+      if (init.arguments.length > 0 && t12.isObjectExpression(init.arguments[0])) {
+        workflow.initialState = extractObjectLiteral2(init.arguments[0]);
+      }
+      contextWorkflows.push(workflow);
+    },
+    // Detect useReducer(reducer, initialState) and extract reducer cases
+    CallExpression(callPath) {
+      if (!t12.isIdentifier(callPath.node.callee, { name: "useReducer" })) return;
+      const args = callPath.node.arguments;
+      if (args.length < 1) return;
+      const reducerArg = args[0];
+      if (!t12.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 extractFieldsFromInterface2(path, interfaceName, workflow) {
+  path.traverse({
+    TSInterfaceDeclaration(ifacePath) {
+      if (!t12.isIdentifier(ifacePath.node.id, { name: interfaceName })) return;
+      for (const prop of ifacePath.node.body.body) {
+        if (!t12.isTSPropertySignature(prop)) continue;
+        if (!t12.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 || !t12.isTSTypeAnnotation(annotation)) return "unknown";
+  const typeNode = annotation.typeAnnotation;
+  if (t12.isTSStringKeyword(typeNode)) return "string";
+  if (t12.isTSNumberKeyword(typeNode)) return "number";
+  if (t12.isTSBooleanKeyword(typeNode)) return "boolean";
+  if (t12.isTSArrayType(typeNode)) return `${extractTSTypeNode(typeNode.elementType)}[]`;
+  if (t12.isTSTypeReference(typeNode) && t12.isIdentifier(typeNode.typeName)) return typeNode.typeName.name;
+  return "unknown";
+}
+function extractTSTypeNode(node) {
+  if (t12.isTSStringKeyword(node)) return "string";
+  if (t12.isTSNumberKeyword(node)) return "number";
+  if (t12.isTSBooleanKeyword(node)) return "boolean";
+  if (t12.isTSTypeReference(node) && t12.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 (t12.isStringLiteral(switchCase.test)) {
+              actions.push({
+                type: switchCase.test.value
+              });
+            }
+          }
+        }
+      });
+    }
+  });
+  return actions;
+}
+function extractObjectLiteral2(obj) {
+  const result = {};
+  for (const prop of obj.properties) {
+    if (!t12.isObjectProperty(prop) || !t12.isIdentifier(prop.key)) continue;
+    if (t12.isStringLiteral(prop.value)) result[prop.key.name] = prop.value.value;
+    else if (t12.isNumericLiteral(prop.value)) result[prop.key.name] = prop.value.value;
+    else if (t12.isBooleanLiteral(prop.value)) result[prop.key.name] = prop.value.value;
+    else if (t12.isNullLiteral(prop.value)) result[prop.key.name] = null;
+    else if (t12.isArrayExpression(prop.value)) result[prop.key.name] = [];
+    else if (t12.isObjectExpression(prop.value)) result[prop.key.name] = extractObjectLiteral2(prop.value);
+  }
+  return result;
+}
+
+// src/babel/emitters/pure-form-emitter.ts
+function toSnakeCase(str) {
+  return str.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
+}
+function convertAction(action) {
+  return {
+    id: action.id,
+    action_type: action.type,
+    config: action.config || {},
+    ...action.condition && { condition: action.condition }
+  };
+}
+function convertDuringAction(during) {
+  return {
+    id: during.id,
+    type: during.type,
+    ...during.interval_ms !== void 0 && { interval_ms: during.interval_ms },
+    ...during.cron && { cron: during.cron },
+    ...during.delay_ms !== void 0 && { delay_ms: during.delay_ms },
+    actions: during.actions.map(convertAction),
+    ...during.condition && { condition: during.condition }
+  };
+}
+function emitPureForm(extracted) {
+  const { slug, name, version, description, category, fields, states, transitions } = extracted;
+  const stateArray = Array.from(states.values());
+  if (stateArray.length === 0) {
+    stateArray.push({
+      name: "draft",
+      type: "START",
+      on_enter: [],
+      during: [],
+      on_exit: []
+    });
+  } else {
+    const hasStart = stateArray.some((s) => s.type === "START");
+    if (!hasStart && stateArray.length > 0) {
+      stateArray[0].type = "START";
+    }
+  }
+  inferTransitionStates(transitions, states);
+  const stateNames = new Set(stateArray.map((s) => s.name));
+  for (const transition of transitions) {
+    if (transition.to && !stateNames.has(transition.to)) {
+      stateArray.push({
+        name: transition.to,
+        type: "REGULAR",
+        on_enter: [],
+        during: [],
+        on_exit: []
+      });
+      stateNames.add(transition.to);
+    }
+  }
+  const metadata = {};
+  if (extracted.experience) {
+    metadata.experience = extracted.experience;
+  }
+  if (extracted.fieldWatchers && extracted.fieldWatchers.length > 0) {
+    metadata.fieldWatchers = extracted.fieldWatchers;
+  }
+  if (extracted.transitionEffects && extracted.transitionEffects.length > 0) {
+    metadata.transitionEffects = extracted.transitionEffects;
+  }
+  if (extracted.extraMetadata) {
+    for (const [key, value] of Object.entries(extracted.extraMetadata)) {
+      metadata[key] = value;
+    }
+  }
+  const ir = {
+    slug,
+    name,
+    version,
+    description,
+    category,
+    fields,
+    states: stateArray,
+    transitions,
+    roles: [],
+    tags: [],
+    metadata
+  };
+  if (extracted.events && extracted.events.length > 0) {
+    ir.on_event = extracted.events;
+  }
+  if (extracted.grammarIslands && extracted.grammarIslands.length > 0) {
+    const extensions = {};
+    for (const island of extracted.grammarIslands) {
+      const key = island.contextTag;
+      if (!extensions[key]) extensions[key] = [];
+      extensions[key].push(island);
+    }
+    ir.extensions = extensions;
+  }
+  return ir;
+}
+function emitWorkflowDefinition(extracted) {
+  const ir = emitPureForm(extracted);
+  const states = ir.states.map((s) => ({
+    name: s.name,
+    state_type: s.type,
+    description: s.description || "",
+    on_enter: (s.on_enter || []).map(convertAction),
+    on_exit: (s.on_exit || []).map(convertAction),
+    during: (s.during || []).map(convertDuringAction),
+    on_event: (s.on_event || []).map(convertOnEvent)
+  }));
+  const fields = ir.fields.map((f) => ({
+    name: toSnakeCase(f.name),
+    field_type: f.type,
+    label: f.label || f.name.replace(/([A-Z])/g, " $1").replace(/^./, (c) => c.toUpperCase()),
+    required: f.required || false,
+    default_value: f.default_value ?? null,
+    ...f.validation && { validation: f.validation },
+    ...f.computed && { computed: f.computed },
+    ...f.computed_deps && { computed_deps: f.computed_deps },
+    ...f.visible_in_states && { visible_in_states: f.visible_in_states },
+    ...f.editable_in_states && { editable_in_states: f.editable_in_states },
+    ...f.visible_to_roles && { visible_to_roles: f.visible_to_roles },
+    ...f.editable_by_roles && { editable_by_roles: f.editable_by_roles },
+    ...f.visible_when && { visible_when: f.visible_when },
+    ...f.editable_when && { editable_when: f.editable_when },
+    ...f.state_home && { state_home: f.state_home }
+  }));
+  const transitions = ir.transitions.map((t14) => ({
+    name: t14.name,
+    from: t14.from,
+    to: t14.to,
+    description: t14.description || "",
+    roles: t14.roles || [],
+    auto: t14.auto || false,
+    conditions: t14.conditions || [],
+    actions: (t14.actions || []).map(convertAction),
+    required_fields: t14.required_fields || [],
+    priority: 0
+  }));
+  const state_data = {};
+  for (const f of fields) {
+    state_data[f.name] = f.default_value;
+  }
+  const on_event = (ir.on_event || []).map(convertOnEvent);
+  return {
+    id: `def-${ir.slug}`,
+    slug: ir.slug,
+    name: ir.name,
+    version: ir.version,
+    description: ir.description || "",
+    category: ir.category,
+    states,
+    transitions,
+    fields,
+    state_data,
+    roles: [],
+    child_definitions: [],
+    tags: ir.tags || [],
+    metadata: ir.metadata || {},
+    ...on_event.length > 0 && { on_event },
+    config: {},
+    is_immutable: false
+  };
+}
+function convertOnEvent(sub) {
+  return {
+    match: sub.match,
+    ...sub.description && { description: sub.description },
+    conditions: sub.conditions || [],
+    actions: sub.actions.map((a) => ({
+      type: a.type,
+      ...a.field && { field: a.field },
+      ...a.expression && { expression: a.expression },
+      ...a.key && { key: a.key },
+      ...a.message && { message: a.message },
+      ...a.config && { config: a.config },
+      ...a.conditions && a.conditions.length > 0 && { conditions: a.conditions }
+    }))
+  };
+}
+function compilerStateToWorkflow(state, metadata) {
+  const fieldWatchers = metadata.fieldWatchers || [];
+  const transitionEffects = metadata.transitionEffects || [];
+  const grammarIslands = metadata.grammarIslands || [];
+  const knownKeys = /* @__PURE__ */ new Set(["slug", "name", "version", "description", "category", "fieldWatchers", "transitionEffects", "grammarIslands"]);
+  const extraMetadata = {};
+  for (const [key, value] of Object.entries(metadata)) {
+    if (!knownKeys.has(key) && value !== void 0) {
+      extraMetadata[key] = value;
+    }
+  }
+  return {
+    slug: metadata.slug || "workflow",
+    name: metadata.name || "Workflow",
+    version: metadata.version || "0.1.0",
+    description: metadata.description,
+    category: metadata.category || "workflow",
+    fields: state.fields || [],
+    states: state.states || /* @__PURE__ */ new Map(),
+    transitions: state.transitions || [],
+    events: state.events || [],
+    experience: state.experience,
+    fieldWatchers: fieldWatchers.length > 0 ? fieldWatchers : void 0,
+    transitionEffects: transitionEffects.length > 0 ? transitionEffects : void 0,
+    grammarIslands: grammarIslands.length > 0 ? grammarIslands : void 0,
+    errors: state.errors,
+    warnings: state.warnings,
+    extraMetadata: Object.keys(extraMetadata).length > 0 ? extraMetadata : void 0
+  };
+}
+
+// src/babel/visitor.ts
+function extractQueryDataSource(path, state) {
+  const args = path.node.arguments;
+  if (args.length < 1) return;
+  const slugArg = args[0];
+  if (!t13.isStringLiteral(slugArg)) return;
+  const slug = slugArg.value;
+  const compilerState = state;
+  const dataSource = {
+    type: "workflow",
+    name: slug,
+    slug,
+    query: "list"
+  };
+  if (args.length > 1 && t13.isObjectExpression(args[1])) {
+    for (const prop of args[1].properties) {
+      if (!t13.isObjectProperty(prop) || !t13.isIdentifier(prop.key)) continue;
+      const key = prop.key.name;
+      if (key === "limit" && t13.isNumericLiteral(prop.value)) {
+        dataSource.pageSize = prop.value.value;
+        dataSource.paginated = true;
+      }
+      if (key === "search" && t13.isStringLiteral(prop.value)) {
+        dataSource.searchFields = [prop.value.value];
+      }
+      if (key === "orderBy" && t13.isStringLiteral(prop.value)) {
+        dataSource.sort = prop.value.value;
+      }
+    }
+  }
+  if (!compilerState.metadata) compilerState.metadata = {};
+  const meta = compilerState.metadata;
+  if (!meta.dataSources) meta.dataSources = [];
+  meta.dataSources.push(dataSource);
+}
+function extractMutationDataSource(path, state) {
+  const args = path.node.arguments;
+  if (args.length < 1) return;
+  const slugArg = args[0];
+  if (!t13.isStringLiteral(slugArg)) return;
+  const slug = slugArg.value;
+  const compilerState = state;
+  if (!compilerState.metadata) compilerState.metadata = {};
+  const meta = compilerState.metadata;
+  if (!meta.mutationTargets) meta.mutationTargets = [];
+  meta.mutationTargets.push(slug);
+}
+var STRICT_BANNED_HOOKS = {
+  useEffect: "STRICT_USE_EFFECT",
+  useLayoutEffect: "STRICT_USE_LAYOUT_EFFECT",
+  useRef: "STRICT_USE_REF",
+  useMemo: "STRICT_USE_MEMO",
+  useCallback: "STRICT_USE_CALLBACK"
+};
+function extractMetadataFromComments(comments, metadata) {
+  for (const comment of comments) {
+    if (comment.type !== "CommentBlock") continue;
+    const lines = comment.value.split("\n");
+    for (const line of lines) {
+      const workflowMatch = line.match(/@workflow\s+(.+)/);
+      if (workflowMatch) {
+        const rest = workflowMatch[1].trim();
+        const kvRegex = /(\w+)="([^"]+)"/g;
+        let kvMatch;
+        let hasKV = false;
+        while ((kvMatch = kvRegex.exec(rest)) !== null) {
+          hasKV = true;
+          const [, key, val] = kvMatch;
+          if (key === "slug") metadata.slug = val;
+          else if (key === "version") metadata.version = val;
+          else if (key === "category") metadata.category = val;
+          else if (key === "description") metadata.description = val;
+        }
+        if (!hasKV) {
+          metadata.slug = rest;
+        }
+        continue;
+      }
+      const match = line.match(/@(\w+)\s+(.+)/);
+      if (match) {
+        const [, tag, value] = match;
+        if (tag === "version") metadata.version = value.trim();
+        if (tag === "category") metadata.category = value.trim();
+        if (tag === "description") metadata.description = value.trim();
+      }
+    }
+  }
+}
+function createVisitor(options = {}) {
+  const mode = options.mode;
+  return {
+    Program: {
+      // Initialize compiler state at program entry
+      enter(_path, state) {
+        resetNodeIdCounter();
+        resetDuringIdCounter();
+        resetWatcherIdCounter();
+        resetTransitionEffectIdCounter();
+        const compilerState = {
+          fields: [],
+          states: /* @__PURE__ */ new Map(),
+          transitions: [],
+          events: [],
+          actionCounter: 0,
+          metadata: {},
+          errors: [],
+          warnings: []
+        };
+        const program = _path.node;
+        const leadingComments = program.leadingComments || [];
+        extractMetadataFromComments(leadingComments, compilerState.metadata);
+        if (program.body.length > 0) {
+          const firstStmt = program.body[0];
+          if (firstStmt.leadingComments) {
+            extractMetadataFromComments(firstStmt.leadingComments, compilerState.metadata);
+          }
+        }
+        const exportDeclaration = program.body.find(
+          (node) => t13.isExportNamedDeclaration(node) || t13.isExportDefaultDeclaration(node)
+        );
+        if (exportDeclaration) {
+          if (t13.isExportNamedDeclaration(exportDeclaration)) {
+            const declaration = exportDeclaration.declaration;
+            if (t13.isFunctionDeclaration(declaration)) {
+              if (declaration.id) {
+                compilerState.metadata.name = declaration.id.name;
+              }
+              if (declaration.leadingComments) {
+                extractMetadataFromComments(declaration.leadingComments, compilerState.metadata);
+              }
+            }
+          } else if (t13.isExportDefaultDeclaration(exportDeclaration)) {
+            const declaration = exportDeclaration.declaration;
+            if (t13.isFunctionDeclaration(declaration)) {
+              if (declaration.id) {
+                compilerState.metadata.name = declaration.id.name;
+              }
+              if (declaration.leadingComments) {
+                extractMetadataFromComments(declaration.leadingComments, compilerState.metadata);
+              }
+            } else if (t13.isIdentifier(declaration)) {
+              compilerState.metadata.name = declaration.name;
+            }
+          }
+        }
+        if (!compilerState.metadata.slug && state.filename) {
+          const fileName = state.filename.split("/").pop() || "";
+          compilerState.metadata.slug = fileName.replace(/\.workflow\.(tsx?|jsx?)$/, "").replace(/\.(tsx?|jsx?)$/, "").replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "");
+          compilerState.metadata.__slugAutoFallback = true;
+        }
+        Object.assign(state, compilerState);
+        if (isModelFile(_path, state.filename)) {
+          extractModelFile(_path, state);
+          state.__isModelFile = true;
+        }
+        extractGrammarIslands(_path, state);
+        if (hasContextCreation(_path)) {
+          extractContextWorkflows(_path, state);
+        }
+        if (isServerActionFile(state.filename)) {
+          extractServerActions(_path, state);
+          state.__isServerActionFile = true;
+        }
+      },
+      // After all extraction, emit Pure Form JSON
+      exit(_path, state) {
+        const compilerState = state;
+        const extracted = compilerStateToWorkflow(compilerState, compilerState.metadata);
+        const ir = emitPureForm(extracted);
+        const definition = emitWorkflowDefinition(extracted);
+        if (compilerState.errors && compilerState.errors.length > 0) {
+          if (!ir.metadata) ir.metadata = {};
+          ir.metadata.errors = compilerState.errors;
+        }
+        if (compilerState.warnings && compilerState.warnings.length > 0) {
+          if (!ir.metadata) ir.metadata = {};
+          ir.metadata.warnings = compilerState.warnings;
+        }
+        if (!state.file.metadata) state.file.metadata = {};
+        state.file.metadata.mindmatrixIR = ir;
+        state.file.metadata.mindmatrixDefinition = definition;
+      }
+    },
+    // Extract metadata from function declarations with JSDoc
+    FunctionDeclaration(path, state) {
+      const comments = path.node.leadingComments || [];
+      const compilerState = state;
+      extractMetadataFromComments(comments, compilerState.metadata);
+    },
+    // Main hook extraction dispatcher
+    CallExpression(path, state) {
+      const callee = path.node.callee;
+      if (!t13.isIdentifier(callee)) return;
+      const compilerState = state;
+      const hookName = callee.name;
+      if (mode === "strict" && STRICT_BANNED_HOOKS[hookName]) {
+        const error = {
+          code: STRICT_BANNED_HOOKS[hookName],
+          message: `${hookName}() is not allowed in strict mode. Use @mindmatrix/react effect hooks instead.`,
+          line: path.node.loc?.start.line,
+          column: path.node.loc?.start.column,
+          severity: "error"
+        };
+        if (!compilerState.errors) compilerState.errors = [];
+        compilerState.errors.push(error);
+        return;
+      }
+      if (mode === "infer" && hookName === "useEffect") {
+        const warning = {
+          code: "INFER_RAW_JSX",
+          message: `useEffect() found in infer mode \u2014 component will be treated as an opaque [raw jsx] grammar island.`,
+          line: path.node.loc?.start.line,
+          column: path.node.loc?.start.column,
+          severity: "warning"
+        };
+        if (!compilerState.warnings) compilerState.warnings = [];
+        compilerState.warnings.push(warning);
+        return;
+      }
+      switch (hookName) {
+        case "useState":
+          extractStates(path, state);
+          break;
+        case "useOnEnter":
+        case "useOnExit":
+          extractEffects(path, state);
+          break;
+        case "useTransition":
+          extractTransitions(path, state);
+          break;
+        case "useOnEvent":
+          extractEvents(path, state);
+          break;
+        case "useWhileIn":
+          extractDuring(path, state);
+          break;
+        case "useOnChange":
+          extractChangeWatcher(path, state);
+          break;
+        case "useOnTransition":
+          extractTransitionEffect(path, state);
+          break;
+        case "useQuery":
+          extractQueryDataSource(path, state);
+          break;
+        case "useMutation":
+          extractMutationDataSource(path, state);
+          break;
+      }
+    },
+    // Strict mode: validate imports
+    ImportDeclaration(path, state) {
+      if (mode !== "strict") return;
+      const compilerState = state;
+      const source = path.node.source.value;
+      if (source.startsWith("@mindmatrix/") || source === "react" || source.startsWith("react/") || source.startsWith(".") || source.startsWith("/")) {
+        return;
+      }
+      const error = {
+        code: "STRICT_FORBIDDEN_IMPORT",
+        message: `Import from '${source}' is not allowed in strict mode. Only @mindmatrix/* and relative imports are permitted.`,
+        line: path.node.loc?.start.line,
+        column: path.node.loc?.start.column,
+        severity: "error"
+      };
+      if (!compilerState.errors) compilerState.errors = [];
+      compilerState.errors.push(error);
+    },
+    // Extract JSX from function component return
+    ReturnStatement(path, state) {
+      if (t13.isJSXElement(path.node.argument) || t13.isJSXFragment(path.node.argument)) {
+        extractComponents(path, state);
+      }
+    }
+  };
+}
+
+// src/babel/index.ts
+function babelPlugin(api, options = {}) {
+  api.assertVersion(7);
+  return {
+    name: "mindmatrix-react",
+    visitor: createVisitor(options)
+  };
+}
+
+export {
+  extractStates,
+  extractEffects,
+  extractTransitions,
+  extractEvents,
+  extractComponents,
+  emitPureForm,
+  compilerStateToWorkflow,
+  createVisitor,
+  babelPlugin
+};