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

package/dist/chunk-K5HX2SVL.mjs

@@ -1,1902 +0,0 @@
-// src/babel/visitor.ts
-import * as t10 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((t11) => t11.from.length === 0 || !t11.to);
-  if (needsInference.length === 0) return;
-  if (startStates.length === 1 && regularStates.length > 0) {
-    needsInference.forEach((t11, idx) => {
-      if (t11.from.length === 0) {
-        t11.from = [startStates[0].name];
-      }
-      if (!t11.to) {
-        t11.to = regularStates[idx % regularStates.length]?.name || startStates[0].name;
-      }
-    });
-  } else {
-    const allStateNames = stateArray.map((s) => s.name);
-    needsInference.forEach((t11, idx) => {
-      if (t11.from.length === 0 && allStateNames.length > 0) {
-        t11.from = [allStateNames[0]];
-      }
-      if (!t11.to && allStateNames.length > 1) {
-        t11.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*(==|!=|>|>=|<|<=|in|not_in|contains|is_set|is_empty)\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 (!compilerState.metadata.slug && interfaceName) {
-    compilerState.metadata.slug = interfaceName.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "");
-  }
-}
-
-// 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;
-  }
-  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;
-  }
-  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((t11) => ({
-    name: t11.name,
-    from: t11.from,
-    to: t11.to,
-    description: t11.description || "",
-    roles: t11.roles || [],
-    auto: t11.auto || false,
-    conditions: t11.conditions || [],
-    actions: (t11.actions || []).map(convertAction),
-    required_fields: t11.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 || [];
-  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,
-    errors: state.errors,
-    warnings: state.warnings
-  };
-}
-
-// src/babel/visitor.ts
-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) => t10.isExportNamedDeclaration(node) || t10.isExportDefaultDeclaration(node)
-        );
-        if (exportDeclaration) {
-          if (t10.isExportNamedDeclaration(exportDeclaration)) {
-            const declaration = exportDeclaration.declaration;
-            if (t10.isFunctionDeclaration(declaration)) {
-              if (declaration.id) {
-                compilerState.metadata.name = declaration.id.name;
-              }
-              if (declaration.leadingComments) {
-                extractMetadataFromComments(declaration.leadingComments, compilerState.metadata);
-              }
-            }
-          } else if (t10.isExportDefaultDeclaration(exportDeclaration)) {
-            const declaration = exportDeclaration.declaration;
-            if (t10.isFunctionDeclaration(declaration)) {
-              if (declaration.id) {
-                compilerState.metadata.name = declaration.id.name;
-              }
-              if (declaration.leadingComments) {
-                extractMetadataFromComments(declaration.leadingComments, compilerState.metadata);
-              }
-            } else if (t10.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(/^-/, "");
-        }
-        Object.assign(state, compilerState);
-        if (isModelFile(_path, state.filename)) {
-          extractModelFile(_path, state);
-          state.__isModelFile = 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 (!t10.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;
-      }
-    },
-    // 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 (t10.isJSXElement(path.node.argument) || t10.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
-};