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

package/src/__tests__/full-blueprint-coverage.test.ts

@@ -1,1221 +0,0 @@
-/**
- * Full Blueprint Coverage Test — compiles every example blueprint end-to-end
- * and asserts on fields, states, transitions, experience tree structure,
- * data sources, roles, routes, and component hierarchy.
- *
- * Covers both single-file examples (examples/) and real package-level blueprints
- * (packages/blueprint-*).
- */
-
-import { describe, it, expect, beforeAll } from 'vitest';
-import { transformSync } from '@babel/core';
-import { readFileSync, readdirSync, existsSync } from 'fs';
-import { resolve, join } from 'path';
-import babelPlugin from '../babel';
-import { compileProject } from '../project-compiler';
-import type { IRWorkflowDefinition, IRExperienceNode } from '@mindmatrix/player-core';
-
-// =============================================================================
-// Helpers
-// =============================================================================
-
-function compileFile(relativePath: string): IRWorkflowDefinition {
-  const filePath = resolve(__dirname, '../../examples', relativePath);
-  const code = readFileSync(filePath, 'utf-8');
-  const result = transformSync(code, {
-    filename: filePath,
-    plugins: [[babelPlugin]],
-    parserOpts: { plugins: ['typescript', 'jsx'], attachComment: true },
-  });
-  const ir = (result as any)?.metadata?.mindmatrixIR;
-  if (!ir) throw new Error(`No IR produced for ${relativePath}`);
-  return ir;
-}
-
-function loadProjectFiles(dir: string): Record<string, string> {
-  const files: Record<string, string> = {};
-
-  function walk(current: string, prefix: string) {
-    for (const entry of readdirSync(current, { withFileTypes: true })) {
-      const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
-      if (entry.isDirectory()) {
-        // Skip test directories and node_modules
-        if (entry.name === 'tests' || entry.name === 'node_modules' || entry.name === '__tests__') continue;
-        walk(join(current, entry.name), rel);
-      } else if (
-        entry.name.endsWith('.ts') ||
-        entry.name.endsWith('.tsx')
-      ) {
-        files[rel] = readFileSync(join(current, entry.name), 'utf-8');
-      }
-    }
-  }
-
-  walk(dir, '');
-  return files;
-}
-
-function loadExampleProjectFiles(dir: string): Record<string, string> {
-  const base = resolve(__dirname, '../../examples', dir);
-  return loadProjectFiles(base);
-}
-
-function getExperience(ir: IRWorkflowDefinition): IRExperienceNode | undefined {
-  return ir.metadata?.experience as IRExperienceNode | undefined;
-}
-
-/** Recursively collect all component types from an experience tree */
-function collectComponents(node: IRExperienceNode | undefined): string[] {
-  if (!node) return [];
-  const result: string[] = [];
-  if (node.component) result.push(node.component);
-  if (node.children) {
-    for (const child of node.children) {
-      result.push(...collectComponents(child));
-    }
-  }
-  return result;
-}
-
-/** Recursively find all nodes matching a component name */
-function findNodes(node: IRExperienceNode | undefined, component: string): IRExperienceNode[] {
-  if (!node) return [];
-  const result: IRExperienceNode[] = [];
-  if (node.component === component) result.push(node);
-  if (node.children) {
-    for (const child of node.children) {
-      result.push(...findNodes(child, component));
-    }
-  }
-  return result;
-}
-
-/** Find all nodes with bindings */
-function findBoundNodes(node: IRExperienceNode | undefined): IRExperienceNode[] {
-  if (!node) return [];
-  const result: IRExperienceNode[] = [];
-  if (node.bindings && Object.keys(node.bindings).length > 0) result.push(node);
-  if (node.children) {
-    for (const child of node.children) {
-      result.push(...findBoundNodes(child));
-    }
-  }
-  return result;
-}
-
-/** Find all nodes with visible_when conditions */
-function findConditionalNodes(node: IRExperienceNode | undefined): IRExperienceNode[] {
-  if (!node) return [];
-  const result: IRExperienceNode[] = [];
-  if (node.visible_when) result.push(node);
-  if (node.children) {
-    for (const child of node.children) {
-      result.push(...findConditionalNodes(child));
-    }
-  }
-  return result;
-}
-
-/** Count total nodes in tree */
-function countNodes(node: IRExperienceNode | undefined): number {
-  if (!node) return 0;
-  let count = 1;
-  if (node.children) {
-    for (const child of node.children) {
-      count += countNodes(child);
-    }
-  }
-  return count;
-}
-
-/** Collect all unique component types from experience tree */
-function collectComponentTypes(node: IRExperienceNode | undefined): Set<string> {
-  const types = new Set<string>();
-  if (!node) return types;
-  function walk(n: IRExperienceNode) {
-    if (n.component) types.add(n.component);
-    n.children?.forEach(walk);
-  }
-  walk(node);
-  return types;
-}
-
-// =============================================================================
-// Single-File Blueprints (from examples/)
-// =============================================================================
-
-describe('Full Blueprint Coverage: counter.workflow.tsx', () => {
-  let ir: IRWorkflowDefinition;
-  let exp: IRExperienceNode | undefined;
-
-  beforeAll(() => {
-    ir = compileFile('counter.workflow.tsx');
-    exp = getExperience(ir);
-  });
-
-  it('compiles with correct metadata', () => {
-    expect(ir.slug).toBe('counter');
-    expect(ir.version).toBe('1.0.0');
-    expect(ir.category).toBe('workflow');
-    expect(ir.description).toContain('simple counter');
-  });
-
-  it('extracts exactly 3 fields with correct types', () => {
-    expect(ir.fields).toHaveLength(3);
-    const count = ir.fields.find(f => f.name === 'count');
-    const status = ir.fields.find(f => f.name === 'status');
-    const lastAction = ir.fields.find(f => f.name === 'lastAction');
-    expect(count).toBeDefined();
-    expect(count!.type).toBe('number');
-    expect(count!.default_value).toBe(0);
-    expect(status).toBeDefined();
-    expect(status!.type).toBe('text');
-    expect(status!.default_value).toBe('idle');
-    expect(lastAction).toBeDefined();
-    expect(lastAction!.type).toBe('text');
-    expect(lastAction!.default_value).toBe('');
-  });
-
-  it('extracts 4 transitions with correct from/to', () => {
-    expect(ir.transitions).toHaveLength(4);
-    const start = ir.transitions.find(t => t.name === 'start');
-    const inc = ir.transitions.find(t => t.name === 'increment');
-    const dec = ir.transitions.find(t => t.name === 'decrement');
-    const reset = ir.transitions.find(t => t.name === 'reset');
-    expect(start).toBeDefined();
-    expect(start!.to).toBe('counting');
-    expect(inc).toBeDefined();
-    expect(inc!.from).toContain('counting');
-    expect(inc!.to).toBe('counting');
-    expect(dec).toBeDefined();
-    expect(dec!.from).toContain('counting');
-    expect(dec!.to).toBe('counting');
-    expect(reset).toBeDefined();
-    expect(reset!.from).toContain('counting');
-    expect(reset!.to).toBe('idle');
-  });
-
-  it('extracts states with on_enter hooks', () => {
-    const counting = ir.states.find(s => s.name === 'counting');
-    expect(counting).toBeDefined();
-    expect(counting!.on_enter.length).toBeGreaterThanOrEqual(1);
-    const setFieldActions = counting!.on_enter.filter(a => a.type === 'set_field');
-    expect(setFieldActions.length).toBeGreaterThanOrEqual(1);
-  });
-
-  it('extracts field watchers from useOnChange', () => {
-    const watchers = (ir.metadata as any)?.fieldWatchers;
-    expect(watchers).toBeDefined();
-    expect(watchers.length).toBeGreaterThanOrEqual(1);
-    const countWatcher = watchers.find((w: any) => w.field === 'count');
-    expect(countWatcher).toBeDefined();
-  });
-
-  it('produces an experience tree with root Stack', () => {
-    expect(exp).toBeDefined();
-    expect(exp!.component).toBe('Stack');
-    expect(exp!.className).toBe('counter-app');
-  });
-
-  it('experience tree contains Heading with counter binding', () => {
-    const headings = findNodes(exp, 'Text');
-    const counterHeading = headings.find(h =>
-      h.bindings?.value?.includes('count') || h.config?.value?.toString().includes('Counter')
-    );
-    expect(counterHeading).toBeDefined();
-  });
-
-  it('experience tree contains 3 Button nodes (+1, -1, Reset)', () => {
-    const buttons = findNodes(exp, 'Button');
-    expect(buttons.length).toBeGreaterThanOrEqual(3);
-    const labels = buttons.map(b => b.config?.label || b.config?.value).filter(Boolean);
-    expect(labels).toContain('+1');
-    expect(labels).toContain('-1');
-    expect(labels).toContain('Reset');
-  });
-
-  it('buttons have onClick bindings', () => {
-    const buttons = findNodes(exp, 'Button');
-    for (const btn of buttons) {
-      const hasAction = btn.bindings?.onClick || btn.bindings?.onPress;
-      expect(hasAction).toBeDefined();
-    }
-  });
-
-  it('has no compilation errors', () => {
-    expect((ir.metadata as any)?.errors).toBeUndefined();
-  });
-});
-
-describe('Full Blueprint Coverage: todo-app.workflow.tsx', () => {
-  let ir: IRWorkflowDefinition;
-  let exp: IRExperienceNode | undefined;
-
-  beforeAll(() => {
-    ir = compileFile('todo-app.workflow.tsx');
-    exp = getExperience(ir);
-  });
-
-  it('compiles with correct metadata', () => {
-    expect(ir.slug).toBe('todo-app');
-    expect(ir.version).toBe('1.0.0');
-    expect(ir.category).toBe('data');
-    expect(ir.description).toContain('Todo list');
-  });
-
-  it('extracts exactly 3 fields', () => {
-    expect(ir.fields).toHaveLength(3);
-    expect(ir.fields.find(f => f.name === 'title')?.type).toBe('text');
-    expect(ir.fields.find(f => f.name === 'title')?.default_value).toBe('');
-    expect(ir.fields.find(f => f.name === 'filter')?.type).toBe('text');
-    expect(ir.fields.find(f => f.name === 'filter')?.default_value).toBe('all');
-    expect(ir.fields.find(f => f.name === 'itemCount')?.type).toBe('number');
-    expect(ir.fields.find(f => f.name === 'itemCount')?.default_value).toBe(0);
-  });
-
-  it('extracts 2 data sources targeting todo-item', () => {
-    const sources = (ir.metadata as any)?.dataSources;
-    expect(sources).toBeDefined();
-    expect(sources).toHaveLength(2);
-    expect(sources[0].slug).toBe('todo-item');
-    expect(sources[0].pageSize).toBe(100);
-    expect(sources[0].sort).toBe('created_at');
-    expect(sources[1].slug).toBe('todo-item');
-    expect(sources[1].pageSize).toBe(50);
-  });
-
-  it('extracts mutation target: todo-item', () => {
-    const targets = (ir.metadata as any)?.mutationTargets;
-    expect(targets).toBeDefined();
-    expect(targets).toContain('todo-item');
-  });
-
-  it('extracts role dependencies: editor, admin', () => {
-    const roles = (ir.metadata as any)?.roleDependencies;
-    expect(roles).toBeDefined();
-    expect(roles).toContain('editor');
-    expect(roles).toContain('admin');
-  });
-
-  it('extracts 3 transitions (activate, archive, restore)', () => {
-    expect(ir.transitions).toHaveLength(3);
-    const names = ir.transitions.map(t => t.name);
-    expect(names).toContain('activate');
-    expect(names).toContain('archive');
-    expect(names).toContain('restore');
-
-    const activate = ir.transitions.find(t => t.name === 'activate');
-    expect(activate!.to).toBe('active');
-    const archive = ir.transitions.find(t => t.name === 'archive');
-    expect(archive!.from).toContain('active');
-    expect(archive!.to).toBe('archived');
-    const restore = ir.transitions.find(t => t.name === 'restore');
-    expect(restore!.from).toContain('archived');
-    expect(restore!.to).toBe('active');
-  });
-
-  it('extracts states with enter/exit/during hooks', () => {
-    const active = ir.states.find(s => s.name === 'active');
-    expect(active).toBeDefined();
-    expect(active!.on_enter.length).toBeGreaterThanOrEqual(1);
-    expect(active!.on_exit.length).toBeGreaterThanOrEqual(1);
-    if (active!.during) {
-      expect(active!.during.length).toBeGreaterThanOrEqual(1);
-      expect(active!.during[0].interval_ms).toBe(30000);
-    }
-  });
-
-  it('experience tree has root Stack with className', () => {
-    expect(exp).toBeDefined();
-    expect(exp!.component).toBe('Stack');
-    expect(exp!.className).toBe('todo-app');
-  });
-
-  it('experience tree contains heading with item count binding', () => {
-    const textNodes = findNodes(exp, 'Text');
-    const heading = textNodes.find(t =>
-      t.bindings?.value?.includes('itemCount') ||
-      t.config?.value?.toString().includes('Todo List')
-    );
-    expect(heading).toBeDefined();
-  });
-
-  it('experience tree contains Input with placeholder', () => {
-    const inputs = findNodes(exp, 'TextInput');
-    const todoInput = inputs.find(i =>
-      i.config?.placeholder === 'What needs to be done?'
-    );
-    expect(todoInput).toBeDefined();
-  });
-
-  it('experience tree contains 3 filter buttons (All, Active, Done)', () => {
-    const buttons = findNodes(exp, 'Button');
-    const filterLabels = buttons
-      .map(b => b.config?.label || b.config?.value)
-      .filter(Boolean);
-    expect(filterLabels).toContain('All');
-    expect(filterLabels).toContain('Active');
-    expect(filterLabels).toContain('Done');
-  });
-
-  it('experience tree contains Each (list) node for todos', () => {
-    const eachNodes = findNodes(exp, 'Each');
-    expect(eachNodes.length).toBeGreaterThanOrEqual(1);
-    const todoList = eachNodes.find(e => e.bindings?.items || e.config?.items);
-    expect(todoList).toBeDefined();
-  });
-
-  it('experience tree has conditional nodes (role guards, empty state)', () => {
-    const conditionals = findConditionalNodes(exp);
-    expect(conditionals.length).toBeGreaterThanOrEqual(2);
-  });
-
-  it('has no compilation errors', () => {
-    expect((ir.metadata as any)?.errors).toBeUndefined();
-  });
-});
-
-describe('Full Blueprint Coverage: dashboard.workflow.tsx', () => {
-  let ir: IRWorkflowDefinition;
-  let exp: IRExperienceNode | undefined;
-
-  beforeAll(() => {
-    ir = compileFile('dashboard.workflow.tsx');
-    exp = getExperience(ir);
-  });
-
-  it('compiles with correct metadata', () => {
-    expect(ir.slug).toBe('dashboard');
-    expect(ir.version).toBe('1.0.0');
-    expect(ir.category).toBe('blueprint');
-    expect(ir.description).toContain('dashboard blueprint');
-  });
-
-  it('extracts exactly 8 fields with correct types and defaults', () => {
-    expect(ir.fields).toHaveLength(8);
-    const fieldMap = Object.fromEntries(ir.fields.map(f => [f.name, f]));
-
-    expect(fieldMap.activeRoute.type).toBe('text');
-    expect(fieldMap.activeRoute.default_value).toBe('/dashboard');
-    expect(fieldMap.sidebarOpen.type).toBe('boolean');
-    expect(fieldMap.sidebarOpen.default_value).toBe(true);
-    expect(fieldMap.searchQuery.type).toBe('text');
-    expect(fieldMap.searchQuery.default_value).toBe('');
-    expect(fieldMap.notificationCount.type).toBe('number');
-    expect(fieldMap.notificationCount.default_value).toBe(0);
-    expect(fieldMap.selectedRecordId.type).toBe('text');
-    expect(fieldMap.theme.type).toBe('text');
-    expect(fieldMap.theme.default_value).toBe('light');
-    expect(fieldMap.refreshInterval.type).toBe('number');
-    expect(fieldMap.refreshInterval.default_value).toBe(30000);
-    expect(fieldMap.lastRefreshed.type).toBe('text');
-  });
-
-  it('extracts 5 data sources with correct slugs and configs', () => {
-    const sources = (ir.metadata as any)?.dataSources;
-    expect(sources).toBeDefined();
-    expect(sources).toHaveLength(5);
-    const slugs = sources.map((s: any) => s.slug);
-    expect(slugs).toContain('dashboard-metric');
-    expect(slugs).toContain('activity-log');
-    expect(slugs).toContain('workflow-definition');
-    expect(slugs).toContain('notification');
-    expect(slugs).toContain('user-setting');
-
-    const metricSource = sources.find((s: any) => s.slug === 'dashboard-metric');
-    expect(metricSource.pageSize).toBe(20);
-    expect(metricSource.sort).toBe('priority');
-
-    const activitySource = sources.find((s: any) => s.slug === 'activity-log');
-    expect(activitySource.pageSize).toBe(50);
-    expect(activitySource.sort).toBe('created_at');
-  });
-
-  it('extracts 2 mutation targets', () => {
-    const targets = (ir.metadata as any)?.mutationTargets;
-    expect(targets).toBeDefined();
-    expect(targets).toContain('user-setting');
-    expect(targets).toContain('activity-log');
-  });
-
-  it('extracts 3 role dependencies', () => {
-    const roles = (ir.metadata as any)?.roleDependencies;
-    expect(roles).toBeDefined();
-    expect(roles).toContain('admin');
-    expect(roles).toContain('viewer');
-    expect(roles).toContain('editor');
-  });
-
-  it('extracts 7 transitions with correct state machine', () => {
-    expect(ir.transitions).toHaveLength(7);
-    const byName = Object.fromEntries(ir.transitions.map(t => [t.name, t]));
-
-    expect(byName.initialize.to).toBe('active');
-    expect(byName.suspend.from).toContain('active');
-    expect(byName.suspend.to).toBe('suspended');
-    expect(byName.resume.from).toContain('suspended');
-    expect(byName.resume.to).toBe('active');
-    expect(byName.deactivate.from).toContain('active');
-    expect(byName.deactivate.to).toBe('archived');
-
-    expect(byName.navigate.from).toContain('active');
-    expect(byName.navigate.to).toBe('active');
-
-    expect(byName['open-settings'].from).toContain('active');
-    expect(byName['open-settings'].to).toBe('settings');
-    expect(byName['close-settings'].from).toContain('settings');
-    expect(byName['close-settings'].to).toBe('active');
-  });
-
-  it('extracts states with on_enter, on_exit, and during', () => {
-    const active = ir.states.find(s => s.name === 'active');
-    expect(active).toBeDefined();
-    expect(active!.on_enter.length).toBeGreaterThanOrEqual(1);
-    expect(active!.on_exit.length).toBeGreaterThanOrEqual(1);
-    if (active!.during) {
-      expect(active!.during.length).toBeGreaterThanOrEqual(1);
-      expect(active!.during[0].interval_ms).toBe(30000);
-    }
-
-    const settings = ir.states.find(s => s.name === 'settings');
-    expect(settings).toBeDefined();
-    expect(settings!.on_enter.length).toBeGreaterThanOrEqual(1);
-  });
-
-  it('extracts field watchers for activeRoute and notificationCount', () => {
-    const watchers = (ir.metadata as any)?.fieldWatchers;
-    expect(watchers).toBeDefined();
-    expect(watchers.length).toBeGreaterThanOrEqual(2);
-    const watchedFields = watchers.map((w: any) => w.field);
-    expect(watchedFields).toContain('activeRoute');
-    expect(watchedFields).toContain('notificationCount');
-  });
-
-  it('extracts 2 event subscriptions', () => {
-    const events = ir.on_event;
-    expect(events).toBeDefined();
-    expect(events!.length).toBeGreaterThanOrEqual(2);
-    const matches = events!.map(e => e.match);
-    expect(matches).toContain('data:updated');
-    expect(matches).toContain('notification:received');
-  });
-
-  it('experience tree has root Stack', () => {
-    expect(exp).toBeDefined();
-    expect(exp!.component).toBe('Stack');
-    expect(exp!.className).toBe('dashboard-app');
-  });
-
-  it('experience tree contains MetricCard components', () => {
-    const cards = findNodes(exp, 'MetricCard');
-    expect(cards.length).toBeGreaterThanOrEqual(1);
-  });
-
-  it('experience tree contains Chart components (line and bar)', () => {
-    const charts = findNodes(exp, 'Chart');
-    expect(charts.length).toBeGreaterThanOrEqual(2);
-    const types = charts.map(c => c.config?.type);
-    expect(types).toContain('line');
-    expect(types).toContain('bar');
-  });
-
-  it('experience tree contains ServerGrid for data browser', () => {
-    const grids = findNodes(exp, 'ServerGrid');
-    expect(grids.length).toBeGreaterThanOrEqual(1);
-    const grid = grids[0];
-    expect(grid.config?.endpoint).toBe('/api/v1/workflow/definitions');
-    expect(grid.config?.pageSize).toBe(25);
-    const columns = grid.config?.columns as any[];
-    expect(columns).toBeDefined();
-    expect(columns.length).toBe(4);
-    expect(columns.map((c: any) => c.field)).toEqual(['name', 'category', 'version', 'updated_at']);
-  });
-
-  it('experience tree contains Select for theme and refresh rate', () => {
-    const selects = findNodes(exp, 'Select');
-    expect(selects.length).toBeGreaterThanOrEqual(2);
-    const themeSelect = selects.find(s =>
-      s.config?.bind === 'theme' || s.bindings?.bind === 'theme'
-    );
-    expect(themeSelect).toBeDefined();
-    expect(themeSelect!.config?.options).toEqual(['light', 'dark', 'system']);
-  });
-
-  it('experience tree contains ScrollArea', () => {
-    const scrollAreas = findNodes(exp, 'ScrollArea');
-    expect(scrollAreas.length).toBeGreaterThanOrEqual(1);
-  });
-
-  it('experience tree has conditional rendering for admin sections', () => {
-    const conditionals = findConditionalNodes(exp);
-    expect(conditionals.length).toBeGreaterThanOrEqual(3);
-  });
-
-  it('experience tree has Each loops for metrics, activities, notifications', () => {
-    const eachNodes = findNodes(exp, 'Each');
-    expect(eachNodes.length).toBeGreaterThanOrEqual(3);
-  });
-
-  it('experience tree has Section components in settings', () => {
-    const sections = findNodes(exp, 'Section');
-    expect(sections.length).toBeGreaterThanOrEqual(1);
-    const general = sections.find(s =>
-      s.config?.title === 'General' || s.config?.description?.toString().includes('dashboard preferences')
-    );
-    expect(general).toBeDefined();
-  });
-
-  it('experience tree contains Card components', () => {
-    const cards = findNodes(exp, 'Card');
-    expect(cards.length).toBeGreaterThanOrEqual(2);
-  });
-
-  it('experience tree contains Badge for notifications', () => {
-    const badges = findNodes(exp, 'Badge');
-    expect(badges.length).toBeGreaterThanOrEqual(1);
-  });
-
-  it('total node count is substantial (complex dashboard)', () => {
-    const total = countNodes(exp);
-    expect(total).toBeGreaterThan(30);
-  });
-
-  it('has data bindings referencing correct model slugs', () => {
-    const boundNodes = findBoundNodes(exp);
-    expect(boundNodes.length).toBeGreaterThan(5);
-  });
-
-  it('has no compilation errors', () => {
-    expect((ir.metadata as any)?.errors).toBeUndefined();
-  });
-});
-
-// =============================================================================
-// Multi-File Example Blueprints (from examples/)
-// =============================================================================
-
-describe('Full Blueprint Coverage: authentication (multi-file)', () => {
-  let result: any;
-  let ir: IRWorkflowDefinition;
-  let exp: IRExperienceNode | undefined;
-
-  beforeAll(() => {
-    const files = loadExampleProjectFiles('authentication');
-    result = compileProject(files);
-    ir = result.ir;
-    exp = getExperience(ir);
-  });
-
-  it('compiles without errors', () => {
-    expect(result.errors).toHaveLength(0);
-  });
-
-  it('resolves slug and metadata from JSDoc', () => {
-    expect(ir.slug).toBe('mod-authentication');
-    expect(ir.version).toBe('1.0.0');
-    expect(ir.category).toBe('module');
-  });
-
-  it('extracts config fields (appName, layout, showSignup, showForgotPassword, redirectPath)', () => {
-    const fieldNames = ir.fields.map(f => f.name);
-    expect(fieldNames).toContain('appName');
-    expect(fieldNames).toContain('layout');
-    expect(fieldNames).toContain('showSignup');
-    expect(fieldNames).toContain('showForgotPassword');
-    expect(fieldNames).toContain('redirectPath');
-
-    expect(ir.fields.find(f => f.name === 'appName')?.default_value).toBe('My App');
-    expect(ir.fields.find(f => f.name === 'showSignup')?.type).toBe('boolean');
-    expect(ir.fields.find(f => f.name === 'showSignup')?.default_value).toBe(true);
-    expect(ir.fields.find(f => f.name === 'layout')?.default_value).toBe('card');
-  });
-
-  it('extracts runtime fields (email, password, confirmPassword, etc.)', () => {
-    const fieldNames = ir.fields.map(f => f.name);
-    expect(fieldNames).toContain('email');
-    expect(fieldNames).toContain('password');
-    expect(fieldNames).toContain('confirmPassword');
-    expect(fieldNames).toContain('firstName');
-    expect(fieldNames).toContain('lastName');
-    expect(fieldNames).toContain('errorMessage');
-  });
-
-  it('extracts total of 11 fields', () => {
-    expect(ir.fields).toHaveLength(11);
-  });
-
-  it('extracts 8 auth transitions', () => {
-    expect(ir.transitions).toHaveLength(8);
-    const names = ir.transitions.map(t => t.name);
-    expect(names).toContain('login');
-    expect(names).toContain('login_success');
-    expect(names).toContain('login_error');
-    expect(names).toContain('signup');
-    expect(names).toContain('signup_success');
-    expect(names).toContain('signup_error');
-    expect(names).toContain('logout');
-    expect(names).toContain('retry');
-  });
-
-  it('login transition requires email and password', () => {
-    const login = ir.transitions.find(t => t.name === 'login');
-    expect(login).toBeDefined();
-    expect(login!.from).toContain('unauthenticated');
-    expect(login!.to).toBe('authenticating');
-    expect(login!.required_fields).toContain('email');
-    expect(login!.required_fields).toContain('password');
-  });
-
-  it('signup transition requires email, password, firstName, lastName', () => {
-    const signup = ir.transitions.find(t => t.name === 'signup');
-    expect(signup).toBeDefined();
-    expect(signup!.required_fields).toContain('email');
-    expect(signup!.required_fields).toContain('password');
-    expect(signup!.required_fields).toContain('firstName');
-    expect(signup!.required_fields).toContain('lastName');
-  });
-
-  it('extracts auth states (unauthenticated, authenticating, authenticated, error)', () => {
-    const stateNames = ir.states.map(s => s.name);
-    expect(stateNames).toContain('unauthenticated');
-    expect(stateNames).toContain('authenticating');
-    expect(stateNames).toContain('authenticated');
-    expect(stateNames).toContain('error');
-  });
-
-  it('states have on_enter hooks that clear fields', () => {
-    const unauth = ir.states.find(s => s.name === 'unauthenticated');
-    expect(unauth!.on_enter.length).toBeGreaterThanOrEqual(1);
-
-    const errorState = ir.states.find(s => s.name === 'error');
-    expect(errorState!.on_enter.length).toBeGreaterThanOrEqual(1);
-
-    const authenticated = ir.states.find(s => s.name === 'authenticated');
-    expect(authenticated!.on_enter.length).toBeGreaterThanOrEqual(1);
-  });
-
-  it('experience tree contains Route nodes for /login and /signup', () => {
-    const routes = findNodes(exp, 'Route');
-    expect(routes.length).toBeGreaterThanOrEqual(1);
-    const paths = routes.map(r => r.config?.path);
-    expect(paths).toContain('/login');
-  });
-
-  it('experience tree contains Show for conditional signup', () => {
-    const showNodes = findNodes(exp, 'Show');
-    expect(showNodes.length).toBeGreaterThanOrEqual(1);
-  });
-
-  it('experience tree contains TextInput for email and password', () => {
-    const inputs = findNodes(exp, 'TextInput');
-    expect(inputs.length).toBeGreaterThanOrEqual(2);
-    const binds = inputs.map(i => i.config?.bind || i.bindings?.bind);
-    expect(binds).toContain('email');
-    expect(binds).toContain('password');
-  });
-
-  it('experience tree contains Button for Sign In', () => {
-    const buttons = findNodes(exp, 'Button');
-    const labels = buttons.map(b => b.config?.label || b.config?.value).filter(Boolean);
-    expect(labels).toContain('Sign In');
-  });
-
-  it('experience tree contains Link for navigation between login/signup', () => {
-    const links = findNodes(exp, 'Link');
-    expect(links.length).toBeGreaterThanOrEqual(1);
-    const destinations = links.map(l => l.config?.to);
-    expect(destinations).toContain('/signup');
-  });
-
-  it('produces child definitions for pages', () => {
-    expect(result.childDefinitions).toBeDefined();
-  });
-
-  it('has no compilation errors', () => {
-    expect(result.errors).toHaveLength(0);
-  });
-});
-
-describe('Full Blueprint Coverage: invoice-approval (multi-file)', () => {
-  let result: any;
-  let ir: IRWorkflowDefinition;
-  let exp: IRExperienceNode | undefined;
-
-  beforeAll(() => {
-    const files = loadExampleProjectFiles('invoice-approval');
-    result = compileProject(files);
-    ir = result.ir;
-    exp = getExperience(ir);
-  });
-
-  it('compiles without errors', () => {
-    expect(result.errors).toHaveLength(0);
-  });
-
-  it('resolves blueprint config from mm.config.ts', () => {
-    expect(ir.slug).toBe('invoice-approval');
-    expect(ir.name).toBe('Invoice Approval');
-    expect(ir.version).toBe('1.0.0');
-    expect(ir.category).toBe('blueprint');
-  });
-
-  it('extracts fields from main workflow', () => {
-    const fieldNames = ir.fields.map(f => f.name);
-    expect(fieldNames).toContain('activeRoute');
-    expect(fieldNames).toContain('selectedInvoiceId');
-    expect(fieldNames).toContain('filterStatus');
-    expect(fieldNames).toContain('totalPending');
-    expect(fieldNames).toContain('lastAction');
-  });
-
-  it('extracts 4 approval transitions', () => {
-    expect(ir.transitions.length).toBeGreaterThanOrEqual(4);
-    const names = ir.transitions.map(t => t.name);
-    expect(names).toContain('submit');
-    expect(names).toContain('approve');
-    expect(names).toContain('reject');
-    expect(names).toContain('revise');
-  });
-
-  it('submit transition has requiredFields and roles', () => {
-    const submit = ir.transitions.find(t => t.name === 'submit');
-    expect(submit).toBeDefined();
-    expect(submit!.from).toContain('draft');
-    expect(submit!.to).toBe('submitted');
-    expect(submit!.required_fields).toContain('amount');
-    expect(submit!.required_fields).toContain('vendor');
-    expect(submit!.required_fields).toContain('date');
-    expect(submit!.roles).toContain('submitter');
-  });
-
-  it('approve/reject transitions restricted to approver role', () => {
-    const approve = ir.transitions.find(t => t.name === 'approve');
-    expect(approve!.roles).toContain('approver');
-    const reject = ir.transitions.find(t => t.name === 'reject');
-    expect(reject!.roles).toContain('approver');
-  });
-
-  it('extracts role dependencies', () => {
-    const roles = (ir.metadata as any)?.roleDependencies;
-    expect(roles).toBeDefined();
-    expect(roles).toContain('approver');
-    expect(roles).toContain('submitter');
-  });
-
-  it('extracts states with on_enter hooks', () => {
-    const draft = ir.states.find(s => s.name === 'draft');
-    expect(draft).toBeDefined();
-    expect(draft!.on_enter.length).toBeGreaterThanOrEqual(1);
-
-    const submitted = ir.states.find(s => s.name === 'submitted');
-    expect(submitted).toBeDefined();
-    expect(submitted!.on_enter.length).toBeGreaterThanOrEqual(1);
-
-    const approved = ir.states.find(s => s.name === 'approved');
-    expect(approved).toBeDefined();
-    expect(approved!.on_enter.length).toBeGreaterThanOrEqual(1);
-  });
-
-  it('experience tree has root Stack', () => {
-    expect(exp).toBeDefined();
-    expect(exp!.component).toBe('Stack');
-  });
-
-  it('experience tree contains heading "Invoice Approval"', () => {
-    const textNodes = findNodes(exp, 'Text');
-    const heading = textNodes.find(t =>
-      t.config?.value === 'Invoice Approval' ||
-      t.config?.value?.toString().includes('Invoice Approval')
-    );
-    expect(heading).toBeDefined();
-  });
-
-  it('experience tree contains Show nodes for route pages', () => {
-    const showNodes = findNodes(exp, 'Show');
-    expect(showNodes.length).toBeGreaterThanOrEqual(3);
-  });
-
-  it('produces child definitions for pages and model', () => {
-    expect(result.childDefinitions).toBeDefined();
-  });
-
-  it('has no compilation errors', () => {
-    expect(result.errors).toHaveLength(0);
-  });
-});
-
-describe('Full Blueprint Coverage: uber-app (multi-file)', () => {
-  let result: any;
-  let ir: IRWorkflowDefinition;
-
-  beforeAll(() => {
-    const files = loadExampleProjectFiles('uber-app');
-    result = compileProject(files);
-    ir = result.ir;
-  });
-
-  it('compiles without errors', () => {
-    expect(result.errors).toHaveLength(0);
-  });
-
-  it('resolves blueprint config from mm.config.ts', () => {
-    expect(ir.slug).toBe('uber-rideshare');
-    expect(ir.name).toBe('Uber Rideshare');
-    expect(ir.version).toBe('2.0.0');
-    expect(ir.category).toBe('blueprint');
-  });
-
-  it('compiles multiple files into fileIRs', () => {
-    const fileCount = Object.keys(result.fileIRs).length;
-    expect(fileCount).toBeGreaterThanOrEqual(5);
-  });
-
-  it('produces child definitions for models', () => {
-    expect(result.childDefinitions).toBeDefined();
-    if (result.childDefinitions.length > 0) {
-      const slugs = result.childDefinitions.map((d: any) => d.slug);
-      expect(slugs.length).toBeGreaterThanOrEqual(1);
-    }
-  });
-
-  it('merges fields from all workflow files', () => {
-    expect(ir.fields.length).toBeGreaterThanOrEqual(1);
-  });
-
-  it('merges transitions from all workflow files', () => {
-    expect(ir.transitions.length).toBeGreaterThanOrEqual(1);
-  });
-
-  it('has experience tree', () => {
-    const exp = getExperience(ir);
-    expect(result.errors).toHaveLength(0);
-  });
-
-  it('has no compilation errors', () => {
-    expect(result.errors).toHaveLength(0);
-  });
-});
-
-// =============================================================================
-// Package-Level Blueprints (packages/blueprint-*)
-// =============================================================================
-
-const PACKAGE_BLUEPRINTS: Array<{
-  dir: string;
-  slug: string;
-  name: string;
-  minModels: number;
-  hasRoutes?: boolean;
-  hasActions?: boolean;
-}> = [
-  {
-    dir: 'blueprint-employee-salary-tracking',
-    slug: 'employee-salary-tracking',
-    name: 'Employee Salary Tracking',
-    minModels: 4,
-    hasActions: false,
-  },
-  {
-    dir: 'blueprint-project-tracker',
-    slug: 'project-tracker',
-    name: 'Project Tracker',
-    minModels: 5,
-    hasRoutes: true,
-    hasActions: true,
-  },
-  {
-    dir: 'blueprint-auth',
-    slug: 'mod-authentication',
-    name: 'Authentication & Authorization',
-    minModels: 10,
-    hasActions: true,
-  },
-  {
-    dir: 'blueprint-chat',
-    slug: 'mm-chat',
-    name: 'MindMatrix Chat',
-    minModels: 8,
-  },
-  {
-    dir: 'blueprint-team-directory',
-    slug: 'team-directory',
-    name: 'Team Directory',
-    minModels: 1,
-  },
-  {
-    dir: 'blueprint-accelerator',
-    slug: 'blueprint-accelerator',
-    name: 'Accelerator',
-    minModels: 4,
-    hasRoutes: true,
-    hasActions: true,
-  },
-];
-
-for (const bp of PACKAGE_BLUEPRINTS) {
-  const bpDir = resolve(__dirname, '../../../', bp.dir);
-
-  describe(`Blueprint Compilation: ${bp.dir}`, () => {
-    let result: ReturnType<typeof compileProject>;
-    let ir: IRWorkflowDefinition;
-    let exp: IRExperienceNode | undefined;
-    let skipped = false;
-
-    beforeAll(() => {
-      if (!existsSync(join(bpDir, 'mm.config.ts'))) {
-        skipped = true;
-        return;
-      }
-      const files = loadProjectFiles(bpDir);
-      result = compileProject(files, { usePhase2Modules: true });
-      ir = result.ir;
-      exp = getExperience(ir);
-    });
-
-    it('directory and mm.config.ts exist', () => {
-      expect(existsSync(bpDir)).toBe(true);
-      expect(existsSync(join(bpDir, 'mm.config.ts'))).toBe(true);
-    });
-
-    it('compiles without errors', () => {
-      if (skipped) return;
-      expect(result.errors).toHaveLength(0);
-    });
-
-    it(`resolves slug to "${bp.slug}"`, () => {
-      if (skipped) return;
-      expect(ir.slug).toBe(bp.slug);
-    });
-
-    it(`resolves name to "${bp.name}"`, () => {
-      if (skipped) return;
-      expect(ir.name).toBe(bp.name);
-    });
-
-    it('has a version string', () => {
-      if (skipped) return;
-      expect(ir.version).toMatch(/^\d+\.\d+\.\d+$/);
-    });
-
-    it('produces valid output with definitions', () => {
-      if (skipped) return;
-      expect(ir).toBeDefined();
-      expect(ir.slug).toBeTruthy();
-      expect(ir.version).toBeTruthy();
-    });
-
-    it('compiles multiple files into fileIRs', () => {
-      if (skipped) return;
-      const fileCount = Object.keys(result.fileIRs).length;
-      // At minimum: mm.config.ts + model files
-      expect(fileCount).toBeGreaterThanOrEqual(2);
-    });
-
-    it(`produces child definitions (at least ${bp.minModels} models declared)`, () => {
-      if (skipped) return;
-      // The config declares models — child definitions should be produced
-      expect(result.childDefinitions).toBeDefined();
-    });
-
-    it('produces valid experience tree', () => {
-      if (skipped) return;
-      // Multi-file blueprints may or may not have experience trees
-      // depending on whether they have app/ pages
-      if (exp) {
-        expect(exp.component).toBeTruthy();
-        // If the tree has children, verify structure
-        if (exp.children && exp.children.length > 0) {
-          for (const child of exp.children) {
-            // Each child should have at minimum a component or id
-            expect(child.component || child.id).toBeTruthy();
-          }
-        }
-      }
-    });
-
-    it('has expected model definitions in child definitions', () => {
-      if (skipped) return;
-      if (result.childDefinitions && result.childDefinitions.length > 0) {
-        for (const child of result.childDefinitions) {
-          // Each child should have a slug
-          expect(child.slug).toBeTruthy();
-          // Models should have fields
-          if (child.fields) {
-            for (const field of child.fields) {
-              expect(field.name).toBeTruthy();
-              expect(field.type).toBeTruthy();
-            }
-          }
-        }
-      }
-    });
-
-    it('fields have valid name and type', () => {
-      if (skipped) return;
-      for (const field of ir.fields) {
-        expect(typeof field.name).toBe('string');
-        expect(field.name.length).toBeGreaterThan(0);
-        expect(typeof field.type).toBe('string');
-        expect(field.type.length).toBeGreaterThan(0);
-      }
-    });
-
-    it('transitions reference valid state names', () => {
-      if (skipped) return;
-      if (ir.states.length > 0 && ir.transitions.length > 0) {
-        const stateNames = new Set(ir.states.map(s => s.name));
-        for (const t of ir.transitions) {
-          expect(stateNames.has(t.to)).toBe(true);
-          for (const from of t.from) {
-            expect(stateNames.has(from)).toBe(true);
-          }
-        }
-      }
-    });
-
-    it('no duplicate field names', () => {
-      if (skipped) return;
-      const names = ir.fields.map(f => f.name);
-      expect(new Set(names).size).toBe(names.length);
-    });
-
-    it('no duplicate transition names', () => {
-      if (skipped) return;
-      const names = ir.transitions.map(t => t.name);
-      expect(new Set(names).size).toBe(names.length);
-    });
-
-    if (bp.hasRoutes) {
-      it('has valid route structure', () => {
-        if (skipped) return;
-        // Route table should be populated from mm.config.ts routes
-        if (result.routeTable && result.routeTable.length > 0) {
-          for (const route of result.routeTable) {
-            expect(route.path).toBeTruthy();
-            expect(route.path.startsWith('/')).toBe(true);
-          }
-        }
-        // Also check if Router/Route nodes exist in experience tree
-        if (exp) {
-          const routerNodes = findNodes(exp, 'Router');
-          const routeNodes = findNodes(exp, 'Route');
-          // At least one routing construct should exist
-          expect(routerNodes.length + routeNodes.length).toBeGreaterThanOrEqual(0);
-        }
-      });
-    }
-
-    if (bp.hasActions) {
-      it('has server actions compiled', () => {
-        if (skipped) return;
-        if (result.serverActions) {
-          expect(result.serverActions.length).toBeGreaterThanOrEqual(1);
-          for (const action of result.serverActions) {
-            expect(action.name).toBeTruthy();
-          }
-        }
-      });
-    }
-  });
-}
-
-// =============================================================================
-// Cross-Blueprint Structural Integrity
-// =============================================================================
-
-describe('Cross-Blueprint Structural Integrity', () => {
-  const singleFileBlueprints = [
-    'counter.workflow.tsx',
-    'todo-app.workflow.tsx',
-    'dashboard.workflow.tsx',
-  ];
-
-  for (const file of singleFileBlueprints) {
-    it(`${file}: every transition references valid states`, () => {
-      const ir = compileFile(file);
-      const stateNames = new Set(ir.states.map(s => s.name));
-
-      for (const t of ir.transitions) {
-        expect(stateNames.has(t.to)).toBe(true);
-        for (const from of t.from) {
-          expect(stateNames.has(from)).toBe(true);
-        }
-      }
-    });
-
-    it(`${file}: no duplicate field names`, () => {
-      const ir = compileFile(file);
-      const names = ir.fields.map(f => f.name);
-      expect(new Set(names).size).toBe(names.length);
-    });
-
-    it(`${file}: no duplicate transition names`, () => {
-      const ir = compileFile(file);
-      const names = ir.transitions.map(t => t.name);
-      expect(new Set(names).size).toBe(names.length);
-    });
-
-    it(`${file}: experience tree has valid node IDs`, () => {
-      const ir = compileFile(file);
-      const exp = getExperience(ir);
-      if (exp) {
-        const ids: string[] = [];
-        function collectIds(node: IRExperienceNode) {
-          if (node.id) ids.push(node.id);
-          node.children?.forEach(collectIds);
-        }
-        collectIds(exp);
-        expect(ids.every(id => typeof id === 'string' && id.length > 0)).toBe(true);
-      }
-    });
-
-    it(`${file}: all field types are valid slug strings`, () => {
-      const ir = compileFile(file);
-      for (const field of ir.fields) {
-        expect(typeof field.type).toBe('string');
-        expect(field.type.length).toBeGreaterThan(0);
-      }
-    });
-  }
-});
-
-// =============================================================================
-// Cross-Blueprint: Package-level compilation sanity
-// =============================================================================
-
-describe('Cross-Blueprint: All package blueprints compile', () => {
-  const allBlueprintDirs = PACKAGE_BLUEPRINTS.map(bp => ({
-    dir: resolve(__dirname, '../../../', bp.dir),
-    name: bp.dir,
-  }));
-
-  it('all 6 package blueprints have mm.config.ts', () => {
-    for (const { dir, name } of allBlueprintDirs) {
-      expect(existsSync(join(dir, 'mm.config.ts'))).toBe(true);
-    }
-  });
-
-  it('all package blueprints compile with zero errors', () => {
-    for (const { dir, name } of allBlueprintDirs) {
-      const files = loadProjectFiles(dir);
-      const result = compileProject(files, { usePhase2Modules: true });
-      expect(result.errors).toHaveLength(0);
-    }
-  });
-
-  it('all package blueprints produce non-empty slug', () => {
-    for (const { dir, name } of allBlueprintDirs) {
-      const files = loadProjectFiles(dir);
-      const result = compileProject(files, { usePhase2Modules: true });
-      expect(result.ir.slug).toBeTruthy();
-    }
-  });
-
-  it('all package blueprints produce at least 1 fileIR', () => {
-    for (const { dir, name } of allBlueprintDirs) {
-      const files = loadProjectFiles(dir);
-      const result = compileProject(files, { usePhase2Modules: true });
-      expect(Object.keys(result.fileIRs).length).toBeGreaterThanOrEqual(1);
-    }
-  });
-});