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

package/dist/chunk-XAJ5BKKL.mjs

@@ -0,0 +1,4947 @@
+// src/babel/visitor.ts
+import * as t17 from "@babel/types";
+
+// src/babel/extractors/state-extractor.ts
+import * as t from "@babel/types";
+var KNOWN_TYPE_REFS = {
+  Date: "date",
+  URL: "url",
+  Record: "json",
+  Map: "json",
+  Set: "json"
+};
+function typeNameToSlug(name) {
+  return name.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "");
+}
+function resolveSingleType(annotation) {
+  if (t.isTSNumberKeyword(annotation)) return "number";
+  if (t.isTSStringKeyword(annotation)) return "text";
+  if (t.isTSBooleanKeyword(annotation)) return "boolean";
+  if (t.isTSTypeReference(annotation)) {
+    const typeName = t.isIdentifier(annotation.typeName) ? annotation.typeName.name : "";
+    if (typeName === "Array") return "multi_select";
+    if (typeName && KNOWN_TYPE_REFS[typeName]) return KNOWN_TYPE_REFS[typeName];
+    if (typeName) return typeNameToSlug(typeName);
+  }
+  if (t.isTSArrayType(annotation)) return "multi_select";
+  if (t.isTSTypeLiteral(annotation) || t.isTSTupleType(annotation)) return "json";
+  return null;
+}
+function inferFieldType(typeAnnotation, defaultValue) {
+  if (typeAnnotation) {
+    if (t.isTSUnionType(typeAnnotation)) {
+      const allStringLiterals = typeAnnotation.types.every(
+        (m) => t.isTSLiteralType(m) && t.isStringLiteral(m.literal)
+      );
+      if (allStringLiterals) return "select";
+      const nonNullMembers = typeAnnotation.types.filter(
+        (m) => !t.isTSNullKeyword(m) && !t.isTSUndefinedKeyword(m)
+      );
+      const allLiteralsExceptNull = nonNullMembers.every(
+        (m) => t.isTSLiteralType(m) && t.isStringLiteral(m.literal)
+      );
+      if (allLiteralsExceptNull && nonNullMembers.length > 0) return "select";
+      if (nonNullMembers.length === 1) {
+        const resolved2 = resolveSingleType(nonNullMembers[0]);
+        if (resolved2) return resolved2;
+      }
+      if (nonNullMembers.length > 1) return "json";
+    }
+    const resolved = resolveSingleType(typeAnnotation);
+    if (resolved) return resolved;
+  }
+  if (defaultValue) {
+    if (t.isNumericLiteral(defaultValue)) return "number";
+    if (t.isStringLiteral(defaultValue)) return "text";
+    if (t.isBooleanLiteral(defaultValue)) return "boolean";
+    if (t.isArrayExpression(defaultValue)) return "json";
+    if (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
+  };
+  if (fieldType === "select" && typeAnnotation && t.isTSUnionType(typeAnnotation)) {
+    const options = typeAnnotation.types.filter((m) => t.isTSLiteralType(m) && t.isStringLiteral(m.literal)).map((m) => m.literal.value);
+    if (options.length > 0) {
+      field.validation = { options };
+    }
+  }
+  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.isBinaryExpression(node)) {
+    return `(${generateCode(node.left)} ${node.operator} ${generateCode(node.right)})`;
+  }
+  if (t2.isLogicalExpression(node)) {
+    return `(${generateCode(node.left)} ${node.operator} ${generateCode(node.right)})`;
+  }
+  if (t2.isConditionalExpression(node)) {
+    return `(${generateCode(node.test)} ? ${generateCode(node.consequent)} : ${generateCode(node.alternate)})`;
+  }
+  if (t2.isUnaryExpression(node) && node.prefix) {
+    return `${node.operator}${generateCode(node.argument)}`;
+  }
+  if (t2.isTemplateLiteral(node)) {
+    return node.quasis.map((q, i) => {
+      const raw = q.value.raw;
+      if (i < node.expressions.length) return raw + "${" + generateCode(node.expressions[i]) + "}";
+      return raw;
+    }).join("");
+  }
+  if (t2.isMemberExpression(node)) {
+    const obj = generateCode(node.object);
+    if (node.computed) {
+      return `${obj}[${generateCode(node.property)}]`;
+    }
+    const prop = t2.isIdentifier(node.property) ? node.property.name : "[property]";
+    return `${obj}.${prop}`;
+  }
+  if (t2.isCallExpression(node)) {
+    if (t2.isIdentifier(node.callee)) {
+      const args = node.arguments.map((a) => generateCode(a)).join(", ");
+      return `${node.callee.name}(${args})`;
+    }
+    if (t2.isMemberExpression(node.callee)) {
+      const obj = generateCode(node.callee.object);
+      const prop = t2.isIdentifier(node.callee.property) ? node.callee.property.name : "[method]";
+      const args = node.arguments.map((a) => generateCode(a)).join(", ");
+      return `${obj}.${prop}(${args})`;
+    }
+  }
+  if (t2.isArrowFunctionExpression(node)) {
+    if (t2.isExpression(node.body)) {
+      const params = node.params;
+      if (params.length === 1 && t2.isIdentifier(params[0])) {
+        const paramName = params[0].name;
+        const bodyCode = generateCode(node.body);
+        return bodyCode.replace(new RegExp(`\\b${paramName}\\b`, "g"), "$prev");
+      }
+    }
+    return "[Function]";
+  }
+  if (t2.isFunctionExpression(node)) return "[Function]";
+  if (t2.isArrayExpression(node)) {
+    const elements = node.elements.map((el) => el ? generateCode(el) : "undefined").join(", ");
+    return `[${elements}]`;
+  }
+  if (t2.isObjectExpression(node)) {
+    const props = node.properties.map((p) => {
+      if (t2.isObjectProperty(p)) {
+        const key = t2.isIdentifier(p.key) ? p.key.name : t2.isStringLiteral(p.key) ? `"${p.key.value}"` : "[key]";
+        if (p.shorthand && t2.isIdentifier(p.value)) return key;
+        return `${key}: ${generateCode(p.value)}`;
+      }
+      if (t2.isSpreadElement(p)) return `...${generateCode(p.argument)}`;
+      return "";
+    }).filter(Boolean).join(", ");
+    return `{ ${props} }`;
+  }
+  if (t2.isTSAsExpression(node)) return generateCode(node.expression);
+  if (t2.isTSNonNullExpression(node)) return generateCode(node.expression);
+  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 = "";
+  let roles;
+  let requiredFields;
+  let auto;
+  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;
+        }
+      } else if (prop.key.name === "roles") {
+        if (t3.isArrayExpression(prop.value)) {
+          roles = prop.value.elements.filter((el) => t3.isStringLiteral(el)).map((el) => el.value);
+        }
+      } else if (prop.key.name === "requiredFields") {
+        if (t3.isArrayExpression(prop.value)) {
+          requiredFields = prop.value.elements.filter((el) => t3.isStringLiteral(el)).map((el) => el.value);
+        }
+      } else if (prop.key.name === "auto") {
+        if (t3.isBooleanLiteral(prop.value)) {
+          auto = prop.value.value;
+        }
+      }
+    }
+  }
+  const transition = {
+    name: transitionName,
+    from,
+    to,
+    actions: [],
+    conditions: [],
+    ...roles && roles.length > 0 && { roles },
+    ...requiredFields && requiredFields.length > 0 && { required_fields: requiredFields },
+    ...auto !== void 0 && { auto }
+  };
+  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((t18) => t18.from.length === 0 || !t18.to);
+  if (needsInference.length === 0) return;
+  if (startStates.length === 1 && regularStates.length > 0) {
+    needsInference.forEach((t18, idx) => {
+      if (t18.from.length === 0) {
+        t18.from = [startStates[0].name];
+      }
+      if (!t18.to) {
+        t18.to = regularStates[idx % regularStates.length]?.name || startStates[0].name;
+      }
+    });
+  } else {
+    const allStateNames = stateArray.map((s) => s.name);
+    needsInference.forEach((t18, idx) => {
+      if (t18.from.length === 0 && allStateNames.length > 0) {
+        t18.from = [allStateNames[0]];
+      }
+      if (!t18.to && allStateNames.length > 1) {
+        t18.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.isNullLiteral(node)) return "null";
+  if (t4.isIdentifier(node)) return node.name;
+  if (t4.isBinaryExpression(node)) {
+    return `(${generateExpression(node.left)} ${node.operator} ${generateExpression(node.right)})`;
+  }
+  if (t4.isLogicalExpression(node)) {
+    return `(${generateExpression(node.left)} ${node.operator} ${generateExpression(node.right)})`;
+  }
+  if (t4.isConditionalExpression(node)) {
+    return `(${generateExpression(node.test)} ? ${generateExpression(node.consequent)} : ${generateExpression(node.alternate)})`;
+  }
+  if (t4.isUnaryExpression(node) && node.prefix) {
+    return `${node.operator}${generateExpression(node.argument)}`;
+  }
+  if (t4.isCallExpression(node) && t4.isIdentifier(node.callee)) {
+    const args = node.arguments.map((arg) => generateExpression(arg)).join(", ");
+    return `${node.callee.name}(${args})`;
+  }
+  if (t4.isCallExpression(node) && t4.isMemberExpression(node.callee)) {
+    const obj = generateExpression(node.callee.object);
+    const prop = t4.isIdentifier(node.callee.property) ? node.callee.property.name : "[method]";
+    const args = node.arguments.map((arg) => generateExpression(arg)).join(", ");
+    return `${obj}.${prop}(${args})`;
+  }
+  if (t4.isMemberExpression(node)) {
+    const obj = generateExpression(node.object);
+    if (node.computed) {
+      const prop2 = generateExpression(node.property);
+      return `${obj}[${prop2}]`;
+    }
+    const prop = t4.isIdentifier(node.property) ? node.property.name : "[property]";
+    return `${obj}.${prop}`;
+  }
+  if (t4.isTemplateLiteral(node)) {
+    return node.quasis.map((q, i) => {
+      const raw = q.value.raw;
+      if (i < node.expressions.length) return raw + "${" + generateExpression(node.expressions[i]) + "}";
+      return raw;
+    }).join("");
+  }
+  if (t4.isArrayExpression(node)) {
+    const elements = node.elements.map((el) => el ? generateExpression(el) : "undefined").join(", ");
+    return `[${elements}]`;
+  }
+  if (t4.isObjectExpression(node)) {
+    const props = node.properties.map((p) => {
+      if (t4.isObjectProperty(p)) {
+        const key = t4.isIdentifier(p.key) ? p.key.name : t4.isStringLiteral(p.key) ? `"${p.key.value}"` : "[key]";
+        if (p.shorthand && t4.isIdentifier(p.value)) return key;
+        return `${key}: ${generateExpression(p.value)}`;
+      }
+      if (t4.isSpreadElement(p)) return `...${generateExpression(p.argument)}`;
+      return "";
+    }).filter(Boolean).join(", ");
+    return `{ ${props} }`;
+  }
+  if (t4.isTSAsExpression(node)) return generateExpression(node.expression);
+  if (t4.isTSNonNullExpression(node)) return generateExpression(node.expression);
+  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 t6 from "@babel/types";
+
+// src/babel/transpilers/ts-to-expression.ts
+import * as t5 from "@babel/types";
+function transpileExpression(node, options = {}) {
+  const ctx = new TranspileContext(options);
+  const expr = ctx.visit(node);
+  return { expression: expr, pure: ctx.isPure };
+}
+function transpileBlock(node, options = {}) {
+  const ctx = new TranspileContext(options);
+  const lines = visitStatements(node.body, ctx);
+  return { expression: lines, pure: ctx.isPure };
+}
+function visitStatements(stmts, ctx) {
+  return stmts.map((s) => visitStatement(s, ctx)).join("\n");
+}
+function visitStatement(stmt, ctx) {
+  if (t5.isVariableDeclaration(stmt)) {
+    const keyword = stmt.kind === "const" ? "const" : stmt.kind === "let" ? "let" : "let";
+    const decls = stmt.declarations.map((d) => {
+      const init = d.init ? ctx.visit(d.init) : "null";
+      const lhs = declaratorPattern(d.id);
+      return `${keyword} ${lhs} = ${init}`;
+    });
+    return decls.join(";\n") + ";";
+  }
+  if (t5.isIfStatement(stmt)) {
+    const test = ctx.visit(stmt.test);
+    const consequent = visitBranchBody(stmt.consequent, ctx);
+    if (stmt.alternate) {
+      const alternate = visitBranchBody(stmt.alternate, ctx);
+      return `if (${test}) ${consequent} else ${alternate}`;
+    }
+    return `if (${test}) ${consequent}`;
+  }
+  if (t5.isForOfStatement(stmt)) {
+    const right = ctx.visit(stmt.right);
+    const varName = forOfPattern(stmt.left);
+    const body = visitBranchBody(stmt.body, ctx);
+    return `for (const ${varName} of ${right}) ${body}`;
+  }
+  if (t5.isWhileStatement(stmt)) {
+    const test = ctx.visit(stmt.test);
+    const body = visitBranchBody(stmt.body, ctx);
+    return `while (${test}) ${body}`;
+  }
+  if (t5.isReturnStatement(stmt)) {
+    if (!stmt.argument) return "return;";
+    return `return ${ctx.visit(stmt.argument)};`;
+  }
+  if (t5.isExpressionStatement(stmt)) {
+    return ctx.visit(stmt.expression) + ";";
+  }
+  if (t5.isBlockStatement(stmt)) {
+    const inner = visitStatements(stmt.body, ctx);
+    return `{
+${indent(inner)}
+}`;
+  }
+  if (t5.isFunctionDeclaration(stmt) && stmt.id) {
+    const name = stmt.id.name;
+    const params = stmt.params.map((p) => t5.isIdentifier(p) ? p.name : "_").join(", ");
+    const body = visitStatements(stmt.body.body, ctx);
+    return `function ${name}(${params}) {
+${indent(body)}
+}`;
+  }
+  return ctx.opaque(`[${stmt.type}]`) + ";";
+}
+function visitBranchBody(node, ctx) {
+  if (t5.isBlockStatement(node)) {
+    const inner2 = visitStatements(node.body, ctx);
+    return `{
+${indent(inner2)}
+}`;
+  }
+  const inner = visitStatement(node, ctx);
+  return `{
+${indent(inner)}
+}`;
+}
+function declaratorPattern(node) {
+  if (t5.isIdentifier(node)) return node.name;
+  if (t5.isObjectPattern(node)) {
+    const props = node.properties.map((p) => {
+      if (t5.isRestElement(p)) {
+        return `...${t5.isIdentifier(p.argument) ? p.argument.name : "_"}`;
+      }
+      if (t5.isObjectProperty(p)) {
+        const key = t5.isIdentifier(p.key) ? p.key.name : "_";
+        const val = t5.isIdentifier(p.value) ? p.value.name : t5.isAssignmentPattern(p.value) && t5.isIdentifier(p.value.left) ? p.value.left.name : "_";
+        return key === val ? key : `${key}: ${val}`;
+      }
+      return "_";
+    });
+    return `{ ${props.join(", ")} }`;
+  }
+  if (t5.isArrayPattern(node)) {
+    const elems = node.elements.map(
+      (e) => e === null ? "" : t5.isIdentifier(e) ? e.name : "_"
+    );
+    return `[${elems.join(", ")}]`;
+  }
+  return "_";
+}
+function forOfPattern(left) {
+  if (t5.isVariableDeclaration(left)) {
+    const d = left.declarations[0];
+    if (d) return declaratorPattern(d.id);
+  }
+  if (t5.isIdentifier(left)) return left.name;
+  return "_";
+}
+function indent(code) {
+  return code.split("\n").map((l) => "  " + l).join("\n");
+}
+var TranspileContext = class {
+  constructor(options) {
+    this.isPure = true;
+    this.localFieldMap = options.localFieldMap ?? /* @__PURE__ */ new Map();
+    this.derivedVarMap = options.derivedVarMap ?? /* @__PURE__ */ new Map();
+    this.setterToFieldMap = options.setterToFieldMap ?? /* @__PURE__ */ new Map();
+  }
+  /**
+   * Emit an opaque JS fallback, marking the result as impure.
+   */
+  opaque(jsCode) {
+    this.isPure = false;
+    return `$expr(${jsCode})`;
+  }
+  /**
+   * Visit an AST node and produce an mm-compute expression string.
+   */
+  visit(node) {
+    if (t5.isStringLiteral(node)) return `"${node.value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+    if (t5.isNumericLiteral(node)) return String(node.value);
+    if (t5.isBooleanLiteral(node)) return String(node.value);
+    if (t5.isNullLiteral(node)) return "null";
+    if (t5.isIdentifier(node)) {
+      const snakeName = this.localFieldMap.get(node.name);
+      if (snakeName) return `$local.${snakeName}`;
+      const derivedInit = this.derivedVarMap.get(node.name);
+      if (derivedInit) return `(${this.visit(derivedInit)})`;
+      if (node.name === "undefined") return "null";
+      if (node.name === "NaN") return "null";
+      if (node.name === "Infinity") return "null";
+      return node.name;
+    }
+    if (t5.isTSAsExpression(node)) return this.visit(node.expression);
+    if (t5.isTSNonNullExpression(node)) return this.visit(node.expression);
+    if (t5.isTSTypeAssertion(node)) return this.visit(node.expression);
+    if (t5.isParenthesizedExpression(node)) return `(${this.visit(node.expression)})`;
+    if (t5.isUnaryExpression(node) && node.prefix) {
+      return this.visitUnary(node);
+    }
+    if (t5.isBinaryExpression(node)) {
+      return this.visitBinary(node);
+    }
+    if (t5.isLogicalExpression(node)) {
+      return this.visitLogical(node);
+    }
+    if (t5.isConditionalExpression(node)) {
+      return `if(${this.visit(node.test)}, ${this.visit(node.consequent)}, ${this.visit(node.alternate)})`;
+    }
+    if (t5.isMemberExpression(node) || t5.isOptionalMemberExpression(node)) {
+      return this.visitMember(node);
+    }
+    if (t5.isCallExpression(node) || t5.isOptionalCallExpression(node)) {
+      return this.visitCall(node);
+    }
+    if (t5.isTemplateLiteral(node)) {
+      return this.visitTemplateLiteral(node);
+    }
+    if (t5.isArrayExpression(node)) {
+      const elements = node.elements.map((el) => {
+        if (el === null) return "null";
+        if (t5.isSpreadElement(el)) return this.opaque(`...${this.visit(el.argument)}`);
+        return t5.isExpression(el) ? this.visit(el) : "null";
+      });
+      return `[${elements.join(", ")}]`;
+    }
+    if (t5.isObjectExpression(node)) {
+      return this.visitObject(node);
+    }
+    if (t5.isArrowFunctionExpression(node)) {
+      return this.visitArrow(node);
+    }
+    if (t5.isNewExpression(node)) {
+      return this.visitNew(node);
+    }
+    if (t5.isAssignmentExpression(node) && node.operator === "=" && t5.isIdentifier(node.left)) {
+      return `${node.left.name} = ${this.visit(node.right)}`;
+    }
+    return this.opaque(fallbackGenerate(node));
+  }
+  // ---------------------------------------------------------------------------
+  // Unary
+  // ---------------------------------------------------------------------------
+  visitUnary(node) {
+    if (node.operator === "!") {
+      return `not(${this.visit(node.argument)})`;
+    }
+    if (node.operator === "-") {
+      if (t5.isNumericLiteral(node.argument)) return String(-node.argument.value);
+      return `(0 - ${this.visit(node.argument)})`;
+    }
+    if (node.operator === "typeof") {
+      return `typeof(${this.visit(node.argument)})`;
+    }
+    return this.opaque(`${node.operator}${fallbackGenerate(node.argument)}`);
+  }
+  // ---------------------------------------------------------------------------
+  // Binary
+  // ---------------------------------------------------------------------------
+  visitBinary(node) {
+    const left = this.visit(node.left);
+    const right = this.visit(node.right);
+    switch (node.operator) {
+      case "===":
+        return `(${left} == ${right})`;
+      case "!==":
+        return `(${left} != ${right})`;
+      case "==":
+        return `(${left} == ${right})`;
+      case "!=":
+        return `(${left} != ${right})`;
+      case "<":
+        return `(${left} < ${right})`;
+      case ">":
+        return `(${left} > ${right})`;
+      case "<=":
+        return `(${left} <= ${right})`;
+      case ">=":
+        return `(${left} >= ${right})`;
+      case "+":
+        return `(${left} + ${right})`;
+      case "-":
+        return `(${left} - ${right})`;
+      case "*":
+        return `(${left} * ${right})`;
+      case "/":
+        return `(${left} / ${right})`;
+      case "%":
+        return `(${left} % ${right})`;
+      default:
+        return this.opaque(`(${left} ${node.operator} ${right})`);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Logical
+  // ---------------------------------------------------------------------------
+  visitLogical(node) {
+    const left = this.visit(node.left);
+    const right = this.visit(node.right);
+    switch (node.operator) {
+      case "&&":
+        return `(${left} && ${right})`;
+      case "||":
+        return `(${left} || ${right})`;
+      case "??":
+        return `coalesce(${left}, ${right})`;
+      default:
+        return this.opaque(`(${left} ${node.operator} ${right})`);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Member expression
+  // ---------------------------------------------------------------------------
+  visitMember(node) {
+    const isOptional = node.optional === true;
+    if (!node.computed && t5.isIdentifier(node.property) && node.property.name === "length") {
+      const obj2 = this.visit(node.object);
+      if (isOptional) {
+        return `if(${obj2} != null, length(${obj2}), null)`;
+      }
+      return `length(${obj2})`;
+    }
+    const obj = this.visit(node.object);
+    if (node.computed) {
+      const prop2 = t5.isExpression(node.property) ? this.visit(node.property) : "0";
+      if (isOptional) {
+        return `if(${obj} != null, get(${obj}, ${prop2}), null)`;
+      }
+      return `${obj}[${prop2}]`;
+    }
+    const prop = t5.isIdentifier(node.property) ? node.property.name : "[property]";
+    if (isOptional) {
+      return `if(${obj} != null, ${obj}.${prop}, null)`;
+    }
+    return `${obj}.${prop}`;
+  }
+  // ---------------------------------------------------------------------------
+  // Call expression
+  // ---------------------------------------------------------------------------
+  visitCall(node) {
+    if (t5.isIdentifier(node.callee)) {
+      const setterField = this.setterToFieldMap.get(node.callee.name);
+      if (setterField) {
+        return this.visitSetterCall(node, setterField);
+      }
+      const args = this.visitArgs(node.arguments);
+      return `${node.callee.name}(${args})`;
+    }
+    if (t5.isMemberExpression(node.callee) || t5.isOptionalMemberExpression(node.callee)) {
+      const methodName = t5.isIdentifier(node.callee.property) ? node.callee.property.name : null;
+      if (!methodName) {
+        return this.opaque(fallbackGenerate(node));
+      }
+      if (t5.isIdentifier(node.callee.object) && node.callee.object.name === "Math") {
+        return this.visitMathCall(methodName, node.arguments);
+      }
+      if (t5.isIdentifier(node.callee.object) && node.callee.object.name === "JSON") {
+        return this.visitJsonCall(methodName, node.arguments);
+      }
+      if (t5.isIdentifier(node.callee.object) && node.callee.object.name === "Date") {
+        if (methodName === "now") return "now_ms()";
+      }
+      const obj = this.visit(node.callee.object);
+      return this.visitMethodCall(obj, methodName, node.arguments);
+    }
+    return this.opaque(fallbackGenerate(node));
+  }
+  // ---------------------------------------------------------------------------
+  // Method call transpilation (obj.method(args))
+  // ---------------------------------------------------------------------------
+  visitMethodCall(obj, method, args) {
+    switch (method) {
+      // --- String methods ---
+      case "toLowerCase":
+        return `lower(${obj})`;
+      case "toUpperCase":
+        return `upper(${obj})`;
+      case "trim":
+        return `trim(${obj})`;
+      case "startsWith": {
+        const [arg] = this.visitArgsList(args);
+        return `starts_with(${obj}, ${arg})`;
+      }
+      case "endsWith": {
+        const [arg] = this.visitArgsList(args);
+        return `ends_with(${obj}, ${arg})`;
+      }
+      case "includes": {
+        const [arg] = this.visitArgsList(args);
+        return `contains(${obj}, ${arg})`;
+      }
+      case "split": {
+        const [sep] = this.visitArgsList(args);
+        return `split(${obj}, ${sep})`;
+      }
+      case "join": {
+        const [sep] = this.visitArgsList(args);
+        return `join(${obj}, ${sep})`;
+      }
+      case "replace": {
+        const visited = this.visitArgsList(args);
+        return `replace(${obj}, ${visited[0]}, ${visited[1]})`;
+      }
+      case "substring":
+      case "slice": {
+        const visited = this.visitArgsList(args);
+        if (visited.length === 1) return `substring(${obj}, ${visited[0]})`;
+        return `substring(${obj}, ${visited[0]}, ${visited[1]})`;
+      }
+      case "charAt": {
+        const [idx] = this.visitArgsList(args);
+        return `substring(${obj}, ${idx}, (${idx} + 1))`;
+      }
+      case "indexOf": {
+        const [arg] = this.visitArgsList(args);
+        return `indexof(${obj}, ${arg})`;
+      }
+      case "toString":
+        return `to_string(${obj})`;
+      case "toISOString":
+        return "now()";
+      case "concat": {
+        const visited = this.visitArgsList(args);
+        return `concat(${obj}, ${visited.join(", ")})`;
+      }
+      // --- Array higher-order methods ---
+      case "filter":
+        return this.visitArrayHigherOrder("filter", obj, args);
+      case "map":
+        return this.visitArrayHigherOrder("map", obj, args);
+      case "find":
+        return this.visitArrayHigherOrder("find", obj, args);
+      case "reduce":
+        return this.visitArrayReduce(obj, args);
+      case "some":
+        return this.visitArrayHigherOrder("some", obj, args);
+      case "every":
+        return this.visitArrayHigherOrder("every", obj, args);
+      // --- Array mutation-free methods ---
+      case "reverse":
+        return `reverse(${obj})`;
+      case "sort":
+        return `sort(${obj})`;
+      case "flat":
+        return `flat(${obj})`;
+      // --- JSON methods on values ---
+      case "stringify":
+        return `to_string(${obj})`;
+      default:
+        return this.opaque(`${obj}.${method}(${this.visitArgs(args)})`);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Array higher-order method transpilation
+  // ---------------------------------------------------------------------------
+  visitArrayHigherOrder(fn, obj, args) {
+    const firstArg = args[0];
+    if (!firstArg || !t5.isExpression(firstArg)) {
+      return this.opaque(`${obj}.${fn}()`);
+    }
+    if (t5.isArrowFunctionExpression(firstArg) && t5.isExpression(firstArg.body)) {
+      const paramName = firstArg.params.length > 0 && t5.isIdentifier(firstArg.params[0]) ? firstArg.params[0].name : "_";
+      const lambdaBody = this.visit(firstArg.body);
+      return `${fn}(${obj}, ${paramName} => ${lambdaBody})`;
+    }
+    const argStr = this.visit(firstArg);
+    return `${fn}(${obj}, ${argStr})`;
+  }
+  visitArrayReduce(obj, args) {
+    const [callbackArg, initArg] = args;
+    if (!callbackArg || !t5.isExpression(callbackArg)) {
+      return this.opaque(`${obj}.reduce()`);
+    }
+    if (t5.isArrowFunctionExpression(callbackArg) && t5.isExpression(callbackArg.body)) {
+      const params = callbackArg.params;
+      const accName = params.length > 0 && t5.isIdentifier(params[0]) ? params[0].name : "acc";
+      const itemName = params.length > 1 && t5.isIdentifier(params[1]) ? params[1].name : "x";
+      const lambdaBody = this.visit(callbackArg.body);
+      const initStr = initArg && t5.isExpression(initArg) ? this.visit(initArg) : "0";
+      return `reduce(${obj}, (${accName}, ${itemName}) => ${lambdaBody}, ${initStr})`;
+    }
+    return this.opaque(fallbackGenerate({ type: "CallExpression" }));
+  }
+  // ---------------------------------------------------------------------------
+  // Math.* methods
+  // ---------------------------------------------------------------------------
+  visitMathCall(method, args) {
+    const visited = this.visitArgsList(args);
+    switch (method) {
+      case "max":
+        return `max(${visited.join(", ")})`;
+      case "min":
+        return `min(${visited.join(", ")})`;
+      case "round":
+        return `round(${visited.join(", ")})`;
+      case "floor":
+        return `floor(${visited.join(", ")})`;
+      case "ceil":
+        return `ceil(${visited.join(", ")})`;
+      case "abs":
+        return `abs(${visited.join(", ")})`;
+      case "pow":
+        return `power(${visited.join(", ")})`;
+      case "sqrt":
+        return `sqrt(${visited.join(", ")})`;
+      case "log":
+        return `log(${visited.join(", ")})`;
+      case "log10":
+        return `log10(${visited.join(", ")})`;
+      case "sign":
+        return `sign(${visited.join(", ")})`;
+      default:
+        return this.opaque(`Math.${method}(${visited.join(", ")})`);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // JSON.* methods
+  // ---------------------------------------------------------------------------
+  visitJsonCall(method, args) {
+    const visited = this.visitArgsList(args);
+    switch (method) {
+      case "stringify":
+        return `to_string(${visited[0]})`;
+      case "parse":
+        return `from_json(${visited[0]})`;
+      default:
+        return this.opaque(`JSON.${method}(${visited.join(", ")})`);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Template literals
+  // ---------------------------------------------------------------------------
+  visitTemplateLiteral(node) {
+    const parts = [];
+    for (let i = 0; i < node.quasis.length; i++) {
+      const raw = node.quasis[i].value.cooked ?? node.quasis[i].value.raw;
+      if (raw) {
+        parts.push(`"${raw.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`);
+      }
+      if (i < node.expressions.length) {
+        const exprStr = this.visit(node.expressions[i]);
+        parts.push(`to_string(${exprStr})`);
+      }
+    }
+    const nonEmpty = parts.filter((p) => p !== '""');
+    if (nonEmpty.length === 0) return '""';
+    if (nonEmpty.length === 1) return nonEmpty[0];
+    return `concat(${nonEmpty.join(", ")})`;
+  }
+  // ---------------------------------------------------------------------------
+  // Object expression
+  // ---------------------------------------------------------------------------
+  visitObject(node) {
+    const props = node.properties.map((prop) => {
+      if (t5.isSpreadElement(prop)) {
+        return this.opaque(`...${this.visit(prop.argument)}`);
+      }
+      if (t5.isObjectProperty(prop)) {
+        const key = t5.isIdentifier(prop.key) ? `"${prop.key.name}"` : t5.isStringLiteral(prop.key) ? `"${prop.key.value}"` : t5.isNumericLiteral(prop.key) ? `"${prop.key.value}"` : '"[key]"';
+        const value = t5.isExpression(prop.value) ? this.visit(prop.value) : "null";
+        return `${key}: ${value}`;
+      }
+      return this.opaque("[method]");
+    });
+    return `{${props.join(", ")}}`;
+  }
+  // ---------------------------------------------------------------------------
+  // Arrow function (lambda)
+  // ---------------------------------------------------------------------------
+  visitArrow(node) {
+    if (t5.isExpression(node.body)) {
+      const params = node.params.map((p) => {
+        if (t5.isIdentifier(p)) return p.name;
+        return "_";
+      }).join(", ");
+      const body = this.visit(node.body);
+      if (node.params.length === 1) return `${params} => ${body}`;
+      return `(${params}) => ${body}`;
+    }
+    return this.opaque(fallbackGenerate(node));
+  }
+  // ---------------------------------------------------------------------------
+  // new expressions
+  // ---------------------------------------------------------------------------
+  visitNew(node) {
+    if (t5.isIdentifier(node.callee) && node.callee.name === "Date" && node.arguments.length === 0) {
+      return "now()";
+    }
+    return this.opaque(fallbackGenerate(node));
+  }
+  // ---------------------------------------------------------------------------
+  // setState setter calls
+  // ---------------------------------------------------------------------------
+  visitSetterCall(node, fieldName) {
+    if (node.arguments.length >= 1) {
+      const arg = node.arguments[0];
+      if ((t5.isArrowFunctionExpression(arg) || t5.isFunctionExpression(arg)) && arg.params.length >= 1 && t5.isIdentifier(arg.params[0])) {
+        const paramName = arg.params[0].name;
+        const bodyExpr = t5.isExpression(arg.body) ? this.visit(arg.body) : "null";
+        const resolved = bodyExpr.replace(
+          new RegExp(`(?<![.$\\w])${paramName}(?![\\w])`, "g"),
+          `$local.${fieldName}`
+        );
+        return `$action.setLocal("${fieldName}")(${resolved})`;
+      }
+      const argStr = t5.isExpression(arg) ? this.visit(arg) : "null";
+      return `$action.setLocal("${fieldName}")(${argStr})`;
+    }
+    return `$action.setLocal("${fieldName}")`;
+  }
+  // ---------------------------------------------------------------------------
+  // Argument helpers
+  // ---------------------------------------------------------------------------
+  visitArgs(args) {
+    return args.map((a) => {
+      if (t5.isExpression(a)) return this.visit(a);
+      if (t5.isSpreadElement(a)) return this.opaque(`...${this.visit(a.argument)}`);
+      return "null";
+    }).join(", ");
+  }
+  visitArgsList(args) {
+    return args.map((a) => {
+      if (t5.isExpression(a)) return this.visit(a);
+      if (t5.isSpreadElement(a)) return this.opaque(`...${this.visit(a.argument)}`);
+      return "null";
+    });
+  }
+};
+function fallbackGenerate(node) {
+  if (t5.isIdentifier(node)) return node.name;
+  if (t5.isStringLiteral(node)) return `"${node.value.replace(/"/g, '\\"')}"`;
+  if (t5.isNumericLiteral(node)) return String(node.value);
+  if (t5.isBooleanLiteral(node)) return String(node.value);
+  if (t5.isNullLiteral(node)) return "null";
+  return `[${node.type}]`;
+}
+
+// src/babel/extractors/component-extractor.ts
+var nodeIdCounter = 0;
+var localFieldMap = /* @__PURE__ */ new Map();
+var setterToFieldMap = /* @__PURE__ */ new Map();
+var derivedVarMap = /* @__PURE__ */ new Map();
+function toSnakeCase(str) {
+  return str.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
+}
+var STATIC_EVAL_FAIL = Symbol("STATIC_EVAL_FAIL");
+function tryStaticEval(node) {
+  if (t6.isStringLiteral(node)) return node.value;
+  if (t6.isNumericLiteral(node)) return node.value;
+  if (t6.isBooleanLiteral(node)) return node.value;
+  if (t6.isNullLiteral(node)) return null;
+  if (t6.isIdentifier(node) && node.name === "undefined") return void 0;
+  if (t6.isUnaryExpression(node) && node.operator === "-" && t6.isNumericLiteral(node.argument)) {
+    return -node.argument.value;
+  }
+  if (t6.isArrayExpression(node)) {
+    const result = [];
+    for (const el of node.elements) {
+      if (el === null) {
+        result.push(null);
+        continue;
+      }
+      if (t6.isSpreadElement(el)) return STATIC_EVAL_FAIL;
+      const val = tryStaticEval(el);
+      if (val === STATIC_EVAL_FAIL) return STATIC_EVAL_FAIL;
+      result.push(val);
+    }
+    return result;
+  }
+  if (t6.isObjectExpression(node)) {
+    const result = {};
+    for (const prop of node.properties) {
+      if (t6.isSpreadElement(prop) || t6.isObjectMethod(prop)) return STATIC_EVAL_FAIL;
+      if (!t6.isObjectProperty(prop)) return STATIC_EVAL_FAIL;
+      let key;
+      if (t6.isIdentifier(prop.key)) key = prop.key.name;
+      else if (t6.isStringLiteral(prop.key)) key = prop.key.value;
+      else if (t6.isNumericLiteral(prop.key)) key = String(prop.key.value);
+      else return STATIC_EVAL_FAIL;
+      if (!t6.isExpression(prop.value)) return STATIC_EVAL_FAIL;
+      const val = tryStaticEval(prop.value);
+      if (val === STATIC_EVAL_FAIL) return STATIC_EVAL_FAIL;
+      result[key] = val;
+    }
+    return result;
+  }
+  if (t6.isTemplateLiteral(node) && node.expressions.length === 0) {
+    return node.quasis[0].value.cooked ?? node.quasis[0].value.raw;
+  }
+  return STATIC_EVAL_FAIL;
+}
+function initLocalFieldMaps(fields) {
+  localFieldMap.clear();
+  setterToFieldMap.clear();
+  for (const field of fields) {
+    const camelName = field.name;
+    const snakeName = toSnakeCase(camelName);
+    localFieldMap.set(camelName, snakeName);
+    const setterName = "set" + camelName.charAt(0).toUpperCase() + camelName.slice(1);
+    setterToFieldMap.set(setterName, snakeName);
+  }
+}
+function registerDerivedVar(name, init) {
+  derivedVarMap.set(name, init);
+}
+function resetNodeIdCounter() {
+  nodeIdCounter = 0;
+  derivedVarMap.clear();
+}
+function jsxToExperienceNode(node) {
+  if (t6.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;
+  let slot;
+  let className;
+  let displayName;
+  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 (t6.isJSXAttribute(attr) && t6.isJSXIdentifier(attr.name)) {
+      const attrName = attr.name.name;
+      const attrValue = attr.value;
+      if (attrName === "visible_when" && t6.isStringLiteral(attrValue)) {
+        visibleWhen = attrValue.value;
+      } else if (attrName === "data-slot" && t6.isStringLiteral(attrValue)) {
+        slot = attrValue.value;
+      } else if (attrName === "className" && t6.isStringLiteral(attrValue)) {
+        className = attrValue.value;
+      } else if (attrName === "displayName" && t6.isStringLiteral(attrValue)) {
+        displayName = attrValue.value;
+      } else if (t6.isJSXExpressionContainer(attrValue)) {
+        const expr = attrValue.expression;
+        if (t6.isJSXEmptyExpression(expr)) continue;
+        if (t6.isNumericLiteral(expr)) {
+          config[attrName] = expr.value;
+        } else if (t6.isBooleanLiteral(expr)) {
+          config[attrName] = expr.value;
+        } else if (t6.isStringLiteral(expr)) {
+          if (expr.value.includes("$instance") || expr.value.includes("$local") || /^[a-zA-Z_]+\(/.test(expr.value)) {
+            bindings[attrName] = expr.value;
+          } else {
+            config[attrName] = expr.value;
+          }
+        } else if (t6.isIdentifier(expr)) {
+          const snakeName = localFieldMap.get(expr.name);
+          bindings[attrName] = snakeName ? `$local.${snakeName}` : `$instance.${expr.name}`;
+        } else if (isEventHandlerProp(attrName) && (t6.isArrowFunctionExpression(expr) || t6.isFunctionExpression(expr))) {
+          const decomposed = decomposeHandlerToSeq(expr);
+          if (decomposed) {
+            bindings[attrName] = decomposed;
+          } else {
+            bindings[attrName] = `$expr(${generateExpression2(expr)})`;
+          }
+        } else if (t6.isExpression(expr)) {
+          const staticVal = tryStaticEval(expr);
+          if (staticVal !== STATIC_EVAL_FAIL) {
+            config[attrName] = staticVal;
+          } else {
+            bindings[attrName] = generateExpression2(expr);
+          }
+        }
+      } else if (t6.isStringLiteral(attrValue)) {
+        config[attrName] = attrValue.value;
+      } else if (attrValue === null) {
+        config[attrName] = true;
+      }
+    } else if (t6.isJSXSpreadAttribute(attr)) {
+      if (t6.isIdentifier(attr.argument)) {
+        bindings["..." + attr.argument.name] = `$instance.${attr.argument.name}`;
+      }
+    }
+  }
+  const children = extractChildren(node.children);
+  const experienceNode = {
+    id,
+    ...displayName && { displayName },
+    component: componentName,
+    ...slot && { slot },
+    ...layout && { layout },
+    ...className && { className },
+    ...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 (t6.isJSXIdentifier(name)) return name.name;
+  if (t6.isJSXMemberExpression(name)) {
+    const obj = resolveComponentName(name.object);
+    return `${obj}.${name.property.name}`;
+  }
+  if (t6.isJSXNamespacedName(name)) {
+    return `${name.namespace.name}:${name.name.name}`;
+  }
+  return "div";
+}
+function extractChildren(children) {
+  const nodes = [];
+  for (const child of children) {
+    if (t6.isJSXElement(child)) {
+      nodes.push(jsxToExperienceNode(child));
+    } else if (t6.isJSXFragment(child)) {
+      nodes.push(jsxToExperienceNode(child));
+    } else if (t6.isJSXText(child)) {
+      const text = child.value.trim();
+      if (text) {
+        nodes.push({
+          id: `text_${++nodeIdCounter}`,
+          component: "Text",
+          config: { value: text }
+        });
+      }
+    } else if (t6.isJSXExpressionContainer(child)) {
+      const expr = child.expression;
+      if (t6.isJSXEmptyExpression(expr)) continue;
+      if (t6.isConditionalExpression(expr)) {
+        const condExpr = generateExpression2(expr.test);
+        if (t6.isJSXElement(expr.consequent) || t6.isJSXFragment(expr.consequent)) {
+          const consequent = jsxToExperienceNode(expr.consequent);
+          consequent.visible_when = condExpr;
+          nodes.push(consequent);
+        }
+        if (t6.isJSXElement(expr.alternate) || t6.isJSXFragment(expr.alternate)) {
+          const alternate = jsxToExperienceNode(expr.alternate);
+          alternate.visible_when = `not(${condExpr})`;
+          nodes.push(alternate);
+        }
+      } else if (t6.isLogicalExpression(expr) && expr.operator === "&&") {
+        const condExpr = generateExpression2(expr.left);
+        if (t6.isJSXElement(expr.right) || t6.isJSXFragment(expr.right)) {
+          const element = jsxToExperienceNode(expr.right);
+          element.visible_when = condExpr;
+          nodes.push(element);
+        }
+      } else if (t6.isCallExpression(expr) && t6.isMemberExpression(expr.callee) && t6.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 (t6.isArrowFunctionExpression(mapFn) || t6.isFunctionExpression(mapFn)) {
+          if (mapFn.params.length > 0 && t6.isIdentifier(mapFn.params[0])) {
+            itemAlias = mapFn.params[0].name;
+          }
+          const body = mapFn.body;
+          if (t6.isJSXElement(body) || t6.isJSXFragment(body)) {
+            itemTemplate = jsxToExperienceNode(body);
+          } else if (t6.isBlockStatement(body)) {
+            for (const stmt of body.body) {
+              if (t6.isReturnStatement(stmt) && stmt.argument) {
+                if (t6.isJSXElement(stmt.argument) || t6.isJSXFragment(stmt.argument)) {
+                  itemTemplate = jsxToExperienceNode(stmt.argument);
+                }
+                break;
+              }
+            }
+          }
+        }
+        nodes.push({
+          id: `each_${++nodeIdCounter}`,
+          component: "Each",
+          bindings: { items: listSource.startsWith("$") ? listSource : `$instance.${listSource}` },
+          config: { as: itemAlias },
+          ...itemTemplate ? { children: [itemTemplate] } : {}
+        });
+      } else if ((t6.isArrowFunctionExpression(expr) || t6.isFunctionExpression(expr)) && extractJSXFromCallback(expr)) {
+        const jsxNode = extractJSXFromCallback(expr);
+        nodes.push(jsxToExperienceNode(jsxNode));
+      } else if (t6.isStringLiteral(expr)) {
+        nodes.push({
+          id: `text_${++nodeIdCounter}`,
+          component: "Text",
+          config: { value: expr.value }
+        });
+      } else if (t6.isIdentifier(expr)) {
+        const snakeName = localFieldMap.get(expr.name);
+        const bindingPath = snakeName ? `$local.${snakeName}` : `$instance.${expr.name}`;
+        nodes.push({
+          id: `text_${++nodeIdCounter}`,
+          component: "Text",
+          bindings: { value: bindingPath }
+        });
+      } else if (t6.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 (t6.isIdentifier(node)) {
+    const snakeName = localFieldMap.get(node.name);
+    if (snakeName) return `$local.${snakeName}`;
+    const derivedInit = derivedVarMap.get(node.name);
+    if (derivedInit) return `(${generateExpression2(derivedInit)})`;
+    return node.name;
+  }
+  if (t6.isStringLiteral(node)) return `"${node.value.replace(/"/g, '\\"')}"`;
+  if (t6.isNumericLiteral(node)) return String(node.value);
+  if (t6.isBooleanLiteral(node)) return String(node.value);
+  if (t6.isNullLiteral(node)) return "null";
+  if (t6.isMemberExpression(node) || t6.isOptionalMemberExpression(node)) {
+    const obj = t6.isExpression(node.object) ? generateExpression2(node.object) : "[object]";
+    const optional = node.optional ? "?." : ".";
+    if (node.computed) {
+      const prop2 = t6.isExpression(node.property) ? generateExpression2(node.property) : "0";
+      return `${obj}[${prop2}]`;
+    }
+    const prop = t6.isIdentifier(node.property) ? node.property.name : "[property]";
+    return `${obj}${optional}${prop}`;
+  }
+  if (t6.isBinaryExpression(node)) {
+    return `(${generateExpression2(node.left)} ${node.operator} ${generateExpression2(node.right)})`;
+  }
+  if (t6.isLogicalExpression(node)) {
+    return `(${generateExpression2(node.left)} ${node.operator} ${generateExpression2(node.right)})`;
+  }
+  if (t6.isConditionalExpression(node)) {
+    return `(${generateExpression2(node.test)} ? ${generateExpression2(node.consequent)} : ${generateExpression2(node.alternate)})`;
+  }
+  if (t6.isUnaryExpression(node) && node.prefix) {
+    const space = node.operator === "typeof" || node.operator === "void" || node.operator === "delete" ? " " : "";
+    return `${node.operator}${space}${generateExpression2(node.argument)}`;
+  }
+  if (t6.isCallExpression(node) || t6.isOptionalCallExpression(node)) {
+    if (t6.isIdentifier(node.callee)) {
+      const setterFieldName = setterToFieldMap.get(node.callee.name);
+      if (setterFieldName) {
+        if (node.arguments.length >= 1) {
+          const arg = node.arguments[0];
+          if ((t6.isArrowFunctionExpression(arg) || t6.isFunctionExpression(arg)) && arg.params.length >= 1 && t6.isIdentifier(arg.params[0])) {
+            const paramName = arg.params[0].name;
+            const bodyExpr = t6.isExpression(arg.body) ? generateExpression2(arg.body) : "undefined";
+            const resolved = bodyExpr.replace(
+              new RegExp(`(?<![.$\\w])${paramName}(?![\\w])`, "g"),
+              `$local.${setterFieldName}`
+            );
+            return `$action.setLocal("${setterFieldName}")(${resolved})`;
+          }
+          const argStr = t6.isExpression(arg) ? generateExpression2(arg) : "undefined";
+          return `$action.setLocal("${setterFieldName}")(${argStr})`;
+        }
+        return `$action.setLocal("${setterFieldName}")`;
+      }
+      const args = node.arguments.map((a) => t6.isExpression(a) ? generateExpression2(a) : t6.isSpreadElement(a) ? `...${generateExpression2(a.argument)}` : "undefined").join(", ");
+      return `${node.callee.name}(${args})`;
+    }
+    if (t6.isMemberExpression(node.callee) || t6.isOptionalMemberExpression(node.callee)) {
+      const mmResult = transpileExpression(node, {
+        localFieldMap,
+        derivedVarMap,
+        setterToFieldMap
+      });
+      if (mmResult.pure) return mmResult.expression;
+      const obj = generateExpression2(node.callee.object);
+      const optional = node.callee.optional ? "?." : ".";
+      const prop = t6.isIdentifier(node.callee.property) ? node.callee.property.name : "[method]";
+      const args = node.arguments.map((a) => t6.isExpression(a) ? generateExpression2(a) : t6.isSpreadElement(a) ? `...${generateExpression2(a.argument)}` : "undefined").join(", ");
+      return `${obj}${optional}${prop}(${args})`;
+    }
+    if (t6.isExpression(node.callee)) {
+      const callee = generateExpression2(node.callee);
+      const args = node.arguments.map((a) => t6.isExpression(a) ? generateExpression2(a) : "undefined").join(", ");
+      return `(${callee})(${args})`;
+    }
+  }
+  if (t6.isTemplateLiteral(node)) {
+    const parts = 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 "`" + parts + "`";
+  }
+  if (t6.isArrowFunctionExpression(node)) {
+    const params = node.params.map((p) => {
+      if (t6.isIdentifier(p)) return p.name;
+      if (t6.isRestElement(p) && t6.isIdentifier(p.argument)) return `...${p.argument.name}`;
+      if (t6.isAssignmentPattern(p) && t6.isIdentifier(p.left)) {
+        return `${p.left.name} = ${t6.isExpression(p.right) ? generateExpression2(p.right) : "undefined"}`;
+      }
+      return "_";
+    }).join(", ");
+    if (t6.isExpression(node.body)) {
+      return `(${params}) => ${generateExpression2(node.body)}`;
+    }
+    if (t6.isBlockStatement(node.body)) {
+      const bodyStr = generateBlockStatement(node.body);
+      return `(${params}) => { ${bodyStr} }`;
+    }
+  }
+  if (t6.isArrayExpression(node)) {
+    const elements = node.elements.map((el) => {
+      if (el === null) return "undefined";
+      if (t6.isSpreadElement(el)) return `...${generateExpression2(el.argument)}`;
+      return t6.isExpression(el) ? generateExpression2(el) : "undefined";
+    }).join(", ");
+    return `[${elements}]`;
+  }
+  if (t6.isObjectExpression(node)) {
+    const props = node.properties.map((prop) => {
+      if (t6.isSpreadElement(prop)) return `...${generateExpression2(prop.argument)}`;
+      if (t6.isObjectProperty(prop)) {
+        const key = t6.isIdentifier(prop.key) ? prop.key.name : t6.isStringLiteral(prop.key) ? `"${prop.key.value}"` : t6.isNumericLiteral(prop.key) ? String(prop.key.value) : "[key]";
+        if (prop.shorthand && t6.isIdentifier(prop.value)) return key;
+        const value = t6.isExpression(prop.value) ? generateExpression2(prop.value) : "undefined";
+        return `${key}: ${value}`;
+      }
+      if (t6.isObjectMethod(prop)) {
+        const key = t6.isIdentifier(prop.key) ? prop.key.name : "[method]";
+        const params = prop.params.map((p) => t6.isIdentifier(p) ? p.name : "_").join(", ");
+        const bodyStr = generateBlockStatement(prop.body);
+        return `${key}(${params}) { ${bodyStr} }`;
+      }
+      return "";
+    }).filter(Boolean).join(", ");
+    return `{ ${props} }`;
+  }
+  if (t6.isParenthesizedExpression(node)) {
+    return `(${generateExpression2(node.expression)})`;
+  }
+  if (t6.isTSAsExpression(node)) return generateExpression2(node.expression);
+  if (t6.isTSNonNullExpression(node)) return generateExpression2(node.expression);
+  if (t6.isTSTypeAssertion(node)) return generateExpression2(node.expression);
+  if (t6.isSequenceExpression(node)) {
+    return `(${node.expressions.map(generateExpression2).join(", ")})`;
+  }
+  if (t6.isAssignmentExpression(node)) {
+    const left = t6.isExpression(node.left) ? generateExpression2(node.left) : "[target]";
+    return `(${left} ${node.operator} ${generateExpression2(node.right)})`;
+  }
+  if (t6.isUpdateExpression(node)) {
+    const arg = generateExpression2(node.argument);
+    return node.prefix ? `${node.operator}${arg}` : `${arg}${node.operator}`;
+  }
+  if (t6.isTaggedTemplateExpression(node)) {
+    return generateExpression2(node.quasi);
+  }
+  if (t6.isSpreadElement(node)) {
+    return `...${generateExpression2(node.argument)}`;
+  }
+  if (t6.isYieldExpression(node)) {
+    return node.argument ? `yield ${generateExpression2(node.argument)}` : "yield";
+  }
+  if (t6.isAwaitExpression(node)) {
+    return `await ${generateExpression2(node.argument)}`;
+  }
+  if (t6.isNewExpression(node)) {
+    const callee = t6.isExpression(node.callee) ? generateExpression2(node.callee) : "Object";
+    const args = node.arguments.map((a) => t6.isExpression(a) ? generateExpression2(a) : "undefined").join(", ");
+    return `new ${callee}(${args})`;
+  }
+  if (t6.isThisExpression(node)) return "this";
+  console.warn(`[component-extractor] Unhandled expression type: ${node.type}`);
+  return "[Expression]";
+}
+function generateBlockStatement(block) {
+  return block.body.map((stmt) => {
+    if (t6.isReturnStatement(stmt)) {
+      return stmt.argument ? `return ${generateExpression2(stmt.argument)};` : "return;";
+    }
+    if (t6.isExpressionStatement(stmt)) {
+      return `${generateExpression2(stmt.expression)};`;
+    }
+    if (t6.isVariableDeclaration(stmt)) {
+      const decls = stmt.declarations.map((d) => {
+        const id = t6.isIdentifier(d.id) ? d.id.name : "_";
+        const init = d.init && t6.isExpression(d.init) ? generateExpression2(d.init) : "undefined";
+        return `${id} = ${init}`;
+      }).join(", ");
+      return `${stmt.kind} ${decls};`;
+    }
+    if (t6.isIfStatement(stmt)) {
+      const test = generateExpression2(stmt.test);
+      const consequent = t6.isBlockStatement(stmt.consequent) ? `{ ${generateBlockStatement(stmt.consequent)} }` : t6.isExpressionStatement(stmt.consequent) ? `{ ${generateExpression2(stmt.consequent.expression)}; }` : "{}";
+      const alternate = stmt.alternate ? t6.isBlockStatement(stmt.alternate) ? ` else { ${generateBlockStatement(stmt.alternate)} }` : t6.isIfStatement(stmt.alternate) ? ` else ${generateBlockStatement(t6.blockStatement([stmt.alternate]))}` : "" : "";
+      return `if (${test}) ${consequent}${alternate}`;
+    }
+    return "/* [Statement] */";
+  }).join(" ");
+}
+function extractJSXFromCallback(node) {
+  const body = node.body;
+  if (t6.isJSXElement(body) || t6.isJSXFragment(body)) {
+    return body;
+  }
+  if (t6.isParenthesizedExpression(body)) {
+    const inner = body.expression;
+    if (t6.isJSXElement(inner) || t6.isJSXFragment(inner)) {
+      return inner;
+    }
+  }
+  if (t6.isBlockStatement(body)) {
+    for (const stmt of body.body) {
+      if (t6.isReturnStatement(stmt) && stmt.argument) {
+        if (t6.isJSXElement(stmt.argument) || t6.isJSXFragment(stmt.argument)) {
+          return stmt.argument;
+        }
+        if (t6.isParenthesizedExpression(stmt.argument)) {
+          const inner = stmt.argument.expression;
+          if (t6.isJSXElement(inner) || t6.isJSXFragment(inner)) {
+            return inner;
+          }
+        }
+      }
+    }
+  }
+  return null;
+}
+function isEventHandlerProp(name) {
+  return /^on[A-Z]/.test(name);
+}
+function expressionToActionAtom(expr) {
+  if (t6.isCallExpression(expr) || t6.isOptionalCallExpression(expr)) {
+    if (t6.isIdentifier(expr.callee)) {
+      const setterFieldName = setterToFieldMap.get(expr.callee.name);
+      if (setterFieldName && expr.arguments.length >= 1) {
+        const arg = expr.arguments[0];
+        if ((t6.isArrowFunctionExpression(arg) || t6.isFunctionExpression(arg)) && arg.params.length >= 1 && t6.isIdentifier(arg.params[0])) {
+          const paramName = arg.params[0].name;
+          const bodyExpr = t6.isExpression(arg.body) ? generateExpression2(arg.body) : "undefined";
+          const resolved = bodyExpr.replace(
+            new RegExp(`(?<![.$\\w])${paramName}(?![\\w])`, "g"),
+            `$local.${setterFieldName}`
+          );
+          return `$action.setLocal("${setterFieldName}", ${resolved})`;
+        }
+        const argStr = t6.isExpression(arg) ? generateExpression2(arg) : "undefined";
+        return `$action.setLocal("${setterFieldName}", ${argStr})`;
+      }
+      return null;
+    }
+    if (t6.isMemberExpression(expr.callee) || t6.isOptionalMemberExpression(expr.callee)) {
+      const generated = generateExpression2(expr);
+      if (generated.startsWith("$action.")) return generated;
+    }
+    return null;
+  }
+  return null;
+}
+function statementToAction(stmt) {
+  if (t6.isExpressionStatement(stmt)) {
+    return expressionToActionAtom(stmt.expression);
+  }
+  if (t6.isIfStatement(stmt)) {
+    const condition = generateExpression2(stmt.test);
+    let thenAction = null;
+    if (t6.isBlockStatement(stmt.consequent)) {
+      const actions = stmt.consequent.body.map((s) => statementToAction(s)).filter(Boolean);
+      if (actions.length === 0 || actions.length !== stmt.consequent.body.length) return null;
+      thenAction = actions.length === 1 ? actions[0] : `$action.seq(${actions.join(", ")})`;
+    } else if (t6.isExpressionStatement(stmt.consequent)) {
+      thenAction = expressionToActionAtom(stmt.consequent.expression);
+    }
+    if (!thenAction) return null;
+    let elseAction = null;
+    if (stmt.alternate) {
+      if (t6.isBlockStatement(stmt.alternate)) {
+        const actions = stmt.alternate.body.map((s) => statementToAction(s)).filter(Boolean);
+        if (actions.length !== stmt.alternate.body.length) return null;
+        elseAction = actions.length === 1 ? actions[0] : `$action.seq(${actions.join(", ")})`;
+      } else if (t6.isIfStatement(stmt.alternate)) {
+        elseAction = statementToAction(stmt.alternate);
+      } else if (t6.isExpressionStatement(stmt.alternate)) {
+        elseAction = expressionToActionAtom(stmt.alternate.expression);
+      }
+      if (!elseAction) return null;
+    }
+    return elseAction ? `$action.when(${condition}, ${thenAction}, ${elseAction})` : `$action.when(${condition}, ${thenAction})`;
+  }
+  return null;
+}
+function decomposeHandlerToSeq(node) {
+  if (t6.isArrowFunctionExpression(node) && t6.isExpression(node.body)) {
+    return expressionToActionAtom(node.body);
+  }
+  const body = node.body;
+  if (!t6.isBlockStatement(body)) return null;
+  const actions = [];
+  for (const stmt of body.body) {
+    const action = statementToAction(stmt);
+    if (!action) return null;
+    actions.push(action);
+  }
+  if (actions.length === 0) return null;
+  if (actions.length === 1) return actions[0];
+  return `$action.seq(${actions.join(", ")})`;
+}
+function extractComponents(path, state) {
+  const arg = path.node.argument;
+  if (!arg) return;
+  const compilerState = state;
+  if (compilerState.fields && compilerState.fields.length > 0) {
+    initLocalFieldMaps(compilerState.fields);
+  }
+  let experienceNode = null;
+  if (t6.isJSXElement(arg)) {
+    experienceNode = jsxToExperienceNode(arg);
+  } else if (t6.isJSXFragment(arg)) {
+    experienceNode = jsxToExperienceNode(arg);
+  }
+  if (experienceNode) {
+    compilerState.experience = experienceNode;
+  }
+}
+
+// src/babel/extractors/during-extractor.ts
+import * as t7 from "@babel/types";
+var duringIdCounter = 0;
+function resetDuringIdCounter() {
+  duringIdCounter = 0;
+}
+function analyzeCallbackBody2(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;
+        const arg1 = args[1];
+        if (field !== void 0 && !t7.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 = t7.isStringLiteral(args[0]) ? args[0].value : void 0;
+        const arg1 = args[1];
+        if (key !== void 0 && !t7.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 (!t7.isArgumentPlaceholder(arg0)) {
+          actions.push({
+            id: `auto_${++actionCounter.value}`,
+            type: "set_field",
+            mode: "auto",
+            config: { field: fieldName, value: extractValue2(arg0) }
+          });
+        }
+      }
+    } 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) {
+        const arg0 = expr.arguments[0];
+        if (!t7.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 (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.isArrayExpression(node)) {
+    return node.elements.map((el) => el && t7.isExpression(el) ? extractValue2(el) : null);
+  }
+  if (t7.isObjectExpression(node)) {
+    const obj = {};
+    node.properties.forEach((prop) => {
+      if (t7.isObjectProperty(prop) && t7.isIdentifier(prop.key) && t7.isExpression(prop.value)) {
+        obj[prop.key.name] = extractValue2(prop.value);
+      }
+    });
+    return obj;
+  }
+  return generateCode2(node);
+}
+function generateCode2(node) {
+  if (t7.isIdentifier(node)) return node.name;
+  if (t7.isNumericLiteral(node)) return String(node.value);
+  if (t7.isStringLiteral(node)) return `"${node.value}"`;
+  if (t7.isBooleanLiteral(node)) return String(node.value);
+  if (t7.isNullLiteral(node)) return "null";
+  if (t7.isBinaryExpression(node)) {
+    return `(${generateCode2(node.left)} ${node.operator} ${generateCode2(node.right)})`;
+  }
+  if (t7.isLogicalExpression(node)) {
+    return `(${generateCode2(node.left)} ${node.operator} ${generateCode2(node.right)})`;
+  }
+  if (t7.isConditionalExpression(node)) {
+    return `(${generateCode2(node.test)} ? ${generateCode2(node.consequent)} : ${generateCode2(node.alternate)})`;
+  }
+  if (t7.isUnaryExpression(node) && node.prefix) {
+    return `${node.operator}${generateCode2(node.argument)}`;
+  }
+  if (t7.isCallExpression(node) && t7.isMemberExpression(node.callee) && t7.isIdentifier(node.callee.object) && node.callee.object.name === "Date" && t7.isIdentifier(node.callee.property) && node.callee.property.name === "now") {
+    return "now()";
+  }
+  if (t7.isMemberExpression(node)) {
+    const obj = generateCode2(node.object);
+    if (node.computed) {
+      return `${obj}[${generateCode2(node.property)}]`;
+    }
+    const prop = t7.isIdentifier(node.property) ? node.property.name : "[property]";
+    return `${obj}.${prop}`;
+  }
+  if (t7.isCallExpression(node)) {
+    if (t7.isIdentifier(node.callee)) {
+      const args = node.arguments.map((a) => generateCode2(a)).join(", ");
+      return `${node.callee.name}(${args})`;
+    }
+    if (t7.isMemberExpression(node.callee)) {
+      const obj = generateCode2(node.callee.object);
+      const prop = t7.isIdentifier(node.callee.property) ? node.callee.property.name : "[method]";
+      const args = node.arguments.map((a) => generateCode2(a)).join(", ");
+      return `${obj}.${prop}(${args})`;
+    }
+  }
+  if (t7.isArrowFunctionExpression(node) || t7.isFunctionExpression(node)) {
+    if (t7.isArrowFunctionExpression(node) && t7.isExpression(node.body)) {
+      const params = node.params;
+      if (params.length === 1 && t7.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]";
+  }
+  if (t7.isTemplateLiteral(node)) {
+    return node.quasis.map((q, i) => {
+      const raw = q.value.raw;
+      if (i < node.expressions.length) return raw + "${" + generateCode2(node.expressions[i]) + "}";
+      return raw;
+    }).join("");
+  }
+  if (t7.isArrayExpression(node)) {
+    const elements = node.elements.map((el) => el ? generateCode2(el) : "undefined").join(", ");
+    return `[${elements}]`;
+  }
+  if (t7.isObjectExpression(node)) {
+    const props = node.properties.map((p) => {
+      if (t7.isObjectProperty(p)) {
+        const key = t7.isIdentifier(p.key) ? p.key.name : t7.isStringLiteral(p.key) ? `"${p.key.value}"` : "[key]";
+        if (p.shorthand && t7.isIdentifier(p.value)) return key;
+        return `${key}: ${generateCode2(p.value)}`;
+      }
+      if (t7.isSpreadElement(p)) return `...${generateCode2(p.argument)}`;
+      return "";
+    }).filter(Boolean).join(", ");
+    return `{ ${props} }`;
+  }
+  if (t7.isTSAsExpression(node)) return generateCode2(node.expression);
+  if (t7.isTSNonNullExpression(node)) return generateCode2(node.expression);
+  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 (!t7.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 (!t7.isStringLiteral(stateArg)) return;
+  const stateName = stateArg.value;
+  let intervalMs = 1e3;
+  if (t7.isNumericLiteral(intervalArg)) {
+    intervalMs = intervalArg.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.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 t8 from "@babel/types";
+var watcherIdCounter = 0;
+function resetWatcherIdCounter() {
+  watcherIdCounter = 0;
+}
+function analyzeCallbackBody3(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: extractValue3(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: 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 (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: extractValue3(expr.arguments[0]) }
+        });
+      }
+    }
+  }
+  return actions;
+}
+function extractValue3(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;
+  if (t8.isTemplateLiteral(node)) {
+    return node.quasis.map((q, i) => {
+      const raw = q.value.raw;
+      if (i < node.expressions.length) {
+        const expr = node.expressions[i];
+        return raw + "${" + (t8.isIdentifier(expr) ? expr.name : "[expr]") + "}";
+      }
+      return raw;
+    }).join("");
+  }
+  if (t8.isArrayExpression(node)) {
+    return node.elements.map((el) => el && t8.isExpression(el) ? extractValue3(el) : null);
+  }
+  if (t8.isObjectExpression(node)) {
+    const obj = {};
+    node.properties.forEach((prop) => {
+      if (t8.isObjectProperty(prop) && t8.isIdentifier(prop.key) && t8.isExpression(prop.value)) {
+        obj[prop.key.name] = extractValue3(prop.value);
+      }
+    });
+    return obj;
+  }
+  if (t8.isMemberExpression(node)) {
+    const obj = t8.isIdentifier(node.object) ? node.object.name : "[object]";
+    const prop = t8.isIdentifier(node.property) ? node.property.name : "[property]";
+    return `${obj}.${prop}`;
+  }
+  if (t8.isConditionalExpression(node)) {
+    return `(${extractValue3(node.test)} ? ${extractValue3(node.consequent)} : ${extractValue3(node.alternate)})`;
+  }
+  if (t8.isBinaryExpression(node)) {
+    return `(${extractValue3(node.left)} ${node.operator} ${extractValue3(node.right)})`;
+  }
+  if (t8.isLogicalExpression(node)) {
+    return `(${extractValue3(node.left)} ${node.operator} ${extractValue3(node.right)})`;
+  }
+  if (t8.isTSAsExpression(node)) return extractValue3(node.expression);
+  if (t8.isTSNonNullExpression(node)) return extractValue3(node.expression);
+  return "[Expression]";
+}
+function extractChangeWatcher(path, state) {
+  const callee = path.node.callee;
+  if (!t8.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 (!t8.isStringLiteral(fieldArg)) return;
+  const field = fieldArg.value;
+  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 = 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/computed-extractor.ts
+import * as t9 from "@babel/types";
+function expressionToString(node) {
+  if (t9.isIdentifier(node)) return node.name;
+  if (t9.isNumericLiteral(node)) return String(node.value);
+  if (t9.isStringLiteral(node)) return `"${node.value}"`;
+  if (t9.isBooleanLiteral(node)) return String(node.value);
+  if (t9.isNullLiteral(node)) return "null";
+  if (t9.isTemplateLiteral(node)) {
+    return node.quasis.map((q, i) => {
+      const raw = q.value.raw;
+      if (i < node.expressions.length) {
+        const expr = node.expressions[i];
+        return raw + "${" + expressionToString(expr) + "}";
+      }
+      return raw;
+    }).join("");
+  }
+  if (t9.isBinaryExpression(node)) {
+    return `${expressionToString(node.left)} ${node.operator} ${expressionToString(node.right)}`;
+  }
+  if (t9.isLogicalExpression(node)) {
+    return `${expressionToString(node.left)} ${node.operator} ${expressionToString(node.right)}`;
+  }
+  if (t9.isConditionalExpression(node)) {
+    return `${expressionToString(node.test)} ? ${expressionToString(node.consequent)} : ${expressionToString(node.alternate)}`;
+  }
+  if (t9.isMemberExpression(node) && !node.computed) {
+    return `${expressionToString(node.object)}.${expressionToString(node.property)}`;
+  }
+  if (t9.isCallExpression(node)) {
+    const callee = expressionToString(node.callee);
+    const args = node.arguments.map((a) => expressionToString(a)).join(", ");
+    return `${callee}(${args})`;
+  }
+  if (t9.isUnaryExpression(node)) {
+    return `${node.operator}${expressionToString(node.argument)}`;
+  }
+  if (t9.isParenthesizedExpression(node)) {
+    return `(${expressionToString(node.expression)})`;
+  }
+  return "[Expression]";
+}
+function inferComputedType(body) {
+  if (t9.isNumericLiteral(body) || t9.isBinaryExpression(body)) return "number";
+  if (t9.isStringLiteral(body) || t9.isTemplateLiteral(body)) return "text";
+  if (t9.isBooleanLiteral(body) || t9.isLogicalExpression(body)) return "boolean";
+  if (t9.isArrayExpression(body)) return "json";
+  if (t9.isObjectExpression(body)) return "json";
+  return "text";
+}
+function extractStringArray(node) {
+  if (!t9.isArrayExpression(node)) return [];
+  return node.elements.filter((el) => t9.isStringLiteral(el)).map((el) => el.value);
+}
+function extractComputed(path, state) {
+  const callee = path.node.callee;
+  if (!t9.isIdentifier(callee) || callee.name !== "useComputed") return;
+  const args = path.node.arguments;
+  if (args.length < 2) return;
+  const nameArg = args[0];
+  if (!t9.isStringLiteral(nameArg)) return;
+  const fieldName = nameArg.value;
+  const computeArg = args[1];
+  if (!t9.isArrowFunctionExpression(computeArg) && !t9.isFunctionExpression(computeArg)) return;
+  let expression;
+  let returnType = "text";
+  if (t9.isExpression(computeArg.body) && !t9.isBlockStatement(computeArg.body)) {
+    expression = expressionToString(computeArg.body);
+    returnType = inferComputedType(computeArg.body);
+  } else if (t9.isBlockStatement(computeArg.body)) {
+    const returnStmt = computeArg.body.body.find(
+      (s) => t9.isReturnStatement(s)
+    );
+    if (returnStmt?.argument) {
+      expression = expressionToString(returnStmt.argument);
+      returnType = inferComputedType(returnStmt.argument);
+    } else {
+      expression = "[Expression]";
+    }
+  } else {
+    expression = "[Expression]";
+  }
+  let mode = "read-time";
+  let deps = [];
+  let staleness;
+  let rlsStalenessOk;
+  let explicitType;
+  if (args.length >= 3 && t9.isObjectExpression(args[2])) {
+    const optObj = args[2];
+    for (const prop of optObj.properties) {
+      if (!t9.isObjectProperty(prop) || !t9.isIdentifier(prop.key)) continue;
+      switch (prop.key.name) {
+        case "mode":
+          if (t9.isStringLiteral(prop.value)) {
+            const modeVal = prop.value.value;
+            if (modeVal === "read-time" || modeVal === "transaction-maintained" || modeVal === "async-materialized") {
+              mode = modeVal;
+            }
+          }
+          break;
+        case "deps":
+          deps = extractStringArray(prop.value);
+          break;
+        case "staleness":
+          if (t9.isStringLiteral(prop.value)) {
+            staleness = prop.value.value;
+          }
+          break;
+        case "rlsStalenessOk":
+          if (t9.isBooleanLiteral(prop.value)) {
+            rlsStalenessOk = prop.value.value;
+          }
+          break;
+        case "type":
+          if (t9.isStringLiteral(prop.value)) {
+            explicitType = prop.value.value;
+          }
+          break;
+      }
+    }
+  }
+  let varName = fieldName;
+  const parent = path.parentPath;
+  if (parent?.isVariableDeclarator() && t9.isIdentifier(parent.node.id)) {
+    varName = parent.node.id.name;
+  }
+  const compilerState = state;
+  const fieldDef = {
+    name: fieldName,
+    type: explicitType || returnType,
+    computed: expression,
+    computed_deps: deps.length > 0 ? deps : void 0
+  };
+  fieldDef.computed_mode = mode;
+  if (staleness !== void 0) {
+    fieldDef.computed_staleness = staleness;
+  }
+  if (rlsStalenessOk !== void 0) {
+    fieldDef.rls_staleness_tolerance = rlsStalenessOk;
+  }
+  compilerState.fields.push(fieldDef);
+  if (!compilerState.metadata) compilerState.metadata = {};
+  const meta = compilerState.metadata;
+  if (!meta.computedFields) meta.computedFields = [];
+  meta.computedFields.push({
+    name: fieldName,
+    varName,
+    expression,
+    deps,
+    mode,
+    type: explicitType || returnType,
+    staleness,
+    rlsStalenessOk
+  });
+}
+
+// src/babel/extractors/transition-effect-extractor.ts
+import * as t10 from "@babel/types";
+var transitionEffectIdCounter = 0;
+function resetTransitionEffectIdCounter() {
+  transitionEffectIdCounter = 0;
+}
+function analyzeCallbackBody4(body, actionCounter) {
+  const actions = [];
+  for (const statement of body) {
+    if (!t10.isExpressionStatement(statement)) continue;
+    const expr = statement.expression;
+    if (t10.isCallExpression(expr) && t10.isIdentifier(expr.callee)) {
+      const calleeName = expr.callee.name;
+      const args = expr.arguments;
+      if (calleeName === "setField" && args.length >= 2) {
+        const field = t10.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 = t10.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 (t10.isCallExpression(expr)) {
+      const callee = expr.callee;
+      if (t10.isMemberExpression(callee) && t10.isIdentifier(callee.object) && callee.object.name === "console" && t10.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 (t10.isNumericLiteral(node)) return node.value;
+  if (t10.isStringLiteral(node)) return node.value;
+  if (t10.isBooleanLiteral(node)) return node.value;
+  if (t10.isNullLiteral(node)) return null;
+  if (t10.isIdentifier(node)) return node.name;
+  if (t10.isArrayExpression(node)) {
+    return node.elements.map((el) => el && t10.isExpression(el) ? extractValue4(el) : null);
+  }
+  if (t10.isObjectExpression(node)) {
+    const obj = {};
+    node.properties.forEach((prop) => {
+      if (t10.isObjectProperty(prop) && t10.isIdentifier(prop.key) && t10.isExpression(prop.value)) {
+        obj[prop.key.name] = extractValue4(prop.value);
+      }
+    });
+    return obj;
+  }
+  if (t10.isMemberExpression(node)) {
+    const obj = t10.isIdentifier(node.object) ? node.object.name : "[object]";
+    const prop = t10.isIdentifier(node.property) ? node.property.name : "[property]";
+    return `${obj}.${prop}`;
+  }
+  if (t10.isConditionalExpression(node)) {
+    return `(${extractValue4(node.test)} ? ${extractValue4(node.consequent)} : ${extractValue4(node.alternate)})`;
+  }
+  if (t10.isTSAsExpression(node)) return extractValue4(node.expression);
+  if (t10.isTSNonNullExpression(node)) return extractValue4(node.expression);
+  return "[Expression]";
+}
+function extractTransitionEffect(path, state) {
+  const callee = path.node.callee;
+  if (!t10.isIdentifier(callee) || callee.name !== "useOnTransition") return;
+  const args = path.node.arguments;
+  if (args.length < 1) return;
+  const callbackArg = args[0];
+  let callbackBody = [];
+  if (t10.isArrowFunctionExpression(callbackArg) || t10.isFunctionExpression(callbackArg)) {
+    const body = callbackArg.body;
+    if (t10.isBlockStatement(body)) {
+      callbackBody = body.body;
+    } else if (t10.isExpression(body)) {
+      callbackBody = [t10.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 t11 from "@babel/types";
+function tsTypeToFieldType(typeAnnotation) {
+  if (!typeAnnotation) return "text";
+  const annotation = typeAnnotation.typeAnnotation;
+  return resolveType(annotation);
+}
+var KNOWN_TYPE_REFS2 = {
+  Date: "datetime",
+  Record: "json",
+  Map: "json",
+  Set: "json",
+  URL: "url"
+};
+function typeNameToSlug2(name) {
+  return name.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "");
+}
+function resolveType(annotation) {
+  if (t11.isTSStringKeyword(annotation)) return "text";
+  if (t11.isTSNumberKeyword(annotation)) return "number";
+  if (t11.isTSBooleanKeyword(annotation)) return "boolean";
+  if (t11.isTSTypeReference(annotation) && t11.isIdentifier(annotation.typeName)) {
+    const typeName = annotation.typeName.name;
+    if (KNOWN_TYPE_REFS2[typeName]) return KNOWN_TYPE_REFS2[typeName];
+    if (typeName === "Array") return "multi_select";
+    return typeNameToSlug2(typeName);
+  }
+  if (t11.isTSArrayType(annotation)) {
+    return "multi_select";
+  }
+  if (t11.isTSUnionType(annotation)) {
+    const allLiterals = annotation.types.every(
+      (t22) => t11.isTSLiteralType(t22) && (t11.isStringLiteral(t22.literal) || t11.isNumericLiteral(t22.literal))
+    );
+    if (allLiterals) return "select";
+    return "text";
+  }
+  if (t11.isTSLiteralType(annotation) && t11.isStringLiteral(annotation.literal)) return "text";
+  if (t11.isTSLiteralType(annotation) && t11.isNumericLiteral(annotation.literal)) return "number";
+  return "text";
+}
+function extractUnionOptions(annotation) {
+  if (!t11.isTSUnionType(annotation)) return void 0;
+  const options = [];
+  for (const member of annotation.types) {
+    if (t11.isTSLiteralType(member) && t11.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 {};
+    // Custom Element-based field types (email, currency, etc.) default to null
+    default:
+      return null;
+  }
+}
+function extractFieldsFromInterface(declaration) {
+  const fields = [];
+  for (const member of declaration.body.body) {
+    if (!t11.isTSPropertySignature(member)) continue;
+    if (!t11.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 (!t11.isObjectProperty(prop)) continue;
+    if (!t11.isIdentifier(prop.key) && !t11.isStringLiteral(prop.key)) continue;
+    if (!t11.isObjectExpression(prop.value)) continue;
+    const name = t11.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 (!t11.isObjectProperty(prop)) continue;
+    if (!t11.isIdentifier(prop.key) && !t11.isStringLiteral(prop.key)) continue;
+    const hookName = t11.isIdentifier(prop.key) ? prop.key.name : prop.key.value;
+    const hookConfig = t11.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 (!t11.isObjectProperty(prop)) continue;
+    const key = t11.isIdentifier(prop.key) ? prop.key.name : t11.isStringLiteral(prop.key) ? prop.key.value : null;
+    if (!key) continue;
+    obj[key] = extractNodeValue(prop.value);
+  }
+  return obj;
+}
+function extractNodeValue(node) {
+  if (t11.isStringLiteral(node)) return node.value;
+  if (t11.isNumericLiteral(node)) return node.value;
+  if (t11.isBooleanLiteral(node)) return node.value;
+  if (t11.isNullLiteral(node)) return null;
+  if (t11.isArrayExpression(node)) {
+    return node.elements.map((el) => {
+      if (!el) return null;
+      if (t11.isSpreadElement(el)) return "[Spread]";
+      return extractNodeValue(el);
+    });
+  }
+  if (t11.isObjectExpression(node)) {
+    return extractObjectLiteral(node);
+  }
+  if (t11.isTemplateLiteral(node)) {
+    return node.quasis.map((q) => q.value.raw).join("${}");
+  }
+  if (t11.isIdentifier(node)) {
+    if (node.name === "undefined") return void 0;
+    return node.name;
+  }
+  if (t11.isConditionalExpression(node)) {
+    return `(${extractNodeValue(node.test)} ? ${extractNodeValue(node.consequent)} : ${extractNodeValue(node.alternate)})`;
+  }
+  if (t11.isBinaryExpression(node)) {
+    return `(${extractNodeValue(node.left)} ${node.operator} ${extractNodeValue(node.right)})`;
+  }
+  if (t11.isLogicalExpression(node)) {
+    return `(${extractNodeValue(node.left)} ${node.operator} ${extractNodeValue(node.right)})`;
+  }
+  if (t11.isMemberExpression(node)) {
+    const obj = t11.isIdentifier(node.object) ? node.object.name : "[object]";
+    const prop = t11.isIdentifier(node.property) ? node.property.name : "[property]";
+    return `${obj}.${prop}`;
+  }
+  if (t11.isTSAsExpression(node)) return extractNodeValue(node.expression);
+  if (t11.isTSNonNullExpression(node)) return extractNodeValue(node.expression);
+  return "[Expression]";
+}
+function isModelFile(path, filename) {
+  if (filename && /\/models\//.test(filename)) return true;
+  let hasInterface = false;
+  let hasTransitions = false;
+  let hasDefineModel = false;
+  for (const node of path.node.body) {
+    if (t11.isExportDefaultDeclaration(node)) {
+      const decl = node.declaration;
+      if (t11.isCallExpression(decl) && t11.isIdentifier(decl.callee) && decl.callee.name === "defineModel") {
+        hasDefineModel = true;
+      }
+    }
+    if (t11.isExportNamedDeclaration(node)) {
+      if (t11.isTSInterfaceDeclaration(node.declaration)) {
+        hasInterface = true;
+      }
+      if (t11.isVariableDeclaration(node.declaration)) {
+        for (const decl of node.declaration.declarations) {
+          if (t11.isIdentifier(decl.id) && decl.id.name === "transitions") {
+            hasTransitions = true;
+          }
+        }
+      }
+    }
+  }
+  return hasDefineModel || hasInterface && hasTransitions;
+}
+function modelTypeToIRType(modelType) {
+  switch (modelType) {
+    case "string":
+      return "text";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "date":
+      return "date";
+    case "array":
+      return "multi_select";
+    case "json":
+      return "json";
+    case "file":
+      return "file";
+    case "relation":
+      return "relation";
+    default:
+      return modelType;
+  }
+}
+function modelStateTypeToIR(type) {
+  if (type === "initial") return "START";
+  if (type === "final") return "END";
+  return "REGULAR";
+}
+function extractDefineModelCall(programPath, compilerState, actionCounter) {
+  for (const node of programPath.node.body) {
+    if (!t11.isExportDefaultDeclaration(node)) continue;
+    const decl = node.declaration;
+    if (!t11.isCallExpression(decl)) continue;
+    if (!t11.isIdentifier(decl.callee) || decl.callee.name !== "defineModel") continue;
+    if (decl.arguments.length === 0 || !t11.isObjectExpression(decl.arguments[0])) continue;
+    const config = extractObjectLiteral(decl.arguments[0]);
+    if (config.slug) compilerState.metadata.slug = String(config.slug);
+    if (config.version) compilerState.metadata.version = String(config.version);
+    if (config.category) {
+      if (Array.isArray(config.category)) {
+        compilerState.metadata.category = String(config.category[0]);
+        compilerState.metadata.categoryArray = config.category;
+      } else {
+        compilerState.metadata.category = String(config.category);
+      }
+    }
+    if (config.description) compilerState.metadata.description = String(config.description);
+    if (config.fields && typeof config.fields === "object" && !Array.isArray(config.fields)) {
+      const fieldsObj = config.fields;
+      for (const [name, fieldConfig] of Object.entries(fieldsObj)) {
+        const irType = modelTypeToIRType(String(fieldConfig.type || "text"));
+        const field = {
+          name,
+          type: irType,
+          required: fieldConfig.required === true,
+          default_value: fieldConfig.default !== void 0 ? fieldConfig.default : extractDefaultValue2(irType)
+        };
+        if (fieldConfig.enum && Array.isArray(fieldConfig.enum)) {
+          field.validation = { options: fieldConfig.enum.map(String) };
+        }
+        compilerState.fields.push(field);
+      }
+    }
+    if (config.states && typeof config.states === "object" && !Array.isArray(config.states)) {
+      const statesObj = config.states;
+      for (const [name, stateConfig] of Object.entries(statesObj)) {
+        const stateType = modelStateTypeToIR(stateConfig.type);
+        if (!compilerState.states.has(name)) {
+          compilerState.states.set(name, {
+            name,
+            type: stateType,
+            description: stateConfig.description,
+            on_enter: [],
+            during: [],
+            on_exit: []
+          });
+        } else {
+          compilerState.states.get(name).type = stateType;
+        }
+      }
+    }
+    if (config.transitions && typeof config.transitions === "object" && !Array.isArray(config.transitions)) {
+      const transObj = config.transitions;
+      for (const [name, transConfig] of Object.entries(transObj)) {
+        let from = [];
+        if (typeof transConfig.from === "string") {
+          from = [transConfig.from];
+        } else if (Array.isArray(transConfig.from)) {
+          from = transConfig.from.map(String);
+        }
+        const to = String(transConfig.to || "");
+        for (const f of from) {
+          if (!compilerState.states.has(f)) {
+            compilerState.states.set(f, {
+              name: f,
+              type: "REGULAR",
+              on_enter: [],
+              during: [],
+              on_exit: []
+            });
+          }
+        }
+        if (to && !compilerState.states.has(to)) {
+          compilerState.states.set(to, {
+            name: to,
+            type: "REGULAR",
+            on_enter: [],
+            during: [],
+            on_exit: []
+          });
+        }
+        const conditions = [];
+        if (transConfig.guard) {
+          conditions.push(parseGuardExpression(String(transConfig.guard)));
+        }
+        compilerState.transitions.push({
+          name,
+          from,
+          to,
+          description: transConfig.description,
+          conditions: conditions.length > 0 ? conditions : void 0,
+          actions: [],
+          roles: transConfig.roles,
+          auto: transConfig.auto,
+          required_fields: transConfig.required_fields
+        });
+      }
+    }
+    if (config.roles && typeof config.roles === "object" && !Array.isArray(config.roles)) {
+      const rolesObj = config.roles;
+      if (!compilerState.metadata.roles) compilerState.metadata.roles = {};
+      for (const [roleName, roleConfig] of Object.entries(rolesObj)) {
+        compilerState.metadata.roles[roleName] = {
+          description: roleConfig.description,
+          permissions: roleConfig.permissions
+        };
+      }
+    }
+    if (config.metadata && typeof config.metadata === "object") {
+      compilerState.metadata.modelMetadata = config.metadata;
+    }
+    return true;
+  }
+  return false;
+}
+function extractModelFile(path, state) {
+  const compilerState = state;
+  if (!compilerState.actionCounter) compilerState.actionCounter = 0;
+  const actionCounter = { value: compilerState.actionCounter };
+  const foundDefineModel = extractDefineModelCall(path, compilerState, actionCounter);
+  if (foundDefineModel) {
+    for (const node of path.node.body) {
+      if (t11.isExportNamedDeclaration(node) && t11.isTSInterfaceDeclaration(node.declaration)) {
+        const interfaceFields = extractFieldsFromInterface(node.declaration);
+        for (const iField of interfaceFields) {
+          const existing = compilerState.fields.find((f) => f.name === iField.name);
+          if (existing) {
+            if (iField.required) existing.required = true;
+          }
+        }
+        if (!compilerState.metadata.name) {
+          compilerState.metadata.name = node.declaration.id.name;
+        }
+      }
+    }
+    compilerState.actionCounter = actionCounter.value;
+    return;
+  }
+  let interfaceName = "";
+  for (const node of path.node.body) {
+    if (!t11.isExportNamedDeclaration(node)) continue;
+    const declaration = node.declaration;
+    if (t11.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 (t11.isVariableDeclaration(declaration)) {
+      for (const decl of declaration.declarations) {
+        if (!t11.isIdentifier(decl.id) || !decl.init) continue;
+        const varName = decl.id.name;
+        if (varName === "transitions" && t11.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 === "states") {
+          const arrExpr = t11.isTSAsExpression(decl.init) ? decl.init.expression : decl.init;
+          if (t11.isArrayExpression(arrExpr)) {
+            for (const el of arrExpr.elements) {
+              if (!t11.isObjectExpression(el)) continue;
+              let stateName = "";
+              let stateType = "REGULAR";
+              let stateDesc = "";
+              for (const prop of el.properties) {
+                if (!t11.isObjectProperty(prop) || !t11.isIdentifier(prop.key)) continue;
+                if (prop.key.name === "name" && t11.isStringLiteral(prop.value)) {
+                  stateName = prop.value.value;
+                } else if (prop.key.name === "type") {
+                  const val = t11.isTSAsExpression(prop.value) ? prop.value.expression : prop.value;
+                  if (t11.isStringLiteral(val)) stateType = val.value;
+                } else if (prop.key.name === "description" && t11.isStringLiteral(prop.value)) {
+                  stateDesc = prop.value.value;
+                }
+              }
+              if (stateName && !compilerState.states.has(stateName)) {
+                compilerState.states.set(stateName, {
+                  name: stateName,
+                  type: stateType,
+                  description: stateDesc || void 0,
+                  on_enter: [],
+                  during: [],
+                  on_exit: []
+                });
+              } else if (stateName) {
+                compilerState.states.get(stateName).type = stateType;
+              }
+            }
+          }
+        }
+        if (varName === "endStates" && t11.isArrayExpression(decl.init)) {
+          for (const el of decl.init.elements) {
+            if (t11.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" && t11.isArrayExpression(decl.init)) {
+          for (const el of decl.init.elements) {
+            if (t11.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" && t11.isObjectExpression(decl.init)) {
+          extractHooksFromObject(decl.init, compilerState.states, actionCounter);
+        }
+        if (varName === "runtime" && t11.isStringLiteral(decl.init)) {
+          compilerState.metadata.runtime = decl.init.value;
+        }
+        if (varName === "fieldOptions" && t11.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 t12 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 (t12.isExportNamedDeclaration(node)) {
+      const decl = node.declaration;
+      if (t12.isFunctionDeclaration(decl) && decl.id) {
+        const action = extractFunctionAction(decl);
+        if (action) {
+          const comments = node.leadingComments || decl.leadingComments || [];
+          action.description = extractDescription(comments);
+          serverActions.push(action);
+        }
+      }
+      if (t12.isVariableDeclaration(decl)) {
+        for (const varDecl of decl.declarations) {
+          if (!t12.isIdentifier(varDecl.id)) continue;
+          const init = varDecl.init;
+          if (t12.isArrowFunctionExpression(init) || t12.isFunctionExpression(init)) {
+            const action = {
+              name: varDecl.id.name,
+              async: init.async || false,
+              params: init.params.filter((p) => t12.isIdentifier(p)).map((p) => p.name)
+            };
+            if (init.params.length > 0) {
+              const firstParam = init.params[0];
+              if (t12.isIdentifier(firstParam) && firstParam.typeAnnotation) {
+                action.contextType = extractTypeName(firstParam.typeAnnotation);
+              }
+            }
+            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) => t12.isIdentifier(p)).map((p) => p.name)
+  };
+  if (decl.params.length > 0) {
+    const firstParam = decl.params[0];
+    if (t12.isIdentifier(firstParam) && firstParam.typeAnnotation) {
+      action.contextType = extractTypeName(firstParam.typeAnnotation);
+    }
+  }
+  return action;
+}
+function extractTypeName(annotation) {
+  if (t12.isTSTypeAnnotation(annotation)) {
+    const typeNode = annotation.typeAnnotation;
+    if (t12.isTSTypeReference(typeNode) && t12.isIdentifier(typeNode.typeName)) {
+      return typeNode.typeName.name;
+    }
+  }
+  return void 0;
+}
+function extractDescription(comments) {
+  for (const comment of comments) {
+    if (comment.type !== "CommentBlock") continue;
+    const lines = comment.value.split("\n");
+    for (const line of lines) {
+      const trimmed = line.replace(/^\s*\*\s?/, "").trim();
+      if (trimmed && !trimmed.startsWith("@")) {
+        return trimmed;
+      }
+    }
+  }
+  return void 0;
+}
+
+// src/babel/extractors/server-action-hook-extractor.ts
+import * as t13 from "@babel/types";
+function extractServerActionHook(path, state) {
+  const args = path.node.arguments;
+  if (args.length < 1) return;
+  const nameArg = args[0];
+  if (!t13.isStringLiteral(nameArg)) return;
+  const compilerState = state;
+  const entry = {
+    name: nameArg.value
+  };
+  if (args.length > 1 && t13.isObjectExpression(args[1])) {
+    for (const prop of args[1].properties) {
+      if (!t13.isObjectProperty(prop) || !t13.isIdentifier(prop.key)) continue;
+      if (prop.key.name === "instanceId" && t13.isStringLiteral(prop.value)) {
+        entry.staticInstanceId = prop.value.value;
+      }
+    }
+  }
+  const parent = path.parentPath;
+  if (parent?.isVariableDeclarator() && t13.isIdentifier(parent.node.id)) {
+    entry.variableName = parent.node.id.name;
+  }
+  if (!compilerState.metadata) compilerState.metadata = {};
+  const meta = compilerState.metadata;
+  if (!meta.serverActionHooks) meta.serverActionHooks = [];
+  meta.serverActionHooks.push(entry);
+}
+
+// src/babel/extractors/server-state-extractor.ts
+import * as t14 from "@babel/types";
+function extractServerState(path, state) {
+  const args = path.node.arguments;
+  if (args.length < 1) return;
+  const compilerState = state;
+  const entry = {};
+  const instanceArg = args[0];
+  if (t14.isStringLiteral(instanceArg)) {
+    entry.staticInstanceId = instanceArg.value;
+  }
+  if (args.length > 1 && t14.isObjectExpression(args[1])) {
+    for (const prop of args[1].properties) {
+      if (!t14.isObjectProperty(prop) || !t14.isIdentifier(prop.key)) continue;
+      if (prop.key.name === "enabled" && t14.isBooleanLiteral(prop.value)) {
+        if (!prop.value.value) entry.disabled = true;
+      }
+    }
+  }
+  const parent = path.parentPath;
+  if (parent?.isVariableDeclarator()) {
+    if (t14.isIdentifier(parent.node.id)) {
+      entry.variableName = parent.node.id.name;
+    } else if (t14.isObjectPattern(parent.node.id)) {
+      const props = parent.node.id.properties.filter((p) => t14.isObjectProperty(p) && t14.isIdentifier(p.key)).map((p) => p.key.name);
+      if (props.length > 0) {
+        entry.variableName = props.join(", ");
+      }
+    }
+  }
+  if (!compilerState.metadata) compilerState.metadata = {};
+  const meta = compilerState.metadata;
+  if (!meta.serverStateSubscriptions) meta.serverStateSubscriptions = [];
+  meta.serverStateSubscriptions.push(entry);
+  meta.requiresSSE = true;
+}
+
+// src/babel/extractors/grammar-island-extractor.ts
+import * as t15 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 (!t15.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 (t15.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 (!t15.isIdentifier(tag) || !GRAMMAR_TAGS.has(tag.name)) return;
+      let slug = "unnamed";
+      const parent = templatePath.parentPath;
+      if (parent && parent.isVariableDeclarator() && t15.isIdentifier(parent.node.id)) {
+        slug = parent.node.id.name;
+      }
+      if (parent && parent.isObjectProperty() && t15.isIdentifier(parent.node.key)) {
+        slug = parent.node.key.name;
+      }
+      if (parent && parent.isObjectProperty() && t15.isStringLiteral(parent.node.key)) {
+        slug = parent.node.key.value;
+      }
+      extractGrammarIsland(templatePath, state, slug);
+    }
+  });
+}
+
+// src/babel/extractors/context-extractor.ts
+import * as t16 from "@babel/types";
+function hasContextCreation(path) {
+  let found = false;
+  path.traverse({
+    CallExpression(callPath) {
+      if (t16.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 || !t16.isCallExpression(init)) return;
+      if (!t16.isIdentifier(init.callee, { name: "createContext" })) return;
+      if (!t16.isIdentifier(declPath.node.id)) return;
+      const contextName = declPath.node.id.name;
+      contextNames.set(contextName, contextName);
+      const workflow = {
+        name: contextName,
+        fields: [],
+        reducerActions: []
+      };
+      const typeParams = init.typeParameters;
+      if (typeParams && t16.isTSTypeParameterInstantiation(typeParams)) {
+        const typeArg = typeParams.params[0];
+        if (t16.isTSTypeReference(typeArg) && t16.isIdentifier(typeArg.typeName)) {
+          const interfaceName = typeArg.typeName.name;
+          extractFieldsFromInterface2(path, interfaceName, workflow);
+        }
+      }
+      if (init.arguments.length > 0 && t16.isObjectExpression(init.arguments[0])) {
+        workflow.initialState = extractObjectLiteral2(init.arguments[0]);
+      }
+      contextWorkflows.push(workflow);
+    },
+    // Detect useReducer(reducer, initialState) and extract reducer cases
+    CallExpression(callPath) {
+      if (!t16.isIdentifier(callPath.node.callee, { name: "useReducer" })) return;
+      const args = callPath.node.arguments;
+      if (args.length < 1) return;
+      const reducerArg = args[0];
+      if (!t16.isIdentifier(reducerArg)) return;
+      const reducerName = reducerArg.name;
+      const actions = extractReducerActions(path, reducerName);
+      if (contextWorkflows.length > 0) {
+        const lastWorkflow = contextWorkflows[contextWorkflows.length - 1];
+        lastWorkflow.reducerActions = actions;
+        lastWorkflow.reducerName = reducerName;
+      }
+    }
+  });
+  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 (!t16.isIdentifier(ifacePath.node.id, { name: interfaceName })) return;
+      for (const prop of ifacePath.node.body.body) {
+        if (!t16.isTSPropertySignature(prop)) continue;
+        if (!t16.isIdentifier(prop.key)) continue;
+        const field = {
+          name: prop.key.name,
+          type: extractTSType(prop.typeAnnotation),
+          optional: prop.optional || false
+        };
+        workflow.fields.push(field);
+      }
+    }
+  });
+}
+function extractTSType(annotation) {
+  if (!annotation || !t16.isTSTypeAnnotation(annotation)) return "unknown";
+  const typeNode = annotation.typeAnnotation;
+  if (t16.isTSStringKeyword(typeNode)) return "string";
+  if (t16.isTSNumberKeyword(typeNode)) return "number";
+  if (t16.isTSBooleanKeyword(typeNode)) return "boolean";
+  if (t16.isTSArrayType(typeNode)) return `${extractTSTypeNode(typeNode.elementType)}[]`;
+  if (t16.isTSTypeReference(typeNode) && t16.isIdentifier(typeNode.typeName)) return typeNode.typeName.name;
+  return "unknown";
+}
+function extractTSTypeNode(node) {
+  if (t16.isTSStringKeyword(node)) return "string";
+  if (t16.isTSNumberKeyword(node)) return "number";
+  if (t16.isTSBooleanKeyword(node)) return "boolean";
+  if (t16.isTSTypeReference(node) && t16.isIdentifier(node.typeName)) return node.typeName.name;
+  return "unknown";
+}
+function extractReducerActions(path, reducerName) {
+  const actions = [];
+  path.traverse({
+    FunctionDeclaration(funcPath) {
+      if (!funcPath.node.id || funcPath.node.id.name !== reducerName) return;
+      funcPath.traverse({
+        SwitchStatement(switchPath) {
+          for (const switchCase of switchPath.node.cases) {
+            if (!switchCase.test) continue;
+            if (t16.isStringLiteral(switchCase.test)) {
+              actions.push({
+                type: switchCase.test.value
+              });
+            }
+          }
+        }
+      });
+    }
+  });
+  return actions;
+}
+function extractObjectLiteral2(obj) {
+  const result = {};
+  for (const prop of obj.properties) {
+    if (!t16.isObjectProperty(prop) || !t16.isIdentifier(prop.key)) continue;
+    if (t16.isStringLiteral(prop.value)) result[prop.key.name] = prop.value.value;
+    else if (t16.isNumericLiteral(prop.value)) result[prop.key.name] = prop.value.value;
+    else if (t16.isBooleanLiteral(prop.value)) result[prop.key.name] = prop.value.value;
+    else if (t16.isNullLiteral(prop.value)) result[prop.key.name] = null;
+    else if (t16.isArrayExpression(prop.value)) result[prop.key.name] = [];
+    else if (t16.isObjectExpression(prop.value)) result[prop.key.name] = extractObjectLiteral2(prop.value);
+  }
+  return result;
+}
+
+// src/babel/emitters/pure-form-emitter.ts
+import { normalizeCategory } from "@mindmatrix/player-core";
+
+// src/babel/emitters/experience-transform.ts
+function transformToFrontend(node) {
+  const result = {
+    id: node.id
+  };
+  if (node.displayName) {
+    result.displayName = node.displayName;
+  } else if (node.config?.displayName && typeof node.config.displayName === "string") {
+    result.displayName = node.config.displayName;
+  }
+  if (node.experienceId) result.experienceId = node.experienceId;
+  if (node.component) result.component = node.component;
+  if (node.slot) {
+    result.slot = node.slot;
+  } else if (node.config?.slot && typeof node.config.slot === "string") {
+    result.slot = node.config.slot;
+  }
+  if (node.className) {
+    result.className = node.className;
+  } else if (node.config?.className && typeof node.config.className === "string") {
+    result.className = node.config.className;
+  }
+  if (node.style) result.style = node.style;
+  if (node.overrides) result.overrides = node.overrides;
+  if (node.layout) result.layout = node.layout;
+  if (node.dataScope) result.dataScope = node.dataScope;
+  if (node.bindings) result.bindings = node.bindings;
+  if (node.visible_when) result.visible_when = node.visible_when;
+  if (node.config) {
+    const cleaned = { ...node.config };
+    delete cleaned.slot;
+    delete cleaned.className;
+    delete cleaned.displayName;
+    if (Object.keys(cleaned).length > 0) {
+      result.config = cleaned;
+    }
+  }
+  if (node.dataSources && node.dataSources.length > 0) {
+    result.dataSources = node.dataSources.map(transformDataSource);
+  }
+  if (node.children && node.children.length > 0) {
+    result.children = node.children.map(transformToFrontend);
+  }
+  return result;
+}
+function transformDataSource(ds) {
+  const d = ds;
+  switch (ds.type) {
+    case "workflow":
+      return {
+        type: "workflow",
+        name: ds.name,
+        slug: ds.slug,
+        query: ds.query,
+        ...d.instanceId && { instanceId: d.instanceId },
+        ...d.entity !== void 0 && { entity: d.entity },
+        ...ds.paginated !== void 0 && { paginated: ds.paginated },
+        ...ds.pageSize !== void 0 && { pageSize: ds.pageSize },
+        ...d.filter && { filter: d.filter },
+        ...d.filters && { filters: d.filters },
+        ...ds.sort && { sort: ds.sort },
+        ...d.search && { search: d.search },
+        ...ds.searchFields && { searchFields: ds.searchFields },
+        ...ds.facets && { facets: ds.facets },
+        ...d.range && { range: d.range },
+        ...d.aggregate && { aggregate: d.aggregate },
+        ...ds.groupBy && { groupBy: ds.groupBy },
+        ...ds.parentInstanceId && { parentInstanceId: ds.parentInstanceId },
+        ...d.autoStart !== void 0 && { autoStart: d.autoStart },
+        ...d.initialData && { initialData: d.initialData },
+        ...d.includeDefinition !== void 0 && { includeDefinition: d.includeDefinition }
+      };
+    case "api":
+      return {
+        type: "api",
+        name: ds.name,
+        endpoint: ds.endpoint,
+        ...d.method && { method: d.method },
+        ...d.mapping && { mapping: d.mapping },
+        ...d.staleTime !== void 0 && { staleTime: d.staleTime }
+      };
+    case "ref":
+      return {
+        type: "ref",
+        name: ds.name,
+        expression: ds.expression
+      };
+    case "static":
+      return {
+        type: "static",
+        name: ds.name,
+        data: ds.data
+      };
+  }
+}
+
+// src/babel/emitters/pure-form-emitter.ts
+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));
+    if (node.children.length === 1 && node.children[0].component === "Text") {
+      const textChild = node.children[0];
+      const configKeys = textChild.config ? Object.keys(textChild.config).filter((k) => k !== "value") : [];
+      const bindingKeys = textChild.bindings ? Object.keys(textChild.bindings).filter((k) => k !== "value") : [];
+      const isSimple = !textChild.style && !textChild.className && !textChild.children && !textChild.visible_when && configKeys.length === 0 && bindingKeys.length === 0;
+      if (isSimple) {
+        const parentRules = PROP_RULES[node.component || ""];
+        const configKey = parentRules?.config?.text || "text";
+        const bindingKey = parentRules?.bindings?.text || "text";
+        if (textChild.config?.value && !textChild.bindings) {
+          if (!node.config) node.config = {};
+          node.config[configKey] = textChild.config.value;
+          delete node.children;
+        } else if (textChild.bindings?.value && !textChild.config?.value) {
+          if (!node.bindings) node.bindings = {};
+          node.bindings[bindingKey] = textChild.bindings.value;
+          delete node.children;
+        }
+      }
+    }
+  }
+  return node;
+}
+function toSnakeCase2(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 dataSources = extracted.extraMetadata?.dataSources;
+    if (dataSources && dataSources.length > 0) {
+      normalizedView.dataSources = dataSources;
+    }
+    if (fields.length > 0) {
+      const localDefaults = {};
+      for (const f of fields) {
+        localDefaults[toSnakeCase2(f.name)] = f.default_value ?? null;
+      }
+      if (!normalizedView.config) normalizedView.config = {};
+      normalizedView.config.localDefaults = localDefaults;
+    }
+  }
+  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.views = { default: normalizedView };
+    ir.frontendViews = { default: transformToFrontend(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;
+  let categoryArray;
+  if (category.includes("/")) {
+    const [primary, ...tags] = category.split("/");
+    categoryArray = normalizeCategory(primary, ...tags);
+  } else {
+    categoryArray = [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 foldTextContent(node) {
+  if (!node || typeof node !== "object") return node;
+  if (node.children && Array.isArray(node.children)) {
+    node.children = node.children.map((child) => foldTextContent(child));
+    if (node.children.length === 1 && node.children[0].component === "Text") {
+      const textChild = node.children[0];
+      const configKeys = textChild.config ? Object.keys(textChild.config).filter((k) => k !== "value") : [];
+      const bindingKeys = textChild.bindings ? Object.keys(textChild.bindings).filter((k) => k !== "value") : [];
+      const isSimple = !textChild.style && !textChild.className && !textChild.children && !textChild.visible_when && configKeys.length === 0 && bindingKeys.length === 0;
+      if (isSimple) {
+        const parentRules = PROP_RULES[node.component || ""];
+        const configKey = parentRules?.config?.text || "text";
+        const bindingKey = parentRules?.bindings?.text || "text";
+        if (textChild.config?.value && !textChild.bindings) {
+          if (!node.config) node.config = {};
+          node.config[configKey] = textChild.config.value;
+          node.children = void 0;
+        } else if (textChild.bindings?.value && !textChild.config?.value) {
+          if (!node.bindings) node.bindings = {};
+          node.bindings[bindingKey] = textChild.bindings.value;
+          node.children = void 0;
+        }
+      }
+    }
+    if (node.children && node.children.length === 0) {
+      node.children = void 0;
+    }
+  }
+  if (!node.children) delete node.children;
+  return node;
+}
+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: toSnakeCase2(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((t18) => ({
+    name: t18.name,
+    from: t18.from,
+    to: t18.to,
+    description: t18.description || "",
+    roles: t18.roles || [],
+    auto: t18.auto || false,
+    conditions: t18.conditions || [],
+    actions: (t18.actions || []).map(convertAction),
+    required_fields: t18.required_fields || [],
+    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);
+  let views;
+  if (extracted.experience) {
+    const viewRoot = foldTextContent(JSON.parse(JSON.stringify(extracted.experience)));
+    const dataSources = extracted.extraMetadata?.dataSources;
+    if (dataSources && dataSources.length > 0) {
+      viewRoot.dataSources = dataSources;
+    }
+    if (extracted.fields.length > 0) {
+      const localDefaults = {};
+      for (const f of extracted.fields) {
+        localDefaults[toSnakeCase2(f.name)] = f.default_value ?? null;
+      }
+      if (!viewRoot.config) viewRoot.config = {};
+      viewRoot.config.localDefaults = localDefaults;
+    }
+    views = { default: viewRoot };
+  }
+  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 || {},
+    ...views && { views },
+    ...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", "__modelImports", "__modelImportSlugs", "__slugAutoFallback"]);
+  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 resolveSlugArg(args, state) {
+  if (args.length < 1) return null;
+  const slugArg = args[0];
+  if (t17.isStringLiteral(slugArg)) return slugArg.value;
+  if (t17.isIdentifier(slugArg)) {
+    const compilerState = state;
+    const meta = compilerState.metadata;
+    const resolvedSlugs = meta.__modelImportSlugs;
+    if (resolvedSlugs?.[slugArg.name]) return resolvedSlugs[slugArg.name];
+    const importSources = meta.__modelImports;
+    if (importSources?.[slugArg.name]) {
+      const importPath = importSources[slugArg.name];
+      const filename = importPath.split("/").pop() || "";
+      return filename.replace(/\.(ts|tsx|js|jsx)$/, "").replace(/\.model$/, "").replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "");
+    }
+  }
+  return null;
+}
+function extractQueryDataSource(path, state) {
+  const args = path.node.arguments;
+  if (args.length < 1) return;
+  const slug = resolveSlugArg(args, state);
+  if (!slug) return;
+  const compilerState = state;
+  const dataSource = {
+    type: "workflow",
+    name: slug,
+    slug,
+    query: "list"
+  };
+  if (args.length > 1 && t17.isObjectExpression(args[1])) {
+    for (const prop of args[1].properties) {
+      if (!t17.isObjectProperty(prop) || !t17.isIdentifier(prop.key)) continue;
+      const key = prop.key.name;
+      const val = prop.value;
+      switch (key) {
+        case "limit":
+          if (t17.isNumericLiteral(val)) {
+            dataSource.pageSize = val.value;
+            dataSource.paginated = true;
+          }
+          break;
+        case "orderBy":
+          if (t17.isStringLiteral(val)) {
+            dataSource.sort = val.value;
+          }
+          break;
+        case "order":
+          if (t17.isStringLiteral(val) && dataSource.sort) {
+            dataSource.sort = `${dataSource.sort}:${val.value}`;
+          }
+          break;
+        case "search":
+          if (t17.isStringLiteral(val)) {
+            dataSource.search = val.value;
+          }
+          break;
+        case "searchFields":
+          if (t17.isArrayExpression(val)) {
+            dataSource.searchFields = val.elements.filter((el) => t17.isStringLiteral(el)).map((el) => el.value);
+          }
+          break;
+        case "filter":
+          if (t17.isObjectExpression(val)) {
+            const filter = {};
+            for (const fp of val.properties) {
+              if (t17.isObjectProperty(fp) && t17.isIdentifier(fp.key) && t17.isStringLiteral(fp.value)) {
+                filter[fp.key.name] = fp.value.value;
+              }
+            }
+            if (Object.keys(filter).length > 0) {
+              dataSource.filter = filter;
+            }
+          }
+          break;
+        case "state":
+          if (t17.isStringLiteral(val)) {
+            if (!dataSource.filter) dataSource.filter = {};
+            dataSource.filter.current_state = val.value;
+          }
+          break;
+        case "groupBy":
+          if (t17.isStringLiteral(val)) {
+            dataSource.groupBy = val.value;
+          }
+          break;
+        case "facets":
+          if (t17.isArrayExpression(val)) {
+            dataSource.facets = val.elements.filter((el) => t17.isStringLiteral(el)).map((el) => el.value);
+          }
+          break;
+      }
+    }
+  }
+  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 slug = resolveSlugArg(args, state);
+  if (!slug) return;
+  const compilerState = state;
+  if (!compilerState.metadata) compilerState.metadata = {};
+  const meta = compilerState.metadata;
+  if (!meta.mutationTargets) meta.mutationTargets = [];
+  meta.mutationTargets.push(slug);
+}
+function extractDuringAction(path, state) {
+  const args = path.node.arguments;
+  if (args.length < 1 || !t17.isObjectExpression(args[0])) return;
+  const compilerState = state;
+  const config = args[0];
+  let stateName;
+  let intervalMs = 1e3;
+  for (const prop of config.properties) {
+    if (!t17.isObjectProperty(prop) || !t17.isIdentifier(prop.key)) continue;
+    if (prop.key.name === "state" && t17.isStringLiteral(prop.value)) {
+      stateName = prop.value.value;
+    }
+    if (prop.key.name === "intervalMs" && t17.isNumericLiteral(prop.value)) {
+      intervalMs = prop.value.value;
+    }
+  }
+  if (!stateName) return;
+  if (!compilerState.states.has(stateName)) {
+    compilerState.states.set(stateName, {
+      name: stateName,
+      type: "REGULAR",
+      on_enter: [],
+      during: [],
+      on_exit: []
+    });
+  }
+  const stateEntry = compilerState.states.get(stateName);
+  if (!stateEntry.during) stateEntry.during = [];
+  compilerState.actionCounter++;
+  stateEntry.during.push({
+    id: `during_${compilerState.actionCounter}`,
+    type: "interval",
+    interval_ms: intervalMs,
+    actions: []
+  });
+}
+function extractRoleDependency(path, state) {
+  const args = path.node.arguments;
+  if (args.length < 1 || !t17.isStringLiteral(args[0])) return;
+  const compilerState = state;
+  if (!compilerState.metadata) compilerState.metadata = {};
+  const meta = compilerState.metadata;
+  if (!meta.roleDependencies) meta.roleDependencies = [];
+  const roles = meta.roleDependencies;
+  const role = args[0].value;
+  if (!roles.includes(role)) roles.push(role);
+}
+function extractViewDependency(path, state) {
+  const args = path.node.arguments;
+  if (args.length < 1 || !t17.isStringLiteral(args[0])) return;
+  const compilerState = state;
+  if (!compilerState.metadata) compilerState.metadata = {};
+  const meta = compilerState.metadata;
+  if (!meta.viewDependencies) meta.viewDependencies = [];
+  const views = meta.viewDependencies;
+  const slug = args[0].value;
+  if (!views.includes(slug)) views.push(slug);
+}
+function extractParamsUsage(_path, state) {
+  const compilerState = state;
+  if (!compilerState.metadata) compilerState.metadata = {};
+  const meta = compilerState.metadata;
+  meta.acceptsParams = true;
+}
+function extractLibraryDependency(path, state) {
+  const args = path.node.arguments;
+  if (args.length < 1 || !t17.isStringLiteral(args[0])) return;
+  const compilerState = state;
+  if (!compilerState.metadata) compilerState.metadata = {};
+  const meta = compilerState.metadata;
+  if (!meta.libraryDependencies) meta.libraryDependencies = [];
+  const libs = meta.libraryDependencies;
+  const slug = args[0].value;
+  if (!libs.includes(slug)) libs.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) => t17.isExportNamedDeclaration(node) || t17.isExportDefaultDeclaration(node)
+        );
+        if (exportDeclaration) {
+          if (exportDeclaration.leadingComments) {
+            extractMetadataFromComments(exportDeclaration.leadingComments, compilerState.metadata);
+          }
+          if (t17.isExportNamedDeclaration(exportDeclaration)) {
+            const declaration = exportDeclaration.declaration;
+            if (t17.isFunctionDeclaration(declaration)) {
+              if (declaration.id) {
+                compilerState.metadata.name = declaration.id.name;
+              }
+              if (declaration.leadingComments) {
+                extractMetadataFromComments(declaration.leadingComments, compilerState.metadata);
+              }
+            }
+          } else if (t17.isExportDefaultDeclaration(exportDeclaration)) {
+            const declaration = exportDeclaration.declaration;
+            if (t17.isFunctionDeclaration(declaration)) {
+              if (declaration.id) {
+                compilerState.metadata.name = declaration.id.name;
+              }
+              if (declaration.leadingComments) {
+                extractMetadataFromComments(declaration.leadingComments, compilerState.metadata);
+              }
+            } else if (t17.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;
+          if (!compilerState.metadata.category) {
+            compilerState.metadata.category = "data";
+          }
+        }
+        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 (!t17.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 "useComputed":
+          extractComputed(path, state);
+          break;
+        case "useOnTransition":
+          extractTransitionEffect(path, state);
+          break;
+        case "useQuery":
+          extractQueryDataSource(path, state);
+          break;
+        case "useMutation":
+          extractMutationDataSource(path, state);
+          break;
+        case "useDuringAction":
+          extractDuringAction(path, state);
+          break;
+        case "useRole":
+          extractRoleDependency(path, state);
+          break;
+        case "useView":
+          extractViewDependency(path, state);
+          break;
+        case "useParams":
+          extractParamsUsage(path, state);
+          break;
+        case "useExpressionLibrary":
+          extractLibraryDependency(path, state);
+          break;
+        case "useServerAction":
+          extractServerActionHook(path, state);
+          break;
+        case "useServerState":
+          extractServerState(path, state);
+          break;
+      }
+    },
+    // Track imports: model imports for useQuery(modelRef) resolution + strict mode validation
+    ImportDeclaration(path, state) {
+      const compilerState = state;
+      const source = path.node.source.value;
+      if (source.match(/\/models\/|\.model(?:\.[tj]sx?)?$/)) {
+        if (!compilerState.metadata) compilerState.metadata = {};
+        const meta = compilerState.metadata;
+        if (!meta.__modelImports) meta.__modelImports = {};
+        const imports = meta.__modelImports;
+        for (const specifier of path.node.specifiers) {
+          if (t17.isImportDefaultSpecifier(specifier) || t17.isImportSpecifier(specifier)) {
+            imports[specifier.local.name] = source;
+          }
+        }
+      }
+      if (mode !== "strict") return;
+      if (source.startsWith("@mindmatrix/") || source.startsWith("@mmapp/") || 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);
+    },
+    // Track derived/computed variable declarations for expression inlining.
+    //
+    // Three cases:
+    // 1. `const hasContent = expr` → registerDerivedVar (inline the expression)
+    // 2. `const users = useQuery(...)` → registerDerivedVar as $instance.{slug}
+    //    (data source results are available on $instance by their slug)
+    // 3. `const sendMsg = useMutation(...)` → registerDerivedVar as $action.transition
+    //    (mutation results are action callbacks)
+    // 4. `const memo = useMemo(() => expr, [])` → registerDerivedVar with body expr
+    VariableDeclarator(path, state) {
+      const compilerState = state;
+      if (!compilerState.metadata) return;
+      const id = path.node.id;
+      const init = path.node.init;
+      if (t17.isArrayPattern(id)) return;
+      if (!t17.isIdentifier(id) || !init || !t17.isExpression(init)) return;
+      const parentFn = path.getFunctionParent();
+      if (!parentFn) return;
+      const parentNode = parentFn.parentPath;
+      const isExportedDirectly = parentNode?.isExportDefaultDeclaration() || parentNode?.isExportNamedDeclaration();
+      let isExportedByName = false;
+      if (!isExportedDirectly && parentNode?.isVariableDeclarator()) {
+        const varId = parentNode.node.id;
+        if (t17.isIdentifier(varId)) {
+          isExportedByName = varId.name === compilerState.metadata?.name;
+        }
+      }
+      if (!isExportedDirectly && !isExportedByName) return;
+      if (t17.isCallExpression(init) && t17.isIdentifier(init.callee)) {
+        const callee = init.callee.name;
+        if (callee === "useQuery") {
+          registerDerivedVar(id.name, t17.optionalMemberExpression(
+            t17.identifier("$instance"),
+            t17.identifier(id.name),
+            false,
+            // computed
+            true
+            // optional
+          ));
+          return;
+        }
+        if (callee === "useMutation") {
+          registerDerivedVar(id.name, t17.memberExpression(
+            t17.identifier("$action"),
+            t17.identifier("transition")
+          ));
+          return;
+        }
+        if (callee === "useServerAction") {
+          registerDerivedVar(id.name, t17.memberExpression(
+            t17.identifier("$action"),
+            t17.identifier("serverAction")
+          ));
+          return;
+        }
+        if (callee === "useServerState") {
+          registerDerivedVar(id.name, t17.optionalMemberExpression(
+            t17.identifier("$instance"),
+            t17.identifier("serverState"),
+            false,
+            true
+          ));
+          return;
+        }
+        if (callee === "useMemo" && init.arguments.length >= 1) {
+          const callback = init.arguments[0];
+          if (t17.isArrowFunctionExpression(callback)) {
+            if (t17.isExpression(callback.body)) {
+              registerDerivedVar(id.name, callback.body);
+            } else if (t17.isBlockStatement(callback.body)) {
+              const retStmt = callback.body.body.find((s) => t17.isReturnStatement(s));
+              if (retStmt?.argument && t17.isExpression(retStmt.argument)) {
+                registerDerivedVar(id.name, retStmt.argument);
+              }
+            }
+          }
+          return;
+        }
+        if (callee.startsWith("use")) return;
+      }
+      registerDerivedVar(id.name, init);
+    },
+    // Extract JSX from function component return.
+    // Only extract from the exported component function's direct return,
+    // not from nested callbacks (Each render functions, helper components, etc.).
+    ReturnStatement(path, state) {
+      if (!t17.isJSXElement(path.node.argument) && !t17.isJSXFragment(path.node.argument)) return;
+      const parentFn = path.getFunctionParent();
+      if (!parentFn) return;
+      const parentNode = parentFn.parentPath;
+      const isExportedDirectly = parentNode?.isExportDefaultDeclaration() || parentNode?.isExportNamedDeclaration();
+      let isExportedByName = false;
+      if (!isExportedDirectly && parentNode?.isVariableDeclarator()) {
+        const varId = parentNode.node.id;
+        if (t17.isIdentifier(varId)) {
+          isExportedByName = varId.name === state.metadata?.name;
+        }
+      }
+      if (isExportedDirectly || isExportedByName) {
+        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,
+  transpileBlock,
+  extractComponents,
+  extractComputed,
+  transformToFrontend,
+  emitIR,
+  emitPureForm,
+  emitCanonical,
+  emitCompiledOutput,
+  compilerStateToWorkflow,
+  createVisitor,
+  babelPlugin
+};