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

package/src/decompiler/state-emitter.ts

@@ -1,1053 +0,0 @@
-/**
- * state-emitter — converts IR field/state/transition declarations back to hook calls.
- *
- * This is the inverse of state-extractor, effect-extractor, and transition-extractor.
- *
- * Conversions:
- *   IRFieldDefinition     → const [name, setName] = useState(defaultValue)
- *   IRStateDefinition     → useOnEnter('state', () => { ... })
- *                           useOnExit('state', () => { ... })
- *   IRTransitionDefinition → const transName = useTransition('name', { from, to, ... })
- *
- * Handles all known action types including set_field, emit_event, call_workflow,
- * spawn_instance, http_request, delay, notify, and log.
- */
-
-import * as t from '@babel/types';
-import type {
-  IRFieldDefinition,
-  IRStateDefinition,
-  IRTransitionDefinition,
-  IRActionDefinition,
-  IRConditionDefinition,
-  IRExperienceNode,
-} from '@mindmatrix/player-core';
-import { valueToExpression } from './sx-emitter';
-import type { ImportTracker } from './index';
-
-// =============================================================================
-// Name Helpers
-// =============================================================================
-
-function toCamelCase(str: string): string {
-  return str.replace(/[-_]([a-z])/g, (_, c: string) => c.toUpperCase());
-}
-
-function toPascalCase(str: string): string {
-  const camel = toCamelCase(str);
-  return camel.charAt(0).toUpperCase() + camel.slice(1);
-}
-
-// =============================================================================
-// Field → useState()
-// =============================================================================
-
-/**
- * IR field type → TypeScript type annotation.
- * Returns null for types where inference is sufficient.
- * When the field has validation.options, emits a union type.
- */
-function fieldTypeAnnotation(field: IRFieldDefinition): t.TSType | null {
-  // Check for options → union type
-  const f = field as unknown as Record<string, unknown>;
-  const validation = f.validation as Record<string, unknown> | undefined;
-  const options = (validation?.options as string[] | undefined)
-    || ((f.metadata as Record<string, unknown> | undefined)?.options as string[] | undefined)
-    || (f.options as string[] | undefined);
-
-  if (options && Array.isArray(options) && options.length > 0
-    && (field.type === 'select' || field.type === 'text')) {
-    return t.tsUnionType(
-      options.map(o => t.tsLiteralType(t.stringLiteral(String(o))))
-    );
-  }
-
-  switch (field.type) {
-    case 'text':
-    case 'rich_text':
-    case 'email':
-    case 'url':
-    case 'phone':
-    case 'color':
-      return t.tsStringKeyword();
-    case 'number':
-    case 'currency':
-    case 'percentage':
-    case 'rating':
-    case 'duration':
-    case 'auto_number':
-      return t.tsNumberKeyword();
-    case 'boolean':
-      return t.tsBooleanKeyword();
-    case 'date':
-    case 'datetime':
-    case 'created_at':
-    case 'updated_at':
-      return t.tsTypeReference(t.identifier('Date'));
-    case 'select':
-      return t.tsStringKeyword();
-    case 'multi_select':
-      return t.tsArrayType(t.tsStringKeyword()); // string[]
-    case 'json':
-      return null; // Inferred from default
-    default:
-      return null;
-  }
-}
-
-/**
- * Emits `const [fieldName, setFieldName] = useState(defaultValue)` statements
- * for each field in the IR.
- *
- * Ephemeral fields get `{ ephemeral: true }` as second argument.
- */
-export function emitFieldDeclarations(
-  fields: IRFieldDefinition[],
-  imports: ImportTracker,
-): t.Statement[] {
-  if (fields.length === 0) return [];
-
-  addImport(imports, '@mindmatrix/react', 'useState');
-  const statements: t.Statement[] = [];
-
-  for (const field of fields) {
-    // Skip computed fields — they're handled separately
-    if (field.computed) continue;
-
-    const camelName = toCamelCase(field.name);
-    const setter = `set${toPascalCase(field.name)}`;
-
-    // Default value expression — use explicit default if set, otherwise infer
-    // from field type. Preserve null as a valid explicit default (useState(null)
-    // is valid JS/TS) to keep model file and useState in agreement.
-    const defaultExpr = (field.default_value !== undefined)
-      ? valueToExpression(field.default_value)
-      : inferDefaultFromType(field.type);
-
-    // Build useState arguments
-    const args: t.Expression[] = [defaultExpr];
-
-    // Ephemeral scope → pass options object
-    if (field.state_home?.scope === 'ephemeral') {
-      args.push(t.objectExpression([
-        t.objectProperty(t.identifier('ephemeral'), t.booleanLiteral(true))
-      ]));
-    }
-
-    // const [name, setName] = useState(default)
-    const declaration = t.variableDeclaration('const', [
-      t.variableDeclarator(
-        t.arrayPattern([
-          t.identifier(camelName),
-          t.identifier(setter),
-        ]),
-        t.callExpression(t.identifier('useState'), args),
-      ),
-    ]);
-
-    // Add type annotation if non-obvious — skip when default is null since the
-    // type is ambiguous and adding an annotation would cause source instability
-    if (field.default_value !== null) {
-      const tsType = fieldTypeAnnotation(field);
-      if (tsType) {
-        const callExpr = (declaration.declarations[0].init as t.CallExpression);
-        callExpr.typeParameters = t.tsTypeParameterInstantiation([tsType]);
-      }
-    }
-
-    statements.push(declaration);
-  }
-
-  return statements;
-}
-
-/**
- * Infers a sensible default value expression from the field type.
- */
-function inferDefaultFromType(fieldType: string): t.Expression {
-  switch (fieldType) {
-    case 'text':
-    case 'rich_text':
-    case 'email':
-    case 'url':
-    case 'phone':
-    case 'color':
-    case 'select':
-      return t.stringLiteral('');
-    case 'number':
-    case 'currency':
-    case 'percentage':
-    case 'rating':
-    case 'duration':
-    case 'auto_number':
-      return t.numericLiteral(0);
-    case 'boolean':
-      return t.booleanLiteral(false);
-    case 'multi_select':
-      return t.arrayExpression([]);
-    case 'json':
-      return t.objectExpression([]);
-    default:
-      return t.nullLiteral();
-  }
-}
-
-// =============================================================================
-// State Effects → useOnEnter / useOnExit
-// =============================================================================
-
-/**
- * Emits useOnEnter/useOnExit calls for states that have entry/exit actions.
- */
-export function emitStateEffects(
-  states: IRStateDefinition[],
-  imports: ImportTracker,
-): t.Statement[] {
-  const statements: t.Statement[] = [];
-
-  for (const state of states) {
-    // useOnEnter
-    if (state.on_enter.length > 0) {
-      addImport(imports, '@mindmatrix/react', 'useOnEnter');
-      statements.push(
-        t.expressionStatement(
-          t.callExpression(t.identifier('useOnEnter'), [
-            t.stringLiteral(state.name),
-            emitActionCallback(state.on_enter),
-          ])
-        )
-      );
-    }
-
-    // useOnExit
-    if (state.on_exit.length > 0) {
-      addImport(imports, '@mindmatrix/react', 'useOnExit');
-      statements.push(
-        t.expressionStatement(
-          t.callExpression(t.identifier('useOnExit'), [
-            t.stringLiteral(state.name),
-            emitActionCallback(state.on_exit),
-          ])
-        )
-      );
-    }
-
-    // During actions → useWhileIn(stateName, intervalMs, callback)
-    if (state.during.length > 0) {
-      addImport(imports, '@mindmatrix/react', 'useWhileIn');
-      for (const during of state.during) {
-        const args: t.Expression[] = [
-          t.stringLiteral(state.name),
-        ];
-
-        // Interval comes BEFORE callback: useWhileIn('state', 30000, () => {...})
-        if (during.interval_ms) {
-          args.push(t.numericLiteral(during.interval_ms));
-        }
-
-        args.push(emitActionCallback(during.actions));
-
-        statements.push(
-          t.expressionStatement(
-            t.callExpression(t.identifier('useWhileIn'), args)
-          )
-        );
-      }
-    }
-  }
-
-  return statements;
-}
-
-// =============================================================================
-// Transitions → useTransition()
-// =============================================================================
-
-/**
- * Emits `const transName = useTransition('name', { from, to, ... })` declarations.
- *
- * Includes a heuristic to fix a known compiler bug: when all transitions share
- * the same `from` state (always the first state), the actual source state is
- * inferred from the transition name, which by convention equals the source state.
- */
-export function emitTransitionDeclarations(
-  transitions: IRTransitionDefinition[],
-  imports: ImportTracker,
-): t.Statement[] {
-  if (transitions.length === 0) return [];
-
-  addImport(imports, '@mindmatrix/react', 'useTransition');
-
-  // Detect the "all same from" compiler bug: if every transition has the same
-  // single `from` value, the compiler stored the first state for all of them.
-  // In that case, use transition.name as the actual source state.
-  const correctedTransitions = correctFromFields(transitions);
-  const statements: t.Statement[] = [];
-
-  for (const transition of correctedTransitions) {
-    const varName = toCamelCase(transition.name);
-
-    // Build config object
-    const configProps: t.ObjectProperty[] = [];
-
-    // from: string | string[] — normalize to array first
-    const fromArr = normalizeFrom(transition.from);
-
-    if (fromArr.length === 1) {
-      configProps.push(
-        t.objectProperty(t.identifier('from'), t.stringLiteral(fromArr[0]))
-      );
-    } else if (fromArr.length > 1) {
-      configProps.push(
-        t.objectProperty(
-          t.identifier('from'),
-          t.arrayExpression(fromArr.map(s => t.stringLiteral(s)))
-        )
-      );
-    }
-
-    // to: string
-    configProps.push(
-      t.objectProperty(t.identifier('to'), t.stringLiteral(transition.to))
-    );
-
-    // conditions
-    if (transition.conditions && transition.conditions.length > 0) {
-      configProps.push(
-        t.objectProperty(
-          t.identifier('when'),
-          emitConditionExpression(transition.conditions)
-        )
-      );
-    }
-
-    // roles
-    if (transition.roles && transition.roles.length > 0) {
-      configProps.push(
-        t.objectProperty(
-          t.identifier('roles'),
-          t.arrayExpression(transition.roles.map(r => t.stringLiteral(r)))
-        )
-      );
-    }
-
-    // auto
-    if (transition.auto) {
-      configProps.push(
-        t.objectProperty(t.identifier('auto'), t.booleanLiteral(true))
-      );
-    }
-
-    // required_fields
-    if (transition.required_fields && transition.required_fields.length > 0) {
-      configProps.push(
-        t.objectProperty(
-          t.identifier('requiredFields'),
-          t.arrayExpression(transition.required_fields.map(f => t.stringLiteral(f)))
-        )
-      );
-    }
-
-    // const transName = useTransition('name', { from, to, ... })
-    statements.push(
-      t.variableDeclaration('const', [
-        t.variableDeclarator(
-          t.identifier(varName),
-          t.callExpression(t.identifier('useTransition'), [
-            t.stringLiteral(transition.name),
-            t.objectExpression(configProps),
-          ])
-        ),
-      ])
-    );
-  }
-
-  return statements;
-}
-
-// =============================================================================
-// Action → Callback Body
-// =============================================================================
-
-/**
- * Converts an array of IR action definitions into an arrow function callback.
- *
- * Handles all known action types with proper JS emission.
- * Unknown types fall back to a runtime-safe `void 0` with a comment.
- */
-function emitActionCallback(actions: IRActionDefinition[]): t.ArrowFunctionExpression {
-  const body: t.Statement[] = [];
-
-  for (const action of actions) {
-    const stmt = emitSingleAction(action);
-    if (stmt) body.push(stmt);
-  }
-
-  if (body.length === 0) {
-    body.push(t.emptyStatement());
-  }
-
-  return t.arrowFunctionExpression([], t.blockStatement(body));
-}
-
-/**
- * Emits a single IR action as a JS statement.
- */
-function emitSingleAction(action: IRActionDefinition): t.Statement | null {
-  switch (action.type) {
-    case 'set_field': {
-      if (!action.config.field) return null;
-      const setter = `set${toPascalCase(String(action.config.field))}`;
-      const expr = action.config.expression
-        ? t.identifier(String(action.config.expression))
-        : valueToExpression(action.config.value ?? null);
-      return t.expressionStatement(
-        t.callExpression(t.identifier(setter), [expr])
-      );
-    }
-
-    case 'log_event':
-    case 'log': {
-      const msg = action.config.message ?? action.config.event ?? action.type;
-      return t.expressionStatement(
-        t.callExpression(
-          t.memberExpression(t.identifier('console'), t.identifier('log')),
-          [t.stringLiteral(String(msg))]
-        )
-      );
-    }
-
-    case 'emit_event': {
-      const eventName = String(action.config.event ?? action.config.name ?? 'unknown');
-      const args: t.Expression[] = [t.stringLiteral(eventName)];
-      if (action.config.payload) {
-        args.push(valueToExpression(action.config.payload));
-      }
-      return t.expressionStatement(
-        t.callExpression(t.identifier('emitEvent'), args)
-      );
-    }
-
-    case 'call_workflow': {
-      const slug = String(action.config.slug ?? action.config.workflow ?? 'unknown');
-      const args: t.Expression[] = [t.stringLiteral(slug)];
-      if (action.config.params) {
-        args.push(valueToExpression(action.config.params));
-      }
-      return t.expressionStatement(
-        t.callExpression(t.identifier('callWorkflow'), args)
-      );
-    }
-
-    case 'spawn_instance':
-    case 'spawn_subworkflow': {
-      const slug = String(action.config.slug ?? action.config.workflow ?? 'unknown');
-      const args: t.Expression[] = [t.stringLiteral(slug)];
-      if (action.config.params || action.config.input) {
-        args.push(valueToExpression(action.config.params ?? action.config.input));
-      }
-      return t.expressionStatement(
-        t.callExpression(t.identifier('spawnInstance'), args)
-      );
-    }
-
-    case 'http_request':
-    case 'webhook':
-    case 'call_webhook': {
-      const url = String(action.config.url ?? '');
-      const method = String(action.config.method ?? 'POST');
-      return t.expressionStatement(
-        t.callExpression(t.identifier('fetch'), [
-          t.stringLiteral(url),
-          t.objectExpression([
-            t.objectProperty(t.identifier('method'), t.stringLiteral(method)),
-          ]),
-        ])
-      );
-    }
-
-    case 'delay': {
-      const ms = Number(action.config.duration_ms ?? action.config.delay_ms ?? 1000);
-      return t.expressionStatement(
-        t.awaitExpression(
-          t.callExpression(
-            t.identifier('delay'),
-            [t.numericLiteral(ms)]
-          )
-        )
-      );
-    }
-
-    case 'notify':
-    case 'send_notification': {
-      const msg = String(action.config.message ?? action.config.body ?? '');
-      return t.expressionStatement(
-        t.callExpression(t.identifier('notify'), [t.stringLiteral(msg)])
-      );
-    }
-
-    case 'noop':
-      return null;
-
-    default: {
-      // Unknown action type — emit as commented void expression
-      const comment = ` ${action.type}(${JSON.stringify(action.config)}) `;
-      const voidExpr = t.unaryExpression('void', t.numericLiteral(0));
-      t.addComment(voidExpr, 'leading', comment, false);
-      return t.expressionStatement(voidExpr);
-    }
-  }
-}
-
-// =============================================================================
-// Condition → Expression
-// =============================================================================
-
-/**
- * Converts IR condition definitions to a guard expression string.
- *
- * Uses the `expression` field directly if present.
- * Falls back to field/operator/value comparison. Supports AND/OR compounds.
- */
-function emitConditionExpression(conditions: IRConditionDefinition[]): t.Expression {
-  if (conditions.length === 1) {
-    return emitSingleCondition(conditions[0]);
-  }
-
-  // Multiple conditions → AND them
-  let result = emitSingleCondition(conditions[0]);
-  for (let i = 1; i < conditions.length; i++) {
-    result = t.logicalExpression('&&', result, emitSingleCondition(conditions[i]));
-  }
-  return result;
-}
-
-function emitSingleCondition(cond: IRConditionDefinition): t.Expression {
-  // Expression-based condition
-  if (cond.expression) {
-    return t.identifier(cond.expression);
-  }
-
-  // Field/operator/value condition
-  if (cond.field && cond.operator) {
-    const fieldExpr = t.identifier(toCamelCase(cond.field));
-    const valueExpr = valueToExpression(cond.value);
-
-    const opMap: Record<string, t.BinaryExpression['operator']> = {
-      eq: '===',
-      ne: '!==',
-      gt: '>',
-      gte: '>=',
-      lt: '<',
-      lte: '<=',
-    };
-
-    const jsOp = opMap[cond.operator];
-    if (jsOp) {
-      return t.binaryExpression(jsOp, fieldExpr, valueExpr);
-    }
-
-    // Special operators
-    if (cond.operator === 'is_set') {
-      return t.binaryExpression('!==', fieldExpr, t.nullLiteral());
-    }
-    if (cond.operator === 'is_empty') {
-      return t.binaryExpression('===', fieldExpr, t.nullLiteral());
-    }
-    if (cond.operator === 'contains' && typeof cond.value === 'string') {
-      return t.callExpression(
-        t.memberExpression(fieldExpr, t.identifier('includes')),
-        [t.stringLiteral(cond.value)]
-      );
-    }
-    if (cond.operator === 'in' && Array.isArray(cond.value)) {
-      return t.callExpression(
-        t.memberExpression(
-          t.arrayExpression(cond.value.map(v => valueToExpression(v))),
-          t.identifier('includes')
-        ),
-        [fieldExpr]
-      );
-    }
-  }
-
-  // OR/AND compound
-  if (cond.OR && cond.OR.length > 0) {
-    let result = emitSingleCondition(cond.OR[0]);
-    for (let i = 1; i < cond.OR.length; i++) {
-      result = t.logicalExpression('||', result, emitSingleCondition(cond.OR[i]));
-    }
-    return result;
-  }
-  if (cond.AND && cond.AND.length > 0) {
-    return emitConditionExpression(cond.AND);
-  }
-
-  // Fallback
-  return t.booleanLiteral(true);
-}
-
-// =============================================================================
-// Roles → useRole()
-// =============================================================================
-
-/**
- * Emits `const varName = useRole('roleName')` declarations.
- *
- * Role dependencies are stored in metadata.roleDependencies (string[]).
- * Variable names are generated from role names: 'admin' → 'isAdmin'.
- */
-export function emitRoleDeclarations(
-  metadata: Record<string, unknown> | undefined,
-  imports: ImportTracker,
-): t.Statement[] {
-  const roleDeps = metadata?.roleDependencies as string[] | undefined;
-  if (!roleDeps || roleDeps.length === 0) return [];
-
-  addImport(imports, '@mindmatrix/react', 'useRole');
-  const statements: t.Statement[] = [];
-
-  for (const role of roleDeps) {
-    const varName = `is${toPascalCase(role)}`;
-    statements.push(
-      t.variableDeclaration('const', [
-        t.variableDeclarator(
-          t.identifier(varName),
-          t.callExpression(t.identifier('useRole'), [t.stringLiteral(role)]),
-        ),
-      ])
-    );
-  }
-
-  return statements;
-}
-
-// =============================================================================
-// Data Sources → useQuery() / useMutation()
-// =============================================================================
-
-/**
- * Emits `const { data: varName } = useQuery('slug', { ...opts })` declarations.
- *
- * Data sources come from metadata.dataSources (IRWorkflowDataSource[]).
- * Mutation targets come from metadata.mutationTargets (string[]).
- */
-export function emitQueryDeclarations(
-  metadata: Record<string, unknown> | undefined,
-  imports: ImportTracker,
-): t.Statement[] {
-  const statements: t.Statement[] = [];
-
-  // useQuery declarations
-  const dataSources = metadata?.dataSources as Array<{
-    type: string;
-    name: string;
-    slug?: string;
-    query?: string;
-    filter?: Record<string, unknown>;
-    sort?: string;
-    search?: string;
-    searchFields?: string[];
-    facets?: string[];
-    groupBy?: string;
-    aggregate?: string;
-    pageSize?: number;
-  }> | undefined;
-
-  // Model imports map: slug → relative import path (set by project-decompiler)
-  const modelImports = metadata?.modelImports as Record<string, string> | undefined;
-  const addedModelImports = new Set<string>();
-
-  if (dataSources && dataSources.length > 0) {
-    addImport(imports, '@mindmatrix/react', 'useQuery');
-    const usedVarNames = new Set<string>();
-
-    for (const ds of dataSources) {
-      if (ds.type !== 'workflow') continue;
-
-      const slug = ds.slug || ds.name;
-      // Strip dotted prefixes (e.g., "driver.earningsHistory" → "earningsHistory")
-      const baseName = ds.name.includes('.') ? ds.name.split('.').pop()! : ds.name;
-      let varName = toCamelCase(baseName.replace(/-/g, '_'));
-      // Deduplicate variable names (multiple queries for same slug)
-      if (usedVarNames.has(varName)) {
-        let suffix = 2;
-        while (usedVarNames.has(`${varName}${suffix}`)) suffix++;
-        varName = `${varName}${suffix}`;
-      }
-      usedVarNames.add(varName);
-
-      // Add typed model import if available
-      const modelPath = modelImports?.[slug];
-      const modelVarName = modelPath ? `${toCamelCase(slug.replace(/-/g, '_'))}Model` : undefined;
-      if (modelPath && modelVarName && !addedModelImports.has(slug)) {
-        addImport(imports, modelPath, `default as ${modelVarName}`);
-        addedModelImports.add(slug);
-      }
-
-      // Build options object
-      const optionProps: t.ObjectProperty[] = [];
-
-      if (ds.pageSize) {
-        optionProps.push(
-          t.objectProperty(t.identifier('limit'), t.numericLiteral(ds.pageSize))
-        );
-      }
-      if (ds.sort) {
-        optionProps.push(
-          t.objectProperty(t.identifier('orderBy'), t.stringLiteral(ds.sort))
-        );
-      }
-      if (ds.filter && Object.keys(ds.filter).length > 0) {
-        optionProps.push(
-          t.objectProperty(t.identifier('filter'), valueToExpression(ds.filter))
-        );
-      }
-      if (ds.search) {
-        optionProps.push(
-          t.objectProperty(t.identifier('search'), t.stringLiteral(ds.search))
-        );
-      }
-      if (ds.groupBy) {
-        optionProps.push(
-          t.objectProperty(t.identifier('groupBy'), t.stringLiteral(ds.groupBy))
-        );
-      }
-
-      // Use typed model reference if available, otherwise string literal
-      const queryTarget: t.Expression = modelVarName
-        ? t.identifier(modelVarName)
-        : t.stringLiteral(slug);
-      const args: t.Expression[] = [queryTarget];
-      if (optionProps.length > 0) {
-        args.push(t.objectExpression(optionProps));
-      }
-
-      // const { data: varName } = useQuery(...)
-      statements.push(
-        t.variableDeclaration('const', [
-          t.variableDeclarator(
-            t.objectPattern([
-              t.objectProperty(
-                t.identifier('data'),
-                t.identifier(varName),
-              ),
-            ]),
-            t.callExpression(t.identifier('useQuery'), args),
-          ),
-        ])
-      );
-    }
-  }
-
-  // useMutation declarations
-  const mutationTargets = metadata?.mutationTargets as string[] | undefined;
-  if (mutationTargets && mutationTargets.length > 0) {
-    addImport(imports, '@mindmatrix/react', 'useMutation');
-
-    for (const slug of mutationTargets) {
-      // Use typed model reference if available
-      const modelPath = modelImports?.[slug];
-      const modelVarName2 = modelPath ? `${toCamelCase(slug.replace(/-/g, '_'))}Model` : undefined;
-      if (modelPath && modelVarName2 && !addedModelImports?.has(slug)) {
-        addImport(imports, modelPath, `default as ${modelVarName2}`);
-        addedModelImports?.add(slug);
-      }
-
-      const mutTarget: t.Expression = modelVarName2
-        ? t.identifier(modelVarName2)
-        : t.stringLiteral(slug);
-      const varName = `${toCamelCase(slug.replace(/-/g, '_'))}Mutation`;
-      statements.push(
-        t.variableDeclaration('const', [
-          t.variableDeclarator(
-            t.identifier(varName),
-            t.callExpression(t.identifier('useMutation'), [mutTarget]),
-          ),
-        ])
-      );
-    }
-  }
-
-  return statements;
-}
-
-// =============================================================================
-// Field Watchers → useOnChange()
-// =============================================================================
-
-/**
- * Emits `useOnChange('fieldName', () => { ...actions })` calls.
- *
- * Field watchers are stored in metadata.fieldWatchers.
- */
-export function emitChangeWatchers(
-  metadata: Record<string, unknown> | undefined,
-  imports: ImportTracker,
-): t.Statement[] {
-  const watchers = metadata?.fieldWatchers as Array<{
-    id: string;
-    field: string;
-    actions: IRActionDefinition[];
-  }> | undefined;
-
-  if (!watchers || watchers.length === 0) return [];
-
-  addImport(imports, '@mindmatrix/react', 'useOnChange');
-  const statements: t.Statement[] = [];
-
-  for (const watcher of watchers) {
-    statements.push(
-      t.expressionStatement(
-        t.callExpression(t.identifier('useOnChange'), [
-          t.stringLiteral(watcher.field),
-          emitActionCallback(watcher.actions),
-        ])
-      )
-    );
-  }
-
-  return statements;
-}
-
-// =============================================================================
-// Event Subscriptions → useOnEvent()
-// =============================================================================
-
-/**
- * Emits `useOnEvent('pattern', () => { ...actions })` calls.
- *
- * Global events come from definition.on_event.
- * State-scoped events come from state.on_event (emitted with { while: 'stateName' }).
- */
-export function emitEventSubscriptions(
-  onEvent: Array<{ match: string; actions: Array<{ type: string; field?: string; expression?: string; message?: string }> }> | undefined,
-  imports: ImportTracker,
-): t.Statement[] {
-  if (!onEvent || onEvent.length === 0) return [];
-
-  addImport(imports, '@mindmatrix/react', 'useOnEvent');
-  const statements: t.Statement[] = [];
-
-  for (const sub of onEvent) {
-    // Convert IROnEventAction[] to IRActionDefinition[] for the callback emitter
-    const actions: IRActionDefinition[] = sub.actions.map((a, i) => ({
-      id: `event_${i}`,
-      type: a.type,
-      mode: 'auto' as const,
-      config: {
-        ...(a.field && { field: a.field }),
-        ...(a.expression && { expression: a.expression }),
-        ...(a.message && { message: a.message }),
-      },
-    }));
-
-    statements.push(
-      t.expressionStatement(
-        t.callExpression(t.identifier('useOnEvent'), [
-          t.stringLiteral(sub.match),
-          emitActionCallback(actions),
-        ])
-      )
-    );
-  }
-
-  return statements;
-}
-
-// =============================================================================
-// Transition Effects → useOnTransition()
-// =============================================================================
-
-/**
- * Emits `useOnTransition('transitionName', () => { ...actions })` calls.
- *
- * Transition effects are stored in metadata.transitionEffects.
- */
-export function emitTransitionEffects(
-  metadata: Record<string, unknown> | undefined,
-  imports: ImportTracker,
-): t.Statement[] {
-  const effects = metadata?.transitionEffects as Array<{
-    id: string;
-    transition: string;
-    actions: IRActionDefinition[];
-  }> | undefined;
-
-  if (!effects || effects.length === 0) return [];
-
-  addImport(imports, '@mindmatrix/react', 'useOnTransition');
-  const statements: t.Statement[] = [];
-
-  for (const effect of effects) {
-    statements.push(
-      t.expressionStatement(
-        t.callExpression(t.identifier('useOnTransition'), [
-          t.stringLiteral(effect.transition),
-          emitActionCallback(effect.actions),
-        ])
-      )
-    );
-  }
-
-  return statements;
-}
-
-// =============================================================================
-// localDefaults → useState() (section-scoped variables from experience tree)
-// =============================================================================
-
-/**
- * Walks the experience tree to find localDefaults on Show/Stack nodes.
- * Emits additional useState() declarations for variables NOT already
- * declared by the definition-level fields.
- *
- * localDefaults values are either:
- *   - Actual defaults: { period: "today", is_online: false }
- *   - Field bindings: { payment: "payment", eta: "etaMinutes" }
- *
- * Field binding values (strings matching camelCase identifiers) use
- * `undefined` as the default since the runtime provides the value.
- */
-export function emitLocalDefaultDeclarations(
-  experience: IRExperienceNode,
-  existingFields: IRFieldDefinition[],
-  imports: ImportTracker,
-): t.Statement[] {
-  // Collect all localDefaults from the tree
-  const allDefaults = new Map<string, unknown>();
-  collectAllLocalDefaults(experience, allDefaults);
-
-  // Build set of existing variable names (both raw and camelCase) for dedup
-  const existingNames = new Set<string>();
-  for (const f of existingFields) {
-    if (f.computed) continue;
-    existingNames.add(f.name);
-    existingNames.add(toCamelCase(f.name));
-  }
-
-  const emittedCamelNames = new Set<string>();
-  const statements: t.Statement[] = [];
-
-  for (const [key, value] of allDefaults) {
-    // Skip dotted keys like "driver.today_earnings" — nested field refs
-    if (key.includes('.')) continue;
-    // Skip if already declared as a field (check both raw and camelCase)
-    if (existingNames.has(key) || existingNames.has(toCamelCase(key))) continue;
-    // Skip if already emitted from a previous localDefaults
-    const camelName = toCamelCase(key);
-    if (emittedCamelNames.has(camelName)) continue;
-    emittedCamelNames.add(camelName);
-
-    addImport(imports, '@mindmatrix/react', 'useState');
-
-    const setter = `set${toPascalCase(key)}`;
-
-    // Determine default value
-    let defaultExpr: t.Expression;
-    if (value === undefined || value === null) {
-      defaultExpr = t.identifier('undefined');
-    } else if (typeof value === 'string' && /^[a-zA-Z]\w*$/.test(value) && value !== key) {
-      // Looks like a field binding name (e.g., "etaMinutes", "processingError")
-      // Use undefined — the runtime provides the value
-      defaultExpr = t.identifier('undefined');
-    } else {
-      defaultExpr = valueToExpression(value);
-    }
-
-    statements.push(
-      t.variableDeclaration('const', [
-        t.variableDeclarator(
-          t.arrayPattern([
-            t.identifier(camelName),
-            t.identifier(setter),
-          ]),
-          t.callExpression(t.identifier('useState'), [defaultExpr]),
-        ),
-      ])
-    );
-  }
-
-  return statements;
-}
-
-function collectAllLocalDefaults(
-  node: IRExperienceNode,
-  out: Map<string, unknown>,
-): void {
-  if (node.config?.localDefaults && typeof node.config.localDefaults === 'object') {
-    const ld = node.config.localDefaults as Record<string, unknown>;
-    for (const [key, value] of Object.entries(ld)) {
-      if (!out.has(key)) out.set(key, value);
-    }
-  }
-  if (node.children) {
-    for (const child of node.children) {
-      collectAllLocalDefaults(child, out);
-    }
-  }
-}
-
-// =============================================================================
-// Transition From-Field Correction
-// =============================================================================
-
-/**
- * Normalizes the `from` field which may be a string or string[] in the DB.
- */
-function normalizeFrom(from: string | string[]): string[] {
-  if (Array.isArray(from)) return from;
-  if (typeof from === 'string') return [from];
-  return [];
-}
-
-/**
- * Detects and corrects the "all same from" compiler bug.
- *
- * When all transitions have the same single `from` value (the first state),
- * but their names correspond to different states, the transition name IS
- * the actual source state (convention: useTransition(from, to)).
- */
-function correctFromFields(
-  transitions: IRTransitionDefinition[],
-): IRTransitionDefinition[] {
-  if (transitions.length <= 1) return transitions;
-
-  // Collect all unique `from` values
-  const fromValues = new Set<string>();
-  for (const t of transitions) {
-    const arr = normalizeFrom(t.from);
-    for (const f of arr) fromValues.add(f);
-  }
-
-  // If all transitions share exactly one `from` value, it's likely the bug
-  if (fromValues.size !== 1) return transitions;
-
-  // Build state set from from/to values ONLY (not transition names).
-  // Only apply correction if every transition name is already a known state
-  // from the from/to values — avoids false positives where transition names
-  // like "increment" happen to match because they were self-added.
-  const stateNames = new Set<string>([...fromValues]);
-  for (const t of transitions) {
-    stateNames.add(t.to);
-  }
-
-  // Only correct if EVERY transition name is a known state
-  const allNamesAreStates = transitions.every(t => stateNames.has(t.name));
-  if (!allNamesAreStates) return transitions;
-
-  // Apply correction: use transition name as the from state
-  return transitions.map(t => ({
-    ...t,
-    from: [t.name],
-  }));
-}
-
-// =============================================================================
-// Helpers
-// =============================================================================
-
-function addImport(tracker: ImportTracker, source: string, name: string): void {
-  if (!tracker.has(source)) tracker.set(source, new Set());
-  tracker.get(source)!.add(name);
-}