novac 2.0.1 → 2.2.0

package/novac/src/core/formatter.js

@@ -0,0 +1,686 @@
+/**
+ * Nova Formatter
+ * Converts AST back to formatted source code
+ */
+
+const { Parser } = require('./parser');
+
+class Formatter {
+  constructor(source) {
+    this.source = source;
+    this.indentLevel = 0;
+    this.indentStr = '  '; // 2 spaces
+  }
+
+  format() {
+    try {
+      const parser = new Parser(this.source);
+      const ast = parser.parse();
+      return this.formatProgram(ast);
+    } catch (e) {
+      // If parsing fails, return original source
+      return this.source;
+    }
+  }
+
+  indent() {
+    return this.indentStr.repeat(this.indentLevel);
+  }
+
+  // ══════════════════════════ PROGRAM ══════════════════════════
+
+  formatProgram(node) {
+    if (!node || !node.nodes) return '';
+    return node.nodes.map(n => this.formatStatement(n)).filter(x => x).join('\n\n');
+  }
+
+  // ══════════════════════════ STATEMENTS ══════════════════════════
+
+  formatStatement(node) {
+    if (!node) return '';
+
+    const ind = this.indent();
+    switch (node.kind) {
+      // ── type declarations ──
+      case 'type_decl':
+        return ind + `type ${node.name}${this.formatTypeParams(node.params)} = ${this.formatTypeExpr(node.def)};`;
+      
+      case 'struct_decl':
+        return ind + `struct ${node.name}${this.formatTypeParams(node.params)} {` +
+          (node.fields.length > 0 ? '\n' + node.fields.map((f, i) => 
+            this.indent() + this.indentStr + `${f.name}: ${this.formatTypeExpr(f.type)}${f.defaultValue ? ' = ' + this.formatExpr(f.defaultValue) : ''}${i < node.fields.length - 1 ? ',' : ''}`
+          ).join('\n') + '\n' + ind : '') + `}`;
+
+      case 'interface_decl':
+        return ind + `interface ${node.name}${this.formatTypeParams(node.params)}${node.extends && node.extends.length ? ' extends ' + node.extends.join(', ') : ''} {` +
+          (node.members.length > 0 ? '\n' + node.members.map((m, i) => 
+            this.indent() + this.indentStr + `${m.name}${m.isOptional ? '?' : ''}${m.isMethod ? '(' + m.params.map(p => p.name + (p.type ? ': ' + this.formatTypeExpr(p.type) : '')).join(', ') + ')' + (m.returnType ? ': ' + this.formatTypeExpr(m.returnType) : '') : m.returnType ? ': ' + this.formatTypeExpr(m.returnType) : ''}${i < node.members.length - 1 ? ',' : ''}`
+          ).join('\n') + '\n' + ind : '') + `}`;
+
+      case 'enum_decl':
+        return ind + `enum ${node.name} {` +
+          (node.variants.length > 0 ? '\n' + node.variants.map((v, i) =>
+            this.indent() + this.indentStr + `${v.name}${v.value ? (v.value.kind === 'tuple' ? '(' + v.value.types.map(t => this.formatTypeExpr(t)).join(', ') + ')' : ' = ' + this.formatExpr(v.value)) : ''}${i < node.variants.length - 1 ? ',' : ''}`
+          ).join('\n') + '\n' + ind : '') + `}`;
+
+      case 'trait_decl':
+        return ind + `trait ${node.name}${this.formatTypeParams(node.params)} {` +
+          (node.methods.length > 0 ? '\n' + node.methods.map(m =>
+            this.indent() + this.indentStr + `${m.name}(${m.args.map(a => this.formatFuncArg(a)).join(', ')}) {${m.body.length > 0 ? '\n' + this.formatBody(m.body) + '\n' + this.indent() + this.indentStr : ''}}` 
+          ).join('\n') + '\n' + ind : '') + `}`;
+
+      case 'impl_decl':
+        return ind + `impl ${node.trait}${node.for ? ' for ' + node.for : ''} {` +
+          (node.methods.length > 0 ? '\n' + node.methods.map(m =>
+            this.indent() + this.indentStr + `${m.name}(${m.args.map(a => this.formatFuncArg(a)).join(', ')}) {${m.body.length > 0 ? '\n' + this.formatBody(m.body) + '\n' + this.indent() + this.indentStr : ''}}` 
+          ).join('\n') + '\n' + ind : '') + `}`;
+
+      // ── variables ──
+      case 'declare': {
+        const prefix = node.isConst ? 'const' : 'let';
+        if (node.destructure) {
+          const destr = node.destructure.kind === 'objpattern'
+            ? '{' + node.destructure.props.map(p => p.key + (p.alias !== p.key ? ': ' + p.alias : '') + (p.defaultValue ? ' = ' + this.formatExpr(p.defaultValue) : '')).join(', ') + '}'
+            : '[' + node.destructure.elements.map(e => (e.rest ? '...' : '') + e.name + (e.defaultValue ? ' = ' + this.formatExpr(e.defaultValue) : '')).join(', ') + ']';
+          return ind + `${prefix} ${node.isPointer ? '*' : ''}${destr}${node.value ? ' = ' + this.formatExpr(node.value) : ''};`;
+        }
+        return ind + `${prefix} ${node.isPointer ? '*' : ''}${node.name}${node.explicitType ? ': ' + this.formatTypeExpr(node.explicitType) : ''}${node.value ? ' = ' + this.formatExpr(node.value) : ''};`;
+      }
+
+      // ── functions ──
+      case 'function':
+        return ind + `function ${node.name}(${node.args.map(a => this.formatFuncArg(a)).join(', ')})${node.returnType ? ': ' + this.formatTypeExpr(node.returnType) : ''} {` +
+          (node.body.length > 0 ? '\n' + this.formatBody(node.body) + '\n' + ind : '') + `}`;
+
+      // ── classes ──
+      case 'class':
+        return ind + `class ${node.name}${node.superClass ? ' extends ' + this.formatExpr(node.superClass) : ''}${node.impls && node.impls.length ? ' implements ' + node.impls.join(', ') : ''} {` +
+          (node.members.length > 0 ? '\n' + node.members.map(m => {
+            const mind = this.indent() + this.indentStr;
+            if (m.kind === 'declare') return mind + `${m.name}: ${this.formatExpr(m.value)}`;
+            if (m.kind === 'function') {
+              return mind + (m.accessor ? m.accessor + ' ' : '') + `${m.name}(${m.args.map(a => this.formatFuncArg(a)).join(', ')})${m.returnType ? ': ' + this.formatTypeExpr(m.returnType) : ''} {` +
+                (m.body.length > 0 ? '\n' + this.formatBody(m.body, this.indentLevel + 2) + '\n' + mind : '') + `}`;
+            }
+            return mind + this.formatStatement(m);
+          }).join('\n') + '\n' + ind : '') + `}`;
+
+      // ── control flow ──
+      case 'branch':
+        return this.formatBranch(node, ind);
+
+      case 'for_of':
+        return ind + `for (${node.varName} of ${this.formatExpr(node.iterable)}) {` +
+          (node.body.length > 0 ? '\n' + this.formatBody(node.body) + '\n' + ind : '') + `}`;
+
+      case 'for_in':
+        return ind + `for (${node.varName} in ${this.formatExpr(node.object)}) {` +
+          (node.body.length > 0 ? '\n' + this.formatBody(node.body) + '\n' + ind : '') + `}`;
+
+      case 'each':
+        return ind + `each ${node.varName}${node.indexName ? ', ' + node.indexName : ''} of ${this.formatExpr(node.iterable)} {` +
+          (node.body.length > 0 ? '\n' + this.formatBody(node.body) + '\n' + ind : '') + `}`;
+
+      case 'switch':
+        return ind + `switch (${this.formatExpr(node.subject)}) {` +
+          (node.cases.length > 0 ? '\n' + node.cases.map(c => {
+            const mind = this.indent() + this.indentStr;
+            if (c.kind === 'default_case') return mind + `default:` + (c.body.length > 0 ? '\n' + this.formatBody(c.body, this.indentLevel + 2) : '');
+            return mind + `case ${this.formatExpr(c.value)}:` + (c.body.length > 0 ? '\n' + this.formatBody(c.body, this.indentLevel + 2) : '');
+          }).join('\n') + '\n' + ind : '') + `}`;
+
+      case 'match':
+        return ind + `match (${this.formatExpr(node.subject)}) {` +
+          (node.cases.length > 0 ? '\n' + node.cases.map(c => {
+            const mind = this.indent() + this.indentStr;
+            if (c.kind === 'default_when') return mind + `default {` + (c.body.length > 0 ? '\n' + this.formatBody(c.body, this.indentLevel + 2) + '\n' + mind : '') + `}`;
+            return mind + `when ${c.patterns.map(p => this.formatExpr(p)).join(', ')}${c.guard ? ' where ' + this.formatExpr(c.guard) : ''} {` +
+              (c.body.length > 0 ? '\n' + this.formatBody(c.body, this.indentLevel + 2) + '\n' + mind : '') + `}`;
+          }).join('\n') + '\n' + ind : '') + `}`;
+
+      case 'try':
+        return ind + `try {` + (node.tryBody.length > 0 ? '\n' + this.formatBody(node.tryBody) + '\n' + ind : '') + `}` +
+          (node.catchBody ? ' catch' + (node.catchName ? `(${node.catchName})` : '') + ` {` +
+            (node.catchBody.length > 0 ? '\n' + this.formatBody(node.catchBody) + '\n' + ind : '') + `}` : '') +
+          (node.finallyBody ? ' finally {' + (node.finallyBody.length > 0 ? '\n' + this.formatBody(node.finallyBody) + '\n' + ind : '') + `}` : '');
+
+      case 'return':
+        return ind + `return${node.value ? ' ' + this.formatExpr(node.value) : ''};`;
+
+      case 'break':
+        return ind + `break;`;
+
+      case 'continue':
+        return ind + `continue;`;
+
+      case 'throw':
+        return ind + `throw ${this.formatExpr(node.value)};`;
+
+      case 'assert':
+        return ind + `assert ${this.formatExpr(node.condition)}${node.message ? ', ' + this.formatExpr(node.message) : ''};`;
+
+      case 'emit_event':
+        return ind + `emit ${this.formatExpr(node.event)}${node.value ? ', ' + this.formatExpr(node.value) : ''};`;
+
+      case 'on_event':
+        return ind + `on ${this.formatExpr(node.event)}${node.param ? `(${node.param})` : ''} {` +
+          (node.body.length > 0 ? '\n' + this.formatBody(node.body) + '\n' + ind : '') + `}`;
+
+      case 'where':
+        return ind + `where (${node.bindings.map(b => `${b.name} = ${this.formatExpr(b.value)}`).join(', ')}) {` +
+          (node.body.length > 0 ? '\n' + this.formatBody(node.body) + '\n' + ind : '') + `}`;
+
+      case 'exec':
+        return ind + `${this.formatExpr(node.expr)};`;
+
+      // ── Nova Classic statements ──
+      case 'foreach':
+        return ind + `foreach (${this.formatExpr(node.iterable)}) (${node.vars.join(', ')}) {` +
+          (node.body.length > 0 ? '\n' + this.formatBody(node.body) + '\n' + ind : '') + `}`;
+
+      case 'temp':
+        return ind + `temp ${node.name} = ${this.formatExpr(node.value)} => {` +
+          (node.body.length > 0 ? '\n' + this.formatBody(node.body) + '\n' + ind : '') + `}`;
+
+      case 'keep':
+        return ind + `keep ${node.name} = ${this.formatExpr(node.value)};`;
+
+      case 'echo':
+        return ind + `echo ${this.formatExpr(node.value)};`;
+
+      case 'gear_decl':
+        return ind + `gear${node.wait && node.wait.value !== 0 ? `(${this.formatExpr(node.wait)})` : ''} ${node.name} {` +
+          (node.body.length > 0 ? '\n' + this.formatBody(node.body) + '\n' + ind : '') + `}`;
+
+      case 'engage':
+        return ind + `engage ${node.gears.join(' >> ')};`;
+
+      case 'sandbox':
+        return ind + `sandbox {${node.code ? ' ' + node.code + ' ' : ''}}`;
+
+      case 'infer':
+        return ind + `infer(${this.formatExpr(node.model)}) => ${node.varName}: ${this.formatExpr(node.prompt)};`;
+
+      case 'addto':
+        return ind + `addto ${node.name} ${this.formatExpr(node.value)}${node.key ? ': ' + this.formatExpr(node.key) : ''};`;
+
+      case 'macro_decl':
+        return ind + `macro ${node.name} = ${this.formatExpr(node.value)};`;
+
+      case 'block_decl':
+        return ind + `block ${node.name} {` +
+          (node.body.length > 0 ? '\n' + this.formatBody(node.body) + '\n' + ind : '') + `}`;
+
+      case 'snippet_decl':
+        return ind + `snippet ${node.name} {` +
+          (node.body.length > 0 ? '\n' + this.formatBody(node.body) + '\n' + ind : '') + `}`;
+
+      case 'defunc_decl':
+        return ind + `defunc ${node.name}(${node.args.map(a => this.formatFuncArg(a)).join(', ')}) => {` +
+          (node.body.length > 0 ? '\n' + this.formatBody(node.body) + '\n' + ind : '') + `}`;
+
+      case 'lambda_decl':
+        return ind + `lambda ${node.name} = ${this.formatExpr(node.fn)};`;
+
+      case 'compose_decl':
+        return ind + `compose ${node.name} = ${node.fns.map(f => this.formatExpr(f)).join(' >> ')};`;
+
+      case 'partial_decl':
+        return ind + `partial ${node.name} = ${this.formatExpr(node.callee)};`;
+
+      case 'backup_val':
+        return ind + `backup ${node.name} = ${this.formatExpr(node.value)};`;
+
+      case 'retrieve_val':
+        return ind + `retrieve ${node.name};`;
+
+      case 'describe':
+        return ind + `describe ${this.formatExpr(node.text)};`;
+
+      case 'using_flag':
+        return ind + `using ${node.flag};`;
+
+      case 'unuse_flag':
+        return ind + `unuse ${node.flag};`;
+
+      case 'classify':
+        return ind + `classify ${this.formatExpr(node.value)}${node.targetType ? ' as ' + this.formatTypeExpr(node.targetType) : ''};`;
+
+      case 'rate_cast':
+        return ind + `rate(${this.formatExpr(node.value)}) ${node.cast_type};`;
+
+      // ── Nova Classic (ported) ──
+      case 'guard':
+        return ind + `guard (${this.formatExpr(node.cond)}) {` + (node.body.length > 0 ? '\n' + this.formatBody(node.body) + '\n' + ind : '') + `}` +
+          (node.elseBody ? ` else {` + (node.elseBody.length > 0 ? '\n' + this.formatBody(node.elseBody, this.indentLevel + 1) + '\n' + ind : '') + `}` : '');
+
+      case 'when_stmt':
+        return ind + `when ${this.formatExpr(node.cond)} do {` +
+          (node.body.length > 0 ? '\n' + this.formatBody(node.body) + '\n' + ind : '') + `}`;
+
+      case 'with_ctx':
+        return ind + `with (${this.formatExpr(node.target)}) {` +
+          (node.body.length > 0 ? '\n' + this.formatBody(node.body) + '\n' + ind : '') + `}`;
+
+      case 'with_option':
+        return ind + `with option ${node.flag} {` +
+          (node.body.length > 0 ? '\n' + this.formatBody(node.body) + '\n' + ind : '') + `}`;
+
+      case 'loop_in':
+        return ind + `loop ${node.varName} in ${this.formatExpr(node.iterable)} {` +
+          (node.body.length > 0 ? '\n' + this.formatBody(node.body) + '\n' + ind : '') + `}`;
+
+      case 'wait_stmt':
+        return ind + `wait(${this.formatExpr(node.ms)});`;
+
+      case 'lend_fn':
+        return ind + `lend fn ${node.source} to ${node.target};`;
+
+      case 'lend_m':
+        return ind + `lend m ${node.mapName} with ${node.funcName};`;
+
+      case 'sstream_decl':
+        return ind + `sstream ${node.name} => {` +
+          (node.body.length > 0 ? '\n' + this.formatBody(node.body) + '\n' + ind : '') + `}`;
+
+      case 'declare_stmt':
+        return ind + `declare (${this.formatExpr(node.value)}) ${node.mode} ${node.name}${node.flags.length > 0 ? ' ' + node.flags.join(' ') : ''};`;
+
+      case 'session_decl':
+        return ind + `session (${this.formatExpr(node.name)}) { ${node.body} }`;
+
+      case 'enter_stmt':
+        return ind + `enter ${node.key} ${node.type};`;
+
+      case 'namespace_decl':
+        return ind + `namespace ${this.formatExpr(node.path)};`;
+
+      case 'resu_decl':
+        return ind + `resu ${node.name}(${node.params.join(', ')}) => { ${node.body} },`;
+
+      case 'warn_stmt':
+        return ind + `warn ${this.formatExpr(node.msg)};`;
+
+      case 'info_stmt':
+        return ind + `info ${this.formatExpr(node.msg)};`;
+
+      case 'time_block':
+        return ind + `time {` +
+          (node.body.length > 0 ? '\n' + this.formatBody(node.body) + '\n' + ind : '') + `}`;
+
+      case 'keyfunc_decl':
+        return ind + `keyfunc ${node.name}(${node.params.join(', ')}) { ${node.matchBody} } { ${node.logic} }`;
+
+      case 'print_stmt':
+        return ind + `print(${node.args.map(a => this.formatExpr(a)).join(', ')});`;
+
+      case 'log_stmt':
+        return ind + `log(${node.args.map(a => this.formatExpr(a)).join(', ')});`;
+
+      case 'println_stmt':
+        return ind + `println(${this.formatExpr(node.value)});`;
+
+      case 'logln_stmt':
+        return ind + `logln(${this.formatExpr(node.value)});`;
+
+      case 'banner_stmt':
+        return ind + `banner${node.args.length > 0 ? '(' + node.args.map(a => this.formatExpr(a)).join(', ') + ')' : ''};`;
+
+      case 'readfile_stmt':
+        return ind + `readFile ${node.varName} = (${this.formatExpr(node.path)});`;
+
+      case 'execfile_stmt':
+        return ind + `execFile(${this.formatExpr(node.path)});`;
+
+      case 'createfile_stmt':
+        return ind + `createFile(${this.formatExpr(node.path)}, ${this.formatExpr(node.content)});`;
+
+      case 'deletefile_stmt':
+        return ind + `deleteFile(${this.formatExpr(node.path)});`;
+
+      case 'listfiles_stmt':
+        return ind + `listFiles(${this.formatExpr(node.dir)})${node.varName ? ' => ' + node.varName : ''};`;
+
+      case 'term_stmt':
+        return ind + `term(${this.formatExpr(node.cmd)}) ${node.shell};`;
+
+      case 'sh_stmt':
+        return ind + `sh { ${node.code} }`;
+
+      case 'exec_stmt':
+        return ind + `exec(${this.formatExpr(node.code)});`;
+
+      case 'notify_stmt':
+        return ind + `notify(${this.formatExpr(node.title)}${node.content ? ', ' + this.formatExpr(node.content) : ''});`;
+
+      case 'toast_stmt':
+        return ind + `toast(${this.formatExpr(node.msg)});`;
+
+      case 'vibrate_stmt':
+        return ind + `vibrate(${this.formatExpr(node.ms)});`;
+
+      case 'clipboard_stmt':
+        return ind + `clipboard(${this.formatExpr(node.text)});`;
+
+      case 'camera_stmt':
+        return ind + `camera(${this.formatExpr(node.path)});`;
+
+      case 'share_stmt':
+        return ind + `share(${this.formatExpr(node.path)});`;
+
+      case 'open_stmt':
+        return ind + `open(${this.formatExpr(node.path)});`;
+
+      case 'sysinfo_stmt':
+        return ind + `${node.info}${node.varName ? ' => ' + node.varName : ''};`;
+
+      case 'path_stmt':
+        return ind + `path${node.sub}(${this.formatExpr(node.target)});`;
+
+      case 'crypto_stmt':
+        return ind + `${node.fn}(${this.formatExpr(node.arg)})${node.varName ? ' => ' + node.varName : ''};`;
+
+      case 'parseurl_stmt':
+        return ind + `parseURL(${this.formatExpr(node.url)})${node.varName ? ' => ' + node.varName : ''};`;
+
+      case 'exists_stmt':
+        return ind + `exists(${this.formatExpr(node.path)})${node.varName ? ' => ' + node.varName : ''};`;
+
+      case 'expt_stmt':
+        return ind + `expt ${node.expected} from {` +
+          (node.body.length > 0 ? '\n' + this.formatBody(node.body) + '\n' + ind : '') + `}`;
+
+      case 'option_stmt':
+        return ind + `option ${node.name} = ${this.formatExpr(node.value)};`;
+
+      case 'env':
+        return ind + `env ${node.varName};`;
+
+      case 'hello':
+        return ind + `hello ${node.args.map(a => this.formatExpr(a)).join(', ')};`;
+
+      case 'eval':
+        return ind + `eval ${this.formatStatement(node.code)};`;
+
+      case 'import':
+        return ind + `import ${this.formatExpr(node.source)}${node.names && node.names.length ? ' as ' + node.names.join(', ') : ''};`;
+
+      case 'import_builtin':
+        return ind + `import_builtin ${node.names.join(', ')};`;
+
+      case 'from_import':
+        return ind + `from ${this.formatExpr(node.source)} import ${node.names.join(', ')};`;
+
+      case 'export':
+        return ind + `export ${node.value ? this.formatExpr(node.value) : ''};`;
+
+      case 'default_export':
+        return ind + `export default ${node.value ? this.formatExpr(node.value) : ''};`;
+
+      case 'namespace':
+        return ind + `namespace ${node.name} {` +
+          (node.body.length > 0 ? '\n' + this.formatBody(node.body) + '\n' + ind : '') + `}`;
+
+      case 'server_decl':
+        return ind + `server(${this.formatExpr(node.port)}) {` +
+          (node.routes.length > 0 ? '\n' + node.routes.map(r =>
+            this.indent() + this.indentStr + `${r.method} ${this.formatExpr(r.path)}${r.params.length > 0 ? '(' + r.params.join(', ') + ')' : ''} {` +
+              (r.body.length > 0 ? '\n' + this.formatBody(r.body, this.indentLevel + 2) + '\n' + this.indent() + this.indentStr : '') + `}`
+          ).join('\n') + '\n' + ind : '') + `}`;
+
+      case 'fetch_stmt':
+        return ind + `fetch(${this.formatExpr(node.url)}${node.options ? ', ' + this.formatExpr(node.options) : ''})${node.varName ? ' => ' + node.varName : ''};`;
+
+      case 'skip':
+        return ind + `skip;`;
+
+      case 'end_stmt':
+        return ind + `end;`;
+
+      case 'clear_env':
+        return ind + `clear;`;
+
+      case 'exec_comment':
+        return ind + `/?/${node.code}`;
+
+      default:
+        return ind + `/* unknown node kind: ${node.kind} */`;
+    }
+  }
+
+  formatBranch(node, ind) {
+    let result = '';
+    let current = node;
+    while (current) {
+      switch (current.type) {
+        case 'if': {
+          result += ind + `if (${this.formatExpr(current.args)}) {` +
+            (current.body.length > 0 ? '\n' + this.formatBody(current.body) + '\n' + ind : '') + `}`;
+          current = current.next;
+          if (current) result += ' ';
+          break;
+        }
+        case 'else': {
+          result += `else {` + (current.body.length > 0 ? '\n' + this.formatBody(current.body) + '\n' + ind : '') + `}`;
+          current = current.next;
+          break;
+        }
+        case 'while': {
+          const c = Array.isArray(current.args) ? current.args[0] : current.args;
+          result += ind + `while (${this.formatExpr(c)}) {` +
+            (current.body.length > 0 ? '\n' + this.formatBody(current.body) + '\n' + ind : '') + `}`;
+          current = current.next;
+          break;
+        }
+        case 'until': {
+          const c = Array.isArray(current.args) ? current.args[0] : current.args;
+          result += ind + `until (${this.formatExpr(c)}) {` +
+            (current.body.length > 0 ? '\n' + this.formatBody(current.body) + '\n' + ind : '') + `}`;
+          current = current.next;
+          break;
+        }
+        case 'unless': {
+          result += ind + `unless (${this.formatExpr(current.args)}) {` +
+            (current.body.length > 0 ? '\n' + this.formatBody(current.body) + '\n' + ind : '') + `}`;
+          current = current.next;
+          break;
+        }
+        case 'do': {
+          const c = Array.isArray(current.args) ? current.args[0] : current.args;
+          result += ind + `do {` + (current.body.length > 0 ? '\n' + this.formatBody(current.body) + '\n' + ind : '') + `} while (${this.formatExpr(c)})`;
+          current = current.next;
+          break;
+        }
+        case 'repeat': {
+          const t = Array.isArray(current.args) ? current.args[0] : current.args;
+          result += ind + `repeat (${this.formatExpr(t)}) {` +
+            (current.body.length > 0 ? '\n' + this.formatBody(current.body) + '\n' + ind : '') + `}`;
+          current = current.next;
+          break;
+        }
+        case 'for': {
+          const [init, cond, upd] = current.args;
+          result += ind + `for (${this.formatStatement(init)}${cond ? ' ' + this.formatExpr(cond) : ''}; ${upd ? this.formatStatement(upd) : ''}) {` +
+            (current.body.length > 0 ? '\n' + this.formatBody(current.body) + '\n' + ind : '') + `}`;
+          current = current.next;
+          break;
+        }
+        default:
+          current = null;
+      }
+    }
+    return result;
+  }
+
+  formatBody(body, indentLevel) {
+    const prevIndent = this.indentLevel;
+    this.indentLevel = indentLevel !== undefined ? indentLevel : this.indentLevel + 1;
+    const result = body.map(stmt => this.formatStatement(stmt)).filter(x => x).join('\n');
+    this.indentLevel = prevIndent;
+    return result;
+  }
+
+  // ══════════════════════════ EXPRESSIONS ══════════════════════════
+
+  formatExpr(node) {
+    if (!node) return '';
+
+    switch (node.kind) {
+      case 'EOF':
+        return '';
+
+      case 'value': {
+        const v = node.value;
+        if (typeof v === 'string') return JSON.stringify(v);
+        if (typeof v === 'number') return String(v);
+        if (typeof v === 'symbol') {
+          const s = v.toString();
+          if (s === 'Symbol(NOVA_TRUE)') return 'true';
+          if (s === 'Symbol(NOVA_FALSE)') return 'false';
+          if (s === 'Symbol(NOVA_NULL)') return 'null';
+        }
+        return String(v);
+      }
+
+      case 'ref':
+        return node.name;
+
+      case 'url_literal':
+        return node.value;
+
+      case 'array':
+        return '[' + node.elements.map(e => this.formatExpr(e)).join(', ') + ']';
+
+      case 'object':
+        return '{' + node.props.map(p => {
+          if (p.kind === 'spread') return '...' + this.formatExpr(p.value);
+          if (p.kind === 'computed') return '[' + this.formatExpr(p.key) + ']: ' + this.formatExpr(p.value);
+          const val = p.value;
+          if (val && val.kind === 'function') return `${p.accessor ? p.accessor + ' ' : ''}${p.key}(${val.args.map(a => this.formatFuncArg(a)).join(', ')}) { ... }`;
+          return `${p.key}: ${this.formatExpr(val)}`;
+        }).join(', ') + '}';
+
+      case 'call':
+        return `${this.formatExpr(node.name)}(${node.args.map(a => this.formatExpr(a)).join(', ')})`;
+
+      case 'prop':
+        return `${this.formatExpr(node.object)}.${node.name}`;
+
+      case 'subscript':
+        return `${this.formatExpr(node.object)}[${this.formatExpr(node.index)}]`;
+
+      case 'optional_call':
+        return `${this.formatExpr(node.callee)}?.(${node.args.map(a => this.formatExpr(a)).join(', ')})`;
+
+      case 'optional_prop':
+        return `${this.formatExpr(node.object)}?.${node.name}`;
+
+      case 'optional_subscript':
+        return `${this.formatExpr(node.object)}?.[${this.formatExpr(node.index)}]`;
+
+      case 'binary':
+        return `${this.formatExpr(node.left)} ${node.operator} ${this.formatExpr(node.right)}`;
+
+      case 'unary':
+        return `${node.operator}${this.formatExpr(node.operand)}`;
+
+      case 'prefix':
+        return `${node.operator}${this.formatExpr(node.operand)}`;
+
+      case 'postfix':
+        return `${this.formatExpr(node.operand)}${node.operator}`;
+
+      case 'ternary':
+        return `${this.formatExpr(node.condition)} ? ${this.formatExpr(node.consequent)} : ${this.formatExpr(node.alternate)}`;
+
+      case 'assign':
+        return `${this.formatExpr(node.name)} = ${this.formatExpr(node.value)}`;
+
+      case 'compound_assign':
+        return `${this.formatExpr(node.name)} ${node.operator} ${this.formatExpr(node.value)}`;
+
+      case 'fstring':
+        return `f"${node.parts.map(p => p.kind === 'value' ? p.value : '${' + this.formatExpr(p) + '}').join('')}"`;
+
+      case 'function': {
+        const fn = node;
+        return `function ${fn.name}(${fn.args.map(a => this.formatFuncArg(a)).join(', ')}) { ... }`;
+      }
+
+      case 'arrowfunc':
+        return `(${node.args.join(', ')}) => { ... }`;
+
+      case 'cast':
+        return `${this.formatExpr(node.value)} as ${this.formatTypeExpr(node.type)}`;
+
+      case 'new_expr':
+        return `new ${this.formatExpr(node.callee)}`;
+
+      case 'deref':
+        return `*${this.formatExpr(node.operand)}`;
+
+      case 'spread':
+        return `...${this.formatExpr(node.value)}`;
+
+      case 'await':
+        return `await ${this.formatExpr(node.operand)}`;
+
+      case 'http_request':
+        return `${node.method} ${this.formatExpr(node.url)}(${node.args.map(a => this.formatExpr(a)).join(', ')})`;
+
+      case 'fetch_expr':
+        return `fetch(${this.formatExpr(node.url)}${node.options ? ', ' + this.formatExpr(node.options) : ''})`;
+
+      case 'classify':
+        return `classify ${this.formatExpr(node.value)}${node.targetType ? ' as ' + this.formatTypeExpr(node.targetType) : ''}`;
+
+      case 'rate_cast':
+        return `rate(${this.formatExpr(node.value)}) ${node.cast_type}`;
+
+      default:
+        return `/* unknown expr kind: ${node.kind} */`;
+    }
+  }
+
+  formatFuncArg(arg) {
+    if (typeof arg === 'string') return arg;
+    return (arg.rest ? '...' : '') + arg.name + (arg.type ? ': ' + this.formatTypeExpr(arg.type) : '') +
+      (arg.defaultValue ? ' = ' + this.formatExpr(arg.defaultValue) : '');
+  }
+
+  formatTypeExpr(type) {
+    if (!type) return 'any';
+    if (typeof type === 'string') return type;
+
+    switch (type.kind) {
+      case 'named_type':
+        return type.name + (type.args && type.args.length ? '<' + type.args.map(a => this.formatTypeExpr(a)).join(', ') + '>' : '');
+
+      case 'array_type':
+        return this.formatTypeExpr(type.of) + '[]';
+
+      case 'union_type':
+        return type.variants.map(v => this.formatTypeExpr(v)).join(' | ');
+
+      case 'intersect_type':
+        return type.parts.map(p => this.formatTypeExpr(p)).join(' & ');
+
+      case 'shape_type':
+        return '{' + Object.entries(type.fields || {}).map(([k, f]) =>
+          k + (f.optional ? '?' : '') + ': ' + this.formatTypeExpr(f.type)
+        ).join(', ') + '}';
+
+      case 'tuple':
+        return '(' + (type.types ? type.types.map(t => this.formatTypeExpr(t)).join(', ') : '') + ')';
+
+      default:
+        return String(type);
+    }
+  }
+
+  formatTypeParams(params) {
+    return params && params.length ? '<' + params.join(', ') + '>' : '';
+  }
+}
+
+module.exports = { Formatter };