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

package/src/decompiler/project-decompiler.ts

@@ -1,1776 +0,0 @@
-/**
- * project-decompiler.ts — Enhanced multi-file project decompiler.
- *
- * Takes a full WorkflowDefinition (with states, transitions, fields,
- * experience, roles) and produces a multi-file project structure:
- *
- *   - States/Transitions → models/{slug}.ts (exported arrays + interface)
- *   - Experience tree    → app/**\/*.tsx pages based on route structure
- *   - Roles             → auth guard helper in app/layout.tsx
- *   - Server actions    → actions/*.server.ts files
- *   - Config            → mm.config.ts
- *
- * Uses the SplitStrategy to determine output complexity and the
- * ConfigGenerator for mm.config.ts emission.
- */
-
-import type {
-  IRExperienceNode,
-  IRFieldDefinition,
-  IRStateDefinition,
-  IRTransitionDefinition,
-} from '@mindmatrix/player-core';
-import { decompile } from './index';
-import type { DecompilerInput } from './index';
-import { determineSplitStrategy } from './split-strategy';
-import type { SplitDecision } from './split-strategy';
-import { extractConfigData, generateMmConfig } from './config-generator';
-import type { FileRole } from '../envelope/fs-tree';
-
-// =============================================================================
-// Public Types
-// =============================================================================
-
-/** A single file produced by project decompilation. */
-export interface EnhancedProjectFile {
-  /** Relative path from project root. */
-  path: string;
-  /** File role per envelope fs-tree. */
-  role: FileRole;
-  /** Generated source code. */
-  content: string;
-  /** SHA-256 hash of content (for workspace hydration). */
-  hash?: string;
-}
-
-/** Result of the enhanced project decompiler. */
-export interface EnhancedDecompileResult {
-  files: EnhancedProjectFile[];
-  entryFile: string;
-  slug: string;
-  splitDecision: SplitDecision;
-}
-
-// =============================================================================
-// Name Helpers
-// =============================================================================
-
-function pascalCase(slug: string): string {
-  return slug
-    .split(/[-_]/)
-    .map(part => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
-    .join('');
-}
-
-function camelCase(str: string): string {
-  return str.replace(/[-_]([a-z])/g, (_, c: string) => c.toUpperCase());
-}
-
-/**
- * Corrects the "all same from" compiler bug in transitions.
- * When all transitions share the same `from` value AND every transition
- * name is an independently-known state name (from `from` + `to` fields only,
- * NOT from the transition names themselves), the transition name is used as
- * the actual source state.
- *
- * This avoids false positives where transitions like "increment" and "reset"
- * share `from: 'idle'` but are NOT state names.
- */
-function correctTransitionFromFields(
-  transitions: IRTransitionDefinition[],
-): IRTransitionDefinition[] {
-  if (transitions.length <= 1) return transitions;
-
-  const fromValues = new Set<string>();
-  for (const t of transitions) {
-    const arr = Array.isArray(t.from) ? t.from : [t.from as unknown as string];
-    for (const f of arr) fromValues.add(f);
-  }
-  if (fromValues.size !== 1) return transitions;
-
-  // Build state set from from/to values ONLY (not from transition names)
-  const stateNames = new Set<string>([...fromValues]);
-  for (const t of transitions) {
-    stateNames.add(t.to);
-  }
-
-  // Only apply correction if EVERY transition name is already a known state
-  const allNamesAreStates = transitions.every(t => stateNames.has(t.name));
-  if (!allNamesAreStates) return transitions;
-
-  return transitions.map(t => ({ ...t, from: [t.name] }));
-}
-
-function fieldTypeToTS(fieldType: string, field?: IRFieldDefinition): string {
-  // Check for options → emit union type
-  const options = getFieldOptions(field);
-  if (options && options.length > 0 && (fieldType === 'select' || fieldType === 'text')) {
-    return options.map(o => `'${esc(String(o))}'`).join(' | ');
-  }
-
-  switch (fieldType) {
-    case 'text': case 'rich_text': case 'email': case 'url':
-    case 'phone': case 'color': case 'select':
-      return 'string';
-    case 'number': case 'currency': case 'percentage':
-    case 'rating': case 'duration': case 'auto_number':
-      return 'number';
-    case 'boolean':
-      return 'boolean';
-    case 'date': case 'datetime': case 'created_at': case 'updated_at':
-      return 'Date';
-    case 'multi_select':
-      return 'string[]';
-    case 'json': case 'object':
-      return 'Record<string, unknown>';
-    case 'array':
-      return 'string[]';
-    case 'file': case 'image':
-      return 'string';
-    case 'relation': case 'lookup':
-      return 'string';
-    default:
-      return 'unknown';
-  }
-}
-
-/**
- * Extracts options from a field's validation or metadata.
- * Options may be stored as:
- *   - field.validation.options (primary — DB schema)
- *   - field.metadata.options (fallback)
- *   - field.options (legacy)
- */
-function getFieldOptions(field?: IRFieldDefinition): string[] | null {
-  if (!field) return null;
-  const f = field as unknown as Record<string, unknown>;
-
-  // Primary: validation.options
-  const validation = f.validation as Record<string, unknown> | undefined;
-  if (validation?.options && Array.isArray(validation.options)) {
-    return validation.options as string[];
-  }
-
-  // Fallback: metadata.options
-  const meta = f.metadata as Record<string, unknown> | undefined;
-  if (meta?.options && Array.isArray(meta.options)) {
-    return meta.options as string[];
-  }
-
-  // Legacy: field.options
-  if (f.options && Array.isArray(f.options)) {
-    return f.options as string[];
-  }
-
-  return null;
-}
-
-// =============================================================================
-// Model File: defineModel() + companion interface
-// =============================================================================
-
-/**
- * Returns a valid JS object key — quoted if the name isn't a valid identifier.
- */
-function safeKey(name: string): string {
-  return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name) ? name : `'${esc(name)}'`;
-}
-
-/**
- * Maps an IR field type to a defineModel field type string.
- */
-function fieldTypeToModelType(fieldType: string): string {
-  switch (fieldType) {
-    case 'text': case 'rich_text': case 'select':
-      return 'string';
-    case 'email': return 'email';
-    case 'url': return 'url';
-    case 'phone': return 'phone';
-    case 'color': return 'color';
-    case 'number': case 'currency': case 'percentage':
-    case 'rating': case 'duration': case 'auto_number':
-      return 'number';
-    case 'boolean':
-      return 'boolean';
-    case 'date': case 'datetime': case 'created_at': case 'updated_at':
-      return 'date';
-    case 'multi_select':
-      return 'array';
-    case 'json': case 'object':
-      return 'json';
-    case 'array':
-      return 'array';
-    case 'file': case 'image':
-      return 'file';
-    case 'relation': case 'lookup':
-      return 'relation';
-    default:
-      return fieldType;
-  }
-}
-
-/**
- * Serializes a default value for defineModel field declarations.
- */
-function serializeDefault(value: unknown): string {
-  if (value === undefined || value === null) return 'null';
-  if (typeof value === 'string') return `'${esc(value)}'`;
-  if (typeof value === 'number' || typeof value === 'boolean') return String(value);
-  if (Array.isArray(value)) {
-    if (value.length === 0) return '[]';
-    return `[${value.map(v => serializeDefault(v)).join(', ')}]`;
-  }
-  return JSON.stringify(value);
-}
-
-/**
- * Generates a complete model file with:
- *   - import { defineModel } from "@mindmatrix/react"
- *   - export default defineModel({ slug, version, category, fields, states, transitions })
- *   - companion TypeScript interface for IntelliSense
- */
-function generateModelFile(
-  slug: string,
-  fields: IRFieldDefinition[],
-  states: IRStateDefinition[],
-  transitions: IRTransitionDefinition[],
-  meta?: { version?: string; category?: string; description?: string },
-): string {
-  const typeName = pascalCase(slug);
-  const interfaceName = `${typeName}Fields`;
-  const version = meta?.version || '0.1.0';
-  const category = meta?.category || 'data';
-  const lines: string[] = [];
-
-  // Import
-  lines.push(`import { defineModel } from '@mindmatrix/react';`);
-  lines.push(``);
-
-  // Companion TypeScript interface for IntelliSense
-  // NOTE: Field labels are deliberately excluded to ensure round-trip stability.
-  // Fields sorted alphabetically for deterministic round-trip output.
-  const sortedFields = [...fields].sort((a, b) => a.name.localeCompare(b.name));
-  if (sortedFields.length > 0) {
-    lines.push(`export interface ${interfaceName} {`);
-    for (const field of sortedFields) {
-      const tsType = fieldTypeToTS(field.type, field);
-      const optional = field.required ? '' : '?';
-      lines.push(`  ${camelCase(field.name)}${optional}: ${tsType};`);
-    }
-    lines.push(`}`);
-    lines.push(``);
-  }
-
-  // defineModel() call
-  lines.push(`export default defineModel({`);
-  lines.push(`  slug: '${esc(slug)}',`);
-  lines.push(`  version: '${esc(version)}',`);
-  lines.push(`  category: '${esc(category)}',`);
-  if (meta?.description) {
-    lines.push(`  description: '${esc(meta.description)}',`);
-  }
-
-  // Fields (sorted alphabetically for determinism)
-  if (sortedFields.length > 0) {
-    lines.push(`  fields: {`);
-    for (const field of sortedFields) {
-      const props: string[] = [];
-      props.push(`type: '${fieldTypeToModelType(field.type)}'`);
-      if (field.required) {
-        props.push(`required: true`);
-      }
-      // Default value — emit when present. Null is emitted explicitly to
-      // distinguish "no default" (undefined) from "default is null".
-      // Skip trivial type-inferred defaults (empty string, 0, false) to keep
-      // model files clean, but always emit null for round-trip stability.
-      if (field.default_value === null) {
-        props.push(`default: null`);
-      } else if (field.default_value !== undefined
-          && field.default_value !== '' && field.default_value !== 0
-          && field.default_value !== false) {
-        props.push(`default: ${serializeDefault(field.default_value)}`);
-      }
-      // Enum/options for select fields
-      const options = getFieldOptions(field);
-      if (options && options.length > 0) {
-        const enumStr = options.map(o => `'${esc(String(o))}'`).join(', ');
-        props.push(`enum: [${enumStr}]`);
-      }
-      lines.push(`    ${camelCase(field.name)}: { ${props.join(', ')} },`);
-    }
-    lines.push(`  },`);
-  }
-
-  // States (sorted alphabetically for determinism, skip empty-named states)
-  const validStates = states.filter(s => s.name !== '');
-  if (validStates.length > 0) {
-    const sortedStates = [...validStates].sort((a, b) => a.name.localeCompare(b.name));
-    lines.push(`  states: {`);
-    for (const state of sortedStates) {
-      const props: string[] = [];
-      if (state.type === 'START') {
-        props.push(`type: 'initial'`);
-      } else if (state.type === 'END') {
-        props.push(`type: 'final'`);
-      }
-      if (state.description) {
-        props.push(`description: '${esc(state.description)}'`);
-      }
-      const body = props.length > 0 ? ` ${props.join(', ')} ` : '';
-      lines.push(`    ${safeKey(state.name)}: {${body}},`);
-    }
-    lines.push(`  },`);
-  }
-
-  // Transitions (sorted alphabetically for determinism, with from-field correction)
-  if (transitions.length > 0) {
-    const correctedTrans = correctTransitionFromFields(transitions);
-    const sortedTrans = [...correctedTrans].sort((a, b) => a.name.localeCompare(b.name));
-    lines.push(`  transitions: {`);
-    for (const trans of sortedTrans) {
-      const fromArr = Array.isArray(trans.from) ? trans.from : [trans.from as unknown as string];
-      const parts: string[] = [];
-      if (fromArr.length === 1) {
-        parts.push(`from: '${esc(fromArr[0])}'`);
-      } else {
-        parts.push(`from: [${fromArr.map(f => `'${esc(f)}'`).join(', ')}]`);
-      }
-      parts.push(`to: '${esc(trans.to)}'`);
-      if (trans.roles && trans.roles.length > 0) {
-        parts.push(`roles: [${trans.roles.map(r => `'${esc(r)}'`).join(', ')}]`);
-      }
-      if (trans.auto) {
-        parts.push(`auto: true`);
-      }
-      if (trans.required_fields && trans.required_fields.length > 0) {
-        parts.push(`required_fields: [${trans.required_fields.map(f => `'${esc(f)}'`).join(', ')}]`);
-      }
-      lines.push(`    ${safeKey(trans.name)}: { ${parts.join(', ')} },`);
-    }
-    lines.push(`  },`);
-  }
-
-  lines.push(`});`);
-  lines.push(``);
-
-  return lines.join('\n');
-}
-
-// =============================================================================
-// Layout File (with auth guards)
-// =============================================================================
-
-/**
- * Generates app/layout.tsx with role-based auth guards.
- */
-function generateLayoutFile(
-  slug: string,
-  roles: Array<{ name: string; permissions: string[] }>,
-): string {
-  const componentName = `${pascalCase(slug)}Layout`;
-  const lines: string[] = [
-    `/**`,
-    ` * ${componentName} — root layout with auth guards.`,
-    ` */`,
-    ``,
-    `import { useRole, Stack } from '@mindmatrix/react';`,
-    ``,
-    `interface LayoutProps {`,
-    `  children: React.ReactNode;`,
-    `}`,
-    ``,
-    `export default function ${componentName}({ children }: LayoutProps) {`,
-  ];
-
-  // Role guard declarations
-  for (const role of roles) {
-    const varName = `is${pascalCase(role.name)}`;
-    lines.push(`  const ${varName} = useRole('${esc(role.name)}');`);
-  }
-
-  if (roles.length > 0) {
-    lines.push(``);
-    // Generate a simple authorized check
-    const roleChecks = roles.map(r => `is${pascalCase(r.name)}`).join(' || ');
-    lines.push(`  const isAuthorized = ${roleChecks};`);
-    lines.push(``);
-    lines.push(`  if (!isAuthorized) {`);
-    lines.push(`    return <Stack sx={{ p: 32, align: 'center' }}>Access denied</Stack>;`);
-    lines.push(`  }`);
-  }
-
-  lines.push(``);
-  lines.push(`  return (`);
-  lines.push(`    <Stack sx={{ minH: '100vh' }}>`);
-  lines.push(`      {children}`);
-  lines.push(`    </Stack>`);
-  lines.push(`  );`);
-  lines.push(`}`);
-  lines.push(``);
-
-  return lines.join('\n');
-}
-
-// =============================================================================
-// Route Table & Page Classification
-// =============================================================================
-
-interface RouteEntry {
-  stateName: string;
-  role: string;
-  page: string;
-  path: string;
-}
-
-interface PageSection {
-  route: string;
-  role: string;
-  slug: string;
-  title: string;
-  componentName: string;
-  tree: IRExperienceNode;
-  filePath: string;
-  localDefaults: Record<string, unknown>;
-  roleGuard?: string;
-  dataSources?: unknown[];
-}
-
-/**
- * Extracts route table from a router child definition.
- * Parses state descriptions like "Route: /admin/analytics" into structured entries.
- */
-function extractRouteTable(childDefinitions?: DecompilerInput[]): RouteEntry[] {
-  if (!childDefinitions) return [];
-  const router = childDefinitions.find(
-    c => c.slug.endsWith('-router') || c.category === 'router',
-  );
-  if (!router?.states) return [];
-
-  return router.states
-    .filter(s => s.description?.startsWith('Route:'))
-    .map(s => {
-      const route = s.description!.replace(/^Route:\s*/, '').replace(/^\//, '');
-      const parts = route.split('/');
-      return {
-        stateName: s.name,
-        role: parts[0] || 'shared',
-        page: parts.slice(1).join('/') || parts[0],
-        path: route,
-      };
-    });
-}
-
-/**
- * BFS search for the first h2 heading text in a subtree.
- */
-function findPageTitle(node: IRExperienceNode, maxDepth = 5): string | null {
-  const queue: Array<{ n: IRExperienceNode; d: number }> = [{ n: node, d: 0 }];
-
-  while (queue.length > 0) {
-    const { n, d } = queue.shift()!;
-    if (d > maxDepth) continue;
-
-    if (
-      (n.component === 'Text' || n.component === 'Heading') &&
-      (n.config?.level === 2 || n.config?.variant === 'h2')
-    ) {
-      if (n.config?.text) return n.config.text as string;
-      // Composite title from children (e.g., "Payment #" + "{id}")
-      if (n.children?.length) {
-        const parts = n.children
-          .filter(c => c.config?.value)
-          .map(c => c.config!.value as string);
-        if (parts.length > 0) return parts.join('');
-      }
-    }
-
-    if (n.children) {
-      for (const child of n.children) {
-        queue.push({ n: child, d: d + 1 });
-      }
-    }
-  }
-
-  return null;
-}
-
-/**
- * Detects the role for a page from bindings, localDefaults keys, and title hints.
- */
-function detectPageRole(node: IRExperienceNode): string {
-  // Show when binding
-  const when = node.bindings?.when || '';
-  if (/isAdmin|is_admin/i.test(when)) return 'admin';
-  if (/isDriver|is_driver/i.test(when)) return 'driver';
-  if (/isRider|is_rider/i.test(when)) return 'rider';
-
-  // localDefaults key prefixes
-  const ld = (node.config?.localDefaults || {}) as Record<string, unknown>;
-  const keys = Object.keys(ld);
-  if (keys.some(k => k.startsWith('driver.') || k === 'is_online')) return 'driver';
-  if (keys.some(k => k.startsWith('earnings.') || k.startsWith('matching.'))) return 'driver';
-  if (keys.some(k => k.startsWith('rider.'))) return 'rider';
-
-  // localDefaults content-based hints
-  if (keys.includes('ride.current_fare') || keys.includes('time_left')) return 'driver';
-  if (keys.includes('selected_vehicle') || keys.includes('driver_location')) return 'rider';
-  if (keys.includes('date_from') || keys.includes('date_to')) return 'rider';
-  if (keys.includes('cvv') || keys.includes('card_number')) return 'rider';
-
-  // Title-based
-  const title = findPageTitle(node);
-  if (title) {
-    const lower = title.toLowerCase();
-    if (lower.includes('driver') || lower.includes('earning') || lower.includes('navigation')) return 'driver';
-    if (lower.includes('ride request') || lower.includes('ride acceptance')) return 'driver';
-    if (lower.includes('payment method') || lower.includes('ride history')) return 'rider';
-    if (lower.includes('your ride') || lower.includes('where to') || lower.includes('ride tracking')) return 'rider';
-    if (lower.includes('analytics') || lower.includes('surge') || lower.includes('fleet')) return 'admin';
-  }
-
-  return 'shared';
-}
-
-/**
- * Checks if a node represents a child workflow view (not a router page).
- * Detected by title containing "#" (instance refs) or EXACT slug match with child defs.
- * Uses strict matching to avoid false positives (e.g., "Incoming Ride Request" ≠ "ride-request").
- */
-function isChildWorkflowView(
-  node: IRExperienceNode,
-  childSlugs: Set<string>,
-): boolean {
-  const title = findPageTitle(node);
-  if (!title) return false;
-
-  // Title contains "#" → references specific instance (e.g., "Payment #abc123")
-  if (title.includes('#')) return true;
-
-  // Exact slug match only (no substring matching to avoid false positives)
-  const titleSlug = title
-    .toLowerCase()
-    .replace(/[^a-z0-9\s]/g, '')
-    .trim()
-    .replace(/\s+/g, '-');
-
-  return childSlugs.has(titleSlug);
-}
-
-/** Converts a page title to a URL-friendly slug. */
-function titleToSlug(title: string): string {
-  const MAP: Record<string, string> = {
-    'where to?': 'home',
-    'where to': 'home',
-    'your ride': 'ride-tracking',
-    'incoming ride request': 'ride-acceptance',
-  };
-  const lower = title.toLowerCase();
-  if (MAP[lower]) return MAP[lower];
-
-  return lower
-    .replace(/[^a-z0-9\s]/g, '')
-    .trim()
-    .replace(/\s+/g, '-');
-}
-
-/** Scores how well a page title matches a route entry. */
-function scoreRouteMatch(title: string, route: RouteEntry): number {
-  const titleSlug = title
-    .toLowerCase()
-    .replace(/[^a-z0-9\s]/g, '')
-    .trim()
-    .replace(/\s+/g, '-');
-  const titleWords = new Set(titleSlug.split('-').filter(w => w.length > 2));
-
-  let score = 0;
-  for (const word of route.page.split('-')) {
-    if (titleWords.has(word)) score += 2;
-  }
-  if (titleSlug.includes(route.page) || route.page.includes(titleSlug)) {
-    score += 3;
-  }
-  return score;
-}
-
-/** Extracts role guard binding from a Show node (e.g., "isAdmin"). */
-function extractRoleGuard(node: IRExperienceNode): string | undefined {
-  const when = node.bindings?.when || '';
-  const match = when.match(/\$instance\.(is\w+)/);
-  return match ? match[1] : undefined;
-}
-
-/** Collects dataSources from a node and its immediate children. */
-function collectDataSources(node: IRExperienceNode): unknown[] {
-  const sources: unknown[] = [];
-  const nodeDS = (node as unknown as Record<string, unknown>).dataSources;
-  if (Array.isArray(nodeDS)) sources.push(...nodeDS);
-
-  if (node.children) {
-    for (const child of node.children) {
-      const childDS = (child as unknown as Record<string, unknown>).dataSources;
-      if (Array.isArray(childDS)) sources.push(...childDS);
-    }
-  }
-  return sources;
-}
-
-/** Strips localDefaults from a node's config (shallow copy). */
-function stripLocalDefaults(node: IRExperienceNode): IRExperienceNode {
-  if (!node.config?.localDefaults) return node;
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  const { localDefaults, ...rest } = node.config;
-  return { ...node, config: Object.keys(rest).length > 0 ? rest : undefined };
-}
-
-/** Gets page content tree: unwraps Show wrappers, removes localDefaults. */
-function getPageContentTree(node: IRExperienceNode): IRExperienceNode {
-  if (node.component === 'Show' && node.children?.length === 1) {
-    return stripLocalDefaults(node.children[0]);
-  }
-  return stripLocalDefaults(node);
-}
-
-/** Infers a field type from a default value. */
-function inferFieldType(value: unknown): string {
-  if (typeof value === 'boolean') return 'boolean';
-  if (typeof value === 'number') return 'number';
-  return 'text';
-}
-
-/**
- * Main page extraction: walks root experience children, classifies them as
- * route pages or child workflow views, and matches pages to router states.
- *
- * Two-pass route matching:
- *   Pass 1: High-confidence keyword overlap (score >= 3)
- *   Pass 2: Assign remaining by elimination within each role group
- */
-function extractPageSections(
-  experience: IRExperienceNode | undefined,
-  childDefinitions?: DecompilerInput[],
-): { pages: PageSection[]; childViews: IRExperienceNode[] } {
-  if (!experience?.children) return { pages: [], childViews: [] };
-
-  // ── Fast path: Router/Route experience (already structured by compiler) ──
-  // When the experience already contains a Router with Route children (e.g. from
-  // a previous compile→decompile cycle), extract pages deterministically from the
-  // Route nodes. This ensures source stabilization (pass N+1 = pass N).
-  const routerExtracted = extractFromRouterExperience(experience);
-  if (routerExtracted) return routerExtracted;
-
-  // ── Heuristic path: flat experience (original source) ──
-  const routeTable = extractRouteTable(childDefinitions);
-  const childSlugs = new Set(
-    (childDefinitions || [])
-      .filter(c => !c.slug.endsWith('-router') && c.category !== 'router')
-      .map(c => c.slug),
-  );
-
-  const pages: PageSection[] = [];
-  const childViews: IRExperienceNode[] = [];
-  const candidates: Array<{
-    title: string | null;
-    role: string;
-    index: number;
-    node: IRExperienceNode;
-    localDefaults: Record<string, unknown>;
-    roleGuard?: string;
-    dataSources?: unknown[];
-  }> = [];
-
-  // Phase 1: classify each child
-  for (let i = 0; i < experience.children.length; i++) {
-    const child = experience.children[i];
-
-    if (isChildWorkflowView(child, childSlugs)) {
-      childViews.push(child);
-      continue;
-    }
-
-    const title = findPageTitle(child);
-    const role = detectPageRole(child);
-    const localDefaults = (child.config?.localDefaults || {}) as Record<string, unknown>;
-    const roleGuard = extractRoleGuard(child);
-    const dataSources = collectDataSources(child);
-
-    candidates.push({
-      title, role, index: i, node: child,
-      localDefaults, roleGuard,
-      dataSources: dataSources.length > 0 ? dataSources : undefined,
-    });
-  }
-
-  // Phase 2: match to routes (two-pass)
-  const assignments = new Map<number, RouteEntry>();
-  const usedRoutes = new Set<string>();
-
-  // Pass 1: high-confidence keyword matches
-  for (const cand of candidates) {
-    if (!cand.title) continue;
-    const roleRoutes = routeTable.filter(
-      r => r.role === cand.role && !usedRoutes.has(r.stateName),
-    );
-    let bestRoute: RouteEntry | null = null;
-    let bestScore = 0;
-    for (const route of roleRoutes) {
-      const score = scoreRouteMatch(cand.title, route);
-      if (score > bestScore) { bestScore = score; bestRoute = route; }
-    }
-    if (bestRoute && bestScore >= 3) {
-      assignments.set(cand.index, bestRoute);
-      usedRoutes.add(bestRoute.stateName);
-    }
-  }
-
-  // Pass 2: iterative elimination — loop until no more assignments made.
-  // This ensures that after a titled candidate consumes a route, title-less
-  // candidates that now have only 1 remaining route in their role group get assigned.
-  let changed = true;
-  while (changed) {
-    changed = false;
-    for (const cand of candidates) {
-      if (assignments.has(cand.index)) continue;
-      const remaining = routeTable.filter(
-        r => r.role === cand.role && !usedRoutes.has(r.stateName),
-      );
-      if (remaining.length === 1) {
-        assignments.set(cand.index, remaining[0]);
-        usedRoutes.add(remaining[0].stateName);
-        changed = true;
-      } else if (remaining.length > 1 && cand.title) {
-        let bestRoute: RouteEntry | null = null;
-        let bestScore = 0;
-        for (const route of remaining) {
-          const score = scoreRouteMatch(cand.title, route);
-          if (score > bestScore) { bestScore = score; bestRoute = route; }
-        }
-        if (bestRoute && bestScore > 0) {
-          assignments.set(cand.index, bestRoute);
-          usedRoutes.add(bestRoute.stateName);
-          changed = true;
-        }
-      }
-    }
-  }
-
-  // Phase 3: build PageSection array
-  for (const cand of candidates) {
-    const route = assignments.get(cand.index);
-    const slug = route?.page || titleToSlug(cand.title || `page-${cand.index}`);
-    const filePath = `app/${cand.role}/${slug}.tsx`;
-    const componentName = pascalCase(slug) + 'Page';
-
-    pages.push({
-      route: route?.path || `${cand.role}/${slug}`,
-      role: cand.role,
-      slug,
-      title: cand.title || slug,
-      componentName,
-      tree: cand.node,
-      filePath,
-      localDefaults: cand.localDefaults,
-      roleGuard: cand.roleGuard,
-      dataSources: cand.dataSources,
-    });
-  }
-
-  return { pages, childViews };
-}
-
-/**
- * Extracts pages from a Router/Route experience tree produced by the compiler.
- * Returns null if the experience is not a Router/Route structure.
- *
- * Router experience layout:
- *   Stack(blueprint-root)
- *     Row(nav-bar) → NavLink children
- *     Router(page-router) → Route children, each wrapping a page tree
- */
-function extractFromRouterExperience(
-  experience: IRExperienceNode,
-): { pages: PageSection[]; childViews: IRExperienceNode[] } | null {
-  if (!experience.children) return null;
-
-  // Find the Router node among experience children
-  const routerNode = experience.children.find(c => c.component === 'Router');
-  if (!routerNode?.children) return null;
-
-  // Collect Route children (skip the index/exact duplicate)
-  const routes = routerNode.children.filter(c => c.component === 'Route');
-  if (routes.length === 0) return null;
-
-  const pages: PageSection[] = [];
-  const seenPaths = new Set<string>();
-
-  for (const route of routes) {
-    const routePath = (route.config?.path as string) || '';
-    // Skip index route (exact: true, path: '/') — it's a duplicate of the first named route
-    if (route.config?.exact && routePath === '/') continue;
-    if (seenPaths.has(routePath)) continue;
-    seenPaths.add(routePath);
-
-    // Derive slug and role from route path: /setup/review → role=setup, slug=review
-    // Single-segment routes (e.g. /page) go directly under app/ to avoid the
-    // compiler's /page suffix stripping creating a path mismatch on round-trip.
-    const segments = routePath.replace(/^\//, '').split('/').filter(Boolean);
-    const role = segments.length > 1 ? segments[0] : undefined;
-    const slug = segments.length > 1 ? segments.slice(1).join('-') : (segments[0] || 'page0');
-    const filePath = role ? `app/${role}/${slug}.tsx` : `app/${slug}.tsx`;
-    const componentName = pascalCase(slug) + 'Page';
-
-    // The page content is the Route's child (unwrap the Route wrapper).
-    // Strip compiler-added gap/padding config that the project-compiler injects
-    // on Route children (config: { ...child.config, gap: 4, padding: 4 }).
-    const rawPageTree = route.children?.[0] || route;
-    const pageTree = { ...rawPageTree };
-    if (pageTree.config) {
-      const { gap, padding, ...restConfig } = pageTree.config as Record<string, unknown>;
-      pageTree.config = Object.keys(restConfig).length > 0 ? restConfig : undefined;
-    }
-    const localDefaults = (pageTree.config?.localDefaults || {}) as Record<string, unknown>;
-
-    pages.push({
-      route: routePath,
-      role: role || '',
-      slug,
-      title: findPageTitle(pageTree) || slug,
-      componentName,
-      tree: pageTree,
-      filePath,
-      localDefaults,
-    });
-  }
-
-  return pages.length > 0 ? { pages, childViews: [] } : null;
-}
-
-/**
- * Generates a standalone page component file from a PageSection.
- * Converts localDefaults to useState, unwraps the tree, includes data sources.
- * When model slugs are referenced via dataSources, emits typed model imports.
- */
-function generatePageFileFromSection(
-  page: PageSection,
-  modelSlugToPath?: Map<string, string>,
-): string {
-  const fields: IRFieldDefinition[] = Object.entries(page.localDefaults)
-    .filter(([key]) => !key.includes('.'))
-    .map(([key, value]) => ({
-      name: key,
-      type: inferFieldType(value),
-      required: false,
-      default_value: value ?? undefined,
-    }));
-
-  const contentTree = getPageContentTree(page.tree);
-
-  const metadata: Record<string, unknown> = {};
-  if (page.dataSources && page.dataSources.length > 0) {
-    metadata.dataSources = page.dataSources;
-
-    // Build model imports map: slug → relative import path from this page file
-    if (modelSlugToPath) {
-      const modelImports: Record<string, string> = {};
-      for (const ds of page.dataSources) {
-        const dsObj = ds as Record<string, unknown>;
-        if (dsObj.type !== 'workflow') continue;
-        const slug = (dsObj.slug || dsObj.name) as string;
-        if (!slug) continue;
-        const modelPath = modelSlugToPath.get(slug);
-        if (modelPath) {
-          // Compute relative path from page file to model file
-          const pageDir = page.filePath.split('/').slice(0, -1).join('/');
-          const rel = computeRelativeImport(pageDir, modelPath);
-          modelImports[slug] = rel;
-        }
-      }
-      if (Object.keys(modelImports).length > 0) {
-        metadata.modelImports = modelImports;
-      }
-    }
-  }
-
-  const pageInput: DecompilerInput = {
-    slug: page.slug,
-    name: page.componentName,
-    version: '1.0.0',
-    category: 'page',
-    states: [],
-    transitions: [],
-    fields,
-    roles: [],
-    experience: contentTree,
-    metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
-  };
-
-  return decompile(pageInput, {
-    componentName: page.componentName,
-    includeAnnotation: false,
-  }).code;
-}
-
-/**
- * Computes a relative import path from a source directory to a target file.
- * E.g. from "app/shared" to "models/task.ts" → "../../models/task"
- */
-function computeRelativeImport(fromDir: string, toFile: string): string {
-  const fromParts = fromDir.split('/').filter(Boolean);
-  const toParts = toFile.replace(/\.(ts|tsx)$/, '').split('/').filter(Boolean);
-
-  // Find common prefix length
-  let common = 0;
-  while (common < fromParts.length && common < toParts.length && fromParts[common] === toParts[common]) {
-    common++;
-  }
-
-  const ups = fromParts.length - common;
-  const downs = toParts.slice(common);
-
-  if (ups === 0 && downs.length === 0) return './index';
-  const prefix = ups > 0 ? '../'.repeat(ups) : './';
-  return prefix + downs.join('/');
-}
-
-/**
- * Generates a main.workflow.tsx that imports page components and composes them.
- * Keeps global hooks from the definition and child workflow views inline.
- */
-function generateMainWithPages(
-  definition: DecompilerInput,
-  pages: PageSection[],
-  childViews: IRExperienceNode[],
-): string {
-  // Build modified experience tree with page component refs
-  const mainChildren: IRExperienceNode[] = [];
-
-  for (const page of pages) {
-    if (page.roleGuard) {
-      mainChildren.push({
-        id: `page-${page.slug}`,
-        component: 'Show',
-        bindings: { when: `$instance.${page.roleGuard}` },
-        children: [{ id: `${page.slug}-ref`, component: page.componentName }],
-      });
-    } else {
-      mainChildren.push({
-        id: `page-${page.slug}`,
-        component: page.componentName,
-      });
-    }
-  }
-
-  for (const cv of childViews) {
-    mainChildren.push(cv);
-  }
-
-  const mainTree: IRExperienceNode = {
-    id: 'root',
-    component: 'Stack',
-    children: mainChildren,
-  };
-
-  // Strip dataSources from metadata for the main file — they belong to
-  // individual page files, not the top-level orchestrator. Including them here
-  // causes import instability (useMutation/useQuery present on pass 1 but not pass 2).
-  const strippedMeta = { ...(definition.metadata || {}) };
-  delete (strippedMeta as any).dataSources;
-  delete (strippedMeta as any).queries;
-  delete (strippedMeta as any).mutations;
-  delete (strippedMeta as any).mutationTargets;
-  const modifiedDef: DecompilerInput = {
-    ...definition,
-    experience: mainTree,
-    metadata: strippedMeta,
-  };
-  const result = decompile(modifiedDef, { includeAnnotation: true });
-
-  // Build import lines for page components
-  const pageImports = pages
-    .map(p => `import ${p.componentName} from './${p.filePath.replace(/\.tsx$/, '')}';`)
-    .join('\n');
-
-  // Insert after last existing import line
-  const code = result.code;
-  const importRegex = /^import .+$/gm;
-  let lastImportEnd = -1;
-  let m: RegExpExecArray | null;
-  while ((m = importRegex.exec(code)) !== null) {
-    lastImportEnd = m.index + m[0].length;
-  }
-
-  if (lastImportEnd > 0) {
-    return code.slice(0, lastImportEnd) + '\n' + pageImports + code.slice(lastImportEnd);
-  }
-  return pageImports + '\n' + code;
-}
-
-// =============================================================================
-// Server Action Extraction
-// =============================================================================
-
-interface ServerAction {
-  name: string;
-  type: string;
-  config: Record<string, unknown>;
-}
-
-const SERVER_ACTION_TYPES = new Set([
-  'http_request', 'webhook', 'call_webhook',
-  'notify', 'send_notification',
-  'call_workflow', 'spawn_instance', 'spawn_subworkflow',
-  'emit_event',
-  'custom',
-]);
-
-function extractServerActions(
-  states: IRStateDefinition[],
-  transitions: IRTransitionDefinition[],
-): ServerAction[] {
-  const seen = new Set<string>();
-  const actions: ServerAction[] = [];
-
-  function collect(defs: Array<{ id: string; type: string; config: Record<string, unknown> }>) {
-    for (const action of defs) {
-      if (SERVER_ACTION_TYPES.has(action.type) && !seen.has(action.id)) {
-        seen.add(action.id);
-        const slug = String(action.config.name || action.config.event || action.config.slug || action.type);
-        const name = camelCase(slug.replace(/[^a-zA-Z0-9_-]/g, '-'));
-        actions.push({ name, type: action.type, config: action.config });
-      }
-    }
-  }
-
-  for (const state of states) {
-    collect(state.on_enter);
-    collect(state.on_exit);
-    for (const during of state.during) {
-      collect(during.actions);
-    }
-  }
-  for (const trans of transitions) {
-    collect(trans.actions);
-  }
-
-  return actions;
-}
-
-function generateServerActionFile(
-  slug: string,
-  actions: ServerAction[],
-): string {
-  const lines: string[] = [
-    `/**`,
-    ` * Server actions for "${slug}".`,
-    ` *`,
-    ` * These run server-side during state transitions.`,
-    ` */`,
-    ``,
-    `import type { TransitionContext } from '@mindmatrix/react';`,
-    ``,
-  ];
-
-  for (const action of actions) {
-    lines.push(`/** ${actionComment(action)} */`);
-    lines.push(`export async function ${action.name}(ctx: TransitionContext): Promise<void> {`);
-    lines.push(`  const { instance, env } = ctx;`);
-
-    switch (action.type) {
-      case 'http_request': case 'webhook': case 'call_webhook': {
-        const url = String(action.config.url || 'https://api.example.com/webhook');
-        const method = String(action.config.method || 'POST');
-        lines.push(`  await fetch('${esc(url)}', {`);
-        lines.push(`    method: '${method}',`);
-        lines.push(`    headers: { 'Content-Type': 'application/json' },`);
-        lines.push(`    body: JSON.stringify({ instanceId: instance.id }),`);
-        lines.push(`  });`);
-        break;
-      }
-      case 'notify': case 'send_notification': {
-        const msg = String(action.config.message || action.config.body || 'Notification');
-        lines.push(`  await env.notify({ message: '${esc(msg)}', instanceId: instance.id });`);
-        break;
-      }
-      case 'call_workflow': case 'spawn_instance': case 'spawn_subworkflow': {
-        const target = String(action.config.slug || action.config.workflow || 'child-workflow');
-        lines.push(`  await env.spawn('${esc(target)}', { parentId: instance.id });`);
-        break;
-      }
-      case 'emit_event': {
-        const event = String(action.config.event || action.config.name || 'custom-event');
-        lines.push(`  await env.emit('${esc(event)}', { instanceId: instance.id });`);
-        break;
-      }
-      case 'custom': {
-        const expr = action.config.expression || action.config.body;
-        if (expr) {
-          lines.push(`  // Original expression: ${String(expr).replace(/\n/g, '\\n').slice(0, 200)}`);
-        }
-        lines.push(`  // TODO: Implement custom action logic`);
-        lines.push(`  throw new Error('Not implemented — decompiled stub');`);
-        break;
-      }
-      default:
-        lines.push(`  // TODO: Implement ${action.type} logic`);
-    }
-
-    lines.push(`}`);
-    lines.push(``);
-  }
-
-  return lines.join('\n');
-}
-
-function actionComment(action: ServerAction): string {
-  switch (action.type) {
-    case 'http_request': case 'webhook': case 'call_webhook':
-      return `HTTP ${action.config.method || 'POST'} to ${action.config.url || 'webhook'}`;
-    case 'notify': case 'send_notification':
-      return `Send notification: ${action.config.message || ''}`;
-    case 'call_workflow': case 'spawn_instance': case 'spawn_subworkflow':
-      return `Spawn workflow: ${action.config.slug || action.config.workflow || ''}`;
-    case 'emit_event':
-      return `Emit event: ${action.config.event || action.config.name || ''}`;
-    case 'custom':
-      return `Custom action: ${action.name}`;
-    default:
-      return `Server action: ${action.type}`;
-  }
-}
-
-// =============================================================================
-// Component Definition Emission (from metadata.componentDefinitions)
-// =============================================================================
-
-/**
- * Emits component files from metadata.componentDefinitions.
- * Each entry maps a component name to its experience tree and props.
- */
-function emitComponentDefinitions(
-  definition: DecompilerInput,
-  files: EnhancedProjectFile[],
-): void {
-  const meta = definition.metadata as Record<string, unknown> | undefined;
-  const componentDefs = meta?.componentDefinitions as
-    Record<string, { experience: IRExperienceNode; props: string[] }> | undefined;
-  if (!componentDefs) return;
-
-  for (const [name, def] of Object.entries(componentDefs)) {
-    const content = generateComponentFromDefinition(name, def.experience, def.props);
-    files.push({
-      path: `components/${name}.tsx`,
-      role: 'component',
-      content,
-    });
-  }
-}
-
-/**
- * Infers a TypeScript type for a component prop by analyzing how it's used
- * in the experience tree (bindings, visible_when, event handlers).
- */
-function inferPropType(propName: string, experience: IRExperienceNode): string {
-  // Walk the tree to find usages
-  const usages: string[] = [];
-  collectPropUsages(propName, experience, usages);
-
-  // Event handlers → callback types
-  if (propName.startsWith('on') && propName.length > 2 && propName[2] === propName[2].toUpperCase()) {
-    return '(() => void)';
-  }
-
-  // Boolean-like names
-  const boolNames = ['show', 'is', 'has', 'enable', 'disable', 'compact', 'track', 'follow'];
-  if (boolNames.some(b => propName.toLowerCase().startsWith(b))) return 'boolean';
-
-  // Known patterns from bindings
-  for (const usage of usages) {
-    if (usage.includes('.address') || usage.includes('Address')) return '{ address: string; latitude: number; longitude: number }';
-    if (usage.includes('.toFixed')) return 'number';
-    if (usage.includes('.toLocaleString')) return 'number';
-    if (usage.includes('.heading')) return '{ latitude: number; longitude: number; heading: number }';
-    if (usage.includes('.length')) return 'unknown[]';
-  }
-
-  // Name-based heuristics
-  if (/url|src|image|avatar|icon/i.test(propName)) return 'string';
-  if (/count|amount|total|rating|eta|minutes|radius|zoom/i.test(propName)) return 'number';
-  if (/style|sx/i.test(propName)) return 'React.CSSProperties';
-  if (/items|list|zones|options/i.test(propName)) return 'unknown[]';
-  if (/location|position|point/i.test(propName)) return '{ latitude: number; longitude: number }';
-
-  return 'unknown';
-}
-
-/** Collects binding expressions that reference a prop name. */
-function collectPropUsages(propName: string, node: IRExperienceNode, out: string[]): void {
-  if (node.bindings) {
-    for (const expr of Object.values(node.bindings)) {
-      if (typeof expr === 'string' && expr.includes(propName)) {
-        out.push(expr);
-      }
-    }
-  }
-  if (node.visible_when && typeof node.visible_when === 'string' && node.visible_when.includes(propName)) {
-    out.push(node.visible_when);
-  }
-  if (node.children) {
-    for (const child of node.children) {
-      collectPropUsages(propName, child, out);
-    }
-  }
-}
-
-/**
- * Generates a component file from an experience tree and prop list.
- * Produces proper TypeScript interfaces with inferred prop types and
- * destructured props in the function signature.
- */
-function generateComponentFromDefinition(
-  name: string,
-  experience: IRExperienceNode,
-  props: string[],
-): string {
-  // Decompile the experience tree into JSX
-  const pageInput: DecompilerInput = {
-    slug: name.toLowerCase(),
-    name,
-    version: '1.0.0',
-    category: 'component',
-    states: [],
-    transitions: [],
-    fields: [],
-    roles: [],
-    experience,
-  };
-
-  const result = decompile(pageInput, {
-    componentName: name,
-    includeAnnotation: false,
-  });
-
-  // If the component has props, inject a typed interface and destructured params
-  if (props.length > 0) {
-    const typedProps = props.map(p => {
-      const type = inferPropType(p, experience);
-      const isCallback = p.startsWith('on') && p.length > 2 && p[2] === p[2].toUpperCase();
-      const optional = isCallback ? '?' : '';
-      return `  ${p}${optional}: ${type};`;
-    });
-
-    const propsInterface = `interface ${name}Props {\n${typedProps.join('\n')}\n}\n\n`;
-    const code = result.code
-      .replace(
-        `export default function ${name}()`,
-        `${propsInterface}export default function ${name}({ ${props.join(', ')} }: ${name}Props)`,
-      );
-    return code;
-  }
-
-  return result.code;
-}
-
-// =============================================================================
-// Server Action Emission from Metadata (preserved bodies)
-// =============================================================================
-
-/**
- * Emits server action files from metadata.serverActions when they have
- * preserved function bodies. Returns the list of emitted file paths.
- */
-function emitServerActionsFromMetadata(
-  definition: DecompilerInput,
-  files: EnhancedProjectFile[],
-): string[] {
-  const meta = definition.metadata as Record<string, unknown> | undefined;
-  const serverActions = meta?.serverActions as Array<{
-    name: string;
-    sourceFile?: string;
-    body?: string;
-    async?: boolean;
-    params?: string[];
-    description?: string;
-    returnType?: string;
-  }> | undefined;
-
-  if (!serverActions || serverActions.length === 0) return [];
-
-  // Only emit if at least one action has a preserved body
-  const actionsWithBodies = serverActions.filter(a => a.body);
-  if (actionsWithBodies.length === 0) return [];
-
-  // Group actions by source file
-  const byFile = new Map<string, typeof actionsWithBodies>();
-  for (const action of actionsWithBodies) {
-    const file = action.sourceFile || `actions/${action.name}.server.ts`;
-    if (!byFile.has(file)) byFile.set(file, []);
-    byFile.get(file)!.push(action);
-  }
-
-  const emittedPaths: string[] = [];
-  for (const [filePath, actions] of byFile) {
-    const content = generateServerActionFileFromBodies(filePath, actions);
-    // Check if a file at this path was already emitted by extractServerActions
-    const existing = files.findIndex(f => f.path === filePath);
-    if (existing !== -1) {
-      // Replace the generated stub with the preserved bodies
-      files[existing].content = content;
-    } else {
-      files.push({ path: filePath, role: 'server-action', content });
-    }
-    emittedPaths.push(filePath);
-  }
-
-  return emittedPaths;
-}
-
-/**
- * Generates a server action file from preserved function bodies.
- * Includes the standard import header and each function's full source.
- */
-function generateServerActionFileFromBodies(
-  filePath: string,
-  actions: Array<{
-    name: string;
-    body?: string;
-    description?: string;
-  }>,
-): string {
-  const lines: string[] = [
-    `/**`,
-    ` * Server actions — ${filePath}`,
-    ` *`,
-    ` * Auto-generated from preserved function bodies.`,
-    ` */`,
-    ``,
-    `import type { TransitionContext, ActionResult } from '@mindmatrix/react';`,
-    ``,
-  ];
-
-  for (const action of actions) {
-    if (action.body) {
-      lines.push(action.body);
-      lines.push(``);
-    }
-  }
-
-  return lines.join('\n');
-}
-
-// =============================================================================
-// Router Transition Reduction
-// =============================================================================
-
-/**
- * Reduces O(n²) router transitions to only meaningful navigation paths:
- *   1. Intra-role transitions (RIDER_HOME → RIDER_HISTORY — same role prefix)
- *   2. Cross-role home transitions (RIDER_HOME → DRIVER_DASHBOARD — between "home" states)
- *
- * This preserves realistic navigation while removing the every-to-every explosion.
- */
-function reduceRouterTransitions(
-  transitions: IRTransitionDefinition[],
-  states: IRStateDefinition[],
-): IRTransitionDefinition[] {
-  if (transitions.length === 0) return transitions;
-
-  // Extract role prefixes from state names (e.g., RIDER, DRIVER, ADMIN)
-  const stateNames = new Set(states.map(s => s.name));
-  const roleGroups = new Map<string, string[]>();
-
-  for (const state of states) {
-    const parts = state.name.split('_');
-    // Role prefix is everything before the last segment (e.g., RIDER from RIDER_HOME)
-    // For states like ADMIN_SURGE_PRICING, group by first segment
-    const role = parts[0];
-    if (!roleGroups.has(role)) roleGroups.set(role, []);
-    roleGroups.get(role)!.push(state.name);
-  }
-
-  // Identify "home" states per role (first state in each role group, or ones with HOME/DASHBOARD)
-  const homeStates = new Set<string>();
-  for (const [, group] of roleGroups) {
-    const home = group.find(s =>
-      s.includes('HOME') || s.includes('DASHBOARD') || s.includes('ANALYTICS')
-    ) || group[0];
-    homeStates.add(home);
-  }
-
-  // Keep transitions that are:
-  // 1. Intra-role (same role prefix)
-  // 2. Between home states of different roles
-  const kept: IRTransitionDefinition[] = [];
-  const seenKeys = new Set<string>();
-
-  for (const t of transitions) {
-    const fromArr = Array.isArray(t.from) ? t.from : [t.from as unknown as string];
-    const fromState = fromArr[0];
-    const toState = t.to;
-
-    if (!fromState || !stateNames.has(fromState) || !stateNames.has(toState)) continue;
-
-    const fromRole = fromState.split('_')[0];
-    const toRole = toState.split('_')[0];
-    const key = `${fromState}→${toState}`;
-
-    if (seenKeys.has(key)) continue;
-
-    // Rule 1: same role group
-    const sameRole = fromRole === toRole;
-
-    // Rule 2: from a home state to another home state
-    const crossRoleHome = homeStates.has(fromState) && homeStates.has(toState);
-
-    if (sameRole || crossRoleHome) {
-      seenKeys.add(key);
-      kept.push(t);
-    }
-  }
-
-  return kept;
-}
-
-// =============================================================================
-// Main: decompileProjectEnhanced
-// =============================================================================
-
-/**
- * Enhanced project decompiler that uses SplitStrategy to determine output
- * complexity and generates a complete multi-file project.
- *
- * @param definition - The full workflow definition to decompile.
- * @returns Files, entry path, slug, and the split decision used.
- */
-export function decompileProjectEnhanced(
-  definition: DecompilerInput,
-): EnhancedDecompileResult {
-  const slug = definition.slug;
-  const decision = determineSplitStrategy(definition);
-  const files: EnhancedProjectFile[] = [];
-  const modelPaths: string[] = [];
-  const entryPaths: string[] = [];
-  const actionPaths: string[] = [];
-
-  // --- Single file mode ---
-  if (decision.tier === 'single') {
-    const result = decompile(definition);
-    files.push({
-      path: 'main.workflow.tsx',
-      role: 'view-entry',
-      content: result.code,
-    });
-    // Even in single-file mode, emit components and actions if present in metadata
-    emitComponentDefinitions(definition, files);
-    emitServerActionsFromMetadata(definition, files);
-    return { files, entryFile: 'main.workflow.tsx', slug, splitDecision: decision };
-  }
-
-  // --- Model file ---
-  if (decision.emitModels && definition.fields.length > 0) {
-    const modelPath = `models/${slug}.ts`;
-    const modelContent = generateModelFile(
-      slug,
-      definition.fields,
-      definition.states,
-      definition.transitions,
-      { version: definition.version, category: Array.isArray(definition.category) ? definition.category[0] : definition.category, description: definition.description },
-    );
-    files.push({ path: modelPath, role: 'model', content: modelContent });
-    modelPaths.push(modelPath);
-  }
-
-  // --- Server actions ---
-  if (decision.emitActions) {
-    const serverActions = extractServerActions(definition.states, definition.transitions);
-    if (serverActions.length > 0) {
-      const actionPath = `actions/${slug}.server.ts`;
-      const actionContent = generateServerActionFile(slug, serverActions);
-      files.push({ path: actionPath, role: 'server-action', content: actionContent });
-      actionPaths.push(actionPath);
-    }
-  }
-
-  // --- Pages from experience tree (role-based split) ---
-  let pagesExtracted = false;
-  let extractedPages: PageSection[] = [];
-  let extractedChildViews: IRExperienceNode[] = [];
-  // Track whether pages were extracted from an existing Router/Route structure.
-  // If so, the router child definition is compiler-generated and should be skipped.
-  let routerIsCompilerGenerated = false;
-  if (decision.emitPages && definition.experience) {
-    // Check if Router/Route structure exists (indicates compiler-generated router)
-    const routerNode = definition.experience.children?.find(
-      (c: IRExperienceNode) => c.component === 'Router',
-    );
-    routerIsCompilerGenerated = !!routerNode;
-
-    const { pages, childViews } = extractPageSections(
-      definition.experience,
-      definition.childDefinitions,
-    );
-    if (pages.length > 0) {
-      pagesExtracted = true;
-      extractedPages = pages;
-      extractedChildViews = childViews;
-
-      // Build slug → model path map for type-safe imports
-      const modelSlugToPath = new Map<string, string>();
-      modelSlugToPath.set(slug, `models/${slug}.ts`);
-      if (definition.childDefinitions) {
-        for (const child of definition.childDefinitions) {
-          const cs = child.slug;
-          if (!cs.endsWith('-router') && child.category !== 'router') {
-            modelSlugToPath.set(cs, `models/${cs}.ts`);
-          }
-        }
-      }
-
-      for (const page of pages) {
-        const pageContent = generatePageFileFromSection(page, modelSlugToPath);
-        files.push({ path: page.filePath, role: 'page', content: pageContent });
-      }
-    }
-  }
-
-  // --- Layout with auth guards ---
-  if (definition.roles && definition.roles.length > 0 && decision.tier === 'large') {
-    const layoutContent = generateLayoutFile(slug, definition.roles);
-    files.push({ path: 'app/layout.tsx', role: 'layout', content: layoutContent });
-  }
-
-  // --- Child definitions (blueprint support) ---
-  // Merge child definitions by slug (compiler may produce duplicates when
-  // both .workflow.tsx and models/*.ts share the same slug). Merge fields,
-  // states, transitions — required=true wins, non-empty default_value wins.
-  // Also skip: router definitions generated from page files, and children whose
-  // slug matches the parent (they are the parent, not a child).
-  const emittedModelSlugs = new Set(modelPaths.map(p => p.replace('models/', '').replace('.ts', '')));
-  const mergedChildren = new Map<string, DecompilerInput>();
-  if (definition.childDefinitions && definition.childDefinitions.length > 0) {
-    for (const child of definition.childDefinitions) {
-      const childSlug = child.slug;
-      if (childSlug === slug) continue; // Skip parent-slug children
-      const isRouter = childSlug.endsWith('-router') || child.category === 'router';
-      if (isRouter && routerIsCompilerGenerated) continue;
-
-      if (!mergedChildren.has(childSlug)) {
-        mergedChildren.set(childSlug, { ...child });
-      } else {
-        // Merge: fields (required + default_value wins), states, transitions
-        const existing = mergedChildren.get(childSlug)!;
-        // Merge fields: merge metadata for existing fields, add new ones
-        const fieldMap = new Map(existing.fields.map(f => [f.name, f]));
-        for (const f of child.fields) {
-          if (fieldMap.has(f.name)) {
-            const ef = fieldMap.get(f.name)!;
-            if (f.required && !ef.required) ef.required = true;
-            if (f.default_value != null && (ef.default_value == null || ef.default_value === '' || ef.default_value === 0 || ef.default_value === false)) {
-              ef.default_value = f.default_value;
-            }
-          } else {
-            existing.fields.push(f);
-            fieldMap.set(f.name, f);
-          }
-        }
-        // Merge states: if a later child has MORE states, prefer its complete set
-        // (model IRs have explicit states arrays, workflow IRs only have inferred states)
-        if (child.states.length > existing.states.length) {
-          // Later child has more states — use its set as the base
-          const existingByName = new Map(existing.states.map(s => [s.name, s]));
-          existing.states = child.states.map(s => {
-            // Preserve actions from existing state if any
-            const ex = existingByName.get(s.name);
-            if (ex && (ex.on_enter.length || ex.on_exit.length || ex.during.length)) {
-              return { ...s, on_enter: ex.on_enter, on_exit: ex.on_exit, during: ex.during };
-            }
-            return s;
-          });
-          // Add non-default states from existing that aren't in the child.
-          // Skip 'draft' if the child already has a START state (it's a compiler default).
-          const childNames = new Set(child.states.map(s => s.name));
-          const hasStart = child.states.some(s => s.type === 'START');
-          for (const s of existingByName.values()) {
-            if (!childNames.has(s.name)) {
-              if (s.name === 'draft' && s.type === 'START' && hasStart) continue;
-              existing.states.push(s);
-            }
-          }
-        } else {
-          // Just add missing states
-          const stateNames = new Set(existing.states.map(s => s.name));
-          for (const s of child.states) {
-            if (!stateNames.has(s.name)) {
-              existing.states.push(s);
-              stateNames.add(s.name);
-            }
-          }
-        }
-        // Merge transitions (add missing)
-        const transNames = new Set(existing.transitions.map(t => t.name));
-        for (const t of child.transitions) {
-          if (!transNames.has(t.name)) {
-            existing.transitions.push(t);
-            transNames.add(t.name);
-          }
-        }
-        // Prefer non-default version/category/description
-        if (child.version && child.version !== '0.1.0' && (!existing.version || existing.version === '0.1.0')) {
-          existing.version = child.version;
-        }
-        if (child.category && child.category !== 'data' && (!existing.category || existing.category === 'data')) {
-          existing.category = child.category;
-        }
-        if (child.description && !existing.description) {
-          existing.description = child.description;
-        }
-      }
-    }
-  }
-
-  for (const [childSlug, child] of mergedChildren) {
-    const isRouter = childSlug.endsWith('-router') || child.category === 'router';
-
-    // For routers, reduce O(n²) transitions to adjacent/related routes
-    const childTransitions = isRouter
-      ? reduceRouterTransitions(child.transitions, child.states)
-      : child.transitions;
-
-    // Child model — skip if parent already emitted a model for this slug
-    if (child.fields.length > 0 && !emittedModelSlugs.has(childSlug)) {
-      const childModelPath = `models/${childSlug}.ts`;
-      files.push({
-        path: childModelPath,
-        role: 'model',
-        content: generateModelFile(childSlug, child.fields, child.states, childTransitions,
-          { version: child.version, category: Array.isArray(child.category) ? child.category[0] : child.category, description: child.description }),
-      });
-      modelPaths.push(childModelPath);
-      emittedModelSlugs.add(childSlug);
-    }
-
-    // Child workflow file — preserve parent version/category if child uses defaults
-    const childInput: DecompilerInput = {
-      ...child,
-      version: child.version || definition.version,
-      category: child.category || definition.category,
-      transitions: childTransitions,
-      experience: ((child as unknown as Record<string, unknown>).views as Record<string, unknown> | undefined)?.default as IRExperienceNode | undefined,
-    };
-    const childResult = decompile(childInput, {
-      componentName: pascalCase(childSlug),
-      includeAnnotation: true,
-    });
-    const childPath = `${childSlug}.workflow.tsx`;
-    files.push({ path: childPath, role: 'view-entry', content: childResult.code });
-    entryPaths.push(childPath);
-  }
-
-  // --- Component definitions from metadata ---
-  emitComponentDefinitions(definition, files);
-
-  // --- Server actions with preserved bodies from metadata ---
-  const emittedActionPaths = emitServerActionsFromMetadata(definition, files);
-  actionPaths.push(...emittedActionPaths);
-
-  // --- Main entry file ---
-  const mainPath = 'main.workflow.tsx';
-  if (pagesExtracted) {
-    const mainContent = generateMainWithPages(definition, extractedPages, extractedChildViews);
-    files.push({ path: mainPath, role: 'view-entry', content: mainContent });
-  } else {
-    const mainResult = decompile(definition);
-    files.push({ path: mainPath, role: 'view-entry', content: mainResult.code });
-  }
-  entryPaths.push(mainPath);
-
-  // --- mm.config.ts ---
-  if (decision.emitConfig) {
-    // Deduplicate paths before config generation (second pass may add duplicates)
-    const configData = extractConfigData(
-      definition,
-      [...new Set(modelPaths)],
-      [...new Set(entryPaths)],
-      [...new Set(actionPaths)],
-    );
-    const configContent = generateMmConfig(configData);
-    files.push({ path: 'mm.config.ts', role: 'config', content: configContent });
-  }
-
-  // --- package.json ---
-  files.push({
-    path: 'package.json',
-    role: 'config',
-    content: generatePackageJson(definition),
-  });
-
-  // --- tsconfig.json ---
-  files.push({
-    path: 'tsconfig.json',
-    role: 'config',
-    content: TSCONFIG_TEMPLATE,
-  });
-
-  return {
-    files,
-    entryFile: mainPath,
-    slug,
-    splitDecision: decision,
-  };
-}
-
-// =============================================================================
-// Package scaffolding
-// =============================================================================
-
-const TSCONFIG_TEMPLATE = JSON.stringify({
-  compilerOptions: {
-    target: 'ES2022',
-    module: 'ESNext',
-    moduleResolution: 'bundler',
-    jsx: 'react-jsx',
-    strict: true,
-    esModuleInterop: true,
-    skipLibCheck: true,
-    forceConsistentCasingInFileNames: true,
-    declaration: true,
-    sourceMap: true,
-    outDir: 'dist',
-    rootDir: '.',
-    baseUrl: '.',
-    paths: { '@/*': ['./*'] },
-  },
-  include: ['**/*.ts', '**/*.tsx'],
-  exclude: ['node_modules', 'dist'],
-}, null, 2) + '\n';
-
-function generatePackageJson(def: DecompilerInput): string {
-  const pkg = {
-    name: `@mindmatrix/blueprint-${def.slug}`,
-    version: def.version || '1.0.0',
-    description: def.description || '',
-    type: 'module',
-    main: 'main.workflow.tsx',
-    scripts: {
-      'type-check': 'tsc --noEmit',
-      build: 'mmrc build --src .',
-      deploy: 'mmrc deploy --build --src .',
-    },
-    peerDependencies: {
-      react: '>=18.0.0',
-      '@mindmatrix/react': 'workspace:*',
-    },
-    devDependencies: {
-      '@mindmatrix/react-compiler': 'workspace:*',
-      '@types/react': '^19.0.0',
-      typescript: '^5.4.0',
-    },
-  };
-  return JSON.stringify(pkg, null, 2) + '\n';
-}
-
-// =============================================================================
-// Helpers
-// =============================================================================
-
-function esc(s: string): string {
-  return s.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
-}