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

package/src/babel/transpilers/ts-to-expression.ts

@@ -1,674 +0,0 @@
-/**
- * TS → mm-compute Expression Transpiler
- *
- * Converts Babel AST Expression nodes into valid mm-compute expression strings.
- * Recognizes common JS/TS idioms and maps them to mm-compute built-in functions.
- *
- * Expressions that cannot be transpiled are emitted as `$expr(...)` opaque markers
- * for the runtime JS evaluator to handle.
- *
- * @module
- */
-
-import * as t from '@babel/types';
-
-// =============================================================================
-// Public API
-// =============================================================================
-
-/**
- * Transpile options — context passed through from the component extractor.
- */
-export interface TranspileOptions {
-  /**
-   * Map of local useState field names → snake_case names for $local bindings.
-   * When set, identifiers matching keys are rewritten to `$local.snake_name`.
-   */
-  localFieldMap?: Map<string, string>;
-  /**
-   * Map of derived variable names → their defining AST expression.
-   * When set, identifiers matching keys are inlined.
-   */
-  derivedVarMap?: Map<string, t.Expression>;
-  /**
-   * Map of setState setter names → field names.
-   * When set, setter calls are rewritten to `$action.setLocal(...)`.
-   */
-  setterToFieldMap?: Map<string, string>;
-}
-
-/**
- * Result of transpilation.
- */
-export interface TranspileResult {
-  /** The mm-compute expression string, or null if not translatable. */
-  expression: string;
-  /**
-   * Whether this expression is fully translatable to mm-compute.
-   * When false, the expression contains `$expr(...)` opaque markers.
-   */
-  pure: boolean;
-}
-
-/**
- * Transpile a Babel AST Expression node to an mm-compute expression string.
- *
- * Returns a {@link TranspileResult} with the expression and whether it's pure
- * (fully mm-compute) or contains opaque JS fallbacks.
- */
-export function transpileExpression(
-  node: t.Expression,
-  options: TranspileOptions = {},
-): TranspileResult {
-  const ctx = new TranspileContext(options);
-  const expr = ctx.visit(node);
-  return { expression: expr, pure: ctx.isPure };
-}
-
-/**
- * Convenience: transpile and return just the expression string.
- */
-export function transpile(node: t.Expression, options: TranspileOptions = {}): string {
-  return transpileExpression(node, options).expression;
-}
-
-// =============================================================================
-// Transpile Context
-// =============================================================================
-
-class TranspileContext {
-  isPure = true;
-  private localFieldMap: Map<string, string>;
-  private derivedVarMap: Map<string, t.Expression>;
-  private setterToFieldMap: Map<string, string>;
-
-  constructor(options: TranspileOptions) {
-    this.localFieldMap = options.localFieldMap ?? new Map();
-    this.derivedVarMap = options.derivedVarMap ?? new Map();
-    this.setterToFieldMap = options.setterToFieldMap ?? new Map();
-  }
-
-  /**
-   * Emit an opaque JS fallback, marking the result as impure.
-   */
-  opaque(jsCode: string): string {
-    this.isPure = false;
-    return `$expr(${jsCode})`;
-  }
-
-  /**
-   * Visit an AST node and produce an mm-compute expression string.
-   */
-  visit(node: t.Expression): string {
-    // --- Literals ---
-    if (t.isStringLiteral(node)) return `"${node.value.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
-    if (t.isNumericLiteral(node)) return String(node.value);
-    if (t.isBooleanLiteral(node)) return String(node.value);
-    if (t.isNullLiteral(node)) return 'null';
-
-    // --- Identifier ---
-    if (t.isIdentifier(node)) {
-      const snakeName = this.localFieldMap.get(node.name);
-      if (snakeName) return `$local.${snakeName}`;
-      const derivedInit = this.derivedVarMap.get(node.name);
-      if (derivedInit) return `(${this.visit(derivedInit)})`;
-      // Known JS globals that don't translate
-      if (node.name === 'undefined') return 'null';
-      if (node.name === 'NaN') return 'null';
-      if (node.name === 'Infinity') return 'null';
-      return node.name;
-    }
-
-    // --- TS type assertions: pass through ---
-    if (t.isTSAsExpression(node)) return this.visit(node.expression);
-    if (t.isTSNonNullExpression(node)) return this.visit(node.expression);
-    if (t.isTSTypeAssertion(node)) return this.visit(node.expression);
-
-    // --- Parenthesized ---
-    if (t.isParenthesizedExpression(node)) return `(${this.visit(node.expression)})`;
-
-    // --- Unary expressions ---
-    if (t.isUnaryExpression(node) && node.prefix) {
-      return this.visitUnary(node);
-    }
-
-    // --- Binary expressions ---
-    if (t.isBinaryExpression(node)) {
-      return this.visitBinary(node);
-    }
-
-    // --- Logical expressions ---
-    if (t.isLogicalExpression(node)) {
-      return this.visitLogical(node);
-    }
-
-    // --- Conditional (ternary) ---
-    if (t.isConditionalExpression(node)) {
-      return `if(${this.visit(node.test)}, ${this.visit(node.consequent)}, ${this.visit(node.alternate)})`;
-    }
-
-    // --- Member expression (including optional chaining) ---
-    if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) {
-      return this.visitMember(node);
-    }
-
-    // --- Call expression (including optional calls) ---
-    if (t.isCallExpression(node) || t.isOptionalCallExpression(node)) {
-      return this.visitCall(node);
-    }
-
-    // --- Template literal ---
-    if (t.isTemplateLiteral(node)) {
-      return this.visitTemplateLiteral(node);
-    }
-
-    // --- Array expression ---
-    if (t.isArrayExpression(node)) {
-      const elements = node.elements.map((el) => {
-        if (el === null) return 'null';
-        if (t.isSpreadElement(el)) return this.opaque(`...${this.visit(el.argument)}`);
-        return t.isExpression(el) ? this.visit(el) : 'null';
-      });
-      return `[${elements.join(', ')}]`;
-    }
-
-    // --- Object expression ---
-    if (t.isObjectExpression(node)) {
-      return this.visitObject(node);
-    }
-
-    // --- Arrow function (for lambdas in higher-order functions) ---
-    if (t.isArrowFunctionExpression(node)) {
-      return this.visitArrow(node);
-    }
-
-    // --- New expression ---
-    if (t.isNewExpression(node)) {
-      return this.visitNew(node);
-    }
-
-    // Fallback: opaque
-    return this.opaque(fallbackGenerate(node));
-  }
-
-  // ---------------------------------------------------------------------------
-  // Unary
-  // ---------------------------------------------------------------------------
-
-  private visitUnary(node: t.UnaryExpression): string {
-    if (node.operator === '!') {
-      return `not(${this.visit(node.argument)})`;
-    }
-    if (node.operator === '-') {
-      // Negative number: -5 → just -5
-      if (t.isNumericLiteral(node.argument)) return String(-node.argument.value);
-      return `(0 - ${this.visit(node.argument)})`;
-    }
-    if (node.operator === 'typeof') {
-      return `typeof(${this.visit(node.argument)})`;
-    }
-    return this.opaque(`${node.operator}${fallbackGenerate(node.argument)}`);
-  }
-
-  // ---------------------------------------------------------------------------
-  // Binary
-  // ---------------------------------------------------------------------------
-
-  private visitBinary(node: t.BinaryExpression): string {
-    const left = this.visit(node.left as t.Expression);
-    const right = this.visit(node.right as t.Expression);
-
-    switch (node.operator) {
-      case '===': return `(${left} == ${right})`;
-      case '!==': return `(${left} != ${right})`;
-      case '==': return `(${left} == ${right})`;
-      case '!=': return `(${left} != ${right})`;
-      case '<': return `(${left} < ${right})`;
-      case '>': return `(${left} > ${right})`;
-      case '<=': return `(${left} <= ${right})`;
-      case '>=': return `(${left} >= ${right})`;
-      case '+': return `(${left} + ${right})`;
-      case '-': return `(${left} - ${right})`;
-      case '*': return `(${left} * ${right})`;
-      case '/': return `(${left} / ${right})`;
-      case '%': return `(${left} % ${right})`;
-      default:
-        return this.opaque(`(${left} ${node.operator} ${right})`);
-    }
-  }
-
-  // ---------------------------------------------------------------------------
-  // Logical
-  // ---------------------------------------------------------------------------
-
-  private visitLogical(node: t.LogicalExpression): string {
-    const left = this.visit(node.left);
-    const right = this.visit(node.right);
-
-    switch (node.operator) {
-      case '&&': return `(${left} && ${right})`;
-      case '||': return `(${left} || ${right})`;
-      case '??':
-        // a ?? b → if(a != null, a, b)
-        // Need to avoid double-evaluation of left, but mm-compute doesn't have
-        // let-bindings, so we emit coalesce() instead
-        return `coalesce(${left}, ${right})`;
-      default:
-        return this.opaque(`(${left} ${node.operator} ${right})`);
-    }
-  }
-
-  // ---------------------------------------------------------------------------
-  // Member expression
-  // ---------------------------------------------------------------------------
-
-  private visitMember(node: t.MemberExpression | t.OptionalMemberExpression): string {
-    const isOptional = (node as t.OptionalMemberExpression).optional === true;
-
-    // --- arr.length → length(arr) ---
-    if (!node.computed && t.isIdentifier(node.property) && node.property.name === 'length') {
-      const obj = this.visit(node.object as t.Expression);
-      if (isOptional) {
-        return `if(${obj} != null, length(${obj}), null)`;
-      }
-      return `length(${obj})`;
-    }
-
-    // Standard member access
-    const obj = this.visit(node.object as t.Expression);
-
-    if (node.computed) {
-      const prop = t.isExpression(node.property) ? this.visit(node.property as t.Expression) : '0';
-      if (isOptional) {
-        return `if(${obj} != null, get(${obj}, ${prop}), null)`;
-      }
-      return `${obj}[${prop}]`;
-    }
-
-    const prop = t.isIdentifier(node.property) ? node.property.name : '[property]';
-
-    if (isOptional) {
-      return `if(${obj} != null, ${obj}.${prop}, null)`;
-    }
-    return `${obj}.${prop}`;
-  }
-
-  // ---------------------------------------------------------------------------
-  // Call expression
-  // ---------------------------------------------------------------------------
-
-  private visitCall(node: t.CallExpression | t.OptionalCallExpression): string {
-    // --- Free-standing function call: fn(args) ---
-    if (t.isIdentifier(node.callee)) {
-      // useState setter calls
-      const setterField = this.setterToFieldMap.get(node.callee.name);
-      if (setterField) {
-        return this.visitSetterCall(node, setterField);
-      }
-      const args = this.visitArgs(node.arguments);
-      return `${node.callee.name}(${args})`;
-    }
-
-    // --- Method call: obj.method(args) ---
-    if (t.isMemberExpression(node.callee) || t.isOptionalMemberExpression(node.callee)) {
-      const methodName = t.isIdentifier(node.callee.property) ? node.callee.property.name : null;
-      if (!methodName) {
-        return this.opaque(fallbackGenerate(node));
-      }
-
-      // --- Math.* ---
-      if (t.isIdentifier(node.callee.object) && node.callee.object.name === 'Math') {
-        return this.visitMathCall(methodName, node.arguments);
-      }
-
-      // --- JSON.* ---
-      if (t.isIdentifier(node.callee.object) && node.callee.object.name === 'JSON') {
-        return this.visitJsonCall(methodName, node.arguments);
-      }
-
-      // --- Date.now() ---
-      if (t.isIdentifier(node.callee.object) && node.callee.object.name === 'Date') {
-        if (methodName === 'now') return 'now_ms()';
-      }
-
-      // --- Instance method calls: obj.method(args) ---
-      const obj = this.visit(node.callee.object as t.Expression);
-      return this.visitMethodCall(obj, methodName, node.arguments);
-    }
-
-    // Fallback for complex callees
-    return this.opaque(fallbackGenerate(node));
-  }
-
-  // ---------------------------------------------------------------------------
-  // Method call transpilation (obj.method(args))
-  // ---------------------------------------------------------------------------
-
-  private visitMethodCall(
-    obj: string,
-    method: string,
-    args: (t.Expression | t.SpreadElement | t.JSXNamespacedName | t.ArgumentPlaceholder)[],
-  ): string {
-    switch (method) {
-      // --- String methods ---
-      case 'toLowerCase': return `lower(${obj})`;
-      case 'toUpperCase': return `upper(${obj})`;
-      case 'trim': return `trim(${obj})`;
-      case 'startsWith': {
-        const [arg] = this.visitArgsList(args);
-        return `starts_with(${obj}, ${arg})`;
-      }
-      case 'endsWith': {
-        const [arg] = this.visitArgsList(args);
-        return `ends_with(${obj}, ${arg})`;
-      }
-      case 'includes': {
-        const [arg] = this.visitArgsList(args);
-        return `contains(${obj}, ${arg})`;
-      }
-      case 'split': {
-        const [sep] = this.visitArgsList(args);
-        return `split(${obj}, ${sep})`;
-      }
-      case 'join': {
-        const [sep] = this.visitArgsList(args);
-        return `join(${obj}, ${sep})`;
-      }
-      case 'replace': {
-        const visited = this.visitArgsList(args);
-        return `replace(${obj}, ${visited[0]}, ${visited[1]})`;
-      }
-      case 'substring':
-      case 'slice': {
-        const visited = this.visitArgsList(args);
-        if (visited.length === 1) return `substring(${obj}, ${visited[0]})`;
-        return `substring(${obj}, ${visited[0]}, ${visited[1]})`;
-      }
-      case 'charAt': {
-        const [idx] = this.visitArgsList(args);
-        return `substring(${obj}, ${idx}, (${idx} + 1))`;
-      }
-      case 'indexOf': {
-        const [arg] = this.visitArgsList(args);
-        return `indexof(${obj}, ${arg})`;
-      }
-      case 'toString': return `to_string(${obj})`;
-      case 'toISOString': return 'now()';
-      case 'concat': {
-        const visited = this.visitArgsList(args);
-        return `concat(${obj}, ${visited.join(', ')})`;
-      }
-
-      // --- Array higher-order methods ---
-      case 'filter': return this.visitArrayHigherOrder('filter', obj, args);
-      case 'map': return this.visitArrayHigherOrder('map', obj, args);
-      case 'find': return this.visitArrayHigherOrder('find', obj, args);
-      case 'reduce': return this.visitArrayReduce(obj, args);
-      case 'some': return this.visitArrayHigherOrder('some', obj, args);
-      case 'every': return this.visitArrayHigherOrder('every', obj, args);
-
-      // --- Array mutation-free methods ---
-      case 'reverse': return `reverse(${obj})`;
-      case 'sort': return `sort(${obj})`;
-      case 'flat': return `flat(${obj})`;
-
-      // --- JSON methods on values ---
-      case 'stringify': return `to_string(${obj})`;
-
-      default:
-        // Unknown method — opaque fallback
-        return this.opaque(`${obj}.${method}(${this.visitArgs(args)})`);
-    }
-  }
-
-  // ---------------------------------------------------------------------------
-  // Array higher-order method transpilation
-  // ---------------------------------------------------------------------------
-
-  private visitArrayHigherOrder(
-    fn: string,
-    obj: string,
-    args: (t.Expression | t.SpreadElement | t.JSXNamespacedName | t.ArgumentPlaceholder)[],
-  ): string {
-    const firstArg = args[0];
-    if (!firstArg || !t.isExpression(firstArg)) {
-      return this.opaque(`${obj}.${fn}()`);
-    }
-
-    // Arrow function: x => expr
-    if (t.isArrowFunctionExpression(firstArg) && t.isExpression(firstArg.body)) {
-      const paramName = firstArg.params.length > 0 && t.isIdentifier(firstArg.params[0])
-        ? firstArg.params[0].name
-        : '_';
-
-      // For simple property access patterns like x => x.name → MAP(arr, "name")
-      // But mm-compute supports lambda syntax, so use that for complex expressions
-      const lambdaBody = this.visit(firstArg.body);
-      return `${fn}(${obj}, ${paramName} => ${lambdaBody})`;
-    }
-
-    // Function reference: arr.filter(isActive) → filter(arr, isActive)
-    const argStr = this.visit(firstArg);
-    return `${fn}(${obj}, ${argStr})`;
-  }
-
-  private visitArrayReduce(
-    obj: string,
-    args: (t.Expression | t.SpreadElement | t.JSXNamespacedName | t.ArgumentPlaceholder)[],
-  ): string {
-    const [callbackArg, initArg] = args;
-    if (!callbackArg || !t.isExpression(callbackArg)) {
-      return this.opaque(`${obj}.reduce()`);
-    }
-
-    if (t.isArrowFunctionExpression(callbackArg) && t.isExpression(callbackArg.body)) {
-      const params = callbackArg.params;
-      const accName = params.length > 0 && t.isIdentifier(params[0]) ? params[0].name : 'acc';
-      const itemName = params.length > 1 && t.isIdentifier(params[1]) ? params[1].name : 'x';
-
-      const lambdaBody = this.visit(callbackArg.body);
-      const initStr = initArg && t.isExpression(initArg) ? this.visit(initArg) : '0';
-      return `reduce(${obj}, (${accName}, ${itemName}) => ${lambdaBody}, ${initStr})`;
-    }
-
-    return this.opaque(fallbackGenerate({ type: 'CallExpression' } as any));
-  }
-
-  // ---------------------------------------------------------------------------
-  // Math.* methods
-  // ---------------------------------------------------------------------------
-
-  private visitMathCall(
-    method: string,
-    args: (t.Expression | t.SpreadElement | t.JSXNamespacedName | t.ArgumentPlaceholder)[],
-  ): string {
-    const visited = this.visitArgsList(args);
-    switch (method) {
-      case 'max': return `max(${visited.join(', ')})`;
-      case 'min': return `min(${visited.join(', ')})`;
-      case 'round': return `round(${visited.join(', ')})`;
-      case 'floor': return `floor(${visited.join(', ')})`;
-      case 'ceil': return `ceil(${visited.join(', ')})`;
-      case 'abs': return `abs(${visited.join(', ')})`;
-      case 'pow': return `power(${visited.join(', ')})`;
-      case 'sqrt': return `sqrt(${visited.join(', ')})`;
-      case 'log': return `log(${visited.join(', ')})`;
-      case 'log10': return `log10(${visited.join(', ')})`;
-      case 'sign': return `sign(${visited.join(', ')})`;
-      default:
-        return this.opaque(`Math.${method}(${visited.join(', ')})`);
-    }
-  }
-
-  // ---------------------------------------------------------------------------
-  // JSON.* methods
-  // ---------------------------------------------------------------------------
-
-  private visitJsonCall(
-    method: string,
-    args: (t.Expression | t.SpreadElement | t.JSXNamespacedName | t.ArgumentPlaceholder)[],
-  ): string {
-    const visited = this.visitArgsList(args);
-    switch (method) {
-      case 'stringify': return `to_string(${visited[0]})`;
-      case 'parse': return `from_json(${visited[0]})`;
-      default:
-        return this.opaque(`JSON.${method}(${visited.join(', ')})`);
-    }
-  }
-
-  // ---------------------------------------------------------------------------
-  // Template literals
-  // ---------------------------------------------------------------------------
-
-  private visitTemplateLiteral(node: t.TemplateLiteral): string {
-    // Collect all parts: string quasis interleaved with expressions
-    const parts: string[] = [];
-
-    for (let i = 0; i < node.quasis.length; i++) {
-      const raw = node.quasis[i].value.cooked ?? node.quasis[i].value.raw;
-      if (raw) {
-        parts.push(`"${raw.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`);
-      }
-      if (i < node.expressions.length) {
-        const exprStr = this.visit(node.expressions[i] as t.Expression);
-        // Wrap in to_string for non-string subexpressions
-        parts.push(`to_string(${exprStr})`);
-      }
-    }
-
-    // Filter out empty strings
-    const nonEmpty = parts.filter(p => p !== '""');
-    if (nonEmpty.length === 0) return '""';
-    if (nonEmpty.length === 1) return nonEmpty[0];
-    return `concat(${nonEmpty.join(', ')})`;
-  }
-
-  // ---------------------------------------------------------------------------
-  // Object expression
-  // ---------------------------------------------------------------------------
-
-  private visitObject(node: t.ObjectExpression): string {
-    // mm-compute supports object literals: {"key": value}
-    const props = node.properties.map((prop) => {
-      if (t.isSpreadElement(prop)) {
-        return this.opaque(`...${this.visit(prop.argument)}`);
-      }
-      if (t.isObjectProperty(prop)) {
-        const key = t.isIdentifier(prop.key) ? `"${prop.key.name}"`
-          : t.isStringLiteral(prop.key) ? `"${prop.key.value}"`
-          : t.isNumericLiteral(prop.key) ? `"${prop.key.value}"`
-          : '"[key]"';
-        const value = t.isExpression(prop.value) ? this.visit(prop.value) : 'null';
-        return `${key}: ${value}`;
-      }
-      // ObjectMethod — not translatable
-      return this.opaque('[method]');
-    });
-    return `{${props.join(', ')}}`;
-  }
-
-  // ---------------------------------------------------------------------------
-  // Arrow function (lambda)
-  // ---------------------------------------------------------------------------
-
-  private visitArrow(node: t.ArrowFunctionExpression): string {
-    // mm-compute supports: x => expr, (x, y) => expr
-    if (t.isExpression(node.body)) {
-      const params = node.params.map((p) => {
-        if (t.isIdentifier(p)) return p.name;
-        return '_';
-      }).join(', ');
-      const body = this.visit(node.body);
-      if (node.params.length === 1) return `${params} => ${body}`;
-      return `(${params}) => ${body}`;
-    }
-    // Block body — can't directly represent in mm-compute
-    return this.opaque(fallbackGenerate(node));
-  }
-
-  // ---------------------------------------------------------------------------
-  // new expressions
-  // ---------------------------------------------------------------------------
-
-  private visitNew(node: t.NewExpression): string {
-    // new Date().toISOString() is handled at the call level
-    // new Date() alone → now()
-    if (t.isIdentifier(node.callee) && node.callee.name === 'Date' && node.arguments.length === 0) {
-      return 'now()';
-    }
-    return this.opaque(fallbackGenerate(node));
-  }
-
-  // ---------------------------------------------------------------------------
-  // setState setter calls
-  // ---------------------------------------------------------------------------
-
-  private visitSetterCall(
-    node: t.CallExpression | t.OptionalCallExpression,
-    fieldName: string,
-  ): string {
-    if (node.arguments.length >= 1) {
-      const arg = node.arguments[0];
-      if (
-        (t.isArrowFunctionExpression(arg) || t.isFunctionExpression(arg)) &&
-        arg.params.length >= 1 &&
-        t.isIdentifier(arg.params[0])
-      ) {
-        const paramName = arg.params[0].name;
-        const bodyExpr = t.isExpression(arg.body) ? this.visit(arg.body) : 'null';
-        const resolved = bodyExpr.replace(
-          new RegExp(`(?<![.$\\w])${paramName}(?![\\w])`, 'g'),
-          `$local.${fieldName}`,
-        );
-        return `$action.setLocal("${fieldName}")(${resolved})`;
-      }
-      const argStr = t.isExpression(arg) ? this.visit(arg) : 'null';
-      return `$action.setLocal("${fieldName}")(${argStr})`;
-    }
-    return `$action.setLocal("${fieldName}")`;
-  }
-
-  // ---------------------------------------------------------------------------
-  // Argument helpers
-  // ---------------------------------------------------------------------------
-
-  private visitArgs(
-    args: (t.Expression | t.SpreadElement | t.JSXNamespacedName | t.ArgumentPlaceholder)[],
-  ): string {
-    return args.map((a) => {
-      if (t.isExpression(a)) return this.visit(a);
-      if (t.isSpreadElement(a)) return this.opaque(`...${this.visit(a.argument)}`);
-      return 'null';
-    }).join(', ');
-  }
-
-  private visitArgsList(
-    args: (t.Expression | t.SpreadElement | t.JSXNamespacedName | t.ArgumentPlaceholder)[],
-  ): string[] {
-    return args.map((a) => {
-      if (t.isExpression(a)) return this.visit(a);
-      if (t.isSpreadElement(a)) return this.opaque(`...${this.visit(a.argument)}`);
-      return 'null';
-    });
-  }
-}
-
-// =============================================================================
-// Fallback code generator (minimal, for opaque markers)
-// =============================================================================
-
-/**
- * Minimal JS code generator for AST nodes we can't transpile.
- * Produces a best-effort JS string for the $expr() wrapper.
- * @internal
- */
-function fallbackGenerate(node: t.Node): string {
-  if (t.isIdentifier(node)) return node.name;
-  if (t.isStringLiteral(node)) return `"${node.value.replace(/"/g, '\\"')}"`;
-  if (t.isNumericLiteral(node)) return String(node.value);
-  if (t.isBooleanLiteral(node)) return String(node.value);
-  if (t.isNullLiteral(node)) return 'null';
-  // For anything complex, produce a type marker
-  return `[${node.type}]`;
-}