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

package/src/babel/visitor.ts

@@ -1,807 +0,0 @@
-/**
- * Babel Visitor — main AST traversal logic for extracting workflow definitions.
- *
- * Handles all @mindmatrix/react hooks:
- * - useState → fields
- * - useOnEnter / useOnExit → state enter/exit actions
- * - useTransition → transitions
- * - useOnEvent → event subscriptions
- * - useWhileIn → during actions (interval while in state)
- * - useOnChange → field watchers
- * - useOnTransition → transition effects
- *
- * Supports strict/infer mode enforcement.
- */
-
-import type { Visitor } from '@babel/traverse';
-import * as t from '@babel/types';
-import type { CompilerState, CompilerOptions, ReactCompilerError } from '../types';
-import { extractStates } from './extractors/state-extractor';
-import { extractEffects } from './extractors/effect-extractor';
-import { extractTransitions } from './extractors/transition-extractor';
-import { extractEvents } from './extractors/event-extractor';
-import { extractComponents, resetNodeIdCounter, registerDerivedVar } from './extractors/component-extractor';
-import { extractDuring, resetDuringIdCounter } from './extractors/during-extractor';
-import { extractChangeWatcher, resetWatcherIdCounter } from './extractors/change-extractor';
-import { extractComputed } from './extractors/computed-extractor';
-import { extractTransitionEffect, resetTransitionEffectIdCounter } from './extractors/transition-effect-extractor';
-import { isModelFile, extractModelFile } from './extractors/model-extractor';
-import { isServerActionFile, extractServerActions } from './extractors/server-action-extractor';
-import { extractServerActionHook } from './extractors/server-action-hook-extractor';
-import { extractServerState } from './extractors/server-state-extractor';
-import { extractGrammarIslands } from './extractors/grammar-island-extractor';
-import { hasContextCreation, extractContextWorkflows } from './extractors/context-extractor';
-import { emitIR, emitCanonical, emitWorkflowDefinition, compilerStateToWorkflow } from './emitters/pure-form-emitter';
-import type { IRDataSource, IRWorkflowDataSource } from '@mindmatrix/player-core';
-import type { NodePath } from '@babel/traverse';
-
-/**
- * Extracts useQuery() calls into IRDataSource declarations.
- * useQuery('channel', { state: 'active' }) → IRDataSource with type 'workflow'
- */
-/**
- * Resolves a useQuery/useMutation slug argument.
- * Supports string literals ('channel') and identifier references to imported defineModel results.
- *
- * When the argument is an identifier (e.g. `useQuery(ChannelModel)`), we:
- * 1. Look up the import source in __modelImports
- * 2. Derive the slug from the import path (e.g. '../models/channel' → 'channel')
- * 3. Also check __modelImportSlugs for slugs resolved from actual file contents
- */
-function resolveSlugArg(args: t.Node[], state: any): string | null {
-  if (args.length < 1) return null;
-  const slugArg = args[0];
-
-  // Direct string literal: useQuery('channel')
-  if (t.isStringLiteral(slugArg)) return slugArg.value;
-
-  // Identifier reference: useQuery(ChannelModel)
-  // Resolve via tracked model imports
-  if (t.isIdentifier(slugArg)) {
-    const compilerState = state as CompilerState;
-    const meta = compilerState.metadata as Record<string, unknown>;
-
-    // Check pre-resolved slugs first (from file content analysis)
-    const resolvedSlugs = meta.__modelImportSlugs as Record<string, string> | undefined;
-    if (resolvedSlugs?.[slugArg.name]) return resolvedSlugs[slugArg.name];
-
-    // Fall back to slug derived from import path
-    const importSources = meta.__modelImports as Record<string, string> | undefined;
-    if (importSources?.[slugArg.name]) {
-      const importPath = importSources[slugArg.name];
-      // Derive slug from the import path's filename
-      // e.g. '../models/channel' → 'channel'
-      // e.g. '../models/user-profile' → 'user-profile'
-      // e.g. './models/OrderItem' → 'order-item'
-      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: NodePath<t.CallExpression>, state: any): void {
-  const args = path.node.arguments;
-  if (args.length < 1) return;
-
-  const slug = resolveSlugArg(args, state);
-  if (!slug) return;
-  const compilerState = state as CompilerState;
-
-  // Build data source from useQuery params
-  const dataSource: IRWorkflowDataSource = {
-    type: 'workflow',
-    name: slug,
-    slug,
-    query: 'list',
-  };
-
-  // Extract options if provided — maps QueryParams → IRWorkflowDataSource fields
-  if (args.length > 1 && t.isObjectExpression(args[1])) {
-    for (const prop of args[1].properties) {
-      if (!t.isObjectProperty(prop) || !t.isIdentifier(prop.key)) continue;
-      const key = prop.key.name;
-      const val = prop.value;
-
-      switch (key) {
-        case 'limit':
-          if (t.isNumericLiteral(val)) {
-            dataSource.pageSize = val.value;
-            dataSource.paginated = true;
-          }
-          break;
-        case 'orderBy':
-          if (t.isStringLiteral(val)) {
-            dataSource.sort = val.value;
-          }
-          break;
-        case 'order':
-          if (t.isStringLiteral(val) && dataSource.sort) {
-            dataSource.sort = `${dataSource.sort}:${val.value}`;
-          }
-          break;
-        case 'search':
-          if (t.isStringLiteral(val)) {
-            dataSource.search = val.value;
-          }
-          break;
-        case 'searchFields':
-          if (t.isArrayExpression(val)) {
-            dataSource.searchFields = val.elements
-              .filter((el): el is t.StringLiteral => t.isStringLiteral(el))
-              .map(el => el.value);
-          }
-          break;
-        case 'filter':
-          if (t.isObjectExpression(val)) {
-            const filter: Record<string, string> = {};
-            for (const fp of val.properties) {
-              if (t.isObjectProperty(fp) && t.isIdentifier(fp.key) && t.isStringLiteral(fp.value)) {
-                filter[fp.key.name] = fp.value.value;
-              }
-            }
-            if (Object.keys(filter).length > 0) {
-              dataSource.filter = filter;
-            }
-          }
-          break;
-        case 'state':
-          // Shorthand: filter by workflow state
-          if (t.isStringLiteral(val)) {
-            if (!dataSource.filter) dataSource.filter = {};
-            dataSource.filter.current_state = val.value;
-          }
-          break;
-        case 'groupBy':
-          if (t.isStringLiteral(val)) {
-            dataSource.groupBy = val.value;
-          }
-          break;
-        case 'facets':
-          if (t.isArrayExpression(val)) {
-            dataSource.facets = val.elements
-              .filter((el): el is t.StringLiteral => t.isStringLiteral(el))
-              .map(el => el.value);
-          }
-          break;
-      }
-    }
-  }
-
-  // Store data sources on the metadata for later emission
-  if (!compilerState.metadata) compilerState.metadata = {};
-  const meta = compilerState.metadata as Record<string, unknown>;
-  if (!meta.dataSources) meta.dataSources = [];
-  (meta.dataSources as IRDataSource[]).push(dataSource);
-}
-
-/**
- * Extracts useMutation() calls into mutation action stubs.
- * useMutation('channel') → records the slug for transition/create capability
- */
-function extractMutationDataSource(path: NodePath<t.CallExpression>, state: any): void {
-  const args = path.node.arguments;
-  if (args.length < 1) return;
-
-  const slug = resolveSlugArg(args, state);
-  if (!slug) return;
-  const compilerState = state as CompilerState;
-
-  // Store mutation targets on metadata
-  if (!compilerState.metadata) compilerState.metadata = {};
-  const meta = compilerState.metadata as Record<string, unknown>;
-  if (!meta.mutationTargets) meta.mutationTargets = [];
-  (meta.mutationTargets as string[]).push(slug);
-}
-
-/**
- * Extracts useDuringAction({ state, action, intervalMs }) into during actions.
- * Alternate API for useWhileIn — config object instead of positional args.
- */
-function extractDuringAction(path: NodePath<t.CallExpression>, state: any): void {
-  const args = path.node.arguments;
-  if (args.length < 1 || !t.isObjectExpression(args[0])) return;
-
-  const compilerState = state as CompilerState;
-  const config = args[0];
-
-  let stateName: string | undefined;
-  let intervalMs = 1000;
-
-  for (const prop of config.properties) {
-    if (!t.isObjectProperty(prop) || !t.isIdentifier(prop.key)) continue;
-    if (prop.key.name === 'state' && t.isStringLiteral(prop.value)) {
-      stateName = prop.value.value;
-    }
-    if (prop.key.name === 'intervalMs' && t.isNumericLiteral(prop.value)) {
-      intervalMs = prop.value.value;
-    }
-  }
-
-  if (!stateName) return;
-
-  // Ensure state exists
-  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: [],
-  });
-}
-
-/**
- * Extracts useRole('roleName') into metadata.roleDependencies.
- */
-function extractRoleDependency(path: NodePath<t.CallExpression>, state: any): void {
-  const args = path.node.arguments;
-  if (args.length < 1 || !t.isStringLiteral(args[0])) return;
-
-  const compilerState = state as CompilerState;
-  if (!compilerState.metadata) compilerState.metadata = {};
-  const meta = compilerState.metadata as Record<string, unknown>;
-  if (!meta.roleDependencies) meta.roleDependencies = [];
-  const roles = meta.roleDependencies as string[];
-  const role = args[0].value;
-  if (!roles.includes(role)) roles.push(role);
-}
-
-/**
- * Extracts useView('slug') into metadata.viewDependencies.
- */
-function extractViewDependency(path: NodePath<t.CallExpression>, state: any): void {
-  const args = path.node.arguments;
-  if (args.length < 1 || !t.isStringLiteral(args[0])) return;
-
-  const compilerState = state as CompilerState;
-  if (!compilerState.metadata) compilerState.metadata = {};
-  const meta = compilerState.metadata as Record<string, unknown>;
-  if (!meta.viewDependencies) meta.viewDependencies = [];
-  const views = meta.viewDependencies as string[];
-  const slug = args[0].value;
-  if (!views.includes(slug)) views.push(slug);
-}
-
-/**
- * Extracts useParams() into metadata.acceptsParams = true.
- */
-function extractParamsUsage(_path: NodePath<t.CallExpression>, state: any): void {
-  const compilerState = state as CompilerState;
-  if (!compilerState.metadata) compilerState.metadata = {};
-  const meta = compilerState.metadata as Record<string, unknown>;
-  meta.acceptsParams = true;
-}
-
-/**
- * Extracts useExpressionLibrary('slug') into metadata.libraryDependencies.
- */
-function extractLibraryDependency(path: NodePath<t.CallExpression>, state: any): void {
-  const args = path.node.arguments;
-  if (args.length < 1 || !t.isStringLiteral(args[0])) return;
-
-  const compilerState = state as CompilerState;
-  if (!compilerState.metadata) compilerState.metadata = {};
-  const meta = compilerState.metadata as Record<string, unknown>;
-  if (!meta.libraryDependencies) meta.libraryDependencies = [];
-  const libs = meta.libraryDependencies as string[];
-  const slug = args[0].value;
-  if (!libs.includes(slug)) libs.push(slug);
-}
-
-/** Hooks banned in strict mode */
-const STRICT_BANNED_HOOKS: Record<string, string> = {
-  useEffect: 'STRICT_USE_EFFECT',
-  useLayoutEffect: 'STRICT_USE_LAYOUT_EFFECT',
-  useRef: 'STRICT_USE_REF',
-  useMemo: 'STRICT_USE_MEMO',
-  useCallback: 'STRICT_USE_CALLBACK',
-};
-
-/**
- * Extracts metadata from JSDoc comments.
- * Shared between Program.enter and FunctionDeclaration.
- */
-function extractMetadataFromComments(comments: any[], metadata: CompilerState['metadata']): void {
-  for (const comment of comments) {
-    if (comment.type !== 'CommentBlock') continue;
-    const lines = comment.value.split('\n');
-    for (const line of lines) {
-      // Match @workflow with inline key=value pairs:
-      // @workflow slug="mm-chat-app" version="1.0.0" category="blueprint"
-      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;
-        }
-        // Fallback: if no key=value pairs, treat whole value as slug
-        if (!hasKV) {
-          metadata.slug = rest;
-        }
-        continue;
-      }
-      // Match standalone @version, @category, @description tags
-      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();
-      }
-    }
-  }
-}
-
-/**
- * Creates the Babel visitor for the plugin.
- */
-export function createVisitor(options: CompilerOptions = {}): Visitor {
-  const mode = options.mode;
-
-  return {
-    Program: {
-      // Initialize compiler state at program entry
-      enter(_path, state: any) {
-        // Reset per-file counters to prevent ID leaks across compilations
-        resetNodeIdCounter();
-        resetDuringIdCounter();
-        resetWatcherIdCounter();
-        resetTransitionEffectIdCounter();
-
-        const compilerState: CompilerState = {
-          fields: [],
-          states: new Map(),
-          transitions: [],
-          events: [],
-          actionCounter: 0,
-          metadata: {},
-          errors: [],
-          warnings: [],
-        };
-
-        // Extract metadata from JSDoc comments
-        const program = _path.node;
-        const leadingComments = program.leadingComments || [];
-        extractMetadataFromComments(leadingComments, compilerState.metadata);
-
-        // Also check leadingComments on first body statement (Babel attaches
-        // top-of-file comments to the first statement, not the program node)
-        if (program.body.length > 0) {
-          const firstStmt = program.body[0];
-          if (firstStmt.leadingComments) {
-            extractMetadataFromComments(firstStmt.leadingComments, compilerState.metadata);
-          }
-        }
-
-        // Extract component name from export and check for JSDoc on function
-        const exportDeclaration = program.body.find((node) =>
-          t.isExportNamedDeclaration(node) || t.isExportDefaultDeclaration(node)
-        );
-
-        if (exportDeclaration) {
-          // Check the export statement's own leading comments (JSDoc may be on the export)
-          if (exportDeclaration.leadingComments) {
-            extractMetadataFromComments(exportDeclaration.leadingComments, compilerState.metadata);
-          }
-
-          if (t.isExportNamedDeclaration(exportDeclaration)) {
-            const declaration = exportDeclaration.declaration;
-            if (t.isFunctionDeclaration(declaration)) {
-              if (declaration.id) {
-                compilerState.metadata.name = declaration.id.name;
-              }
-              if (declaration.leadingComments) {
-                extractMetadataFromComments(declaration.leadingComments, compilerState.metadata);
-              }
-            }
-          } else if (t.isExportDefaultDeclaration(exportDeclaration)) {
-            const declaration = exportDeclaration.declaration;
-            if (t.isFunctionDeclaration(declaration)) {
-              if (declaration.id) {
-                compilerState.metadata.name = declaration.id.name;
-              }
-              if (declaration.leadingComments) {
-                extractMetadataFromComments(declaration.leadingComments, compilerState.metadata);
-              }
-            } else if (t.isIdentifier(declaration)) {
-              compilerState.metadata.name = declaration.name;
-            }
-          }
-        }
-
-        // Infer slug from file name if not set by JSDoc
-        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(/^-/, '');
-          // Track that this was auto-derived (model extractor may override)
-          (compilerState.metadata as any).__slugAutoFallback = true;
-        }
-
-        // Store in state for later phases
-        Object.assign(state, compilerState);
-
-        // Model file detection — extract immediately since all declarations are top-level
-        if (isModelFile(_path, state.filename)) {
-          extractModelFile(_path, state);
-          // Mark as model file so CallExpression/ReturnStatement visitors can skip
-          (state as any).__isModelFile = true;
-          // Model files default to category 'data' (creates a data workflow definition)
-          if (!compilerState.metadata.category) {
-            compilerState.metadata.category = 'data';
-          }
-        }
-
-        // Grammar island extraction — detect tagged templates (cedar, sql, cron, etc.)
-        // Works in both model files and regular workflow files
-        extractGrammarIslands(_path, state);
-
-        // Context workflow extraction — detect createContext() calls
-        if (hasContextCreation(_path)) {
-          extractContextWorkflows(_path, state);
-        }
-
-        // Server action file detection — extract exported functions
-        if (isServerActionFile(state.filename)) {
-          extractServerActions(_path, state);
-          (state as any).__isServerActionFile = true;
-        }
-      },
-
-      // After all extraction, emit Pure Form JSON
-      exit(_path, state: any) {
-        const compilerState = state as CompilerState;
-
-        // Convert to ExtractedWorkflow and emit IR, engine definition, and canonical tree
-        const extracted = compilerStateToWorkflow(compilerState, compilerState.metadata);
-        const ir = emitIR(extracted);
-        const definition = emitWorkflowDefinition(extracted);
-        const canonical = emitCanonical(extracted, state.filename);
-
-        // Attach errors/warnings to IR
-        if (compilerState.errors && compilerState.errors.length > 0) {
-          if (!ir.metadata) ir.metadata = {};
-          (ir.metadata as any).errors = compilerState.errors;
-        }
-        if (compilerState.warnings && compilerState.warnings.length > 0) {
-          if (!ir.metadata) ir.metadata = {};
-          (ir.metadata as any).warnings = compilerState.warnings;
-        }
-
-        // Attach all outputs to file metadata for compile script to consume
-        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: any) {
-      const comments = path.node.leadingComments || [];
-      const compilerState = state as CompilerState;
-      extractMetadataFromComments(comments, compilerState.metadata);
-    },
-
-    // Main hook extraction dispatcher
-    CallExpression(path, state) {
-      const callee = path.node.callee;
-      if (!t.isIdentifier(callee)) return;
-
-      const compilerState = state as CompilerState;
-      const hookName = callee.name;
-
-      // Strict mode enforcement — ban forbidden hooks
-      if (mode === 'strict' && STRICT_BANNED_HOOKS[hookName]) {
-        const error: ReactCompilerError = {
-          code: STRICT_BANNED_HOOKS[hookName] as any,
-          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;
-      }
-
-      // Infer mode: warn about useEffect (component becomes opaque)
-      if (mode === 'infer' && hookName === 'useEffect') {
-        const warning: ReactCompilerError = {
-          code: 'INFER_RAW_JSX',
-          message: `useEffect() found in infer mode — 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':
-          // useDuringAction({ state, action, intervalMs }) → during action (alias for useWhileIn)
-          extractDuringAction(path, state);
-          break;
-        case 'useRole':
-          // useRole('admin') → records role dependency in metadata
-          extractRoleDependency(path, state);
-          break;
-        case 'useView':
-          // useView('my-view') → records view dependency in metadata
-          extractViewDependency(path, state);
-          break;
-        case 'useParams':
-          // useParams() → records that the workflow accepts invocation params
-          extractParamsUsage(path, state);
-          break;
-        case 'useExpressionLibrary':
-          // useExpressionLibrary('tax-calc') → records library dependency
-          extractLibraryDependency(path, state);
-          break;
-        case 'useServerAction':
-          // useServerAction('approve', { instanceId }) → records server action dependency
-          extractServerActionHook(path, state);
-          break;
-        case 'useServerState':
-          // useServerState(instanceId) → records SSE state subscription
-          extractServerState(path, state);
-          break;
-      }
-    },
-
-    // Track imports: model imports for useQuery(modelRef) resolution + strict mode validation
-    ImportDeclaration(path, state) {
-      const compilerState = state as CompilerState;
-      const source = path.node.source.value;
-
-      // Track model imports: imports from paths containing /models/ or ending with .model
-      // e.g. import ChannelModel from '../models/channel'
-      // e.g. import { Channel } from './models/channel.model'
-      if (source.match(/\/models\/|\.model(?:\.[tj]sx?)?$/)) {
-        if (!compilerState.metadata) compilerState.metadata = {};
-        const meta = compilerState.metadata as Record<string, unknown>;
-        if (!meta.__modelImports) meta.__modelImports = {};
-        const imports = meta.__modelImports as Record<string, string>;
-
-        for (const specifier of path.node.specifiers) {
-          if (t.isImportDefaultSpecifier(specifier) || t.isImportSpecifier(specifier)) {
-            imports[specifier.local.name] = source;
-          }
-        }
-      }
-
-      // Strict mode: validate imports
-      if (mode !== 'strict') return;
-
-      // Allow @mindmatrix/* imports and react itself (for types)
-      if (
-        source.startsWith('@mindmatrix/') ||
-        source === 'react' ||
-        source.startsWith('react/') ||
-        source.startsWith('.') ||
-        source.startsWith('/')
-      ) {
-        return;
-      }
-
-      const error: ReactCompilerError = {
-        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 as CompilerState;
-      if (!compilerState.metadata) return;
-
-      const id = path.node.id;
-      const init = path.node.init;
-
-      // Skip array destructuring (useState pattern: const [x, setX] = useState(...))
-      if (t.isArrayPattern(id)) return;
-      if (!t.isIdentifier(id) || !init || !t.isExpression(init)) return;
-
-      // Only track declarations inside the exported component function body
-      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 (t.isIdentifier(varId)) {
-          isExportedByName = varId.name === compilerState.metadata?.name;
-        }
-      }
-      if (!isExportedDirectly && !isExportedByName) return;
-
-      // Handle hook call results
-      if (t.isCallExpression(init) && t.isIdentifier(init.callee)) {
-        const callee = init.callee.name;
-
-        // useQuery result → reference as $instance.{varName}
-        // The data source is already extracted by extractQueryDataSource.
-        // At runtime, the CTR makes query results available on $instance.
-        if (callee === 'useQuery') {
-          // Use optional member expression: $instance?.{varName}
-          // Data sources may not be loaded yet on initial render.
-          registerDerivedVar(id.name, t.optionalMemberExpression(
-            t.identifier('$instance'),
-            t.identifier(id.name),
-            false,  // computed
-            true,   // optional
-          ));
-          return;
-        }
-
-        // useMutation result → reference as $action.transition
-        if (callee === 'useMutation') {
-          registerDerivedVar(id.name, t.memberExpression(
-            t.identifier('$action'),
-            t.identifier('transition'),
-          ));
-          return;
-        }
-
-        // useServerAction result → reference as $action.serverAction
-        if (callee === 'useServerAction') {
-          registerDerivedVar(id.name, t.memberExpression(
-            t.identifier('$action'),
-            t.identifier('serverAction'),
-          ));
-          return;
-        }
-
-        // useServerState result → reference as $instance.serverState
-        if (callee === 'useServerState') {
-          registerDerivedVar(id.name, t.optionalMemberExpression(
-            t.identifier('$instance'),
-            t.identifier('serverState'),
-            false,
-            true,
-          ));
-          return;
-        }
-
-        // useMemo → extract the callback body expression
-        if (callee === 'useMemo' && init.arguments.length >= 1) {
-          const callback = init.arguments[0];
-          if (t.isArrowFunctionExpression(callback)) {
-            if (t.isExpression(callback.body)) {
-              // () => expression
-              registerDerivedVar(id.name, callback.body);
-            } else if (t.isBlockStatement(callback.body)) {
-              // () => { return expression; }
-              const retStmt = callback.body.body.find(s => t.isReturnStatement(s)) as t.ReturnStatement | undefined;
-              if (retStmt?.argument && t.isExpression(retStmt.argument)) {
-                registerDerivedVar(id.name, retStmt.argument);
-              }
-            }
-          }
-          return;
-        }
-
-        // Skip other hooks (useState handled by extractStates, etc.)
-        if (callee.startsWith('use')) return;
-      }
-
-      // Regular const declaration: inline the expression
-      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 (!t.isJSXElement(path.node.argument) && !t.isJSXFragment(path.node.argument)) return;
-
-      // Walk up to find the nearest enclosing function
-      const parentFn = path.getFunctionParent();
-      if (!parentFn) return;
-
-      // Check if this function is the exported component:
-      // export default function Foo() { ... }
-      // export function Foo() { ... }
-      // export default Foo  (where Foo is defined as function above)
-      const parentNode = parentFn.parentPath;
-      const isExportedDirectly =
-        parentNode?.isExportDefaultDeclaration() ||
-        parentNode?.isExportNamedDeclaration();
-
-      // Also handle: const Foo = () => { return <JSX/> }; export default Foo;
-      // In this case parentFn is the arrow/function expression assigned to a variable.
-      // We check if the variable name matches the exported identifier.
-      let isExportedByName = false;
-      if (!isExportedDirectly && parentNode?.isVariableDeclarator()) {
-        const varId = parentNode.node.id;
-        if (t.isIdentifier(varId)) {
-          isExportedByName = varId.name === (state as CompilerState).metadata?.name;
-        }
-      }
-
-      if (isExportedDirectly || isExportedByName) {
-        extractComponents(path, state);
-      }
-    },
-  };
-}