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

package/dist/chunk-EY2CSXYA.mjs

@@ -0,0 +1,822 @@
+// src/babel/visitor.ts
+import * as t6 from "@babel/types";
+
+// src/babel/extractors/state-extractor.ts
+import * as t from "@babel/types";
+function inferFieldType(typeAnnotation, defaultValue) {
+  if (typeAnnotation) {
+    if (t.isTSNumberKeyword(typeAnnotation)) return "number";
+    if (t.isTSStringKeyword(typeAnnotation)) return "text";
+    if (t.isTSBooleanKeyword(typeAnnotation)) return "boolean";
+    if (t.isTSTypeReference(typeAnnotation)) {
+      const typeName = t.isIdentifier(typeAnnotation.typeName) ? typeAnnotation.typeName.name : "";
+      if (typeName === "Date") return "date";
+    }
+    if (t.isTSArrayType(typeAnnotation) || t.isTSTypeLiteral(typeAnnotation) || t.isTSTupleType(typeAnnotation)) {
+      return "json";
+    }
+  }
+  if (defaultValue) {
+    if (t.isNumericLiteral(defaultValue)) return "number";
+    if (t.isStringLiteral(defaultValue)) return "text";
+    if (t.isBooleanLiteral(defaultValue)) return "boolean";
+    if (t.isArrayExpression(defaultValue) || t.isObjectExpression(defaultValue)) {
+      return "json";
+    }
+    if (t.isNewExpression(defaultValue) && t.isIdentifier(defaultValue.callee)) {
+      if (defaultValue.callee.name === "Date") return "date";
+    }
+  }
+  return "text";
+}
+function extractDefaultValue(arg) {
+  if (t.isNumericLiteral(arg)) return arg.value;
+  if (t.isStringLiteral(arg)) return arg.value;
+  if (t.isBooleanLiteral(arg)) return arg.value;
+  if (t.isNullLiteral(arg)) return null;
+  if (t.isArrayExpression(arg)) {
+    return arg.elements.map(
+      (el) => el && t.isExpression(el) ? extractDefaultValue(el) : null
+    );
+  }
+  if (t.isObjectExpression(arg)) {
+    const obj = {};
+    arg.properties.forEach((prop) => {
+      if (t.isObjectProperty(prop) && t.isIdentifier(prop.key) && t.isExpression(prop.value)) {
+        obj[prop.key.name] = extractDefaultValue(prop.value);
+      }
+    });
+    return obj;
+  }
+  return void 0;
+}
+function extractStates(path, state) {
+  const parent = path.parentPath;
+  if (!parent.isVariableDeclarator()) return;
+  const id = parent.node.id;
+  if (!t.isArrayPattern(id) || id.elements.length < 1) return;
+  const firstElement = id.elements[0];
+  if (!t.isIdentifier(firstElement)) return;
+  const fieldName = firstElement.name;
+  const args = path.node.arguments;
+  const defaultValue = args.length > 0 && t.isExpression(args[0]) ? args[0] : null;
+  let typeAnnotation = null;
+  if (path.node.typeParameters && t.isTSTypeParameterInstantiation(path.node.typeParameters)) {
+    const params = path.node.typeParameters.params;
+    if (params.length > 0) {
+      typeAnnotation = params[0];
+    }
+  }
+  const fieldType = inferFieldType(typeAnnotation, defaultValue);
+  const fieldDefaultValue = defaultValue ? extractDefaultValue(defaultValue) : void 0;
+  const field = {
+    name: fieldName,
+    type: fieldType,
+    default_value: fieldDefaultValue
+  };
+  const compilerState = state;
+  if (!compilerState.fields) compilerState.fields = [];
+  if (!compilerState.fields.some((f) => f.name === fieldName)) {
+    compilerState.fields.push(field);
+  }
+}
+
+// src/babel/extractors/effect-extractor.ts
+import * as t2 from "@babel/types";
+function analyzeCallbackBody(body, actionCounter) {
+  const actions = [];
+  for (const statement of body) {
+    if (t2.isExpressionStatement(statement)) {
+      const expr = statement.expression;
+      if (t2.isCallExpression(expr) && t2.isIdentifier(expr.callee)) {
+        const calleeName = expr.callee.name;
+        const args = expr.arguments;
+        if (calleeName === "setField" && args.length >= 2) {
+          const field = t2.isStringLiteral(args[0]) ? args[0].value : void 0;
+          const arg1 = args[1];
+          if (field !== void 0 && !t2.isArgumentPlaceholder(arg1)) {
+            const value = extractValue(arg1);
+            actions.push({
+              id: `auto_${++actionCounter.value}`,
+              type: "set_field",
+              mode: "auto",
+              config: { field, value }
+            });
+          }
+        } else if (calleeName === "setMemory" && args.length >= 2) {
+          const key = t2.isStringLiteral(args[0]) ? args[0].value : void 0;
+          const arg1 = args[1];
+          if (key !== void 0 && !t2.isArgumentPlaceholder(arg1)) {
+            const value = extractValue(arg1);
+            actions.push({
+              id: `auto_${++actionCounter.value}`,
+              type: "set_memory",
+              mode: "auto",
+              config: { key, value }
+            });
+          }
+        } else if (calleeName.startsWith("set") && args.length >= 1) {
+          const fieldName = calleeName.slice(3).charAt(0).toLowerCase() + calleeName.slice(4);
+          const arg0 = args[0];
+          if (!t2.isArgumentPlaceholder(arg0)) {
+            const value = extractValue(arg0);
+            actions.push({
+              id: `auto_${++actionCounter.value}`,
+              type: "set_field",
+              mode: "auto",
+              config: { field: fieldName, value }
+            });
+          }
+        }
+      } else if (t2.isCallExpression(expr)) {
+        const callee = expr.callee;
+        const args = expr.arguments;
+        if (t2.isMemberExpression(callee) && t2.isIdentifier(callee.object) && callee.object.name === "console" && t2.isIdentifier(callee.property) && callee.property.name === "log" && args.length > 0) {
+          const arg0 = args[0];
+          if (!t2.isArgumentPlaceholder(arg0)) {
+            const message = extractValue(arg0);
+            actions.push({
+              id: `auto_${++actionCounter.value}`,
+              type: "log_event",
+              mode: "auto",
+              config: { message }
+            });
+          }
+        } else {
+          actions.push({
+            id: `auto_${++actionCounter.value}`,
+            type: "custom",
+            mode: "auto",
+            config: { expression: generateCode(expr) }
+          });
+        }
+      }
+    }
+  }
+  return actions;
+}
+function extractValue(node) {
+  if (t2.isNumericLiteral(node)) return node.value;
+  if (t2.isStringLiteral(node)) return node.value;
+  if (t2.isBooleanLiteral(node)) return node.value;
+  if (t2.isNullLiteral(node)) return null;
+  if (t2.isArrayExpression(node)) {
+    return node.elements.map((el) => el && t2.isExpression(el) ? extractValue(el) : null);
+  }
+  if (t2.isObjectExpression(node)) {
+    const obj = {};
+    node.properties.forEach((prop) => {
+      if (t2.isObjectProperty(prop) && t2.isIdentifier(prop.key) && t2.isExpression(prop.value)) {
+        obj[prop.key.name] = extractValue(prop.value);
+      }
+    });
+    return obj;
+  }
+  return generateCode(node);
+}
+function generateCode(node) {
+  if (t2.isIdentifier(node)) return node.name;
+  if (t2.isNumericLiteral(node)) return String(node.value);
+  if (t2.isStringLiteral(node)) return `"${node.value}"`;
+  if (t2.isBooleanLiteral(node)) return String(node.value);
+  if (t2.isNullLiteral(node)) return "null";
+  if (t2.isCallExpression(node) && t2.isMemberExpression(node.callee) && t2.isIdentifier(node.callee.object) && node.callee.object.name === "Date" && t2.isIdentifier(node.callee.property) && node.callee.property.name === "now") {
+    return "now()";
+  }
+  if (t2.isCallExpression(node) && t2.isMemberExpression(node.callee) && t2.isNewExpression(node.callee.object) && t2.isIdentifier(node.callee.object.callee) && node.callee.object.callee.name === "Date" && t2.isIdentifier(node.callee.property) && node.callee.property.name === "toISOString") {
+    return "now()";
+  }
+  if (t2.isTemplateLiteral(node)) {
+    return node.quasis.map((q) => q.value.raw).join("${}");
+  }
+  if (t2.isMemberExpression(node) && t2.isIdentifier(node.object) && t2.isIdentifier(node.property)) {
+    return `${node.object.name}.${node.property.name}`;
+  }
+  return "[Expression]";
+}
+function ensureState(states, stateName) {
+  if (!states.has(stateName)) {
+    states.set(stateName, {
+      name: stateName,
+      type: "REGULAR",
+      on_enter: [],
+      during: [],
+      on_exit: []
+    });
+  }
+  return states.get(stateName);
+}
+function extractEffects(path, state) {
+  const callee = path.node.callee;
+  if (!t2.isIdentifier(callee)) return;
+  const hookName = callee.name;
+  const args = path.node.arguments;
+  if ((hookName === "useOnEnter" || hookName === "useOnExit") && args.length >= 2) {
+    const stateArg = args[0];
+    const callbackArg = args[1];
+    if (!t2.isStringLiteral(stateArg)) return;
+    const stateName = stateArg.value;
+    let callbackBody = [];
+    if (t2.isArrowFunctionExpression(callbackArg) || t2.isFunctionExpression(callbackArg)) {
+      const body = callbackArg.body;
+      if (t2.isBlockStatement(body)) {
+        callbackBody = body.body;
+      } else if (t2.isExpression(body)) {
+        callbackBody = [t2.expressionStatement(body)];
+      }
+    }
+    const compilerState = state;
+    if (!compilerState.states) compilerState.states = /* @__PURE__ */ new Map();
+    if (!compilerState.actionCounter) compilerState.actionCounter = 0;
+    const stateDefinition = ensureState(compilerState.states, stateName);
+    const actions = analyzeCallbackBody(callbackBody, { value: compilerState.actionCounter });
+    compilerState.actionCounter += actions.length;
+    if (hookName === "useOnEnter") {
+      stateDefinition.on_enter.push(...actions);
+    } else if (hookName === "useOnExit") {
+      stateDefinition.on_exit.push(...actions);
+    }
+  }
+}
+
+// src/babel/extractors/transition-extractor.ts
+import * as t3 from "@babel/types";
+function extractTransitions(path, state) {
+  const callee = path.node.callee;
+  if (!t3.isIdentifier(callee) || callee.name !== "useTransition") return;
+  const args = path.node.arguments;
+  if (args.length < 1) return;
+  const nameArg = args[0];
+  if (!t3.isStringLiteral(nameArg)) return;
+  const transitionName = nameArg.value;
+  const compilerState = state;
+  if (!compilerState.transitions) compilerState.transitions = [];
+  const existing = compilerState.transitions.find((tr) => tr.name === transitionName);
+  if (existing) return;
+  let from = [];
+  let to = "";
+  if (args.length >= 2 && t3.isObjectExpression(args[1])) {
+    const opts = args[1];
+    for (const prop of opts.properties) {
+      if (!t3.isObjectProperty(prop) || !t3.isIdentifier(prop.key)) continue;
+      if (prop.key.name === "from") {
+        if (t3.isArrayExpression(prop.value)) {
+          from = prop.value.elements.filter((el) => t3.isStringLiteral(el)).map((el) => el.value);
+        } else if (t3.isStringLiteral(prop.value)) {
+          from = [prop.value.value];
+        }
+      } else if (prop.key.name === "to") {
+        if (t3.isStringLiteral(prop.value)) {
+          to = prop.value.value;
+        }
+      }
+    }
+  }
+  const transition = {
+    name: transitionName,
+    from,
+    to,
+    actions: [],
+    conditions: []
+  };
+  compilerState.transitions.push(transition);
+}
+function inferTransitionStates(transitions, states) {
+  const stateArray = Array.from(states.values());
+  const startStates = stateArray.filter((s) => s.type === "START");
+  const regularStates = stateArray.filter((s) => s.type === "REGULAR");
+  const needsInference = transitions.filter((t7) => t7.from.length === 0 || !t7.to);
+  if (needsInference.length === 0) return;
+  if (startStates.length === 1 && regularStates.length > 0) {
+    needsInference.forEach((t7, idx) => {
+      if (t7.from.length === 0) {
+        t7.from = [startStates[0].name];
+      }
+      if (!t7.to) {
+        t7.to = regularStates[idx % regularStates.length]?.name || startStates[0].name;
+      }
+    });
+  } else {
+    const allStateNames = stateArray.map((s) => s.name);
+    needsInference.forEach((t7, idx) => {
+      if (t7.from.length === 0 && allStateNames.length > 0) {
+        t7.from = [allStateNames[0]];
+      }
+      if (!t7.to && allStateNames.length > 1) {
+        t7.to = allStateNames[Math.min(idx + 1, allStateNames.length - 1)];
+      }
+    });
+  }
+}
+
+// src/babel/extractors/event-extractor.ts
+import * as t4 from "@babel/types";
+function analyzeEventCallback(body) {
+  const actions = [];
+  for (const statement of body) {
+    if (t4.isExpressionStatement(statement)) {
+      const expr = statement.expression;
+      if (t4.isCallExpression(expr) && t4.isIdentifier(expr.callee)) {
+        const calleeName = expr.callee.name;
+        const args = expr.arguments;
+        if (calleeName === "setField" && args.length >= 2) {
+          const field = t4.isStringLiteral(args[0]) ? args[0].value : void 0;
+          const expression = generateExpression(args[1]);
+          if (field) {
+            actions.push({
+              type: "set_field",
+              field,
+              expression
+            });
+          }
+        } else if (calleeName === "setMemory" && args.length >= 2) {
+          const key = t4.isStringLiteral(args[0]) ? args[0].value : void 0;
+          const expression = generateExpression(args[1]);
+          if (key) {
+            actions.push({
+              type: "set_memory",
+              key,
+              expression
+            });
+          }
+        }
+      } else if (t4.isCallExpression(expr)) {
+        const callee = expr.callee;
+        const args = expr.arguments;
+        if (t4.isMemberExpression(callee) && t4.isIdentifier(callee.object) && callee.object.name === "console" && t4.isIdentifier(callee.property) && callee.property.name === "log") {
+          const message = args.length > 0 ? generateExpression(args[0]) : "";
+          actions.push({
+            type: "log_event",
+            message
+          });
+        }
+      }
+    }
+  }
+  return actions;
+}
+function generateExpression(node) {
+  if (t4.isStringLiteral(node)) return node.value;
+  if (t4.isNumericLiteral(node)) return String(node.value);
+  if (t4.isBooleanLiteral(node)) return String(node.value);
+  if (t4.isIdentifier(node)) return node.name;
+  if (t4.isBinaryExpression(node)) {
+    return `${generateExpression(node.left)} ${node.operator} ${generateExpression(node.right)}`;
+  }
+  if (t4.isCallExpression(node) && t4.isIdentifier(node.callee)) {
+    const args = node.arguments.map((arg) => generateExpression(arg)).join(", ");
+    return `${node.callee.name}(${args})`;
+  }
+  return "[Expression]";
+}
+function ensureState2(states, stateName) {
+  if (!states.has(stateName)) {
+    states.set(stateName, {
+      name: stateName,
+      type: "REGULAR",
+      on_enter: [],
+      during: [],
+      on_exit: []
+    });
+  }
+  return states.get(stateName);
+}
+function extractEvents(path, state) {
+  const callee = path.node.callee;
+  if (!t4.isIdentifier(callee) || callee.name !== "useOnEvent") return;
+  const args = path.node.arguments;
+  if (args.length < 2) return;
+  const patternArg = args[0];
+  const callbackArg = args[1];
+  const optionsArg = args.length > 2 ? args[2] : null;
+  if (!t4.isStringLiteral(patternArg)) return;
+  const pattern = patternArg.value;
+  let callbackBody = [];
+  if (t4.isArrowFunctionExpression(callbackArg) || t4.isFunctionExpression(callbackArg)) {
+    const body = callbackArg.body;
+    if (t4.isBlockStatement(body)) {
+      callbackBody = body.body;
+    } else if (t4.isExpression(body)) {
+      callbackBody = [t4.expressionStatement(body)];
+    }
+  }
+  let stateName = null;
+  if (optionsArg && t4.isObjectExpression(optionsArg)) {
+    const whileProp = optionsArg.properties.find(
+      (prop) => t4.isObjectProperty(prop) && t4.isIdentifier(prop.key) && prop.key.name === "while"
+    );
+    if (whileProp && t4.isObjectProperty(whileProp) && t4.isStringLiteral(whileProp.value)) {
+      stateName = whileProp.value.value;
+    }
+  }
+  const actions = analyzeEventCallback(callbackBody);
+  const subscription = {
+    match: pattern,
+    conditions: [],
+    actions
+  };
+  const compilerState = state;
+  if (!compilerState.states) compilerState.states = /* @__PURE__ */ new Map();
+  if (stateName) {
+    const stateDefinition = ensureState2(compilerState.states, stateName);
+    if (!stateDefinition.on_event) stateDefinition.on_event = [];
+    stateDefinition.on_event.push(subscription);
+  } else {
+    if (!compilerState.events) compilerState.events = [];
+    compilerState.events.push(subscription);
+  }
+}
+
+// src/babel/extractors/component-extractor.ts
+import * as t5 from "@babel/types";
+var nodeIdCounter = 0;
+function jsxToExperienceNode(node) {
+  if (t5.isJSXFragment(node)) {
+    return {
+      id: `fragment_${++nodeIdCounter}`,
+      children: node.children.map(jsxChildToNode).filter(Boolean)
+    };
+  }
+  const element = node.openingElement;
+  const componentName = t5.isJSXIdentifier(element.name) ? element.name.name : "div";
+  const id = generateNodeId(componentName);
+  const config = {};
+  const bindings = {};
+  let visibleWhen;
+  for (const attr of element.attributes) {
+    if (t5.isJSXAttribute(attr) && t5.isJSXIdentifier(attr.name)) {
+      const attrName = attr.name.name;
+      const attrValue = attr.value;
+      if (attrName === "visible_when" && t5.isStringLiteral(attrValue)) {
+        visibleWhen = attrValue.value;
+      } else if (attrName === "data-slot" && t5.isStringLiteral(attrValue)) {
+        config.slot = attrValue.value;
+      } else if (t5.isJSXExpressionContainer(attrValue)) {
+        const expr = attrValue.expression;
+        if (t5.isIdentifier(expr)) {
+          bindings[attrName] = `$instance.${expr.name}`;
+        } else if (t5.isExpression(expr)) {
+          bindings[attrName] = generateExpression2(expr);
+        }
+      } else if (t5.isStringLiteral(attrValue)) {
+        config[attrName] = attrValue.value;
+      }
+    }
+  }
+  const children = node.children.map(jsxChildToNode).filter(Boolean);
+  const experienceNode = {
+    id,
+    component: componentName,
+    ...Object.keys(bindings).length > 0 && { bindings },
+    ...Object.keys(config).length > 0 && { config },
+    ...visibleWhen && { visible_when: visibleWhen },
+    ...children.length > 0 && { children }
+  };
+  return experienceNode;
+}
+function jsxChildToNode(child) {
+  if (t5.isJSXElement(child)) {
+    return jsxToExperienceNode(child);
+  }
+  if (t5.isJSXFragment(child)) {
+    return jsxToExperienceNode(child);
+  }
+  return null;
+}
+function generateNodeId(componentName) {
+  const id = componentName.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "");
+  return `${id}_${++nodeIdCounter}`;
+}
+function generateExpression2(node) {
+  if (t5.isIdentifier(node)) return node.name;
+  if (t5.isStringLiteral(node)) return node.value;
+  if (t5.isNumericLiteral(node)) return String(node.value);
+  if (t5.isBooleanLiteral(node)) return String(node.value);
+  if (t5.isMemberExpression(node)) {
+    const obj = generateExpression2(node.object);
+    const prop = t5.isIdentifier(node.property) ? node.property.name : "[property]";
+    return `${obj}.${prop}`;
+  }
+  return "[Expression]";
+}
+function extractComponents(path, state) {
+  const arg = path.node.argument;
+  if (!arg) return;
+  let experienceNode = null;
+  if (t5.isJSXElement(arg)) {
+    experienceNode = jsxToExperienceNode(arg);
+  } else if (t5.isJSXFragment(arg)) {
+    experienceNode = jsxToExperienceNode(arg);
+  }
+  if (experienceNode) {
+    const compilerState = state;
+    compilerState.experience = experienceNode;
+  }
+}
+
+// src/babel/emitters/pure-form-emitter.ts
+function toSnakeCase(str) {
+  return str.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
+}
+function convertAction(action) {
+  return {
+    id: action.id,
+    action_type: action.type,
+    config: action.config || {}
+  };
+}
+function emitPureForm(extracted) {
+  const { slug, name, version, description, category, fields, states, transitions } = extracted;
+  const stateArray = Array.from(states.values());
+  if (stateArray.length === 0) {
+    stateArray.push({
+      name: "draft",
+      type: "START",
+      on_enter: [],
+      during: [],
+      on_exit: []
+    });
+  } else {
+    const hasStart = stateArray.some((s) => s.type === "START");
+    if (!hasStart && stateArray.length > 0) {
+      stateArray[0].type = "START";
+    }
+  }
+  inferTransitionStates(transitions, states);
+  const stateNames = new Set(stateArray.map((s) => s.name));
+  for (const transition of transitions) {
+    if (transition.to && !stateNames.has(transition.to)) {
+      stateArray.push({
+        name: transition.to,
+        type: "REGULAR",
+        on_enter: [],
+        during: [],
+        on_exit: []
+      });
+      stateNames.add(transition.to);
+    }
+  }
+  return {
+    slug,
+    name,
+    version,
+    description,
+    category,
+    fields,
+    states: stateArray,
+    transitions,
+    roles: [],
+    tags: [],
+    metadata: extracted.experience ? { experience: extracted.experience } : {}
+  };
+}
+function emitWorkflowDefinition(extracted) {
+  const ir = emitPureForm(extracted);
+  const states = ir.states.map((s) => ({
+    name: s.name,
+    state_type: s.type,
+    description: "",
+    on_enter: (s.on_enter || []).map(convertAction),
+    on_exit: (s.on_exit || []).map(convertAction),
+    during: s.during || [],
+    on_event: []
+  }));
+  const fields = ir.fields.map((f) => ({
+    name: toSnakeCase(f.name),
+    field_type: f.type,
+    label: f.name.replace(/([A-Z])/g, " $1").replace(/^./, (c) => c.toUpperCase()),
+    required: false,
+    default_value: f.default_value ?? null
+  }));
+  const transitions = ir.transitions.map((t7) => ({
+    name: t7.name,
+    from: t7.from,
+    to: t7.to,
+    description: "",
+    roles: [],
+    auto: false,
+    conditions: t7.conditions || [],
+    actions: (t7.actions || []).map(convertAction),
+    required_fields: [],
+    priority: 0
+  }));
+  const state_data = {};
+  for (const f of fields) {
+    state_data[f.name] = f.default_value;
+  }
+  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 || {},
+    config: {},
+    is_immutable: false
+  };
+}
+function compilerStateToWorkflow(state, metadata) {
+  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
+  };
+}
+
+// src/babel/visitor.ts
+function createVisitor(_options = {}) {
+  return {
+    Program: {
+      // Initialize compiler state at program entry
+      enter(_path, state) {
+        const compilerState = {
+          fields: [],
+          states: /* @__PURE__ */ new Map(),
+          transitions: [],
+          events: [],
+          actionCounter: 0,
+          metadata: {}
+        };
+        const extractMetadataFromComments = (comments) => {
+          for (const comment of comments) {
+            if (comment.type === "CommentBlock") {
+              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") compilerState.metadata.slug = val;
+                    else if (key === "version") compilerState.metadata.version = val;
+                    else if (key === "category") compilerState.metadata.category = val;
+                    else if (key === "description") compilerState.metadata.description = val;
+                  }
+                  if (!hasKV) {
+                    compilerState.metadata.slug = rest;
+                  }
+                  continue;
+                }
+                const match = line.match(/@(\w+)\s+(.+)/);
+                if (match) {
+                  const [, tag, value] = match;
+                  if (tag === "version") compilerState.metadata.version = value.trim();
+                  if (tag === "category") compilerState.metadata.category = value.trim();
+                  if (tag === "description") compilerState.metadata.description = value.trim();
+                }
+              }
+            }
+          }
+        };
+        const program = _path.node;
+        const leadingComments = program.leadingComments || [];
+        extractMetadataFromComments(leadingComments);
+        const exportDeclaration = program.body.find(
+          (node) => t6.isExportNamedDeclaration(node) || t6.isExportDefaultDeclaration(node)
+        );
+        if (exportDeclaration) {
+          if (t6.isExportNamedDeclaration(exportDeclaration)) {
+            const declaration = exportDeclaration.declaration;
+            if (t6.isFunctionDeclaration(declaration)) {
+              if (declaration.id) {
+                compilerState.metadata.name = declaration.id.name;
+              }
+              if (declaration.leadingComments) {
+                extractMetadataFromComments(declaration.leadingComments);
+              }
+            }
+          } else if (t6.isExportDefaultDeclaration(exportDeclaration)) {
+            const declaration = exportDeclaration.declaration;
+            if (t6.isFunctionDeclaration(declaration)) {
+              if (declaration.id) {
+                compilerState.metadata.name = declaration.id.name;
+              }
+              if (declaration.leadingComments) {
+                extractMetadataFromComments(declaration.leadingComments);
+              }
+            } else if (t6.isIdentifier(declaration)) {
+              compilerState.metadata.name = declaration.name;
+            }
+          }
+        }
+        if (!compilerState.metadata.slug && state.filename) {
+          const fileName = state.filename.split("/").pop() || "";
+          compilerState.metadata.slug = fileName.replace(/\.workflow\.(tsx?|jsx?)$/, "").replace(/\.(tsx?|jsx?)$/, "").replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "");
+        }
+        Object.assign(state, compilerState);
+      },
+      // After all extraction, emit Pure Form JSON
+      exit(_path, state) {
+        const compilerState = state;
+        const extracted = compilerStateToWorkflow(compilerState, compilerState.metadata);
+        const ir = emitPureForm(extracted);
+        const definition = emitWorkflowDefinition(extracted);
+        if (!state.file.metadata) state.file.metadata = {};
+        state.file.metadata.mindmatrixIR = ir;
+        state.file.metadata.mindmatrixDefinition = definition;
+      }
+    },
+    // Extract metadata from function declarations with JSDoc
+    FunctionDeclaration(path, state) {
+      const comments = path.node.leadingComments || [];
+      const compilerState = state;
+      for (const comment of comments) {
+        if (comment.type === "CommentBlock") {
+          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") compilerState.metadata.slug = val;
+                else if (key === "version") compilerState.metadata.version = val;
+                else if (key === "category") compilerState.metadata.category = val;
+                else if (key === "description") compilerState.metadata.description = val;
+              }
+              if (!hasKV) compilerState.metadata.slug = rest;
+              continue;
+            }
+            const match = line.match(/@(\w+)\s+(.+)/);
+            if (match) {
+              const [, tag, value] = match;
+              if (tag === "version") compilerState.metadata.version = value.trim();
+              if (tag === "category") compilerState.metadata.category = value.trim();
+              if (tag === "description") compilerState.metadata.description = value.trim();
+            }
+          }
+        }
+      }
+    },
+    // Extract useState calls
+    CallExpression(path, state) {
+      const callee = path.node.callee;
+      if (!t6.isIdentifier(callee)) return;
+      switch (callee.name) {
+        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;
+      }
+    },
+    // Extract JSX from function component return
+    ReturnStatement(path, state) {
+      if (t6.isJSXElement(path.node.argument) || t6.isJSXFragment(path.node.argument)) {
+        extractComponents(path, state);
+      }
+    }
+  };
+}
+
+// src/babel/index.ts
+function babelPlugin(api, options = {}) {
+  api.assertVersion(7);
+  return {
+    name: "mindmatrix-react",
+    visitor: createVisitor(options)
+  };
+}
+
+export {
+  extractStates,
+  extractEffects,
+  extractTransitions,
+  extractEvents,
+  extractComponents,
+  emitPureForm,
+  compilerStateToWorkflow,
+  createVisitor,
+  babelPlugin
+};