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

package/src/babel/extractors/model-extractor.ts

@@ -1,1018 +0,0 @@
-/**
- * Model Extractor — extracts TypeScript model files into workflow definitions.
- *
- * Model files (e.g., models/channel.ts) define workflows declaratively:
- *
- *   export interface Channel {
- *     name: string;
- *     status: 'active' | 'archived';
- *     memberCount: number;
- *     isPublic: boolean;
- *     createdAt: Date;
- *     tags: string[];
- *     metadata?: Record<string, unknown>;
- *   }
- *
- *   export const transitions = {
- *     archive: { from: 'active', to: 'archived', guard: '$user.role == "admin"', roles: ['admin'] },
- *     activate: { from: ['archived', 'draft'], to: 'active', required_fields: ['name'] },
- *   };
- *
- *   export const endStates = ['deleted'];
- *   export const cancelledStates = ['cancelled'];
- *
- *   export const hooks = {
- *     on_enter_active: { emit: 'channel:activated', actions: ['notifyMembers'] },
- *     on_exit_active: { actions: ['logDeactivation'] },
- *   };
- *
- *   export const runtime: RuntimeProfile = 'backend';
- *
- *   export const fieldOptions = {
- *     name: { scope: 'instance', persistence: 'durable' },
- *     memberCount: {
- *       computed: 'count(refs("member", { channel_id: $instance.id }))',
- *       computed_deps: [],
- *       visible_in_states: ['active'],
- *       editable_by_roles: ['admin'],
- *     },
- *   };
- */
-
-import type { NodePath } from '@babel/traverse';
-import * as t from '@babel/types';
-import type {
-  IRFieldDefinition,
-  IRTransitionDefinition,
-  IRConditionDefinition,
-  IRActionDefinition,
-  IRStateDefinition,
-  IRWorkflowFieldType,
-  IRStateType as _IRStateType,
-  IRFieldValidation,
-  IRStateHome,
-  RuntimeProfile,
-} from '@mindmatrix/player-core';
-import type { CompilerState } from '../../types';
-
-// =============================================================================
-// Type Mapping
-// =============================================================================
-
-/**
- * Maps TypeScript type annotation strings to IR field types.
- */
-function tsTypeToFieldType(typeAnnotation: t.TSTypeAnnotation | t.TypeAnnotation | null | undefined): IRWorkflowFieldType {
-  if (!typeAnnotation) return 'text';
-  const annotation = typeAnnotation.typeAnnotation;
-  return resolveType(annotation);
-}
-
-/** Well-known TypeScript type names that map to built-in IR field types */
-const KNOWN_TYPE_REFS: Record<string, IRWorkflowFieldType> = {
-  Date: 'datetime',
-  Record: 'json',
-  Map: 'json',
-  Set: 'json',
-  URL: 'url',
-};
-
-/**
- * Converts a PascalCase TypeScript name to a kebab-case slug.
- */
-function typeNameToSlug(name: string): string {
-  return name
-    .replace(/([A-Z])/g, '-$1')
-    .toLowerCase()
-    .replace(/^-/, '');
-}
-
-function resolveType(annotation: t.Node): IRWorkflowFieldType {
-  // string
-  if (t.isTSStringKeyword(annotation)) return 'text';
-  // number
-  if (t.isTSNumberKeyword(annotation)) return 'number';
-  // boolean
-  if (t.isTSBooleanKeyword(annotation)) return 'boolean';
-
-  // Named type references
-  if (t.isTSTypeReference(annotation) && t.isIdentifier(annotation.typeName)) {
-    const typeName = annotation.typeName.name;
-    // Check known types first
-    if (KNOWN_TYPE_REFS[typeName]) return KNOWN_TYPE_REFS[typeName];
-    // Array<T> → multi_select
-    if (typeName === 'Array') return 'multi_select';
-    // Unknown type reference → emit as slug (Element-based custom field type)
-    return typeNameToSlug(typeName);
-  }
-
-  // Array types: string[] or Array<string>
-  if (t.isTSArrayType(annotation)) {
-    return 'multi_select';
-  }
-
-  // Union of string literals → select
-  if (t.isTSUnionType(annotation)) {
-    const allLiterals = annotation.types.every(
-      (t2) => t.isTSLiteralType(t2) && (t.isStringLiteral(t2.literal) || t.isNumericLiteral(t2.literal))
-    );
-    if (allLiterals) return 'select';
-    // Union containing null/undefined means optional
-    return 'text';
-  }
-
-  // Literal types (single literal)
-  if (t.isTSLiteralType(annotation) && t.isStringLiteral(annotation.literal)) return 'text';
-  if (t.isTSLiteralType(annotation) && t.isNumericLiteral(annotation.literal)) return 'number';
-
-  return 'text';
-}
-
-/**
- * Extracts validation options from union string literal types.
- */
-function extractUnionOptions(annotation: t.Node): string[] | undefined {
-  if (!t.isTSUnionType(annotation)) return undefined;
-  const options: string[] = [];
-  for (const member of annotation.types) {
-    if (t.isTSLiteralType(member) && t.isStringLiteral(member.literal)) {
-      options.push(member.literal.value);
-    }
-  }
-  return options.length > 0 ? options : undefined;
-}
-
-/**
- * Extracts default value from an interface property's type.
- */
-function extractDefaultValue(fieldType: IRWorkflowFieldType): unknown {
-  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;
-  }
-}
-
-// =============================================================================
-// Interface Extraction → Fields
-// =============================================================================
-
-/**
- * Extracts fields from an exported TypeScript interface.
- */
-function extractFieldsFromInterface(
-  declaration: t.TSInterfaceDeclaration
-): IRFieldDefinition[] {
-  const fields: IRFieldDefinition[] = [];
-
-  for (const member of declaration.body.body) {
-    if (!t.isTSPropertySignature(member)) continue;
-    if (!t.isIdentifier(member.key)) continue;
-
-    const name = member.key.name;
-    const required = !member.optional;
-    const typeAnno = member.typeAnnotation as t.TSTypeAnnotation | undefined;
-    const fieldType = tsTypeToFieldType(typeAnno);
-
-    const field: IRFieldDefinition = {
-      name,
-      type: fieldType,
-      label: name.replace(/([A-Z])/g, ' $1').replace(/^./, (c) => c.toUpperCase()),
-      required,
-      default_value: extractDefaultValue(fieldType),
-    };
-
-    // Extract select options from union types
-    if (typeAnno) {
-      const options = extractUnionOptions(typeAnno.typeAnnotation);
-      if (options) {
-        field.validation = { options };
-      }
-    }
-
-    fields.push(field);
-  }
-
-  return fields;
-}
-
-// =============================================================================
-// Transitions Extraction
-// =============================================================================
-
-interface TransitionConfig {
-  from: string | string[];
-  to: string;
-  guard?: string;
-  roles?: string[];
-  auto?: boolean;
-  required_fields?: string[];
-  description?: string;
-  actions?: Array<Record<string, unknown>>;
-  conditions?: Array<Record<string, unknown>>;
-}
-
-/**
- * Extracts transitions from `export const transitions = { ... }`.
- */
-function extractTransitionsFromObject(
-  init: t.ObjectExpression,
-  actionCounter: { value: number }
-): IRTransitionDefinition[] {
-  const transitions: IRTransitionDefinition[] = [];
-
-  for (const prop of init.properties) {
-    if (!t.isObjectProperty(prop)) continue;
-    if (!t.isIdentifier(prop.key) && !t.isStringLiteral(prop.key)) continue;
-    if (!t.isObjectExpression(prop.value)) continue;
-
-    const name = t.isIdentifier(prop.key) ? prop.key.name : prop.key.value;
-    const config = extractObjectLiteral(prop.value) as unknown as TransitionConfig;
-
-    // Parse from: can be string or array of strings
-    let from: string[] = [];
-    if (typeof config.from === 'string') {
-      from = [config.from];
-    } else if (Array.isArray(config.from)) {
-      from = config.from.map(String);
-    }
-
-    const to = String(config.to || '');
-
-    // Build conditions from guard expression
-    const conditions: IRConditionDefinition[] = [];
-    if (config.guard) {
-      conditions.push(parseGuardExpression(config.guard));
-    }
-    // Also merge any explicit conditions
-    if (config.conditions && Array.isArray(config.conditions)) {
-      for (const cond of config.conditions) {
-        conditions.push(cond as IRConditionDefinition);
-      }
-    }
-
-    // Build actions from inline actions
-    const actions: IRActionDefinition[] = [];
-    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 as any).type || 'custom',
-            mode: 'auto',
-            config: action as Record<string, unknown>,
-          });
-        }
-      }
-    }
-
-    transitions.push({
-      name,
-      from,
-      to,
-      description: config.description,
-      conditions: conditions.length > 0 ? conditions : undefined,
-      actions,
-      roles: config.roles,
-      auto: config.auto,
-      required_fields: config.required_fields,
-    });
-  }
-
-  return transitions;
-}
-
-// =============================================================================
-// Guard Expression Parsing
-// =============================================================================
-
-/**
- * Parses a guard expression string into IRConditionDefinition.
- *
- * Supports:
- *   - Simple field comparison: "$user.role == \"admin\""
- *   - Expression form: any string → expression condition
- */
-function parseGuardExpression(guard: string): IRConditionDefinition {
-  // Try to parse simple field operator value patterns
-  // The \$? prefix is included in the capture group so $user.role stays as $user.role
-  // Operators are ordered longest-first to prevent partial matches (>= before >)
-  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: Record<string, IRConditionDefinition['operator']> = {
-      '==': '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: unknown = rawValue?.trim();
-      if (value === undefined || value === '') {
-        // Unary operators like is_set/is_empty
-        return { field, operator };
-      }
-      // Parse value
-      if (typeof value === 'string') {
-        // Remove quotes
-        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 };
-    }
-  }
-
-  // Fall back to expression form
-  return { expression: guard };
-}
-
-// =============================================================================
-// Hooks Extraction
-// =============================================================================
-
-/**
- * Extracts hooks from `export const hooks = { ... }`.
- *
- * Format:
- *   on_enter_stateName: { emit: 'event:name', actions: ['handler1', 'handler2'] }
- *   on_exit_stateName: { actions: ['cleanup'] }
- */
-function extractHooksFromObject(
-  init: t.ObjectExpression,
-  states: Map<string, IRStateDefinition>,
-  actionCounter: { value: number }
-): void {
-  for (const prop of init.properties) {
-    if (!t.isObjectProperty(prop)) continue;
-    if (!t.isIdentifier(prop.key) && !t.isStringLiteral(prop.key)) continue;
-
-    const hookName = t.isIdentifier(prop.key) ? prop.key.name : prop.key.value;
-    const hookConfig = t.isObjectExpression(prop.value)
-      ? extractObjectLiteral(prop.value)
-      : {};
-
-    // Parse hook name: on_enter_active, on_exit_draft, etc.
-    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';
-
-    // Ensure state exists
-    if (!states.has(stateName)) {
-      states.set(stateName, {
-        name: stateName,
-        type: 'REGULAR',
-        on_enter: [],
-        during: [],
-        on_exit: [],
-      });
-    }
-    const state = states.get(stateName)!;
-
-    // Process emit → emit_event action
-    if (hookConfig.emit && typeof hookConfig.emit === 'string') {
-      const action: IRActionDefinition = {
-        id: `auto_${++actionCounter.value}`,
-        type: 'emit_event',
-        mode: 'auto',
-        config: { event: hookConfig.emit },
-      };
-      state[phase].push(action);
-    }
-
-    // Process actions[] → server_action references
-    if (hookConfig.actions && Array.isArray(hookConfig.actions)) {
-      for (const handler of hookConfig.actions) {
-        if (typeof handler === 'string') {
-          const action: IRActionDefinition = {
-            id: `auto_${++actionCounter.value}`,
-            type: 'server_action',
-            mode: 'auto',
-            config: { handler },
-          };
-          state[phase].push(action);
-        }
-      }
-    }
-  }
-}
-
-// =============================================================================
-// Field Options Extraction
-// =============================================================================
-
-/**
- * Extracts field options from `export const fieldOptions = { ... }`.
- * Enriches existing fields with ACL, computed, validation, state home.
- */
-function applyFieldOptions(
-  fields: IRFieldDefinition[],
-  init: t.ObjectExpression
-): void {
-  const options = extractObjectLiteral(init) as Record<string, Record<string, unknown>>;
-
-  for (const [fieldName, opts] of Object.entries(options)) {
-    const field = fields.find((f) => f.name === fieldName);
-    if (!field) continue;
-
-    // State home
-    if (opts.scope || opts.persistence || opts.sync) {
-      field.state_home = {
-        scope: (opts.scope as IRStateHome['scope']) || 'instance',
-        persistence: (opts.persistence as IRStateHome['persistence']) || 'durable',
-        sync: (opts.sync as IRStateHome['sync']) || 'none',
-      };
-    }
-
-    // Computed fields
-    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);
-    }
-
-    // Field-level ACL
-    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;
-    }
-
-    // Validation enrichment
-    if (opts.validation && typeof opts.validation === 'object') {
-      const val = opts.validation as Record<string, unknown>;
-      const validation: IRFieldValidation = field.validation || {};
-      if (val.min !== undefined) validation.min = Number(val.min);
-      if (val.max !== undefined) validation.max = Number(val.max);
-      if (val.minLength !== undefined) validation.minLength = Number(val.minLength);
-      if (val.maxLength !== undefined) 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: any) => ({
-          expression: String(r.expression || ''),
-          message: String(r.message || ''),
-          severity: r.severity === 'warning' ? 'warning' : 'error',
-        }));
-      }
-      field.validation = validation;
-    }
-  }
-}
-
-// =============================================================================
-// Utility: Extract JS object literal to plain object
-// =============================================================================
-
-/**
- * Converts an AST ObjectExpression to a plain JavaScript object.
- * Handles string, number, boolean, null, arrays, and nested objects.
- */
-function extractObjectLiteral(node: t.ObjectExpression): Record<string, unknown> {
-  const obj: Record<string, unknown> = {};
-
-  for (const prop of node.properties) {
-    if (!t.isObjectProperty(prop)) continue;
-
-    const key = t.isIdentifier(prop.key)
-      ? prop.key.name
-      : t.isStringLiteral(prop.key)
-        ? prop.key.value
-        : null;
-    if (!key) continue;
-
-    obj[key] = extractNodeValue(prop.value);
-  }
-
-  return obj;
-}
-
-/**
- * Extracts a value from an AST node into a plain JS value.
- */
-function extractNodeValue(node: t.Node): unknown {
-  if (t.isStringLiteral(node)) return node.value;
-  if (t.isNumericLiteral(node)) return node.value;
-  if (t.isBooleanLiteral(node)) return node.value;
-  if (t.isNullLiteral(node)) return null;
-
-  if (t.isArrayExpression(node)) {
-    return node.elements.map((el) => {
-      if (!el) return null;
-      if (t.isSpreadElement(el)) return '[Spread]';
-      return extractNodeValue(el);
-    });
-  }
-
-  if (t.isObjectExpression(node)) {
-    return extractObjectLiteral(node);
-  }
-
-  if (t.isTemplateLiteral(node)) {
-    return node.quasis.map((q) => q.value.raw).join('${}');
-  }
-
-  if (t.isIdentifier(node)) {
-    // For bare identifiers like `true` treated as identifier in some contexts
-    if (node.name === 'undefined') return undefined;
-    return node.name;
-  }
-
-  if (t.isConditionalExpression(node)) {
-    return `(${extractNodeValue(node.test)} ? ${extractNodeValue(node.consequent)} : ${extractNodeValue(node.alternate)})`;
-  }
-  if (t.isBinaryExpression(node)) {
-    return `(${extractNodeValue(node.left)} ${node.operator} ${extractNodeValue(node.right)})`;
-  }
-  if (t.isLogicalExpression(node)) {
-    return `(${extractNodeValue(node.left)} ${node.operator} ${extractNodeValue(node.right)})`;
-  }
-  if (t.isMemberExpression(node)) {
-    const obj = t.isIdentifier(node.object) ? node.object.name : '[object]';
-    const prop = t.isIdentifier(node.property) ? node.property.name : '[property]';
-    return `${obj}.${prop}`;
-  }
-  if (t.isTSAsExpression(node)) return extractNodeValue(node.expression);
-  if (t.isTSNonNullExpression(node)) return extractNodeValue(node.expression);
-
-  return '[Expression]';
-}
-
-// =============================================================================
-// Main Extraction Entry Point
-// =============================================================================
-
-/**
- * Detects whether a file is a model file.
- * Criteria: file path includes /models/ OR exports an interface + transitions
- *           OR has an `export default defineModel(...)` call.
- */
-export function isModelFile(path: NodePath<t.Program>, filename: string | undefined): boolean {
-  // Path-based detection
-  if (filename && /\/models\//.test(filename)) return true;
-
-  let hasInterface = false;
-  let hasTransitions = false;
-  let hasDefineModel = false;
-
-  for (const node of path.node.body) {
-    // Check for defineModel() in export default
-    if (t.isExportDefaultDeclaration(node)) {
-      const decl = node.declaration;
-      if (t.isCallExpression(decl) && t.isIdentifier(decl.callee) && decl.callee.name === 'defineModel') {
-        hasDefineModel = true;
-      }
-    }
-    // Duck-typing: check for exported interface + exported transitions
-    if (t.isExportNamedDeclaration(node)) {
-      if (t.isTSInterfaceDeclaration(node.declaration)) {
-        hasInterface = true;
-      }
-      if (t.isVariableDeclaration(node.declaration)) {
-        for (const decl of node.declaration.declarations) {
-          if (t.isIdentifier(decl.id) && decl.id.name === 'transitions') {
-            hasTransitions = true;
-          }
-        }
-      }
-    }
-  }
-
-  return hasDefineModel || (hasInterface && hasTransitions);
-}
-
-// =============================================================================
-// defineModel() extraction
-// =============================================================================
-
-/**
- * Maps a defineModel field type string back to an IR field type.
- */
-function modelTypeToIRType(modelType: string): IRWorkflowFieldType {
-  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 as IRWorkflowFieldType;
-  }
-}
-
-/**
- * Maps a defineModel state type ('initial'/'final') to IR state type.
- */
-function modelStateTypeToIR(type: string | undefined): 'START' | 'END' | 'REGULAR' {
-  if (type === 'initial') return 'START';
-  if (type === 'final') return 'END';
-  return 'REGULAR';
-}
-
-/**
- * Extracts a defineModel({ ... }) call and populates compiler state.
- * Returns true if a defineModel call was found and extracted.
- */
-function extractDefineModelCall(
-  programPath: NodePath<t.Program>,
-  compilerState: CompilerState,
-  actionCounter: { value: number },
-): boolean {
-  for (const node of programPath.node.body) {
-    if (!t.isExportDefaultDeclaration(node)) continue;
-    const decl = node.declaration;
-    if (!t.isCallExpression(decl)) continue;
-    if (!t.isIdentifier(decl.callee) || decl.callee.name !== 'defineModel') continue;
-    if (decl.arguments.length === 0 || !t.isObjectExpression(decl.arguments[0])) continue;
-
-    const config = extractObjectLiteral(decl.arguments[0]);
-
-    // Metadata from top-level properties
-    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);
-
-    // Fields
-    if (config.fields && typeof config.fields === 'object' && !Array.isArray(config.fields)) {
-      const fieldsObj = config.fields as Record<string, Record<string, unknown>>;
-      for (const [name, fieldConfig] of Object.entries(fieldsObj)) {
-        const irType = modelTypeToIRType(String(fieldConfig.type || 'text'));
-        const field: IRFieldDefinition = {
-          name,
-          type: irType,
-          required: fieldConfig.required === true,
-          default_value: fieldConfig.default !== undefined ? fieldConfig.default : extractDefaultValue(irType),
-        };
-        // Enum → validation.options
-        if (fieldConfig.enum && Array.isArray(fieldConfig.enum)) {
-          (field as any).validation = { options: fieldConfig.enum.map(String) };
-        }
-        compilerState.fields.push(field);
-      }
-    }
-
-    // States
-    if (config.states && typeof config.states === 'object' && !Array.isArray(config.states)) {
-      const statesObj = config.states as Record<string, Record<string, unknown>>;
-      for (const [name, stateConfig] of Object.entries(statesObj)) {
-        const stateType = modelStateTypeToIR(stateConfig.type as string | undefined);
-        if (!compilerState.states.has(name)) {
-          compilerState.states.set(name, {
-            name,
-            type: stateType,
-            description: stateConfig.description as string | undefined,
-            on_enter: [],
-            during: [],
-            on_exit: [],
-          });
-        } else {
-          // Explicit states are authoritative
-          compilerState.states.get(name)!.type = stateType;
-        }
-      }
-    }
-
-    // Transitions
-    if (config.transitions && typeof config.transitions === 'object' && !Array.isArray(config.transitions)) {
-      const transObj = config.transitions as Record<string, Record<string, unknown>>;
-      for (const [name, transConfig] of Object.entries(transObj)) {
-        let from: string[] = [];
-        if (typeof transConfig.from === 'string') {
-          from = [transConfig.from];
-        } else if (Array.isArray(transConfig.from)) {
-          from = transConfig.from.map(String);
-        }
-        const to = String(transConfig.to || '');
-
-        // Ensure referenced states exist
-        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: IRConditionDefinition[] = [];
-        if (transConfig.guard) {
-          conditions.push(parseGuardExpression(String(transConfig.guard)));
-        }
-
-        compilerState.transitions.push({
-          name,
-          from,
-          to,
-          description: transConfig.description as string | undefined,
-          conditions: conditions.length > 0 ? conditions : undefined,
-          actions: [],
-          roles: transConfig.roles as string[] | undefined,
-          auto: transConfig.auto as boolean | undefined,
-          required_fields: transConfig.required_fields as string[] | undefined,
-        });
-      }
-    }
-
-    // Roles (with descriptions and permissions)
-    if (config.roles && typeof config.roles === 'object' && !Array.isArray(config.roles)) {
-      const rolesObj = config.roles as Record<string, Record<string, unknown>>;
-      if (!compilerState.metadata.roles) compilerState.metadata.roles = {};
-      for (const [roleName, roleConfig] of Object.entries(rolesObj)) {
-        (compilerState.metadata.roles as Record<string, unknown>)[roleName] = {
-          description: roleConfig.description,
-          permissions: roleConfig.permissions,
-        };
-      }
-    }
-
-    // Metadata
-    if (config.metadata && typeof config.metadata === 'object') {
-      compilerState.metadata.modelMetadata = config.metadata;
-    }
-
-    return true;
-  }
-
-  return false;
-}
-
-/**
- * Extracts a complete workflow from a model file.
- * Called from visitor.ts when a model file is detected.
- *
- * Supports two formats:
- *   1. defineModel({ slug, fields, states, transitions }) — preferred
- *   2. Legacy: export interface + export const states/transitions
- */
-export function extractModelFile(path: NodePath<t.Program>, state: any): void {
-  const compilerState = state as CompilerState;
-  if (!compilerState.actionCounter) compilerState.actionCounter = 0;
-  const actionCounter = { value: compilerState.actionCounter };
-
-  // Try defineModel() format first — if found, also extract companion interface
-  // for field metadata (required, types) but defineModel is authoritative for
-  // slug/version/category/states/transitions.
-  const foundDefineModel = extractDefineModelCall(path, compilerState, actionCounter);
-
-  if (foundDefineModel) {
-    // Also extract companion interface fields for richer type metadata
-    // (e.g. required status from TS syntax: `name: string` vs `name?: string`)
-    for (const node of path.node.body) {
-      if (t.isExportNamedDeclaration(node) && t.isTSInterfaceDeclaration(node.declaration)) {
-        const interfaceFields = extractFieldsFromInterface(node.declaration);
-        // Merge required + type from interface into existing defineModel fields
-        for (const iField of interfaceFields) {
-          const existing = compilerState.fields.find(f => f.name === iField.name);
-          if (existing) {
-            if (iField.required) existing.required = true;
-          }
-        }
-        // Set metadata name from interface name
-        if (!compilerState.metadata.name) {
-          compilerState.metadata.name = node.declaration.id.name;
-        }
-      }
-    }
-    compilerState.actionCounter = actionCounter.value;
-    return;
-  }
-
-  // Legacy format: export interface + export const states/transitions
-  let interfaceName = '';
-
-  for (const node of path.node.body) {
-    if (!t.isExportNamedDeclaration(node)) continue;
-    const declaration = node.declaration;
-
-    // Interface → fields
-    if (t.isTSInterfaceDeclaration(declaration)) {
-      interfaceName = declaration.id.name;
-      const fields = extractFieldsFromInterface(declaration);
-      compilerState.fields.push(...fields);
-
-      // Infer states from union-typed fields (first union field found)
-      for (const field of fields) {
-        if (field.validation?.options && field.validation.options.length > 0) {
-          // Create states for each option
-          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: [],
-              });
-            }
-          }
-          // First option is the START state
-          const firstState = compilerState.states.get(field.validation.options[0]);
-          if (firstState) firstState.type = 'START';
-          break; // Only use first union field for state inference
-        }
-      }
-
-      // Set metadata name from interface name
-      if (!compilerState.metadata.name) {
-        compilerState.metadata.name = interfaceName;
-      }
-    }
-
-    // Variable declarations
-    if (t.isVariableDeclaration(declaration)) {
-      for (const decl of declaration.declarations) {
-        if (!t.isIdentifier(decl.id) || !decl.init) continue;
-        const varName = decl.id.name;
-
-        // transitions = { ... }
-        if (varName === 'transitions' && t.isObjectExpression(decl.init)) {
-          const transitions = extractTransitionsFromObject(decl.init, actionCounter);
-          compilerState.transitions.push(...transitions);
-
-          // Ensure all referenced states exist
-          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: [],
-              });
-            }
-          }
-        }
-
-        // states = [{ name: 'draft', type: 'START' as const }, ...] as const
-        // Parse the explicit states array used in decompiler-generated model files
-        if (varName === 'states') {
-          const arrExpr = t.isTSAsExpression(decl.init) ? decl.init.expression : decl.init;
-          if (t.isArrayExpression(arrExpr)) {
-            for (const el of arrExpr.elements) {
-              if (!t.isObjectExpression(el)) continue;
-              let stateName = '';
-              let stateType = 'REGULAR';
-              let stateDesc = '';
-              for (const prop of el.properties) {
-                if (!t.isObjectProperty(prop) || !t.isIdentifier(prop.key)) continue;
-                if (prop.key.name === 'name' && t.isStringLiteral(prop.value)) {
-                  stateName = prop.value.value;
-                } else if (prop.key.name === 'type') {
-                  // type: 'START' as const → unwrap TSAsExpression
-                  const val = t.isTSAsExpression(prop.value) ? prop.value.expression : prop.value;
-                  if (t.isStringLiteral(val)) stateType = val.value;
-                } else if (prop.key.name === 'description' && t.isStringLiteral(prop.value)) {
-                  stateDesc = prop.value.value;
-                }
-              }
-              if (stateName && !compilerState.states.has(stateName)) {
-                compilerState.states.set(stateName, {
-                  name: stateName,
-                  type: stateType as 'START' | 'END' | 'REGULAR',
-                  description: stateDesc || undefined,
-                  on_enter: [],
-                  during: [],
-                  on_exit: [],
-                });
-              } else if (stateName) {
-                // Explicit states array is authoritative — always override type
-                // (even downgrading from inferred START to declared REGULAR).
-                compilerState.states.get(stateName)!.type = stateType as 'START' | 'END' | 'REGULAR';
-              }
-            }
-          }
-        }
-
-        // endStates = ['deleted']
-        if (varName === 'endStates' && t.isArrayExpression(decl.init)) {
-          for (const el of decl.init.elements) {
-            if (t.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';
-              }
-            }
-          }
-        }
-
-        // cancelledStates = ['cancelled']
-        if (varName === 'cancelledStates' && t.isArrayExpression(decl.init)) {
-          for (const el of decl.init.elements) {
-            if (t.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';
-              }
-            }
-          }
-        }
-
-        // hooks = { ... }
-        if (varName === 'hooks' && t.isObjectExpression(decl.init)) {
-          extractHooksFromObject(decl.init, compilerState.states, actionCounter);
-        }
-
-        // runtime = 'backend'
-        if (varName === 'runtime' && t.isStringLiteral(decl.init)) {
-          compilerState.metadata.runtime = decl.init.value as RuntimeProfile;
-        }
-
-        // fieldOptions = { ... }
-        if (varName === 'fieldOptions' && t.isObjectExpression(decl.init)) {
-          applyFieldOptions(compilerState.fields, decl.init);
-        }
-      }
-    }
-  }
-
-  compilerState.actionCounter = actionCounter.value;
-
-  // For model files, derive slug from interface name if slug was auto-derived from filename
-  // (JSDoc @workflow slug takes precedence and should never be overridden)
-  if (interfaceName && (compilerState.metadata as any).__slugAutoFallback) {
-    compilerState.metadata.slug = interfaceName
-      .replace(/([A-Z])/g, '-$1')
-      .toLowerCase()
-      .replace(/^-/, '');
-    delete (compilerState.metadata as any).__slugAutoFallback;
-  }
-}