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

package/dist/chunk-7ZKGHTNB.mjs

@@ -1,4952 +0,0 @@
-// 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 push: arr.push(item) → arr = concat(arr, [item]) ---
-      case "push": {
-        const [item] = this.visitArgsList(args);
-        return `${obj} = concat(${obj}, [${item}])`;
-      }
-      // --- 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
-};