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

package/dist/chunk-ITGUSH2Z.mjs

@@ -1,2783 +0,0 @@
-// 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
-import { normalizeCategory } from "@mindmatrix/player-core";
-var PROP_RULES = {
-  Text: {
-    config: { text: "value" },
-    bindings: { text: "value" }
-  },
-  Heading: {
-    config: { text: "value" },
-    bindings: { text: "value" }
-  },
-  Button: {
-    config: { text: "label" },
-    bindings: { text: "label", onPress: "onClick" }
-  }
-};
-var COMPONENT_RENAMES = {
-  Heading: "Text"
-};
-var RENAME_EXTRA_CONFIG = {
-  Heading: { variant: "h2" }
-};
-function normalizeViewNode(node, fieldNames) {
-  if (!node || typeof node !== "object") return node;
-  const originalComponent = node.component;
-  if (originalComponent && COMPONENT_RENAMES[originalComponent]) {
-    node.component = COMPONENT_RENAMES[originalComponent];
-    const extra = RENAME_EXTRA_CONFIG[originalComponent];
-    if (extra) {
-      node.config = { ...extra, ...node.config || {} };
-    }
-  }
-  const rules = PROP_RULES[originalComponent || ""] || PROP_RULES[node.component || ""];
-  if (rules) {
-    if (node.config && rules.config) {
-      for (const [from, to] of Object.entries(rules.config)) {
-        if (from in node.config && !(to in node.config)) {
-          node.config[to] = node.config[from];
-          delete node.config[from];
-        }
-      }
-    }
-    if (node.bindings && rules.bindings) {
-      for (const [from, to] of Object.entries(rules.bindings)) {
-        if (from in node.bindings && !(to in node.bindings)) {
-          node.bindings[to] = node.bindings[from];
-          delete node.bindings[from];
-        }
-      }
-    }
-  }
-  if (node.config && fieldNames.size > 0) {
-    for (const [prop, val] of Object.entries(node.config)) {
-      if (typeof val !== "string") continue;
-      const templateRe = /\{\{(\w+)\}\}|\{(\w+)\}/g;
-      let match;
-      const refs = [];
-      while ((match = templateRe.exec(val)) !== null) {
-        const field = match[1] || match[2];
-        if (fieldNames.has(field)) {
-          refs.push({ full: match[0], field, index: match.index });
-        }
-      }
-      if (refs.length > 0) {
-        const parts = [];
-        let lastEnd = 0;
-        for (const ref of refs) {
-          const before = val.slice(lastEnd, ref.index);
-          if (before) parts.push(`"${before}"`);
-          parts.push(`$instance.state_data.${ref.field}`);
-          lastEnd = ref.index + ref.full.length;
-        }
-        const trailing = val.slice(lastEnd);
-        if (trailing) parts.push(`"${trailing}"`);
-        const expr = `$fn.concat(${parts.join(", ")})`;
-        if (!node.bindings) node.bindings = {};
-        node.bindings[prop] = expr;
-        delete node.config[prop];
-      }
-    }
-  }
-  if (node.bindings) {
-    for (const [prop, expr] of Object.entries(node.bindings)) {
-      if (typeof expr !== "string") continue;
-      if (expr.endsWith(".fire")) {
-        const transitionName = expr.slice(0, -5);
-        node.bindings[prop] = `$action.transition("${transitionName}")`;
-        continue;
-      }
-      if (fieldNames.size > 0 && expr.startsWith("$instance.")) {
-        const field = expr.slice("$instance.".length);
-        if (fieldNames.has(field)) {
-          node.bindings[prop] = `$instance.state_data.${field}`;
-        }
-      }
-    }
-  }
-  if (node.children && Array.isArray(node.children)) {
-    node.children = node.children.map((child) => normalizeViewNode(child, fieldNames));
-  }
-  return node;
-}
-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 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 emitIR(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 fieldNames = new Set(fields.map((f) => f.name));
-  let normalizedView;
-  if (extracted.experience) {
-    normalizedView = normalizeViewNode(
-      JSON.parse(JSON.stringify(extracted.experience)),
-      fieldNames
-    );
-  }
-  const metadata = {
-    stable_id: `def-${slug}`,
-    provenance: {
-      frontend: "react-compiler",
-      source: `${slug}.workflow.tsx`,
-      compiler_version: "1.0.0"
-    }
-  };
-  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;
-    }
-  }
-  if (extracted.experience) {
-    metadata.experience = extracted.experience;
-  }
-  const ir = {
-    slug,
-    name,
-    version,
-    description,
-    category,
-    fields,
-    states: stateArray,
-    transitions,
-    roles: [],
-    tags: [],
-    metadata
-  };
-  if (normalizedView) {
-    ir.view = normalizedView;
-  }
-  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;
-}
-var emitPureForm = emitIR;
-function liftAction(action) {
-  const parts = [];
-  if (action.config) {
-    for (const [key, value] of Object.entries(action.config)) {
-      parts.push({
-        slug: key,
-        category: ["atom"],
-        parts: [{ slug: String(value), category: ["atom"] }]
-      });
-    }
-  }
-  if (action.condition) {
-    parts.push({
-      slug: "condition",
-      category: ["expression", "guard"],
-      parts: [{ slug: action.condition, category: ["binding"] }]
-    });
-  }
-  return {
-    slug: action.id,
-    category: normalizeCategory("expression", "mutation", action.type),
-    parts: parts.length > 0 ? parts : void 0
-  };
-}
-function liftSchedule(during) {
-  const parts = [];
-  if (during.interval_ms !== void 0) {
-    parts.push({
-      slug: "every",
-      category: ["atom"],
-      parts: [{ slug: String(during.interval_ms), category: ["literal"] }]
-    });
-  }
-  if (during.cron) {
-    parts.push({
-      slug: "cron",
-      category: ["atom"],
-      parts: [{ slug: during.cron, category: ["literal"] }]
-    });
-  }
-  if (during.delay_ms !== void 0) {
-    parts.push({
-      slug: "delay",
-      category: ["atom"],
-      parts: [{ slug: String(during.delay_ms), category: ["literal"] }]
-    });
-  }
-  for (const action of during.actions) {
-    parts.push({
-      slug: "do",
-      category: normalizeCategory("expression", "mutation", action.type),
-      parts: Object.entries(action.config || {}).map(([key, value]) => ({
-        slug: key,
-        category: ["atom"],
-        parts: [{ slug: String(value), category: ["atom"] }]
-      }))
-    });
-  }
-  return {
-    slug: during.id,
-    category: normalizeCategory("schedule", during.type),
-    parts
-  };
-}
-function liftState(state) {
-  const parts = [];
-  const tags = [];
-  if (state.type === "START") tags.push("start");
-  if (state.type === "END") tags.push("end");
-  if (state.type === "CANCELLED") tags.push("cancelled");
-  if (state.on_enter && state.on_enter.length > 0) {
-    parts.push({
-      slug: "on_enter",
-      category: normalizeCategory("expression", "sequence"),
-      parts: state.on_enter.map(liftAction)
-    });
-  }
-  if (state.on_exit && state.on_exit.length > 0) {
-    parts.push({
-      slug: "on_exit",
-      category: normalizeCategory("expression", "sequence"),
-      parts: state.on_exit.map(liftAction)
-    });
-  }
-  if (state.during && state.during.length > 0) {
-    for (const d of state.during) {
-      parts.push(liftSchedule(d));
-    }
-  }
-  return {
-    slug: state.name,
-    category: normalizeCategory("state", ...tags),
-    parts: parts.length > 0 ? parts : void 0
-  };
-}
-function liftTransition(transition) {
-  const parts = [];
-  if (transition.from && transition.from.length > 0) {
-    parts.push({
-      slug: "from",
-      category: ["part"],
-      parts: transition.from.map((s) => ({ slug: s, category: ["ref"] }))
-    });
-  }
-  if (transition.to) {
-    parts.push({
-      slug: "to",
-      category: ["part"],
-      parts: [{ slug: transition.to, category: ["ref"] }]
-    });
-  }
-  if (transition.actions && transition.actions.length > 0) {
-    parts.push({
-      slug: "actions",
-      category: normalizeCategory("expression", "sequence"),
-      parts: transition.actions.map(liftAction)
-    });
-  }
-  if (transition.conditions && transition.conditions.length > 0) {
-    parts.push({
-      slug: "conditions",
-      category: normalizeCategory("expression", "guard"),
-      parts: transition.conditions.map((c, i) => ({
-        slug: `condition_${i}`,
-        category: normalizeCategory("expression", c.type || "condition"),
-        parts: c.expression ? [{ slug: c.expression, category: ["binding"] }] : void 0
-      }))
-    });
-  }
-  return {
-    slug: transition.name,
-    category: ["transition"],
-    parts
-  };
-}
-function liftField(field) {
-  const parts = [];
-  if (field.label) {
-    parts.push({
-      slug: "label",
-      category: ["atom"],
-      parts: [{ slug: field.label, category: ["atom"] }]
-    });
-  }
-  if (field.default_value !== void 0) {
-    parts.push({
-      slug: "default",
-      category: ["atom"],
-      parts: [{ slug: String(field.default_value), category: ["literal"] }]
-    });
-  }
-  if (field.required) {
-    parts.push({ slug: "required", category: ["atom"], parts: [{ slug: "true", category: ["literal"] }] });
-  }
-  if (field.computed) {
-    parts.push({
-      slug: "computed",
-      category: ["expression"],
-      parts: [{ slug: field.computed, category: ["binding"] }]
-    });
-  }
-  return {
-    slug: field.name,
-    category: normalizeCategory("field", field.type),
-    parts: parts.length > 0 ? parts : void 0
-  };
-}
-function liftView(node) {
-  const componentTag = (node.component || "stack").toLowerCase().replace(/\s+/g, "-");
-  const parts = [];
-  if (node.config) {
-    for (const [key, value] of Object.entries(node.config)) {
-      parts.push({
-        slug: key,
-        category: ["atom"],
-        parts: [{ slug: String(value), category: ["atom"] }]
-      });
-    }
-  }
-  if (node.bindings) {
-    for (const [key, expr] of Object.entries(node.bindings)) {
-      if (key === "onClick" || key === "onPress") {
-        const match = typeof expr === "string" ? expr.match(/\$action\.transition\("(.+?)"\)/) : null;
-        if (match) {
-          parts.push({
-            slug: key,
-            category: normalizeCategory("expression", "effect", "transition"),
-            parts: [{ slug: match[1], category: ["ref"] }]
-          });
-        } else {
-          parts.push({
-            slug: key,
-            category: normalizeCategory("expression", "binding"),
-            parts: [{ slug: String(expr), category: ["binding"] }]
-          });
-        }
-      } else {
-        parts.push({
-          slug: key,
-          category: normalizeCategory("expression", "binding"),
-          parts: [{ slug: String(expr), category: ["binding"] }]
-        });
-      }
-    }
-  }
-  if (node.visible_when) {
-    const eqMatch = node.visible_when.match(/\$fn\.eq\((.+?),\s*"(.+?)"\)/);
-    if (eqMatch) {
-      parts.push({
-        slug: "visible_when",
-        category: normalizeCategory("expression", "guard"),
-        parts: [{
-          slug: "body",
-          category: normalizeCategory("expression", "eq"),
-          parts: [
-            { slug: "lhs", category: normalizeCategory("expression", "path"), parts: [{ slug: eqMatch[1], category: ["binding"] }] },
-            { slug: "rhs", category: normalizeCategory("expression", "literal"), parts: [{ slug: eqMatch[2], category: ["literal"] }] }
-          ]
-        }]
-      });
-    } else {
-      parts.push({
-        slug: "visible_when",
-        category: normalizeCategory("expression", "guard"),
-        parts: [{ slug: node.visible_when, category: ["binding"] }]
-      });
-    }
-  }
-  if (node.children && node.children.length > 0) {
-    for (const child of node.children) {
-      parts.push(liftView(child));
-    }
-  }
-  return {
-    slug: node.id,
-    category: normalizeCategory("view", componentTag),
-    parts: parts.length > 0 ? parts : void 0
-  };
-}
-function emitCanonical(extracted, sourceFilename) {
-  const ir = emitIR(extracted);
-  const parts = [];
-  for (const state of ir.states) {
-    parts.push(liftState(state));
-  }
-  for (const transition of ir.transitions) {
-    parts.push(liftTransition(transition));
-  }
-  for (const field of ir.fields) {
-    parts.push(liftField(field));
-  }
-  if (extracted.experience) {
-    parts.push(liftView(extracted.experience));
-  }
-  parts.push({
-    slug: "manifest",
-    category: normalizeCategory("meta", "manifest"),
-    parts: [
-      {
-        slug: "workflows",
-        category: ["ref-list"],
-        parts: [{ slug: ir.slug, category: ["ref"] }]
-      },
-      {
-        slug: "route",
-        category: ["route"],
-        parts: [
-          { slug: "path", category: ["atom"], parts: [{ slug: `/${ir.slug}`, category: ["atom"] }] },
-          { slug: "label", category: ["atom"], parts: [{ slug: ir.name, category: ["atom"] }] }
-        ]
-      }
-    ]
-  });
-  const category = extracted.category;
-  const categoryArray = category === "workflow" ? ["workflow"] : normalizeCategory("workflow", category);
-  return {
-    slug: ir.slug,
-    category: categoryArray,
-    parts,
-    metadata: {
-      stable_id: `def-${ir.slug}`,
-      provenance: {
-        frontend: "react-compiler",
-        source: sourceFilename || `${ir.slug}.workflow.tsx`,
-        compiler_version: "1.0.0",
-        compiled_at: (/* @__PURE__ */ new Date()).toISOString()
-      }
-    }
-  };
-}
-function emitCompiledOutput(extracted, sourceFilename) {
-  return {
-    canonical: emitCanonical(extracted, sourceFilename),
-    ir: emitIR(extracted)
-  };
-}
-function emitWorkflowDefinition(extracted) {
-  const ir = emitIR(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 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 = emitIR(extracted);
-        const definition = emitWorkflowDefinition(extracted);
-        const canonical = emitCanonical(extracted, state.filename);
-        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;
-        state.file.metadata.mindmatrixCanonical = canonical;
-      }
-    },
-    // 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,
-  emitIR,
-  emitPureForm,
-  emitCanonical,
-  emitCompiledOutput,
-  compilerStateToWorkflow,
-  createVisitor,
-  babelPlugin
-};