thyscript 1.0.0

package/src/compiler/CodeGenerator.js

@@ -0,0 +1,1449 @@
+'use strict';
+/**
+ * ThyScript CodeGenerator
+ * Translates a ThyScript AST into optimized, runnable Node.js JavaScript.
+ *
+ * Every compiled file receives:
+ *   - 'use strict' directive
+ *   - Full __thy_stdlib object (all built-ins)
+ *   - All necessary require/import stubs
+ *   - Optimised code for every ThyScript AST node type
+ */
+
+class CodeGenerator {
+  constructor(options = {}) {
+    this.options = Object.assign({
+      optimise: true,
+      sourceMap: false,
+      minify: false,
+      targetES: 2022,
+    }, options);
+
+    /** Indentation depth */
+    this._indent = 0;
+    /** Unique counter for generated identifiers */
+    this._uid = 0;
+    /** Whether express app has been declared in this file */
+    this._expressAppDeclared = false;
+    /** Whether readline interface has been declared */
+    this._readlineDeclared = false;
+    /** Whether tf (TensorFlow.js) has been declared */
+    this._tfDeclared = false;
+    /** Whether Matter.js has been declared */
+    this._matterDeclared = false;
+    /** Collected top-level require statements */
+    this._requires = new Set();
+    /** Lines of the header section (stdlib + requires) */
+    this._headerLines = [];
+    /** Lines of the body section (compiled statements) */
+    this._bodyLines = [];
+  }
+
+  // ─── helpers ────────────────────────────────────────────────────────────────
+
+  _uid_() { return `__thy_${this._uid++}`; }
+
+  _tab() { return '  '.repeat(this._indent); }
+
+  _emit(line) {
+    this._bodyLines.push(this._tab() + line);
+  }
+
+  _emitRaw(line) {
+    this._bodyLines.push(line);
+  }
+
+  _push() { this._indent++; }
+  _pop() { if (this._indent > 0) this._indent--; }
+
+  _needRequire(pkg) { this._requires.add(pkg); }
+
+  _escStr(s) {
+    return String(s)
+      .replace(/\\/g, '\\\\')
+      .replace(/'/g, "\\'")
+      .replace(/\n/g, '\\n')
+      .replace(/\r/g, '\\r')
+      .replace(/\t/g, '\\t');
+  }
+
+  // ─── stdlib header ───────────────────────────────────────────────────────────
+
+  _buildStdlib() {
+    return `
+// ═══════════════════════════════════════════════════════════════
+//  ThyScript Standard Library  –  __thy_stdlib
+//  Auto-generated by ThyScript CodeGenerator
+// ═══════════════════════════════════════════════════════════════
+const __thy_stdlib = (() => {
+  'use strict';
+  const _fs   = require('fs');
+  const _path = require('path');
+  const _os   = require('os');
+  const _crypto = require('crypto');
+
+  // ── math ──────────────────────────────────────────────────────
+  const math = {
+    pi:      Math.PI,
+    e:       Math.E,
+    inf:     Infinity,
+    nan:     NaN,
+    epsilon: Number.EPSILON,
+    abs:     (x) => Math.abs(x),
+    sqrt:    (x) => Math.sqrt(x),
+    pow:     (x, y) => Math.pow(x, y),
+    floor:   (x) => Math.floor(x),
+    ceil:    (x) => Math.ceil(x),
+    round:   (x) => Math.round(x),
+    sin:     (x) => Math.sin(x),
+    cos:     (x) => Math.cos(x),
+    tan:     (x) => Math.tan(x),
+    asin:    (x) => Math.asin(x),
+    acos:    (x) => Math.acos(x),
+    atan:    (x) => Math.atan(x),
+    atan2:   (y, x) => Math.atan2(y, x),
+    log:     (x) => Math.log(x),
+    log2:    (x) => Math.log2(x),
+    log10:   (x) => Math.log10(x),
+    exp:     (x) => Math.exp(x),
+    random:  () => Math.random(),
+    min:     (...args) => Math.min(...args),
+    max:     (...args) => Math.max(...args),
+    clamp:   (v, lo, hi) => Math.max(lo, Math.min(hi, v)),
+    lerp:    (a, b, t) => a + (b - a) * t,
+    hypot:   (...args) => Math.hypot(...args),
+    sign:    (x) => Math.sign(x),
+    trunc:   (x) => Math.trunc(x),
+    cbrt:    (x) => Math.cbrt(x),
+    // Fast integer math via typed arrays
+    imul:    (a, b) => Math.imul(a, b),
+    fround:  (x) => Math.fround(x),
+    clz32:   (x) => Math.clz32(x),
+  };
+
+  // Fast-math helpers using Float64Array for type stability
+  const _buf64 = new Float64Array(1);
+  const _buf32 = new Float32Array(1);
+  const fastFloor = (x) => { _buf64[0] = x; return x | 0; };
+  const fastAbs   = (x) => x < 0 ? -x : x;
+  const fastMod   = (a, b) => a - b * ((a / b) | 0);
+
+  // ── vectors ───────────────────────────────────────────────────
+  const vec = {
+    add:       (a, b) => a.map((v, i) => v + b[i]),
+    sub:       (a, b) => a.map((v, i) => v - b[i]),
+    scale:     (a, s) => a.map(v => v * s),
+    dot:       (a, b) => a.reduce((acc, v, i) => acc + v * b[i], 0),
+    cross3:    (a, b) => [
+      a[1]*b[2] - a[2]*b[1],
+      a[2]*b[0] - a[0]*b[2],
+      a[0]*b[1] - a[1]*b[0],
+    ],
+    length:    (a) => Math.hypot(...a),
+    normalize: (a) => { const len = Math.hypot(...a) || 1; return a.map(v => v / len); },
+    distance:  (a, b) => Math.hypot(...a.map((v, i) => v - b[i])),
+  };
+
+  // ── string helpers ────────────────────────────────────────────
+  const str = {
+    upper:   (s) => String(s).toUpperCase(),
+    lower:   (s) => String(s).toLowerCase(),
+    trim:    (s) => String(s).trim(),
+    split:   (s, sep) => String(s).split(sep),
+    replace: (s, pat, rep) => String(s).replace(pat, rep),
+    includes:(s, sub) => String(s).includes(sub),
+    startsWith:(s, pre) => String(s).startsWith(pre),
+    endsWith: (s, suf) => String(s).endsWith(suf),
+    repeat:  (s, n) => String(s).repeat(n),
+    pad:     (s, n, ch = ' ') => String(s).padStart(n, ch),
+    padEnd:  (s, n, ch = ' ') => String(s).padEnd(n, ch),
+    indexOf: (s, sub) => String(s).indexOf(sub),
+    slice:   (s, start, end) => String(s).slice(start, end),
+    charCode:(s, i = 0) => String(s).charCodeAt(i),
+    fromCode:(n) => String.fromCharCode(n),
+    reverse: (s) => String(s).split('').reverse().join(''),
+    count:   (s, sub) => { let c = 0, i = 0; while ((i = s.indexOf(sub, i)) !== -1) { c++; i++; } return c; },
+    format:  (tpl, ...args) => tpl.replace(/{(\\d+)}/g, (_, i) => args[i] ?? ''),
+    escape:  (s) => String(s).replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;').replace(/"/g,'&quot;'),
+  };
+
+  // ── array helpers ─────────────────────────────────────────────
+  const arr = {
+    map:     (a, fn) => Array.from(a).map(fn),
+    filter:  (a, fn) => Array.from(a).filter(fn),
+    reduce:  (a, fn, init) => Array.from(a).reduce(fn, init),
+    find:    (a, fn) => Array.from(a).find(fn),
+    findIdx: (a, fn) => Array.from(a).findIndex(fn),
+    sort:    (a, fn) => [...a].sort(fn),
+    flat:    (a, d = 1) => Array.from(a).flat(d),
+    flatMap: (a, fn) => Array.from(a).flatMap(fn),
+    unique:  (a) => [...new Set(a)],
+    zip:     (...arrs) => arrs[0].map((_, i) => arrs.map(a => a[i])),
+    chunk:   (a, n) => { const res = []; for (let i = 0; i < a.length; i += n) res.push(a.slice(i, i+n)); return res; },
+    shuffle: (a) => { const r = [...a]; for (let i = r.length-1; i > 0; i--) { const j = Math.floor(Math.random()*(i+1)); [r[i],r[j]]=[r[j],r[i]]; } return r; },
+    range:   (start, end, step = 1) => { const r = []; for (let i = start; i < end; i += step) r.push(i); return r; },
+    sum:     (a) => a.reduce((acc, v) => acc + v, 0),
+    avg:     (a) => a.reduce((acc, v) => acc + v, 0) / a.length,
+    min:     (a) => Math.min(...a),
+    max:     (a) => Math.max(...a),
+    includes:(a, v) => Array.from(a).includes(v),
+    count:   (a, v) => Array.from(a).filter(x => x === v).length,
+    first:   (a) => a[0],
+    last:    (a) => a[a.length - 1],
+    take:    (a, n) => a.slice(0, n),
+    drop:    (a, n) => a.slice(n),
+    reverse: (a) => [...a].reverse(),
+  };
+
+  // ── object helpers ────────────────────────────────────────────
+  const obj = {
+    keys:    (o) => Object.keys(o),
+    values:  (o) => Object.values(o),
+    entries: (o) => Object.entries(o),
+    merge:   (...os) => Object.assign({}, ...os),
+    clone:   (o) => JSON.parse(JSON.stringify(o)),
+    pick:    (o, keys) => keys.reduce((acc, k) => { if (k in o) acc[k] = o[k]; return acc; }, {}),
+    omit:    (o, keys) => { const r = {...o}; keys.forEach(k => delete r[k]); return r; },
+    has:     (o, k) => Object.prototype.hasOwnProperty.call(o, k),
+    freeze:  (o) => Object.freeze(o),
+    seal:    (o) => Object.seal(o),
+    fromEntries: (e) => Object.fromEntries(e),
+    assign:  (target, ...sources) => Object.assign(target, ...sources),
+    flatten: (o, prefix = '') => {
+      return Object.keys(o).reduce((acc, k) => {
+        const key = prefix ? prefix + '.' + k : k;
+        if (typeof o[k] === 'object' && o[k] !== null && !Array.isArray(o[k]))
+          Object.assign(acc, obj.flatten(o[k], key));
+        else acc[key] = o[k];
+        return acc;
+      }, {});
+    },
+  };
+
+  // ── I/O helpers ───────────────────────────────────────────────
+  const io = {
+    print:   (...args) => { process.stdout.write(args.map(a => __thy_stringify(a)).join(' ') + '\\n'); },
+    printErr:(...args) => { process.stderr.write(args.map(a => __thy_stringify(a)).join(' ') + '\\n'); },
+    write:   (s) => { process.stdout.write(String(s)); },
+    read:    (fp) => _fs.readFileSync(fp, 'utf8'),
+    readLines:(fp) => _fs.readFileSync(fp, 'utf8').split('\\n'),
+    write_:  (fp, data) => _fs.writeFileSync(fp, data, 'utf8'),
+    append:  (fp, data) => _fs.appendFileSync(fp, data, 'utf8'),
+    exists:  (fp) => _fs.existsSync(fp),
+    mkdir:   (fp) => _fs.mkdirSync(fp, { recursive: true }),
+    readdir: (fp) => _fs.readdirSync(fp),
+    rm:      (fp) => _fs.rmSync(fp, { recursive: true, force: true }),
+    stat:    (fp) => _fs.statSync(fp),
+    isFile:  (fp) => _fs.existsSync(fp) && _fs.statSync(fp).isFile(),
+    isDir:   (fp) => _fs.existsSync(fp) && _fs.statSync(fp).isDirectory(),
+    cwd:     () => process.cwd(),
+    home:    () => _os.homedir(),
+    tempDir: () => _os.tmpdir(),
+    sep:     _path.sep,
+    join:    (...parts) => _path.join(...parts),
+    resolve: (...parts) => _path.resolve(...parts),
+    dirname: (p) => _path.dirname(p),
+    basename:(p, ext) => _path.basename(p, ext),
+    ext:     (p) => _path.extname(p),
+  };
+
+  // ── crypto helpers ────────────────────────────────────────────
+  const security = {
+    hash:    (data, alg = 'sha256') => _crypto.createHash(alg).update(String(data)).digest('hex'),
+    hmac:    (key, data, alg = 'sha256') => _crypto.createHmac(alg, key).update(String(data)).digest('hex'),
+    random:  (n = 16) => _crypto.randomBytes(n).toString('hex'),
+    uuid:    () => _crypto.randomUUID ? _crypto.randomUUID() : _crypto.randomBytes(16).toString('hex').replace(/(........)(....)(....)(....)(............)/, '$1-$2-$3-$4-$5'),
+    encrypt: (text, key) => {
+      const iv = _crypto.randomBytes(16);
+      const k  = _crypto.createHash('sha256').update(key).digest();
+      const c  = _crypto.createCipheriv('aes-256-cbc', k, iv);
+      return iv.toString('hex') + ':' + Buffer.concat([c.update(text), c.final()]).toString('hex');
+    },
+    decrypt: (enc, key) => {
+      const [ivHex, data] = enc.split(':');
+      const iv = Buffer.from(ivHex, 'hex');
+      const k  = _crypto.createHash('sha256').update(key).digest();
+      const d  = _crypto.createDecipheriv('aes-256-cbc', k, iv);
+      return Buffer.concat([d.update(Buffer.from(data, 'hex')), d.final()]).toString();
+    },
+    base64encode: (s) => Buffer.from(String(s)).toString('base64'),
+    base64decode: (s) => Buffer.from(String(s), 'base64').toString(),
+  };
+
+  // ── type helpers ──────────────────────────────────────────────
+  const types = {
+    isNum:   (v) => typeof v === 'number' && !isNaN(v),
+    isStr:   (v) => typeof v === 'string',
+    isBool:  (v) => typeof v === 'boolean',
+    isNull:  (v) => v === null,
+    isUndef: (v) => v === undefined,
+    isArr:   (v) => Array.isArray(v),
+    isObj:   (v) => v !== null && typeof v === 'object' && !Array.isArray(v),
+    isFn:    (v) => typeof v === 'function',
+    type:    (v) => v === null ? 'null' : Array.isArray(v) ? 'array' : typeof v,
+    toNum:   (v) => Number(v),
+    toStr:   (v) => String(v),
+    toBool:  (v) => Boolean(v),
+    toInt:   (v) => parseInt(v, 10),
+    toFloat: (v) => parseFloat(v),
+    toArr:   (v) => Array.isArray(v) ? v : [v],
+    toJson:  (v) => JSON.stringify(v, null, 2),
+    fromJson:(v) => JSON.parse(v),
+  };
+
+  // ── time helpers ──────────────────────────────────────────────
+  const time = {
+    now:     () => Date.now(),
+    date:    () => new Date(),
+    sleep:   (ms) => new Promise(r => setTimeout(r, ms)),
+    perf:    () => typeof performance !== 'undefined' ? performance.now() : Number(process.hrtime.bigint()) / 1e6,
+    format:  (d = new Date()) => d.toISOString(),
+    unix:    () => Math.floor(Date.now() / 1000),
+  };
+
+  // ── async/process helpers ─────────────────────────────────────
+  const proc = {
+    env:     (k, def = '') => process.env[k] || def,
+    args:    () => process.argv.slice(2),
+    exit:    (code = 0) => process.exit(code),
+    pid:     () => process.pid,
+    memUsage:() => process.memoryUsage(),
+    cpuUsage:() => process.cpuUsage(),
+    platform:() => process.platform,
+    arch:    () => process.arch,
+    version: () => process.version,
+    hrtime:  () => process.hrtime.bigint(),
+    nextTick:(fn) => process.nextTick(fn),
+  };
+
+  // ── http helpers ──────────────────────────────────────────────
+  const http = {
+    fetch: async (url, opts = {}) => {
+      const https = url.startsWith('https') ? require('https') : require('http');
+      return new Promise((resolve, reject) => {
+        const req = https.request(url, { method: opts.method || 'GET', headers: opts.headers || {} }, (res) => {
+          let data = '';
+          res.on('data', chunk => data += chunk);
+          res.on('end', () => resolve({ status: res.statusCode, headers: res.headers, body: data,
+            json: () => JSON.parse(data), text: () => data }));
+        });
+        req.on('error', reject);
+        if (opts.body) req.write(typeof opts.body === 'string' ? opts.body : JSON.stringify(opts.body));
+        req.end();
+      });
+    },
+    get:  async (url, headers = {}) => http.fetch(url, { method: 'GET', headers }),
+    post: async (url, body, headers = {}) => http.fetch(url, { method: 'POST', body, headers: { 'Content-Type': 'application/json', ...headers } }),
+  };
+
+  // ── persist helpers ───────────────────────────────────────────
+  const persist = {
+    save: (name, data) => {
+      const fp = _path.join(process.cwd(), name + '.thysave');
+      _fs.writeFileSync(fp, JSON.stringify(data, null, 2), 'utf8');
+    },
+    load: (name) => {
+      const fp = _path.join(process.cwd(), name + '.thysave');
+      if (!_fs.existsSync(fp)) return null;
+      return JSON.parse(_fs.readFileSync(fp, 'utf8'));
+    },
+    del: (name) => {
+      const fp = _path.join(process.cwd(), name + '.thysave');
+      if (_fs.existsSync(fp)) _fs.unlinkSync(fp);
+    },
+  };
+
+  // ── optimised calculate ───────────────────────────────────────
+  const __thy_calculate = (expr) => {
+    // expr is already a JS expression string – evaluate safely
+    // This is called at runtime for dynamic calculate() statements
+    try {
+      // Use Function constructor for safe, optimisable evaluation
+      return (new Function('Math', \`return (\${expr});\`))(Math);
+    } catch(e) {
+      throw new TypeError('[ThyScript] calculate error: ' + e.message);
+    }
+  };
+
+  return Object.freeze({
+    math, vec, str, arr, obj, io, security, types, time, proc, http, persist,
+    fastFloor, fastAbs, fastMod,
+    __thy_calculate,
+    // convenience top-level aliases
+    print: io.print,
+    len:   (v) => (Array.isArray(v) || typeof v === 'string') ? v.length : Object.keys(v).length,
+    range: arr.range,
+    type:  types.type,
+    hash:  security.hash,
+    sleep: time.sleep,
+    now:   time.now,
+    env:   proc.env,
+    fetch: http.fetch,
+    save:  persist.save,
+    load:  persist.load,
+  });
+})();
+
+// Convenience globals injected from stdlib
+const __thy_print  = __thy_stdlib.print;
+const __thy_len    = __thy_stdlib.len;
+const __thy_range  = __thy_stdlib.range;
+const __thy_sleep  = __thy_stdlib.time.sleep;
+
+function __thy_stringify(v) {
+  if (v === null) return 'null';
+  if (v === undefined) return 'undefined';
+  if (typeof v === 'object') { try { return JSON.stringify(v); } catch(_) { return String(v); } }
+  return String(v);
+}
+
+// Shared typed buffers for hot numeric paths
+const __thy_f64 = new Float64Array(256);
+const __thy_i32 = new Int32Array(256);
+const __thy_sab = typeof SharedArrayBuffer !== 'undefined' ? new SharedArrayBuffer(4096) : null;
+`.trimStart();
+  }
+
+  // ─── entry point ─────────────────────────────────────────────────────────────
+
+  /**
+   * Generate optimised JS source from a ThyScript AST.
+   * @param {Object} ast  – The parsed AST (Program node)
+   * @returns {string}    – Runnable Node.js JavaScript source
+   */
+  generate(ast) {
+    // Unwrap { ast, errors } if returned directly from parser
+    if (ast && ast.ast && typeof ast.ast === 'object') {
+      ast = ast.ast;
+    }
+
+    // Reset state
+    this._indent = 0;
+    this._uid = 0;
+    this._expressAppDeclared = false;
+    this._readlineDeclared = false;
+    this._tfDeclared = false;
+    this._matterDeclared = false;
+    this._requires = new Set();
+    this._headerLines = [];
+    this._bodyLines = [];
+
+    // Walk the AST
+    this._genNode(ast);
+
+    // Build final source
+    const parts = [
+      "'use strict';",
+      '// Auto-generated by ThyScript CodeGenerator – do not edit manually',
+      this._buildStdlib(),
+    ];
+
+    // Extra requires collected during generation
+    for (const pkg of this._requires) {
+      parts.push(`const ${this._requireVarName(pkg)} = (() => { try { return require('${pkg}'); } catch(_) { return null; } })();`);
+    }
+
+    if (this._expressAppDeclared) {
+      parts.push(`const __thy_express = (() => { try { return require('express'); } catch(_) { return null; } })();`);
+      parts.push(`const __thy_app = __thy_express ? __thy_express() : null;`);
+    }
+
+    parts.push('');
+    parts.push(this._bodyLines.join('\n'));
+
+    return parts.join('\n');
+  }
+
+  _requireVarName(pkg) {
+    return '__thy_req_' + pkg.replace(/[^a-zA-Z0-9]/g, '_');
+  }
+
+  // ─── node dispatcher ─────────────────────────────────────────────────────────
+
+  _genNode(node) {
+    if (!node) return 'undefined';
+    switch (node.type) {
+      case 'Program':          return this._genProgram(node);
+      case 'VarDecl':          return this._genVarDecl(node);
+      case 'DestructureDecl':  return this._genDestructureDecl(node);
+      case 'PrintStmt':        return this._genPrintStmt(node);
+      case 'ClassDecl':        return this._genClassDecl(node);
+      case 'HtmlClassDecl':    return this._genHtmlClassDecl(node);
+      case 'IfStmt':           return this._genIfStmt(node);
+      case 'WhileStmt':        return this._genWhileStmt(node);
+      case 'ForStmt':          return this._genForStmt(node);
+      case 'AddStmt':          return this._genAddStmt(node);
+      case 'ChangeStmt':       return this._genChangeStmt(node);
+      case 'CalculateStmt':    return this._genCalculateStmt(node);
+      case 'InputStmt':        return this._genInputStmt(node);
+      case 'SaveStmt':         return this._genSaveStmt(node);
+      case 'FreeStmt':         return this._genFreeStmt(node);
+      case 'FunctionDecl':     return this._genFunctionDecl(node);
+      case 'ReturnStmt':       return this._genReturnStmt(node);
+      case 'TryCatch':         return this._genTryCatch(node);
+      case 'ImportDecl':       return this._genImportDecl(node);
+      case 'ExportDecl':       return this._genExportDecl(node);
+      case 'ServerDecl':       return this._genServerDecl(node);
+      case 'RouteDecl':        return this._genRouteDecl(node);
+      case 'ComponentDecl':    return this._genComponentDecl(node);
+      case 'NeuralDecl':       return this._genNeuralDecl(node);
+      case 'PhysicsDecl':      return this._genPhysicsDecl(node);
+      case 'ParallelDecl':     return this._genParallelDecl(node);
+      case 'StreamDecl':       return this._genStreamDecl(node);
+      case 'BreakStmt':        return this._emit('break;');
+      case 'ContinueStmt':     return this._emit('continue;');
+      case 'ThrowStmt':        return this._emit(`throw ${this._genExpr(node.argument || node.value)};`);
+      case 'ExprStmt':         return this._emit(`${this._genExpr(node.expression)};`);
+      case 'ExpressionStmt':   return this._emit(`${this._genExpr(node.expression)};`);
+      case 'Block':            return node.body.forEach(n => this._genNode(n));
+      case 'SwitchStmt':       return this._genSwitchStmt(node);
+      case 'MatchStmt':        return this._genMatchStmt(node);
+      case 'AwaitExpr':        return this._genExpr(node); // handled in expr
+      default:
+        // Fallback: try to generate as expression statement
+        try {
+          const expr = this._genExpr(node);
+          if (expr && expr !== 'undefined') this._emit(`${expr};`);
+        } catch (_) {
+          this._emit(`/* [ThyScript] unhandled node type: ${node.type} */`);
+        }
+    }
+  }
+
+  // ─── program ─────────────────────────────────────────────────────────────────
+
+  _genProgram(node) {
+    this._emit('// ── program body ──────────────────────────────────────────────');
+    this._emit('(async () => {');
+    this._push();
+    for (const stmt of (node.body || [])) {
+      this._genNode(stmt);
+    }
+    this._pop();
+    this._emit('})().catch(e => { console.error("[ThyScript Runtime Error]", e); process.exit(1); });');
+  }
+
+  // ─── variable declaration ────────────────────────────────────────────────────
+
+  _genVarDecl(node) {
+    // `const table x = 0` → `let x = 0;`
+    // Always use `let` so ThyScript variables are mutable by default
+    const name = node.name;
+    const init = node.init != null ? this._genExpr(node.init) : 'undefined';
+    this._emit(`let ${name} = ${init};`);
+  }
+
+  // ─── destructuring declaration ──────────────────────────────────────────────
+
+  _genDestructureDecl(node) {
+    // `const table [a, b, ...rest] = init`  →  `let [a, b, ...rest] = init;`
+    // `const table {x, y: z} = init`       →  `let { x, y: z } = init;`
+    const init = this._genExpr(node.init);
+    if (node.kind === 'array') {
+      const elems = (node.targets || []).map(t => (t.rest ? `...${t.name}` : t.name));
+      this._emit(`let [${elems.join(', ')}] = ${init};`);
+    } else {
+      const props = (node.targets || []).map(({ key, alias, default: def }) => {
+        const target = key === alias ? key : `${key}: ${alias}`;
+        return def != null ? `${target} = ${this._genExpr(def)}` : target;
+      });
+      this._emit(`let { ${props.join(', ')} } = ${init};`);
+    }
+  }
+
+  // ─── print ───────────────────────────────────────────────────────────────────
+
+  _genPrintStmt(node) {
+    const args = (node.args || [node.value]).map(a => this._genExpr(a)).join(', ');
+    this._emit(`__thy_print(${args});`);
+  }
+
+  // ─── class ───────────────────────────────────────────────────────────────────
+
+  _genBlockOrList(body) {
+    if (!body) return;
+    if (Array.isArray(body)) {
+      for (const s of body) this._genNode(s);
+    } else if (body.type === 'Block') {
+      for (const s of (body.body || [])) this._genNode(s);
+    } else {
+      this._genNode(body);
+    }
+  }
+
+  // ─── class ───────────────────────────────────────────────────────────────────
+
+  _genClassDecl(node) {
+    const name    = node.name;
+    const parent  = node.superClass ? ` extends ${node.superClass}` : '';
+    const access  = node.access || 'public';   // public / private
+    this._emit(`// [${access}] class`);
+    this._emit(`class ${name}${parent} {`);
+    this._push();
+
+    const stmts = Array.isArray(node.body) ? node.body : (node.body && node.body.body ? node.body.body : []);
+    const props = [];
+    const methods = [...(node.methods || [])];
+    const constructorStmts = [...(node.constructorBody || [])];
+
+    for (const stmt of stmts) {
+      if (stmt.type === 'VarDecl') {
+        props.push(stmt);
+      } else if (stmt.type === 'FunctionDecl') {
+        methods.push(stmt);
+      } else {
+        constructorStmts.push(stmt);
+      }
+    }
+
+    this._emit(`constructor(${(node.constructorParams || []).join(', ')}) {`);
+    this._push();
+    if (node.superClass) this._emit('super();');
+    for (const prop of props) {
+      const init = prop.init != null ? this._genExpr(prop.init) : 'undefined';
+      this._emit(`this.${prop.name} = ${init};`);
+    }
+    for (const stmt of constructorStmts) this._genNode(stmt);
+    this._pop();
+    this._emit('}');
+
+    const propNames = props.map(p => p.name);
+    const methodNames = methods.map(m => m.name);
+    for (const method of methods) {
+      this._genMethod(method, propNames, methodNames);
+    }
+    for (const prop of (node.staticProps || [])) {
+      this._emit(`static ${prop.name} = ${this._genExpr(prop.value)};`);
+    }
+    this._pop();
+    this._emit('}');
+  }
+
+  _genMethod(method, classProps = [], classMethods = []) {
+    const isStatic = method.isStatic ? 'static ' : '';
+    const isAsync  = method.isAsync  ? 'async '  : '';
+    const name     = method.name;
+    const params   = (method.params || []).map(p => typeof p === 'string' ? p : p.name).join(', ');
+    this._emit(`${isStatic}${isAsync}${name}(${params}) {`);
+    this._push();
+    if (!isStatic && classMethods.length > 0) {
+      for (const m of classMethods) {
+        if (m !== name) {
+          this._emit(`const ${m} = (...args) => this.${m}(...args);`);
+        }
+      }
+    }
+    if (!isStatic && classProps.length > 0) {
+      // Destructure class props as mutable lets (allows += inside methods)
+      this._emit('let { ' + classProps.join(', ') + ' } = this;');
+      this._genBlockOrList(method.body);
+      // Write any mutations back to the instance
+      this._emit('Object.assign(this, { ' + classProps.join(', ') + ' });');
+    } else {
+      this._genBlockOrList(method.body);
+    }
+    this._pop();
+    this._emit('}');
+  }
+
+  // ─── HTML class (express route serving HTML) ──────────────────────────────────
+
+  _genHtmlClassDecl(node) {
+    this._expressAppDeclared = true;
+    const route   = node.route  || `/${node.name}`;
+    const name    = (node.name || 'html_page').replace(/[^a-zA-Z0-9_]/g, '_');
+    const safeHtml = (node.html || '').replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\${/g, '\\${');
+    this._emit(`// HtmlClass: ${node.name}`);
+    this._emit(`const __html_${name} = \`${safeHtml}\`;`);
+    this._emit(`if (typeof response !== 'undefined' && response && typeof response.send === 'function') {`);
+    this._push();
+    this._emit(`response.setHeader('Content-Type', 'text/html; charset=utf-8');`);
+    this._emit(`response.send(__html_${name});`);
+    this._pop();
+    this._emit(`} else if (typeof __thy_app !== 'undefined' && __thy_app) {`);
+    this._push();
+    this._emit(`__thy_app.get('${route}', (req, res) => {`);
+    this._push();
+    this._emit(`res.setHeader('Content-Type', 'text/html; charset=utf-8');`);
+    this._emit(`res.send(__html_${name});`);
+    this._pop();
+    this._emit(`});`);
+    this._pop();
+    this._emit(`}`);
+  }
+
+  // ─── if / elif / else ────────────────────────────────────────────────────────
+
+  _genIfStmt(node) {
+    const cond = this._genExpr(node.condition || node.test);
+    this._emit(`if (${cond}) {`);
+    this._push();
+    this._genBlockOrList(node.consequent);
+    this._pop();
+    const alternates = node.alternates || node.elseifs || [];
+    if (alternates.length > 0) {
+      for (const alt of alternates) {
+        const altCond = this._genExpr(alt.condition || alt.test);
+        this._emit(`} else if (${altCond}) {`);
+        this._push();
+        this._genBlockOrList(alt.body || alt.consequent);
+        this._pop();
+      }
+    }
+    if (node.alternate) {
+      this._emit('} else {');
+      this._push();
+      this._genBlockOrList(node.alternate);
+      this._pop();
+    }
+    this._emit('}');
+  }
+
+  // ─── while ───────────────────────────────────────────────────────────────────
+
+  _genWhileStmt(node) {
+    const cond = this._genExpr(node.condition || node.test);
+    this._emit(`while (${cond}) {`);
+    this._push();
+    this._genBlockOrList(node.body);
+    this._pop();
+    this._emit('}');
+  }
+
+  // ─── for ─────────────────────────────────────────────────────────────────────
+
+  _genForStmt(node) {
+    if (node.style === 'range' || node.to != null) {
+      const varName = node.var || node.variable;
+      const from_   = this._genExpr(node.from || { type: 'Literal', value: 0 });
+      const to_     = this._genExpr(node.to);
+      const step_   = node.step ? this._genExpr(node.step) : '1';
+      this._emit(`for (let ${varName} = ${from_}; ${varName} < ${to_}; ${varName} += ${step_}) {`);
+    } else {
+      const varName  = node.var || node.variable || (node.left && node.left.name ? node.left.name : 'item');
+      const iterExpr = this._genExpr(node.iterable || node.right);
+      this._emit(`for (const ${varName} of ${iterExpr}) {`);
+    }
+    this._push();
+    this._genBlockOrList(node.body);
+    this._pop();
+    this._emit('}');
+  }
+
+  // ─── add stmt  `add 10 in x` ─────────────────────────────────────────────────
+
+  _genAddStmt(node) {
+    const target = typeof node.target === 'string' ? node.target : this._genExpr(node.target);
+    const value  = this._genExpr(node.value);
+    this._emit(`if (Array.isArray(${target})) { ${target}.push(${value}); } else { ${target} += ${value}; }`);
+  }
+
+  // ─── change stmt  `change(x to(0))` ─────────────────────────────────────────
+
+  _genChangeStmt(node) {
+    const target = typeof node.target === 'string' ? node.target : this._genExpr(node.target);
+    const value  = this._genExpr(node.value);
+    this._emit(`${target} = ${value};`);
+  }
+
+  // ─── calculate  `calculate(x + y)` ───────────────────────────────────────────
+
+  _genCalculateStmt(node) {
+    if (node.result) {
+      // calculate(expr) stored in a variable
+      const expr   = this._genExpr(node.expression);
+      const target = node.result;
+      this._emit(`${target} = (${expr});`);
+    } else {
+      const expr = this._genExpr(node.expression);
+      this._emit(`(${expr});`);
+    }
+  }
+
+  // ─── input  `input(prompt)` ──────────────────────────────────────────────────
+
+  _genInputStmt(node) {
+    if (!this._readlineDeclared) {
+      this._readlineDeclared = true;
+      this._emit(`const __thy_rl = require('readline').createInterface({ input: process.stdin, output: process.stdout });`);
+      this._emit(`const __thy_input = (prompt) => new Promise(resolve => __thy_rl.question(prompt, resolve));`);
+    }
+    const prompt = node.prompt ? this._genExpr(node.prompt) : "''";
+    if (node.result) {
+      this._emit(`const ${node.result} = await __thy_input(${prompt});`);
+    } else {
+      this._emit(`await __thy_input(${prompt});`);
+    }
+  }
+
+  // ─── save  `save(var)` ───────────────────────────────────────────────────────
+
+  _genSaveStmt(node) {
+    const varName = typeof node.value === 'string' ? node.value : this._genExpr(node.value);
+    const filename = node.filename ? this._genExpr(node.filename) : `'${varName}'`;
+    this._emit(`__thy_stdlib.persist.save(${filename}, ${varName});`);
+  }
+
+  // ─── free  `free()` ──────────────────────────────────────────────────────────
+
+  _genFreeStmt(node) {
+    for (const v of (node.vars || (node.value ? [node.value] : []))) {
+      const name = typeof v === 'string' ? v : this._genExpr(v);
+      this._emit(`${name} = null; // GC hint`);
+    }
+    if (node.gc) {
+      this._emit(`if (global.gc) global.gc(); // expose-gc`);
+    }
+  }
+
+  // ─── function declaration ────────────────────────────────────────────────────
+
+  _genFunctionDecl(node) {
+    const name    = node.name;
+    const params  = (node.params || []).map(p => {
+      if (typeof p === 'string') return p;
+      if (p.default != null) return `${p.name} = ${this._genExpr(p.default)}`;
+      if (p.rest) return `...${p.name}`;
+      return p.name;
+    }).join(', ');
+    const isAsync = node.isAsync !== false ? 'async ' : '';
+    const isGen   = node.isGenerator ? '*' : '';
+    this._emit(`${isAsync}function${isGen} ${name}(${params}) {`);
+    this._push();
+    // V8 hint: mark as optimisable by keeping hot paths monomorphic
+    this._emit(`// [ThyScript JIT] function "${name}" – V8 optimisation target`);
+    this._genBlockOrList(node.body);
+    this._pop();
+    this._emit('}');
+  }
+
+  // ─── return ──────────────────────────────────────────────────────────────────
+
+  _genReturnStmt(node) {
+    const val = node.argument != null ? node.argument : node.value;
+    if (val != null) {
+      this._emit(`return ${this._genExpr(val)};`);
+    } else {
+      this._emit('return;');
+    }
+  }
+
+  // ─── try / catch / finally ───────────────────────────────────────────────────
+
+  _genTryCatch(node) {
+    this._emit('try {');
+    this._push();
+    this._genBlockOrList(node.tryBody || node.block);
+    this._pop();
+    if (node.catchBody || node.handler) {
+      const errName = node.catchVar || (node.handler && node.handler.param ? node.handler.param.name : '__thy_err');
+      this._emit(`} catch (${errName}) {`);
+      this._push();
+      this._genBlockOrList(node.catchBody || (node.handler && node.handler.body));
+      this._pop();
+    }
+    if (node.finallyBody || node.finalizer) {
+      this._emit('} finally {');
+      this._push();
+      this._genBlockOrList(node.finallyBody || node.finalizer);
+      this._pop();
+    }
+    this._emit('}');
+  }
+
+  // ─── import ──────────────────────────────────────────────────────────────────
+
+  _genImportDecl(node) {
+    const src = node.source;
+    if (node.default) {
+      this._emit(`const ${node.default} = require(${JSON.stringify(src)});`);
+    } else if (node.named && node.named.length) {
+      const bindings = node.named.map(n => typeof n === 'string' ? n : `${n.imported}: ${n.local}`).join(', ');
+      this._emit(`const { ${bindings} } = require(${JSON.stringify(src)});`);
+    } else if (node.namespace) {
+      this._emit(`const ${node.namespace} = require(${JSON.stringify(src)});`);
+    } else {
+      this._emit(`require(${JSON.stringify(src)});`);
+    }
+  }
+
+  // ─── export ──────────────────────────────────────────────────────────────────
+
+  _genExportDecl(node) {
+    if (node.default) {
+      this._emit(`module.exports = ${this._genExpr(node.value)};`);
+    } else if (node.named) {
+      const bindings = (node.named || []).map(n => typeof n === 'string' ? n : `${n}: ${n}`).join(', ');
+      this._emit(`Object.assign(module.exports, { ${bindings} });`);
+    }
+  }
+
+  // ─── server declaration ──────────────────────────────────────────────────────
+
+  _genServerDecl(node) {
+    this._expressAppDeclared = true;
+    const port    = node.port ? this._genExpr(node.port) : '3000';
+    const host    = node.host ? this._genExpr(node.host) : "'0.0.0.0'";
+    const name    = node.name || '__thy_server';
+    this._emit(`// [ThyScript] Server declaration`);
+    this._emit(`if (!__thy_express) throw new Error('[ThyScript] express is not installed. Run: npm install express');`);
+    this._emit(`__thy_app.use(require('express').json());`);
+    this._emit(`__thy_app.use(require('express').urlencoded({ extended: true }));`);
+    // Body
+    this._genBlockOrList(node.body);
+    // listen
+    this._emit(`const ${name} = __thy_app.listen(${port}, ${host}, () => {`);
+    this._push();
+    this._emit(`__thy_print(\`[ThyScript] Server running on http://\${${host}}:\${${port}}\`);`);
+    this._pop();
+    this._emit(`});`);
+    // Socket.IO support
+    if (node.socket) {
+      this._emit(`const __thy_io = (() => { try { const { Server } = require('socket.io'); return new Server(${name}); } catch(_) { return null; } })();`);
+      this._emit(`if (__thy_io) { __thy_print('[ThyScript] Socket.IO attached'); }`);
+    }
+  }
+
+  // ─── route declaration ───────────────────────────────────────────────────────
+
+  _genRouteDecl(node) {
+    this._expressAppDeclared = true;
+    const method  = (node.method || 'get').toLowerCase();
+    const path_   = this._genExpr(node.path);
+    const reqVar  = node.reqVar  || 'request';
+    const resVar  = node.resVar  || 'response';
+    const isAsync = node.isAsync !== false;
+    this._emit(`if (__thy_app) {`);
+    this._push();
+    this._emit(`__thy_app.${method}(${path_}, ${isAsync ? 'async ' : ''}(${reqVar}, ${resVar}) => {`);
+    this._push();
+    this._emit(`const req = ${reqVar}; const res = ${resVar};`);
+    this._genBlockOrList(node.body);
+    this._pop();
+    this._emit(`});`);
+    this._pop();
+    this._emit(`}`);
+  }
+
+  // ─── component (React-like) ──────────────────────────────────────────────────
+
+  _genComponentDecl(node) {
+    const name   = node.name;
+    const props  = (node.props || []).join(', ');
+    this._emit(`// [ThyScript] Component: ${name}`);
+    this._emit(`function ${name}({ ${props} }) {`);
+    this._push();
+    this._emit(`// state`);
+    for (const s of (node.state || [])) {
+      this._emit(`let __state_${s.name} = ${this._genExpr(s.init)};`);
+    }
+    this._emit(`// render`);
+    this._emit(`const render = () => {`);
+    this._push();
+    this._genBlockOrList(node.body);
+    this._pop();
+    this._emit(`};`);
+    this._emit(`render();`);
+    this._emit(`return { render, getState: () => ({ ${(node.state || []).map(s => s.name + ': __state_' + s.name).join(', ')} }) };`);
+    this._pop();
+    this._emit(`}`);
+  }
+
+  // ─── neural declaration (TensorFlow.js) ─────────────────────────────────────
+
+  _genNeuralDecl(node) {
+    if (!this._tfDeclared) {
+      this._tfDeclared = true;
+      this._emit(`const __thy_tf = (() => { try { return require('@tensorflow/tfjs-node'); } catch(_) { try { return require('@tensorflow/tfjs'); } catch(__) { return null; } } })();`);
+    }
+    const name    = node.name || '__thy_model';
+    const layers  = node.layers || [];
+    const optName = (node.optimizer || 'adam').toLowerCase();
+    const loss    = node.loss    || 'meanSquaredError';
+    const lr      = node.learningRate || 0.001;
+
+    this._emit(`// [ThyScript] Neural network: ${name}`);
+    this._emit(`let ${name} = null;`);
+    this._emit(`if (__thy_tf) {`);
+    this._push();
+    this._emit(`${name} = __thy_tf.sequential();`);
+    for (const layer of layers) {
+      const ltype   = layer.kind || 'dense';
+      const units   = layer.units || 1;
+      const activ   = layer.activation || 'relu';
+      const inputSh = layer.inputShape ? `, inputShape: [${layer.inputShape}]` : '';
+      this._emit(`${name}.add(__thy_tf.layers.${ltype}({ units: ${units}, activation: '${activ}'${inputSh} }));`);
+    }
+    const optStr = optName === 'adam' ?
+      `__thy_tf.train.adam(${lr})` :
+      optName === 'sgd' ? `__thy_tf.train.sgd(${lr})` :
+      `__thy_tf.train.${optName}(${lr})`;
+    this._emit(`${name}.compile({ optimizer: ${optStr}, loss: '${loss}', metrics: ['accuracy'] });`);
+    this._emit(`__thy_print('[ThyScript Neural] Model "${name}" compiled');`);
+    this._pop();
+    this._emit(`} else { __thy_print('[ThyScript Neural] TensorFlow.js not installed – model "${name}" skipped'); }`);
+
+    // train / predict helpers
+    this._emit(`const __train_${name} = async (xs, ys, epochs = 10, batchSize = 32) => {`);
+    this._push();
+    this._emit(`if (!${name}) return null;`);
+    this._emit(`const xsTensor = __thy_tf.tensor(xs);`);
+    this._emit(`const ysTensor = __thy_tf.tensor(ys);`);
+    this._emit(`const hist = await ${name}.fit(xsTensor, ysTensor, { epochs, batchSize });`);
+    this._emit(`xsTensor.dispose(); ysTensor.dispose();`);
+    this._emit(`return hist;`);
+    this._pop();
+    this._emit(`};`);
+
+    this._emit(`const __predict_${name} = (xs) => {`);
+    this._push();
+    this._emit(`if (!${name}) return null;`);
+    this._emit(`return ${name}.predict(__thy_tf.tensor(xs)).arraySync();`);
+    this._pop();
+    this._emit(`};`);
+  }
+
+  // ─── physics declaration (matter.js) ────────────────────────────────────────
+
+  _genPhysicsDecl(node) {
+    if (!this._matterDeclared) {
+      this._matterDeclared = true;
+      this._emit(`const __thy_matter = (() => { try { return require('matter-js'); } catch(_) { return null; } })();`);
+    }
+    const name    = node.name || '__thy_physics';
+    const gravity = node.gravity != null ? node.gravity : 1;
+    const bodies  = node.bodies || [];
+
+    this._emit(`// [ThyScript] Physics world: ${name}`);
+    this._emit(`let ${name} = null;`);
+    this._emit(`if (__thy_matter) {`);
+    this._push();
+    this._emit(`const { Engine, World, Bodies, Runner } = __thy_matter;`);
+    this._emit(`const __engine_${name} = Engine.create({ gravity: { y: ${gravity} } });`);
+    this._emit(`${name} = __engine_${name}.world;`);
+    for (const body of bodies) {
+      const bname  = body.name || this._uid_();
+      const btype  = body.kind || 'rectangle';
+      const bx     = body.x || 0;
+      const by     = body.y || 0;
+      const bw     = body.width  || 100;
+      const bh     = body.height || 100;
+      const bopts  = body.isStatic ? ', { isStatic: true }' : '';
+      this._emit(`const __body_${bname} = Bodies.${btype}(${bx}, ${by}, ${bw}, ${bh}${bopts});`);
+      this._emit(`World.add(${name}, __body_${bname});`);
+    }
+    this._emit(`Runner.run(__engine_${name});`);
+    this._emit(`__thy_print('[ThyScript Physics] World "${name}" running');`);
+    this._pop();
+    this._emit(`} else { __thy_print('[ThyScript Physics] matter-js not installed'); }`);
+  }
+
+  // ─── parallel declaration (worker_threads) ───────────────────────────────────
+
+  _genParallelDecl(node) {
+    this._emit(`// [ThyScript] Parallel execution – worker_threads`);
+    const { Worker, isMainThread, parentPort, workerData } = require('worker_threads');
+    const tasks   = node.tasks || [];
+    const workers = node.workers || 4;
+    const name    = node.name || '__thy_parallel';
+
+    this._emit(`const { Worker: __W, isMainThread: __IMT } = require('worker_threads');`);
+    this._emit(`const __thy_parallel_run = async (fn, data, nWorkers = ${workers}) => {`);
+    this._push();
+    this._emit(`const chunks = [];`);
+    this._emit(`const chunkSize = Math.ceil(data.length / nWorkers);`);
+    this._emit(`for (let i = 0; i < data.length; i += chunkSize) chunks.push(data.slice(i, i + chunkSize));`);
+    this._emit(`const code = \`'use strict'; const { parentPort, workerData } = require('worker_threads'); parentPort.postMessage((\${fn.toString()})(workerData));\`;`);
+    this._emit(`const results = await Promise.all(chunks.map(chunk => new Promise((res, rej) => {`);
+    this._push();
+    this._emit(`const w = new __W(code, { eval: true, workerData: chunk });`);
+    this._emit(`w.on('message', res); w.on('error', rej);`);
+    this._pop();
+    this._emit(`})));`);
+    this._emit(`return results.flat();`);
+    this._pop();
+    this._emit(`};`);
+
+    for (const task of tasks) {
+      const tname  = task.name || this._uid_();
+      const tdata  = this._genExpr(task.data || { type: 'Literal', value: [] });
+      this._emit(`const __parallel_result_${tname} = await __thy_parallel_run(${task.fn || 'x => x'}, ${tdata}, ${workers});`);
+    }
+  }
+
+  // ─── stream declaration ──────────────────────────────────────────────────────
+
+  _genStreamDecl(node) {
+    this._emit(`// [ThyScript] Stream`);
+    const name   = node.name || '__thy_stream';
+    const src    = node.source ? this._genExpr(node.source) : "process.stdin";
+    const dest   = node.dest   ? this._genExpr(node.dest)   : "process.stdout";
+    const transforms = node.transforms || [];
+
+    this._emit(`const { Transform: __TransformStream, pipeline: __pipeline } = require('stream');`);
+    this._emit(`const { promisify: __promisify } = require('util');`);
+    this._emit(`const __pipelineAsync = __promisify(__pipeline);`);
+
+    for (const t of transforms) {
+      const tname = t.name || this._uid_();
+      const logic = t.fn   || '(chunk, enc, cb) => cb(null, chunk)';
+      this._emit(`const __transform_${tname} = new __TransformStream({ transform: ${logic} });`);
+    }
+
+    const pipeChain = transforms.length > 0
+      ? [src, ...transforms.map(t => `__transform_${t.name || '__t'}`), dest].join(', ')
+      : `${src}, ${dest}`;
+    this._emit(`await __pipelineAsync(${pipeChain}).catch(e => console.error('[ThyScript Stream]', e));`);
+  }
+
+  // ─── switch ──────────────────────────────────────────────────────────────────
+
+  _genSwitchStmt(node) {
+    const disc = this._genExpr(node.discriminant);
+    this._emit(`switch (${disc}) {`);
+    this._push();
+    for (const c of (node.cases || [])) {
+      if (c.test) {
+        this._emit(`case ${this._genExpr(c.test)}:`);
+      } else {
+        this._emit('default:');
+      }
+      this._push();
+      this._genBlockOrList(c.body);
+      if (!c.fallthrough) this._emit('break;');
+      this._pop();
+    }
+    this._pop();
+    this._emit('}');
+  }
+
+  // ─── match statement (pattern matching) ──────────────────────────────────────
+
+  _genMatchStmt(node) {
+    const disc = this._genExpr(node.discriminant);
+    const tmp  = this._uid_();
+    this._emit(`const ${tmp} = ${disc};`);
+    let first  = true;
+    for (const arm of (node.arms || [])) {
+      const kw = first ? 'if' : '} else if';
+      first = false;
+      if (arm.pattern === '_' || arm.isOtherwise) {
+        this._emit('} else {');
+      } else {
+        const pat = this._genExpr(arm.pattern);
+        this._emit(`${kw} (${tmp} === ${pat}) {`);
+      }
+      this._push();
+      this._genBlockOrList(arm.body);
+      this._pop();
+    }
+    this._emit('}');
+  }
+
+  // ─── expression generator ────────────────────────────────────────────────────
+
+  _genExpr(node) {
+    if (node == null) return 'undefined';
+
+    // Raw string shorthand
+    if (typeof node === 'string') return node;
+    if (typeof node === 'number') return String(node);
+    if (typeof node === 'boolean') return String(node);
+
+    switch (node.type) {
+      case 'Literal':          return this._genLiteral(node);
+      case 'Identifier':       return this._genIdentifier(node);
+      case 'BinaryExpr':       return this._genBinaryExpr(node);
+      case 'UnaryExpr':        return this._genUnaryExpr(node);
+      case 'LogicalExpr':      return this._genLogicalExpr(node);
+      case 'AssignExpr':       return this._genAssignExpr(node);
+      case 'CallExpr':         return this._genCallExpr(node);
+      case 'MemberExpr':       return this._genMemberExpr(node);
+      case 'IndexExpr':        return this._genIndexExpr(node);
+      case 'ArrayExpr':        return this._genArrayExpr(node);
+      case 'ObjectExpr':       return this._genObjectExpr(node);
+      case 'ArrowFunc':
+      case 'ArrowFunctionExpr':return this._genArrowFunc(node);
+      case 'FunctionExpr':     return this._genFunctionExpr(node);
+      case 'ConditionalExpr':  return this._genConditionalExpr(node);
+      case 'TemplateLiteral':  return this._genTemplateLiteral(node);
+      case 'SpreadExpr':       return `...${this._genExpr(node.argument)}`;
+      case 'AwaitExpr':        return `await ${this._genExpr(node.argument)}`;
+      case 'YieldExpr':        return `yield ${this._genExpr(node.argument)}`;
+      case 'NewExpr':          return this._genNewExpr(node);
+      case 'InputExpr':        return `await __thy_input(${node.prompt ? this._genExpr(node.prompt) : "''"})`;
+      case 'TypeofExpr':       return `typeof ${this._genExpr(node.argument)}`;
+      case 'InstanceofExpr':   return `(${this._genExpr(node.left)} instanceof ${this._genExpr(node.right)})`;
+      case 'NullCoalesce':     return `(${this._genExpr(node.left)} ?? ${this._genExpr(node.right)})`;
+      case 'OptionalChain':    return `${this._genExpr(node.object)}?.${this._genExpr(node.property)}`;
+      case 'DeleteExpr':       return `delete ${this._genExpr(node.argument)}`;
+      case 'VoidExpr':         return `void ${this._genExpr(node.argument)}`;
+      case 'SequenceExpr':     return `(${(node.expressions || []).map(e => this._genExpr(e)).join(', ')})`;
+      case 'TaggedTemplate':   return `${this._genExpr(node.tag)}\`${this._genExpr(node.quasi)}\``;
+      case 'CalculateExpr':    return `(${this._genExpr(node.expression)})`;
+      case 'MathExpr':         return this._genMathExpr(node);
+      case 'VectorExpr':       return this._genVectorExpr(node);
+      case 'MatrixExpr':       return this._genMatrixExpr(node);
+
+      default:
+        // Try to coerce unknown expression nodes
+        if (node.value !== undefined && Object.keys(node).length <= 3) return this._genLiteral(node);
+        return `/* unknown expr: ${node.type} */ undefined`;
+    }
+  }
+
+  _genLiteral(node) {
+    const v = node.value;
+    if (v === null)      return 'null';
+    if (v === undefined) return 'undefined';
+    if (typeof v === 'string') return `'${this._escStr(v)}'`;
+    if (typeof v === 'boolean') return String(v);
+    if (typeof v === 'number') return String(v);
+    // Array / object literals embedded
+    try { return JSON.stringify(v); } catch(_) { return String(v); }
+  }
+
+  _genIdentifier(node) {
+    // Map ThyScript built-in identifiers to stdlib aliases
+    const aliases = {
+      'true':  'true',
+      'false': 'false',
+      'null':  'null',
+      'undefined': 'undefined',
+      'NaN':   'NaN',
+      'Infinity': 'Infinity',
+      'this':  'this',
+      'self':  'this',
+      'super': 'super',
+      'print': '__thy_print',
+      'len':   '__thy_len',
+      'range': '__thy_range',
+      'sleep': '__thy_stdlib.time.sleep',
+      'now':   '__thy_stdlib.time.now',
+      'env':   '__thy_stdlib.proc.env',
+      'fetch': '__thy_stdlib.http.fetch',
+      'save':  '__thy_stdlib.persist.save',
+      'load':  '__thy_stdlib.persist.load',
+    };
+    return aliases[node.name] || node.name;
+  }
+
+  _genBinaryExpr(node) {
+    const l = this._genExpr(node.left);
+    const r = this._genExpr(node.right);
+    const opMap = {
+      '+':   '+',  '-':   '-',  '*':   '*',  '/':   '/',
+      '%':   '%',  '**':  '**', '&':   '&',  '|':   '|',
+      '^':   '^',  '<<':  '<<', '>>':  '>>',
+      '==':  '===', '!=': '!==', '<':  '<',  '>':   '>',
+      '<=':  '<=', '>=':  '>=',
+      'and': '&&', 'or':  '||',
+      'is':  '===', 'isnt': '!==',
+    };
+    const rawOp = node.operator || node.op;
+    const op = opMap[rawOp] || rawOp;
+
+    if (this.options.optimise && (op === '+' || op === '-' || op === '*' || op === '/')) {
+      return `(${l} ${op} ${r})`;
+    }
+    return `(${l} ${op} ${r})`;
+  }
+
+  _genUnaryExpr(node) {
+    const opMap = { 'not': '!', '!': '!', '-': '-', '+': '+', '~': '~', '++': '++', '--': '--' };
+    const rawOp = node.operator || node.op;
+    const op  = opMap[rawOp] || rawOp;
+    const arg = this._genExpr(node.argument || node.operand);
+    // Word-like unary operators (typeof/await/yield/delete/void) need a space.
+    const wordOps = new Set(['typeof', 'await', 'yield', 'delete', 'void', 'new', 'instanceof', 'not', 'in']);
+    const sep = wordOps.has(op) ? ' ' : '';
+    return node.prefix !== false ? `${op}${sep}${arg}` : `${arg}${op}`;
+  }
+
+  _genLogicalExpr(node) {
+    const l  = this._genExpr(node.left);
+    const r  = this._genExpr(node.right);
+    const opMap = { 'and': '&&', 'or': '||', '&&': '&&', '||': '||' };
+    const rawOp = node.operator || node.op;
+    const op = opMap[rawOp] || rawOp;
+    return `(${l} ${op} ${r})`;
+  }
+
+  _genAssignExpr(node) {
+    const l  = this._genExpr(node.left);
+    const r  = this._genExpr(node.right);
+    const op = node.operator || node.op || '=';
+    return `${l} ${op} ${r}`;
+  }
+
+  _genCallExpr(node) {
+    const callee = this._genExpr(node.callee);
+    const args   = (node.args || node.arguments || []).map(a => this._genExpr(a)).join(', ');
+    const opt    = node.optional ? '?.' : '';
+
+    // Intercept ThyScript built-in calls and map them
+    const builtins = {
+      'print':      `__thy_print(${args})`,
+      'len':        `__thy_len(${args})`,
+      'range':      `__thy_range(${args})`,
+      'sleep':      `await __thy_stdlib.time.sleep(${args})`,
+      'fetch':      `await __thy_stdlib.http.fetch(${args})`,
+      'hash':       `__thy_stdlib.security.hash(${args})`,
+      'save':       `__thy_stdlib.persist.save(${args})`,
+      'load':       `__thy_stdlib.persist.load(${args})`,
+      'type':       `__thy_stdlib.types.type(${args})`,
+      'int':        `parseInt(${args})`,
+      'float':      `parseFloat(${args})`,
+      'str':        `String(${args})`,
+      'bool':       `Boolean(${args})`,
+      'abs':        `Math.abs(${args})`,
+      'sqrt':       `Math.sqrt(${args})`,
+      'floor':      `Math.floor(${args})`,
+      'ceil':       `Math.ceil(${args})`,
+      'round':      `Math.round(${args})`,
+      'min':        `Math.min(${args})`,
+      'max':        `Math.max(${args})`,
+      'pow':        `Math.pow(${args})`,
+      'random':     `Math.random()`,
+      'input':      `await __thy_input(${args})`,
+      'calculate':  `__thy_stdlib.__thy_calculate(${args})`,
+    };
+
+    const calleeStr = typeof node.callee === 'object' && node.callee.type === 'Identifier'
+      ? node.callee.name : null;
+
+    if (calleeStr && builtins[calleeStr]) return builtins[calleeStr];
+
+    const awaitPrefix = node.isAwaited ? 'await ' : '';
+    return `${awaitPrefix}${callee}${opt}(${args})`;
+  }
+
+  _genMemberExpr(node) {
+    const obj_  = this._genExpr(node.object);
+    const prop  = node.computed
+      ? `[${this._genExpr(node.property)}]`
+      : `.${typeof node.property === 'string' ? node.property : this._genExpr(node.property)}`;
+    const opt   = node.optional ? '?' : '';
+    return `${obj_}${opt}${prop}`;
+  }
+
+  _genIndexExpr(node) {
+    const obj_ = this._genExpr(node.object);
+    const idx  = this._genExpr(node.index);
+    return `${obj_}[${idx}]`;
+  }
+
+  _genArrayExpr(node) {
+    const elems = (node.elements || []).map(e => e ? this._genExpr(e) : '').join(', ');
+    return `[${elems}]`;
+  }
+
+  _genObjectExpr(node) {
+    const props = (node.properties || []).map(p => {
+      if (p.spread) return `...${this._genExpr(p.argument)}`;
+      const key = p.computed ? `[${this._genExpr(p.key)}]` :
+        (typeof p.key === 'string' ? p.key : this._genExpr(p.key));
+      if (p.shorthand) return key;
+      const val = this._genExpr(p.value);
+      if (p.method) {
+        const isAsync = p.async ? 'async ' : '';
+        const isGen   = p.generator ? '*' : '';
+        const params  = (p.params || []).join(', ');
+        return `${isAsync}${isGen}${key}(${params}) { ${val} }`;
+      }
+      return `${key}: ${val}`;
+    }).join(', ');
+    return `{ ${props} }`;
+  }
+
+  _genArrowFunc(node) {
+    const params  = (node.params || []).map(p =>
+      typeof p === 'string' ? p : p.name || this._genExpr(p)).join(', ');
+    const isAsync = node.isAsync ? 'async ' : '';
+    if (node.expression || (node.body && node.body.type !== 'Block' && !Array.isArray(node.body))) {
+      return `${isAsync}(${params}) => ${this._genExpr(node.body)}`;
+    }
+    const lines = [];
+    const savedBody = this._bodyLines;
+    this._bodyLines = lines;
+    const savedIndent = this._indent;
+    this._indent = 0;
+    this._genBlockOrList(node.body);
+    this._bodyLines = savedBody;
+    this._indent = savedIndent;
+    return `${isAsync}(${params}) => { ${lines.join(' ')} }`;
+  }
+
+  _genFunctionExpr(node) {
+    const name    = node.name ? ` ${node.name}` : '';
+    const params  = (node.params || []).map(p =>
+      typeof p === 'string' ? p : p.name || this._genExpr(p)).join(', ');
+    const isAsync = node.isAsync ? 'async ' : '';
+    const lines   = [];
+    const savedBody = this._bodyLines;
+    this._bodyLines = lines;
+    const savedIndent = this._indent;
+    this._indent = 0;
+    this._genBlockOrList(node.body);
+    this._bodyLines = savedBody;
+    this._indent = savedIndent;
+    return `${isAsync}function${name}(${params}) { ${lines.join(' ')} }`;
+  }
+
+  _genConditionalExpr(node) {
+    const test = this._genExpr(node.test);
+    const cons = this._genExpr(node.consequent);
+    const alt  = this._genExpr(node.alternate);
+    return `(${test} ? ${cons} : ${alt})`;
+  }
+
+  _genTemplateLiteral(node) {
+    // node.parts is an array of { type: 'str'|'expr', value }
+    const parts = (node.parts || node.quasis || []).map(p => {
+      if (p.type === 'str' || p.type === 'TemplateElement') {
+        const raw = (p.value && p.value.raw) ? p.value.raw : String(p.value || '');
+        return raw;
+      }
+      // expr part: the embedded expression is stored in p.value (sub-AST)
+      // or p.expression (ESTree-style). Fall back to the part itself.
+      const exprNode = (p.expression != null) ? p.expression : (p.value != null ? p.value : p);
+      return `\${${this._genExpr(exprNode)}}`;
+    });
+    return '`' + parts.join('') + '`';
+  }
+
+  _genNewExpr(node) {
+    let ctorNode = node.callee;
+    let argsList = node.args || node.arguments || [];
+    if (ctorNode && ctorNode.type === 'CallExpr') {
+      argsList = ctorNode.args || ctorNode.arguments || [];
+      ctorNode = ctorNode.callee;
+    }
+    const ctor = this._genExpr(ctorNode);
+    const args = argsList.map(a => this._genExpr(a)).join(', ');
+    return `new ${ctor}(${args})`;
+  }
+
+  // ─── math expression (fast-math) ─────────────────────────────────────────────
+
+  _genMathExpr(node) {
+    // Use typed-array backed computation for numeric heavy paths
+    // V8 will emit efficient machine code for monomorphic Float64 ops
+    const expr = this._genExpr(node.expression);
+    return `(__thy_f64[0] = ${expr}, __thy_f64[0])`;
+  }
+
+  _genVectorExpr(node) {
+    const components = (node.components || []).map(c => this._genExpr(c)).join(', ');
+    return `new Float64Array([${components}])`;
+  }
+
+  _genMatrixExpr(node) {
+    const rows = (node.rows || []).map(r =>
+      `[${(r || []).map(c => this._genExpr(c)).join(', ')}]`
+    ).join(', ');
+    return `[${rows}]`;
+  }
+}
+
+module.exports = CodeGenerator;