tova 0.2.9 → 0.3.1

package/src/stdlib/inline.js

@@ -2,10 +2,10 @@
 // Single source of truth for all inline stdlib code used in code generation.
 // Used by: base-codegen.js, client-codegen.js, bin/tova.js
 
-export const RESULT_OPTION = `function Ok(value) { return Object.freeze({ __tag: "Ok", value, map(fn) { return Ok(fn(value)); }, flatMap(fn) { const r = fn(value); if (r && r.__tag) return r; throw new Error("flatMap callback must return Ok/Err"); }, unwrap() { return value; }, unwrapOr(_) { return value; }, expect(_) { return value; }, isOk() { return true; }, isErr() { return false; }, mapErr(_) { return this; }, unwrapErr() { throw new Error("Called unwrapErr on Ok"); }, or(_) { return this; }, and(other) { return other; } }); }
-function Err(error) { return Object.freeze({ __tag: "Err", error, map(_) { return this; }, flatMap(_) { return this; }, unwrap() { throw new Error("Called unwrap on Err: " + (typeof error === "object" ? JSON.stringify(error) : error)); }, unwrapOr(def) { return def; }, expect(msg) { throw new Error(msg); }, isOk() { return false; }, isErr() { return true; }, mapErr(fn) { return Err(fn(error)); }, unwrapErr() { return error; }, or(other) { return other; }, and(_) { return this; } }); }
-function Some(value) { return Object.freeze({ __tag: "Some", value, map(fn) { return Some(fn(value)); }, flatMap(fn) { const r = fn(value); if (r && r.__tag) return r; throw new Error("flatMap callback must return Some/None"); }, unwrap() { return value; }, unwrapOr(_) { return value; }, expect(_) { return value; }, isSome() { return true; }, isNone() { return false; }, or(_) { return this; }, and(other) { return other; }, filter(pred) { return pred(value) ? this : None; } }); }
-const None = Object.freeze({ __tag: "None", map(_) { return None; }, flatMap(_) { return None; }, unwrap() { throw new Error("Called unwrap on None"); }, unwrapOr(def) { return def; }, expect(msg) { throw new Error(msg); }, isSome() { return false; }, isNone() { return true; }, or(other) { return other; }, and(_) { return None; }, filter(_) { return None; } });`;
+export const RESULT_OPTION = `function Ok(value) { return Object.freeze({ __tag: "Ok", value, map(fn) { return Ok(fn(value)); }, flatMap(fn) { const r = fn(value); if (r && r.__tag) return r; throw new Error("flatMap callback must return Ok/Err"); }, andThen(fn) { return this.flatMap(fn); }, unwrap() { return value; }, unwrapOr(_) { return value; }, expect(_) { return value; }, isOk() { return true; }, isErr() { return false; }, mapErr(_) { return this; }, unwrapErr() { throw new Error("Called unwrapErr on Ok"); }, or(_) { return this; }, and(other) { return other; }, context(_) { return this; } }); }
+function Err(error) { return Object.freeze({ __tag: "Err", error, map(_) { return this; }, flatMap(_) { return this; }, andThen(_) { return this; }, unwrap() { throw new Error("Called unwrap on Err: " + (typeof error === "object" ? JSON.stringify(error) : error)); }, unwrapOr(def) { return def; }, expect(msg) { throw new Error(msg); }, isOk() { return false; }, isErr() { return true; }, mapErr(fn) { return Err(fn(error)); }, unwrapErr() { return error; }, or(other) { return other; }, and(_) { return this; }, context(msg) { const inner = typeof error === "object" ? JSON.stringify(error) : String(error); return Err(msg + " \\u2192 caused by: " + inner); } }); }
+function Some(value) { return Object.freeze({ __tag: "Some", value, map(fn) { return Some(fn(value)); }, flatMap(fn) { const r = fn(value); if (r && r.__tag) return r; throw new Error("flatMap callback must return Some/None"); }, andThen(fn) { return this.flatMap(fn); }, unwrap() { return value; }, unwrapOr(_) { return value; }, expect(_) { return value; }, isSome() { return true; }, isNone() { return false; }, or(_) { return this; }, and(other) { return other; }, filter(pred) { return pred(value) ? this : None; } }); }
+const None = Object.freeze({ __tag: "None", map(_) { return None; }, flatMap(_) { return None; }, andThen(_) { return None; }, unwrap() { throw new Error("Called unwrap on None"); }, unwrapOr(def) { return def; }, expect(msg) { throw new Error(msg); }, isSome() { return false; }, isNone() { return true; }, or(other) { return other; }, and(_) { return None; }, filter(_) { return None; } });`;
 
 export const PROPAGATE = `function __propagate(val) {
   if (val && val.__tag === "Err") throw { __tova_propagate: true, value: val };
@@ -25,8 +25,8 @@ export const BUILTIN_FUNCTIONS = {
   sorted: `function sorted(a, k) { const c = [...a]; if (k) c.sort((x, y) => { const kx = k(x), ky = k(y); return kx < ky ? -1 : kx > ky ? 1 : 0; }); else c.sort((x, y) => x < y ? -1 : x > y ? 1 : 0); return c; }`,
   reversed: `function reversed(a) { return [...a].reverse(); }`,
   zip: `function zip(...as) { if (as.length === 0) return []; const m = Math.min(...as.map(a => a.length)); const r = []; for (let i = 0; i < m; i++) r.push(as.map(a => a[i])); return r; }`,
-  min: `function min(a) { return a.length === 0 ? null : Math.min(...a); }`,
-  max: `function max(a) { return a.length === 0 ? null : Math.max(...a); }`,
+  min: `function min(a) { if (a.length === 0) return null; let m = a[0]; for (let i = 1; i < a.length; i++) if (a[i] < m) m = a[i]; return m; }`,
+  max: `function max(a) { if (a.length === 0) return null; let m = a[0]; for (let i = 1; i < a.length; i++) if (a[i] > m) m = a[i]; return m; }`,
   type_of: `function type_of(v) { if (v === null) return 'Nil'; if (Array.isArray(v)) return 'List'; if (v?.__tag) return v.__tag; const t = typeof v; switch(t) { case 'number': return Number.isInteger(v) ? 'Int' : 'Float'; case 'string': return 'String'; case 'boolean': return 'Bool'; case 'function': return 'Function'; case 'object': return 'Object'; default: return 'Unknown'; } }`,
   filter: `function filter(arr, fn) { return arr.filter(fn); }`,
   map: `function map(arr, fn) { return arr.map(fn); }`,
@@ -80,6 +80,21 @@ export const BUILTIN_FUNCTIONS = {
   assert_eq: `function assert_eq(a, b, msg) { if (a !== b) throw new Error(msg || \`Assertion failed: \${JSON.stringify(a)} !== \${JSON.stringify(b)}\`); }`,
   assert_ne: `function assert_ne(a, b, msg) { if (a === b) throw new Error(msg || \`Assertion failed: values should not be equal: \${JSON.stringify(a)}\`); }`,
   assert: `function assert(cond, msg) { if (!cond) throw new Error(msg || "Assertion failed"); }`,
+  assert_throws: `function assert_throws(fn, expected) {
+  try { fn(); } catch (e) {
+    if (expected !== undefined) {
+      const msg = e instanceof Error ? e.message : String(e);
+      if (typeof expected === 'string' && !msg.includes(expected)) {
+        throw new Error("Expected error containing \\"" + expected + "\\" but got \\"" + msg + "\\"");
+      }
+      if (expected instanceof RegExp && !expected.test(msg)) {
+        throw new Error("Expected error matching " + expected + " but got \\"" + msg + "\\"");
+      }
+    }
+    return e;
+  }
+  throw new Error("Expected function to throw" + (expected ? " \\"" + expected + "\\"" : "") + " but it did not");
+}`,
 
   // ── Missing from module files (synced to BUILTIN_FUNCTIONS) ──
   find_index: `function find_index(arr, fn) { const i = arr.findIndex(fn); return i === -1 ? null : i; }`,
@@ -163,12 +178,12 @@ Table.prototype = { get rows() { return this._rows.length; }, get columns() { re
   agg_count: `function agg_count(fn) { if (!fn) return (rows) => rows.length; return (rows) => rows.filter(fn).length; }`,
   agg_mean: `function agg_mean(fn) { return (rows) => { if (rows.length === 0) return 0; return rows.reduce((a, r) => a + (typeof fn === 'function' ? fn(r) : r[fn]), 0) / rows.length; }; }`,
   agg_median: `function agg_median(fn) { return (rows) => { if (rows.length === 0) return 0; const vs = rows.map(r => typeof fn === 'function' ? fn(r) : r[fn]).sort((a, b) => a - b); const m = Math.floor(vs.length / 2); return vs.length % 2 !== 0 ? vs[m] : (vs[m - 1] + vs[m]) / 2; }; }`,
-  agg_min: `function agg_min(fn) { return (rows) => rows.length === 0 ? null : Math.min(...rows.map(r => typeof fn === 'function' ? fn(r) : r[fn])); }`,
-  agg_max: `function agg_max(fn) { return (rows) => rows.length === 0 ? null : Math.max(...rows.map(r => typeof fn === 'function' ? fn(r) : r[fn])); }`,
+  agg_min: `function agg_min(fn) { return (rows) => { if (rows.length === 0) return null; let m = typeof fn === 'function' ? fn(rows[0]) : rows[0][fn]; for (let i = 1; i < rows.length; i++) { const v = typeof fn === 'function' ? fn(rows[i]) : rows[i][fn]; if (v < m) m = v; } return m; }; }`,
+  agg_max: `function agg_max(fn) { return (rows) => { if (rows.length === 0) return null; let m = typeof fn === 'function' ? fn(rows[0]) : rows[0][fn]; for (let i = 1; i < rows.length; i++) { const v = typeof fn === 'function' ? fn(rows[i]) : rows[i][fn]; if (v > m) m = v; } return m; }; }`,
 
   // ── Data exploration ────────────────────────────────
   peek: `function peek(table, opts) { const o = typeof opts === 'object' ? opts : {}; console.log(table._format ? table._format(o.n || 10, o.title) : String(table)); return table; }`,
-  describe: `function describe(table) { const stats = []; for (const col of table._columns) { const vals = table._rows.map(r => r[col]).filter(v => v != null); const st = { Column: col, Type: 'Unknown', 'Non-Null': vals.length }; if (vals.length > 0) { const s = vals[0]; if (typeof s === 'number') { st.Type = Number.isInteger(s) ? 'Int' : 'Float'; st.Mean = vals.reduce((a, b) => a + b, 0) / vals.length; st.Min = Math.min(...vals); st.Max = Math.max(...vals); } else if (typeof s === 'string') { st.Type = 'String'; st.Unique = new Set(vals).size; } else if (typeof s === 'boolean') { st.Type = 'Bool'; } } stats.push(st); } const dt = Table(stats); console.log(dt._format(100, 'describe()')); return dt; }`,
+  describe: `function describe(table) { const stats = []; for (const col of table._columns) { const vals = table._rows.map(r => r[col]).filter(v => v != null); const st = { Column: col, Type: 'Unknown', 'Non-Null': vals.length }; if (vals.length > 0) { const s = vals[0]; if (typeof s === 'number') { st.Type = Number.isInteger(s) ? 'Int' : 'Float'; st.Mean = vals.reduce((a, b) => a + b, 0) / vals.length; let mn = vals[0], mx = vals[0]; for (let i = 1; i < vals.length; i++) { if (vals[i] < mn) mn = vals[i]; if (vals[i] > mx) mx = vals[i]; } st.Min = mn; st.Max = mx; } else if (typeof s === 'string') { st.Type = 'String'; st.Unique = new Set(vals).size; } else if (typeof s === 'boolean') { st.Type = 'Bool'; } } stats.push(st); } const dt = Table(stats); console.log(dt._format(100, 'describe()')); return dt; }`,
   schema_of: `function schema_of(table) { const sc = {}; if (table._rows.length === 0) { for (const c of table._columns) sc[c] = 'Unknown'; } else { const s = table._rows[0]; for (const c of table._columns) { const v = s[c]; if (v == null) sc[c] = 'Nil'; else if (typeof v === 'number') sc[c] = Number.isInteger(v) ? 'Int' : 'Float'; else if (typeof v === 'string') sc[c] = 'String'; else if (typeof v === 'boolean') sc[c] = 'Bool'; else if (Array.isArray(v)) sc[c] = 'Array'; else sc[c] = 'Object'; } } console.log('Schema:'); for (const [c, t] of Object.entries(sc)) console.log('  ' + c + ': ' + t); return sc; }`,
 
   // ── Data cleaning ───────────────────────────────────
@@ -290,6 +305,7 @@ Table.prototype = { get rows() { return this._rows.length; }, get columns() { re
 
   // ── Async (new) ────────────────────────────────────────
   parallel: `function parallel(list) { return Promise.all(list); }`,
+  race: `function race(promises) { return Promise.race(promises); }`,
   timeout: `function timeout(promise, ms) { return Promise.race([promise, new Promise((_, reject) => setTimeout(() => reject(new Error('Timeout after ' + ms + 'ms')), ms))]); }`,
   retry: `async function retry(fn, opts) { const o = opts || {}; const times = o.times || 3; const delay = o.delay || 100; const backoff = o.backoff || 1; let lastErr; for (let i = 0; i < times; i++) { try { return await fn(); } catch (e) { lastErr = e; if (i < times - 1) await new Promise(r => setTimeout(r, delay * Math.pow(backoff, i))); } } throw lastErr; }`,
 
@@ -302,7 +318,7 @@ Table.prototype = { get rows() { return this._rows.length; }, get columns() { re
   // ── Math (new) ─────────────────────────────────────────
   hypot: `function hypot(a, b) { return Math.hypot(a, b); }`,
   lerp: `function lerp(a, b, t) { return a + (b - a) * t; }`,
-  divmod: `function divmod(a, b) { return [Math.floor(a / b), a % b]; }`,
+  divmod: `function divmod(a, b) { const q = Math.floor(a / b); return [q, a - q * b]; }`,
   avg: `function avg(arr) { return arr.length === 0 ? 0 : arr.reduce((a, b) => a + b, 0) / arr.length; }`,
 
   // ── Date/Time (new) ────────────────────────────────────
@@ -374,7 +390,7 @@ Table.prototype = { get rows() { return this._rows.length; }, get columns() { re
   combinations: `function combinations(arr, r) { const result = []; const combo = []; function gen(start, depth) { if (depth === r) { result.push([...combo]); return; } for (let i = start; i < arr.length; i++) { combo.push(arr[i]); gen(i + 1, depth + 1); combo.pop(); } } gen(0, 0); return result; }`,
   permutations: `function permutations(arr, r) { const n = r === undefined ? arr.length : r; const result = []; const perm = []; const used = new Array(arr.length).fill(false); function gen() { if (perm.length === n) { result.push([...perm]); return; } for (let i = 0; i < arr.length; i++) { if (!used[i]) { used[i] = true; perm.push(arr[i]); gen(); perm.pop(); used[i] = false; } } } gen(); return result; }`,
   intersperse: `function intersperse(arr, sep) { if (arr.length <= 1) return [...arr]; const r = [arr[0]]; for (let i = 1; i < arr.length; i++) { r.push(sep, arr[i]); } return r; }`,
-  interleave: `function interleave(...arrs) { const m = Math.max(...arrs.map(a => a.length)); const r = []; for (let i = 0; i < m; i++) { for (const a of arrs) { if (i < a.length) r.push(a[i]); } } return r; }`,
+  interleave: `function interleave(...arrs) { if (arrs.length === 0) return []; const m = Math.max(...arrs.map(a => a.length)); const r = []; for (let i = 0; i < m; i++) { for (const a of arrs) { if (i < a.length) r.push(a[i]); } } return r; }`,
   repeat_value: `function repeat_value(val, n) { return Array(n).fill(val); }`,
 
   // ── Array Utilities ────────────────────────────────────
@@ -397,11 +413,534 @@ Table.prototype = { get rows() { return this._rows.length; }, get columns() { re
 
   // ── String (extended) ──────────────────────────────────
   fmt: `function fmt(template, ...args) { let i = 0; return template.replace(/\\{\\}/g, () => i < args.length ? String(args[i++]) : '{}'); }`,
+
+  // ── Scripting: Environment & CLI ──────────────────────
+  env: `function env(key, fallback) { if (key === undefined) return { ...process.env }; const v = process.env[key]; return v !== undefined ? v : (fallback !== undefined ? fallback : null); }`,
+  set_env: `function set_env(key, value) { process.env[key] = String(value); }`,
+  args: `function args() { return typeof __tova_args !== 'undefined' ? __tova_args : process.argv.slice(2); }`,
+  exit: `function exit(code) { process.exit(code !== undefined ? code : 0); }`,
+
+  // ── Scripting: Filesystem ─────────────────────────────
+  exists: `function exists(path) { const fs = require('fs'); return fs.existsSync(path); }`,
+  is_dir: `function is_dir(path) { try { return require('fs').statSync(path).isDirectory(); } catch { return false; } }`,
+  is_file: `function is_file(path) { try { return require('fs').statSync(path).isFile(); } catch { return false; } }`,
+  ls: `function ls(dir, opts) { const fs = require('fs'); const p = require('path'); const d = dir || '.'; const entries = fs.readdirSync(d); if (opts && opts.full) return entries.map(e => p.join(d, e)); return entries; }`,
+  glob_files: `function glob_files(pattern, opts) { if (typeof Bun !== 'undefined' && Bun.Glob) { const glob = new Bun.Glob(pattern); const results = [...glob.scanSync(opts && opts.cwd || '.')]; return results; } const fs = require('fs'); if (fs.globSync) return fs.globSync(pattern, opts); return []; }`,
+  mkdir: `function mkdir(dir) { try { require('fs').mkdirSync(dir, { recursive: true }); return Ok(dir); } catch (e) { return Err(e.message); } }`,
+  rm: `function rm(path, opts) { try { require('fs').rmSync(path, { recursive: !!(opts && opts.recursive), force: !!(opts && opts.force) }); return Ok(path); } catch (e) { return Err(e.message); } }`,
+  cp: `function cp(src, dest, opts) { try { const fs = require('fs'); if (opts && opts.recursive) { fs.cpSync(src, dest, { recursive: true }); } else { fs.copyFileSync(src, dest); } return Ok(dest); } catch (e) { return Err(e.message); } }`,
+  mv: `function mv(src, dest) { try { require('fs').renameSync(src, dest); return Ok(dest); } catch (e) { return Err(e.message); } }`,
+  cwd: `function cwd() { return process.cwd(); }`,
+  chdir: `function chdir(dir) { try { process.chdir(dir); return Ok(dir); } catch (e) { return Err(e.message); } }`,
+  read_text: `function read_text(path, enc) { try { return Ok(require('fs').readFileSync(path, enc || 'utf-8')); } catch (e) { return Err(e.message); } }`,
+  read_bytes: `function read_bytes(path) { try { return Ok(require('fs').readFileSync(path)); } catch (e) { return Err(e.message); } }`,
+  write_text: `function write_text(path, content, opts) { try { const fs = require('fs'); if (opts && opts.append) fs.appendFileSync(path, content); else fs.writeFileSync(path, content); return Ok(path); } catch (e) { return Err(e.message); } }`,
+
+  // ── Scripting: Shell ──────────────────────────────────
+  // sh() uses shell:true for convenience (pipes, redirects). For trusted commands only.
+  // exec() uses shell:false — safe from injection by default (array args).
+  sh: `function sh(cmd, opts) { try { const cp = require('child_process'); const o = opts || {}; const result = cp.spawnSync(cmd, { shell: true, cwd: o.cwd, env: o.env ? { ...process.env, ...o.env } : undefined, timeout: o.timeout, stdio: o.inherit ? 'inherit' : 'pipe', encoding: 'utf-8' }); if (result.error) return Err(result.error.message); return Ok({ stdout: (result.stdout || '').trimEnd(), stderr: (result.stderr || '').trimEnd(), exitCode: result.status }); } catch (e) { return Err(e.message); } }`,
+  exec: `function exec(cmd, cmdArgs, opts) { try { const cp = require('child_process'); if (cmdArgs && typeof cmdArgs === 'object' && !Array.isArray(cmdArgs)) { opts = cmdArgs; cmdArgs = []; } const o = opts || {}; const a = cmdArgs || []; const result = cp.spawnSync(cmd, a, { shell: false, cwd: o.cwd, env: o.env ? { ...process.env, ...o.env } : undefined, timeout: o.timeout, stdio: o.inherit ? 'inherit' : 'pipe', encoding: 'utf-8' }); if (result.error) return Err(result.error.message); return Ok({ stdout: (result.stdout || '').trimEnd(), stderr: (result.stderr || '').trimEnd(), exitCode: result.status }); } catch (e) { return Err(e.message); } }`,
+
+  // ── Scripting: stdin ─────────────────────────────────
+  read_stdin: `function read_stdin() { try { return require('fs').readFileSync(0, 'utf-8'); } catch { return ''; } }`,
+  read_lines: `function read_lines() { try { return require('fs').readFileSync(0, 'utf-8').split('\\n').filter(l => l.length > 0); } catch { return []; } }`,
+
+  // ── Scripting: Script path ──────────────────────────
+  script_path: `function script_path() { return typeof __tova_filename !== 'undefined' ? __tova_filename : null; }`,
+  script_dir: `function script_dir() { return typeof __tova_dirname !== 'undefined' ? __tova_dirname : null; }`,
+
+  // ── Scripting: Argument parsing ──────────────────────
+  parse_args: `function parse_args(argv) { const flags = {}; const positional = []; let i = 0; while (i < argv.length) { const arg = argv[i]; if (arg === '--') { positional.push(...argv.slice(i + 1)); break; } if (arg.startsWith('--')) { const eq = arg.indexOf('='); if (eq !== -1) { flags[arg.slice(2, eq)] = arg.slice(eq + 1); } else if (i + 1 < argv.length && !argv[i + 1].startsWith('-')) { flags[arg.slice(2)] = argv[i + 1]; i++; } else { flags[arg.slice(2)] = true; } } else if (arg.startsWith('-') && arg.length > 1) { for (let j = 1; j < arg.length; j++) flags[arg[j]] = true; } else { positional.push(arg); } i++; } return { flags, positional }; }`,
+
+  // ── Lazy Iterators / Sequences ──────────────────────
+  iter: `function iter(source) { return new Seq(function*() { for (const x of source) yield x; }); }`,
+  Seq: `class Seq {
+  constructor(gen) { this._gen = gen; }
+  filter(fn) { const g = this._gen; return new Seq(function*() { for (const x of g()) if (fn(x)) yield x; }); }
+  map(fn) { const g = this._gen; return new Seq(function*() { for (const x of g()) yield fn(x); }); }
+  take(n) { const g = this._gen; return new Seq(function*() { let i = 0; for (const x of g()) { if (i++ >= n) return; yield x; } }); }
+  drop(n) { const g = this._gen; return new Seq(function*() { let i = 0; for (const x of g()) { if (i++ < n) continue; yield x; } }); }
+  zip(other) { const g1 = this._gen; const g2 = other._gen; return new Seq(function*() { const i1 = g1(), i2 = g2(); while (true) { const a = i1.next(), b = i2.next(); if (a.done || b.done) return; yield [a.value, b.value]; } }); }
+  flat_map(fn) { const g = this._gen; return new Seq(function*() { for (const x of g()) { const result = fn(x); if (result && result._gen) { for (const y of result._gen()) yield y; } else if (result && result[Symbol.iterator]) { for (const y of result) yield y; } else { yield result; } } }); }
+  enumerate() { const g = this._gen; return new Seq(function*() { let i = 0; for (const x of g()) yield [i++, x]; }); }
+  collect() { return [...this._gen()]; }
+  toArray() { return this.collect(); }
+  reduce(fn, init) { let acc = init; for (const x of this._gen()) acc = fn(acc, x); return acc; }
+  first() { for (const x of this._gen()) return Some(x); return None; }
+  count() { let n = 0; for (const x of this._gen()) n++; return n; }
+  forEach(fn) { for (const x of this._gen()) fn(x); }
+  any(fn) { for (const x of this._gen()) if (fn(x)) return true; return false; }
+  all(fn) { for (const x of this._gen()) if (!fn(x)) return false; return true; }
+  find(fn) { for (const x of this._gen()) if (fn(x)) return Some(x); return None; }
+  [Symbol.iterator]() { return this._gen(); }
+}`,
+
+  // ── Scripting: Terminal colors ──────────────────────
+  color: `function color(text, name) { if (typeof process !== 'undefined' && (process.env.NO_COLOR || (process.stdout && !process.stdout.isTTY))) return String(text); const codes = { red: '31', green: '32', yellow: '33', blue: '34', magenta: '35', cyan: '36', white: '37', gray: '90' }; const c = codes[name]; return c ? '\\x1b[' + c + 'm' + text + '\\x1b[0m' : String(text); }`,
+  bold: `function bold(text) { if (typeof process !== 'undefined' && (process.env.NO_COLOR || (process.stdout && !process.stdout.isTTY))) return String(text); return '\\x1b[1m' + text + '\\x1b[0m'; }`,
+  dim: `function dim(text) { if (typeof process !== 'undefined' && (process.env.NO_COLOR || (process.stdout && !process.stdout.isTTY))) return String(text); return '\\x1b[2m' + text + '\\x1b[0m'; }`,
+
+  // ── Scripting: Signal handling ────────────────────────
+  on_signal: `function on_signal(name, callback) { process.on(name, callback); }`,
+
+  // ── Scripting: File stat ──────────────────────────────
+  file_stat: `function file_stat(path) { try { const s = require('fs').statSync(path); return Ok({ size: s.size, mode: s.mode, mtime: s.mtime.toISOString(), atime: s.atime.toISOString(), isDir: s.isDirectory(), isFile: s.isFile(), isSymlink: s.isSymbolicLink() }); } catch (e) { return Err(e.message); } }`,
+  file_size: `function file_size(path) { try { return Ok(require('fs').statSync(path).size); } catch (e) { return Err(e.message); } }`,
+
+  // ── Scripting: Path utilities ─────────────────────────
+  path_join: `function path_join(...parts) { return require('path').join(...parts); }`,
+  path_dirname: `function path_dirname(p) { return require('path').dirname(p); }`,
+  path_basename: `function path_basename(p, ext) { return ext ? require('path').basename(p, ext) : require('path').basename(p); }`,
+  path_resolve: `function path_resolve(p) { return require('path').resolve(p); }`,
+  path_ext: `function path_ext(p) { return require('path').extname(p); }`,
+  path_relative: `function path_relative(from, to) { return require('path').relative(from, to); }`,
+
+  // ── Scripting: Symlinks ───────────────────────────────
+  symlink: `function symlink(target, path) { try { require('fs').symlinkSync(target, path); return Ok(null); } catch (e) { return Err(e.message); } }`,
+  readlink: `function readlink(path) { try { return Ok(require('fs').readlinkSync(path)); } catch (e) { return Err(e.message); } }`,
+  is_symlink: `function is_symlink(path) { try { return require('fs').lstatSync(path).isSymbolicLink(); } catch { return false; } }`,
+
+  // ── Scripting: Async shell ────────────────────────────
+  spawn: `function spawn(cmd, cmdArgs, opts) { if (cmdArgs && typeof cmdArgs === 'object' && !Array.isArray(cmdArgs)) { opts = cmdArgs; cmdArgs = []; } const o = opts || {}; const a = cmdArgs || []; return new Promise(function(resolve) { try { const cp = require('child_process'); const child = cp.spawn(cmd, a, { shell: !!o.shell, cwd: o.cwd, env: o.env ? Object.assign({}, process.env, o.env) : undefined, stdio: 'pipe' }); let stdout = ''; let stderr = ''; child.stdout.on('data', function(d) { stdout += d; }); child.stderr.on('data', function(d) { stderr += d; }); child.on('error', function(e) { resolve(Err(e.message)); }); child.on('close', function(code) { resolve(Ok({ stdout: stdout.trimEnd(), stderr: stderr.trimEnd(), exitCode: code })); }); } catch (e) { resolve(Err(e.message)); } }); }`,
+
+  // ── Ordering type ─────────────────────────────────────
+  Less: `const Less = Object.freeze({ __tag: "Less", value: -1 });`,
+  Equal: `const Equal = Object.freeze({ __tag: "Equal", value: 0 });`,
+  Greater: `const Greater = Object.freeze({ __tag: "Greater", value: 1 });`,
+  compare: `function compare(a, b) { if (a < b) return Less; if (a > b) return Greater; return Equal; }`,
+  compare_by: `function compare_by(arr, fn) { return [...arr].sort(function(a, b) { const ord = fn(a, b); return ord.value; }); }`,
+
+  // ── Regex Builder ─────────────────────────────────────
+  RegexBuilder: `class RegexBuilder {
+  constructor() { this._parts = []; this._flags = ''; }
+  literal(s) { this._parts.push(s.replace(/[.*+?^\${}()|[\\]\\\\]/g, '\\\\$&')); return this; }
+  digits(n) { this._parts.push(n ? '\\\\d{' + n + '}' : '\\\\d+'); return this; }
+  word() { this._parts.push('\\\\w+'); return this; }
+  space() { this._parts.push('\\\\s+'); return this; }
+  any() { this._parts.push('.'); return this; }
+  oneOf(chars) { this._parts.push('[' + chars.replace(/[\\]\\\\]/g, '\\\\$&') + ']'); return this; }
+  group(name) { this._parts.push(name ? '(?<' + name + '>' : '('); return this; }
+  endGroup() { this._parts.push(')'); return this; }
+  optional() { this._parts.push('?'); return this; }
+  oneOrMore() { this._parts.push('+'); return this; }
+  zeroOrMore() { this._parts.push('*'); return this; }
+  startOfLine() { this._parts.push('^'); return this; }
+  endOfLine() { this._parts.push('$'); return this; }
+  flags(f) { this._flags = f; return this; }
+  build() { return new RegExp(this._parts.join(''), this._flags); }
+  test(s) { return this.build().test(s); }
+  match(s) { return s.match(this.build()); }
+}`,
+  regex_builder: `function regex_builder() { return new RegexBuilder(); }`,
+
+  // ── Namespace modules ──────────────────────────────────
+  math: `const math = Object.freeze({
+  sin(n) { return Math.sin(n); },
+  cos(n) { return Math.cos(n); },
+  tan(n) { return Math.tan(n); },
+  asin(n) { return Math.asin(n); },
+  acos(n) { return Math.acos(n); },
+  atan(n) { return Math.atan(n); },
+  atan2(y, x) { return Math.atan2(y, x); },
+  log(n) { return Math.log(n); },
+  log2(n) { return Math.log2(n); },
+  log10(n) { return Math.log10(n); },
+  exp(n) { return Math.exp(n); },
+  abs(n) { return Math.abs(n); },
+  floor(n) { return Math.floor(n); },
+  ceil(n) { return Math.ceil(n); },
+  round(n) { return Math.round(n); },
+  sqrt(n) { return Math.sqrt(n); },
+  pow(b, e) { return Math.pow(b, e); },
+  clamp(n, lo, hi) { return Math.min(Math.max(n, lo), hi); },
+  random() { return Math.random(); },
+  sign(n) { return Math.sign(n); },
+  trunc(n) { return Math.trunc(n); },
+  hypot(a, b) { return Math.hypot(a, b); },
+  lerp(a, b, t) { return a + (b - a) * t; },
+  gcd(a, b) { a = Math.abs(a); b = Math.abs(b); while (b) { [a, b] = [b, a % b]; } return a; },
+  lcm(a, b) { if (a === 0 && b === 0) return 0; let x = Math.abs(a), y = Math.abs(b); while (y) { const t = y; y = x % y; x = t; } return Math.abs(a * b) / x; },
+  factorial(n) { if (n < 0) return null; if (n <= 1) return 1; let r = 1; for (let i = 2; i <= n; i++) r *= i; return r; },
+  PI: Math.PI,
+  E: Math.E,
+  INF: Infinity
+});`,
+
+  str: `const str = Object.freeze({
+  upper(s) { return s.toUpperCase(); },
+  lower(s) { return s.toLowerCase(); },
+  trim(s) { return s.trim(); },
+  trim_start(s) { return s.trimStart(); },
+  trim_end(s) { return s.trimEnd(); },
+  split(s, sep) { return s.split(sep); },
+  join(arr, sep) { return arr.join(sep); },
+  replace(s, from, to) { return typeof from === 'string' ? s.replaceAll(from, to) : s.replace(from, to); },
+  repeat(s, n) { return s.repeat(n); },
+  contains(s, sub) { return s.includes(sub); },
+  starts_with(s, prefix) { return s.startsWith(prefix); },
+  ends_with(s, suffix) { return s.endsWith(suffix); },
+  chars(s) { return [...s]; },
+  words(s) { return s.split(/\\s+/).filter(Boolean); },
+  lines(s) { return s.split('\\n'); },
+  capitalize(s) { return s.length ? s.charAt(0).toUpperCase() + s.slice(1) : s; },
+  title_case(s) { return s.replace(/\\b\\w/g, c => c.toUpperCase()); },
+  snake_case(s) { return s.replace(/[-\\s]+/g, '_').replace(/([a-z0-9])([A-Z])/g, '$1_$2').toLowerCase().replace(/^_/, ''); },
+  camel_case(s) { return s.replace(/[-_\\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : '').replace(/^[A-Z]/, c => c.toLowerCase()); },
+  kebab_case(s) { return s.replace(/[-\\s]+/g, '-').replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase().replace(/^-/, ''); },
+  index_of(s, sub) { const i = s.indexOf(sub); return i === -1 ? null : i; },
+  last_index_of(s, sub) { const i = s.lastIndexOf(sub); return i === -1 ? null : i; },
+  pad_start(s, n, fill) { return s.padStart(n, fill || ' '); },
+  pad_end(s, n, fill) { return s.padEnd(n, fill || ' '); },
+  center(s, n, fill) { if (s.length >= n) return s; const f = fill || ' '; const total = n - s.length; const left = Math.floor(total / 2); const right = total - left; return f.repeat(Math.ceil(left / f.length)).slice(0, left) + s + f.repeat(Math.ceil(right / f.length)).slice(0, right); },
+  slugify(s) { return s.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, ''); },
+  escape_html(s) { return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&#39;'); },
+  unescape_html(s) { return s.replace(/&amp;/g, '&').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&quot;/g, '"').replace(/&#39;/g, "'"); }
+});`,
+
+  arr: `const arr = Object.freeze({
+  sorted(a, k) { const c = [...a]; if (k) c.sort((x, y) => { const kx = k(x), ky = k(y); return kx < ky ? -1 : kx > ky ? 1 : 0; }); else c.sort((x, y) => x < y ? -1 : x > y ? 1 : 0); return c; },
+  reversed(a) { return [...a].reverse(); },
+  unique(a) { return [...new Set(a)]; },
+  chunk(a, n) { const r = []; for (let i = 0; i < a.length; i += n) r.push(a.slice(i, i + n)); return r; },
+  flatten(a) { return a.flat(); },
+  take(a, n) { return a.slice(0, n); },
+  drop(a, n) { return a.slice(n); },
+  first(a) { return a.length > 0 ? a[0] : null; },
+  last(a) { return a.length > 0 ? a[a.length - 1] : null; },
+  count(a, fn) { return a.filter(fn).length; },
+  partition(a, fn) { const y = [], n = []; for (const v of a) { (fn(v) ? y : n).push(v); } return [y, n]; },
+  group_by(a, fn) { const r = {}; for (const v of a) { const k = fn(v); if (!r[k]) r[k] = []; r[k].push(v); } return r; },
+  zip_with(a, b, fn) { const m = Math.min(a.length, b.length); const r = []; for (let i = 0; i < m; i++) r.push(fn ? fn(a[i], b[i]) : [a[i], b[i]]); return r; },
+  frequencies(a) { const r = {}; for (const v of a) { const k = String(v); r[k] = (r[k] || 0) + 1; } return r; },
+  scan(a, fn, init) { const r = []; let acc = init; for (const v of a) { acc = fn(acc, v); r.push(acc); } return r; },
+  min_by(a, fn) { if (a.length === 0) return null; let best = a[0], bestK = fn(a[0]); for (let i = 1; i < a.length; i++) { const k = fn(a[i]); if (k < bestK) { best = a[i]; bestK = k; } } return best; },
+  max_by(a, fn) { if (a.length === 0) return null; let best = a[0], bestK = fn(a[0]); for (let i = 1; i < a.length; i++) { const k = fn(a[i]); if (k > bestK) { best = a[i]; bestK = k; } } return best; },
+  sum_by(a, fn) { let s = 0; for (const v of a) s += fn(v); return s; },
+  compact(a) { return a.filter(v => v != null); },
+  rotate(a, n) { if (a.length === 0) return []; const k = ((n % a.length) + a.length) % a.length; return [...a.slice(k), ...a.slice(0, k)]; },
+  insert_at(a, idx, val) { const r = [...a]; r.splice(idx, 0, val); return r; },
+  remove_at(a, idx) { const r = [...a]; r.splice(idx, 1); return r; },
+  binary_search(a, target, keyFn) { let lo = 0, hi = a.length - 1; while (lo <= hi) { const mid = (lo + hi) >> 1; const val = keyFn ? keyFn(a[mid]) : a[mid]; if (val === target) return mid; if (val < target) lo = mid + 1; else hi = mid - 1; } return -1; },
+  is_sorted(a, keyFn) { for (let i = 1; i < a.length; i++) { const x = keyFn ? keyFn(a[i - 1]) : a[i - 1]; const y = keyFn ? keyFn(a[i]) : a[i]; if (x > y) return false; } return true; }
+});`,
+
+  dt: `const dt = Object.freeze({
+  now() { return Date.now(); },
+  now_iso() { return new Date().toISOString(); },
+  parse(s) { const d = new Date(s); return isNaN(d.getTime()) ? Err('Invalid date: ' + s) : Ok(d); },
+  format(d, fmt) { if (typeof d === 'number') d = new Date(d); if (fmt === 'iso') return d.toISOString(); if (fmt === 'date') return d.toISOString().slice(0, 10); if (fmt === 'time') return d.toTimeString().slice(0, 8); if (fmt === 'datetime') return d.toISOString().slice(0, 10) + ' ' + d.toTimeString().slice(0, 8); return fmt.replace('YYYY', String(d.getFullYear())).replace('MM', String(d.getMonth() + 1).padStart(2, '0')).replace('DD', String(d.getDate()).padStart(2, '0')).replace('HH', String(d.getHours()).padStart(2, '0')).replace('mm', String(d.getMinutes()).padStart(2, '0')).replace('ss', String(d.getSeconds()).padStart(2, '0')); },
+  add(d, amount, unit) { if (typeof d === 'number') d = new Date(d); const r = new Date(d.getTime()); if (unit === 'years') r.setFullYear(r.getFullYear() + amount); else if (unit === 'months') r.setMonth(r.getMonth() + amount); else if (unit === 'days') r.setDate(r.getDate() + amount); else if (unit === 'hours') r.setHours(r.getHours() + amount); else if (unit === 'minutes') r.setMinutes(r.getMinutes() + amount); else if (unit === 'seconds') r.setSeconds(r.getSeconds() + amount); return r; },
+  diff(d1, d2, unit) { if (typeof d1 === 'number') d1 = new Date(d1); if (typeof d2 === 'number') d2 = new Date(d2); const ms = d2.getTime() - d1.getTime(); if (unit === 'seconds') return Math.floor(ms / 1000); if (unit === 'minutes') return Math.floor(ms / 60000); if (unit === 'hours') return Math.floor(ms / 3600000); if (unit === 'days') return Math.floor(ms / 86400000); if (unit === 'months') return (d2.getFullYear() - d1.getFullYear()) * 12 + (d2.getMonth() - d1.getMonth()); if (unit === 'years') return d2.getFullYear() - d1.getFullYear(); return ms; },
+  from(parts) { return new Date(parts.year || 0, (parts.month || 1) - 1, parts.day || 1, parts.hour || 0, parts.minute || 0, parts.second || 0); },
+  part(d, p) { if (typeof d === 'number') d = new Date(d); if (p === 'year') return d.getFullYear(); if (p === 'month') return d.getMonth() + 1; if (p === 'day') return d.getDate(); if (p === 'hour') return d.getHours(); if (p === 'minute') return d.getMinutes(); if (p === 'second') return d.getSeconds(); if (p === 'weekday') return d.getDay(); return null; },
+  time_ago(d) { if (typeof d === 'number') d = new Date(d); const s = Math.floor((Date.now() - d.getTime()) / 1000); if (s < 60) return s + ' seconds ago'; const m = Math.floor(s / 60); if (m < 60) return m + (m === 1 ? ' minute ago' : ' minutes ago'); const h = Math.floor(m / 60); if (h < 24) return h + (h === 1 ? ' hour ago' : ' hours ago'); const dy = Math.floor(h / 24); if (dy < 30) return dy + (dy === 1 ? ' day ago' : ' days ago'); const mo = Math.floor(dy / 30); if (mo < 12) return mo + (mo === 1 ? ' month ago' : ' months ago'); const yr = Math.floor(mo / 12); return yr + (yr === 1 ? ' year ago' : ' years ago'); }
+});`,
+
+  re: `const re = Object.freeze({
+  test(s, pattern, flags) { return new RegExp(pattern, flags).test(s); },
+  match(s, pattern, flags) { const m = s.match(new RegExp(pattern, flags)); if (!m) return Err('No match'); return Ok({ match: m[0], index: m.index, groups: m.slice(1) }); },
+  find_all(s, pattern, flags) { const r = new RegExp(pattern, (flags || '') + (flags && flags.includes('g') ? '' : 'g')); const results = []; let m; while ((m = r.exec(s)) !== null) { results.push({ match: m[0], index: m.index, groups: m.slice(1) }); } return results; },
+  replace(s, pattern, replacement, flags) { return s.replace(new RegExp(pattern, flags || 'g'), replacement); },
+  split(s, pattern, flags) { return s.split(new RegExp(pattern, flags)); },
+  capture(s, pattern, flags) { const m = s.match(new RegExp(pattern, flags)); if (!m) return Err('No match'); if (!m.groups) return Err('No named groups'); return Ok(m.groups); }
+});`,
+
+  json: `const json = Object.freeze({
+  parse(s) { try { return Ok(JSON.parse(s)); } catch (e) { return Err(e.message); } },
+  stringify(v) { return JSON.stringify(v); },
+  pretty(v) { return JSON.stringify(v, null, 2); }
+});`,
+
+  fs: `const fs = Object.freeze({
+  read_text(path, enc) { try { return Ok(require('fs').readFileSync(path, enc || 'utf-8')); } catch (e) { return Err(e.message); } },
+  write_text(path, content, opts) { try { const f = require('fs'); if (opts && opts.append) f.appendFileSync(path, content); else f.writeFileSync(path, content); return Ok(path); } catch (e) { return Err(e.message); } },
+  exists(path) { return require('fs').existsSync(path); },
+  is_dir(path) { try { return require('fs').statSync(path).isDirectory(); } catch { return false; } },
+  is_file(path) { try { return require('fs').statSync(path).isFile(); } catch { return false; } },
+  ls(dir, opts) { const f = require('fs'); const p = require('path'); const d = dir || '.'; const entries = f.readdirSync(d); if (opts && opts.full) return entries.map(e => p.join(d, e)); return entries; },
+  mkdir(dir) { try { require('fs').mkdirSync(dir, { recursive: true }); return Ok(dir); } catch (e) { return Err(e.message); } },
+  rm(path, opts) { try { require('fs').rmSync(path, { recursive: !!(opts && opts.recursive), force: !!(opts && opts.force) }); return Ok(path); } catch (e) { return Err(e.message); } },
+  cp(src, dest, opts) { try { const f = require('fs'); if (opts && opts.recursive) { f.cpSync(src, dest, { recursive: true }); } else { f.copyFileSync(src, dest); } return Ok(dest); } catch (e) { return Err(e.message); } },
+  mv(src, dest) { try { require('fs').renameSync(src, dest); return Ok(dest); } catch (e) { return Err(e.message); } },
+  glob_files(pattern, opts) { if (typeof Bun !== 'undefined' && Bun.Glob) { const glob = new Bun.Glob(pattern); return [...glob.scanSync(opts && opts.cwd || '.')]; } const f = require('fs'); if (f.globSync) return f.globSync(pattern, opts); return []; }
+});`,
+
+  url: `const url = Object.freeze({
+  parse(s) { try { const u = new URL(s); return Ok({ protocol: u.protocol.replace(':', ''), host: u.host, pathname: u.pathname, search: u.search, hash: u.hash }); } catch (e) { return Err('Invalid URL: ' + s); } },
+  build(parts) { let u = (parts.protocol || 'https') + '://' + (parts.host || ''); u += parts.pathname || '/'; if (parts.search) u += (parts.search.startsWith('?') ? '' : '?') + parts.search; if (parts.hash) u += (parts.hash.startsWith('#') ? '' : '#') + parts.hash; return u; },
+  parse_query(s) { const r = {}; const qs = s.startsWith('?') ? s.slice(1) : s; if (!qs) return r; for (const pair of qs.split('&')) { const [k, ...v] = pair.split('='); r[decodeURIComponent(k)] = decodeURIComponent(v.join('=')); } return r; },
+  build_query(obj) { return Object.entries(obj).map(([k, v]) => encodeURIComponent(k) + '=' + encodeURIComponent(v)).join('&'); }
+});`,
+
+  // ── Channel-based async ───────────────────────────────
+  Channel: `class Channel {
+  constructor(capacity) {
+    this._capacity = capacity || 0;
+    this._buffer = [];
+    this._closed = false;
+    this._sendWaiters = [];
+    this._recvWaiters = [];
+  }
+  async send(value) {
+    if (this._closed) throw new Error('Cannot send on closed channel');
+    if (this._recvWaiters.length > 0) {
+      const waiter = this._recvWaiters.shift();
+      waiter(Some(value));
+      return;
+    }
+    if (this._capacity > 0 && this._buffer.length < this._capacity) {
+      this._buffer.push(value);
+      return;
+    }
+    return new Promise(function(resolve) {
+      this._sendWaiters.push({ value: value, resolve: resolve });
+    }.bind(this));
+  }
+  async receive() {
+    if (this._buffer.length > 0) {
+      const value = this._buffer.shift();
+      if (this._sendWaiters.length > 0) {
+        const waiter = this._sendWaiters.shift();
+        this._buffer.push(waiter.value);
+        waiter.resolve();
+      }
+      return Some(value);
+    }
+    if (this._closed) return None;
+    if (this._sendWaiters.length > 0) {
+      const waiter = this._sendWaiters.shift();
+      waiter.resolve();
+      return Some(waiter.value);
+    }
+    return new Promise(function(resolve) {
+      this._recvWaiters.push(resolve);
+    }.bind(this));
+  }
+  close() {
+    this._closed = true;
+    for (const waiter of this._recvWaiters) waiter(None);
+    this._recvWaiters = [];
+  }
+  [Symbol.asyncIterator]() {
+    const ch = this;
+    return {
+      async next() {
+        const val = await ch.receive();
+        if (val.__tag === 'None') return { done: true, value: undefined };
+        return { done: false, value: val.value };
+      }
+    };
+  }
+}`,
+
+  // ── Snapshot testing ──────────────────────────────────
+  assert_snapshot: `function assert_snapshot(value, name) {
+  const snap = typeof value === 'string' ? value : JSON.stringify(value, null, 2);
+  const updateMode = typeof process !== 'undefined' && process.env.TOVA_UPDATE_SNAPSHOTS === '1';
+  if (typeof __tova_snapshots === 'undefined') { globalThis.__tova_snapshots = {}; }
+  const key = name || ('snapshot_' + Object.keys(__tova_snapshots).length);
+  if (updateMode || !__tova_snapshots[key]) {
+    __tova_snapshots[key] = snap;
+    return;
+  }
+  if (__tova_snapshots[key] !== snap) {
+    throw new Error('Snapshot mismatch for "' + key + '":\\nExpected:\\n' + __tova_snapshots[key] + '\\nActual:\\n' + snap);
+  }
+}`,
+
+  // ── Property-based testing ────────────────────────────
+  Gen: `const Gen = {
+  int: function(min, max) { return function() { const lo = min !== undefined ? min : -1000; const hi = max !== undefined ? max : 1000; return Math.floor(Math.random() * (hi - lo + 1)) + lo; }; },
+  float: function(min, max) { return function() { const lo = min !== undefined ? min : -1000; const hi = max !== undefined ? max : 1000; return Math.random() * (hi - lo) + lo; }; },
+  bool: function() { return function() { return Math.random() < 0.5; }; },
+  string: function(maxLen) { return function() { const len = Math.floor(Math.random() * (maxLen || 20)); const chars = 'abcdefghijklmnopqrstuvwxyz0123456789'; let s = ''; for (let i = 0; i < len; i++) s += chars[Math.floor(Math.random() * chars.length)]; return s; }; },
+  array: function(gen, maxLen) { return function() { const len = Math.floor(Math.random() * (maxLen || 10)); const arr = []; for (let i = 0; i < len; i++) arr.push(gen()); return arr; }; },
+  oneOf: function(values) { return function() { return values[Math.floor(Math.random() * values.length)]; }; }
+};`,
+  forAll: `function forAll(generators, property, opts) {
+  const runs = (opts && opts.runs) || 100;
+  for (let i = 0; i < runs; i++) {
+    const args = generators.map(function(g) { return g(); });
+    let result;
+    try { result = property.apply(null, args); } catch (e) { throw new Error('Property failed on input ' + JSON.stringify(args) + ': ' + e.message); }
+    if (result === false) { throw new Error('Property failed on input: ' + JSON.stringify(args)); }
+  }
+}`,
+
+  // ── Mock / Spy Utilities ────────────────────────────────
+  create_spy: `function create_spy(impl) {
+  const spy = function(...args) {
+    spy.calls.push(args);
+    spy.call_count++;
+    spy.called = true;
+    spy.last_args = args;
+    if (spy._impl) return spy._impl(...args);
+    return spy._return_value;
+  };
+  spy.calls = [];
+  spy.call_count = 0;
+  spy.called = false;
+  spy.last_args = null;
+  spy._impl = impl || null;
+  spy._return_value = undefined;
+  spy.returns = function(val) { spy._return_value = val; spy._impl = null; return spy; };
+  spy.reset = function() { spy.calls = []; spy.call_count = 0; spy.called = false; spy.last_args = null; };
+  spy.called_with = function(...expected) {
+    return spy.calls.some(function(call) {
+      return expected.length === call.length && expected.every(function(v, i) { return v === call[i]; });
+    });
+  };
+  return spy;
+}`,
+  create_mock: `function create_mock(return_value) {
+  return create_spy(typeof return_value === 'function' ? return_value : function() { return return_value; });
+}`,
+
+  // ── Advanced Collections ────────────────────────────────
+  OrderedDict: `class OrderedDict {
+  constructor(entries) { this._map = new Map(entries || []); }
+  get(key) { return this._map.has(key) ? this._map.get(key) : null; }
+  set(key, value) { const m = new Map(this._map); m.set(key, value); return new OrderedDict([...m]); }
+  delete(key) { const m = new Map(this._map); m.delete(key); return new OrderedDict([...m]); }
+  has(key) { return this._map.has(key); }
+  keys() { return [...this._map.keys()]; }
+  values() { return [...this._map.values()]; }
+  entries() { return [...this._map.entries()]; }
+  get length() { return this._map.size; }
+  [Symbol.iterator]() { return this._map[Symbol.iterator](); }
+  toString() { return 'OrderedDict(' + this._map.size + ' entries)'; }
+}`,
+
+  DefaultDict: `class DefaultDict {
+  constructor(defaultFn) { this._map = new Map(); this._default = defaultFn; }
+  get(key) { if (!this._map.has(key)) { this._map.set(key, this._default()); } return this._map.get(key); }
+  set(key, value) { this._map.set(key, value); return this; }
+  has(key) { return this._map.has(key); }
+  delete(key) { this._map.delete(key); return this; }
+  keys() { return [...this._map.keys()]; }
+  values() { return [...this._map.values()]; }
+  entries() { return [...this._map.entries()]; }
+  get length() { return this._map.size; }
+  [Symbol.iterator]() { return this._map[Symbol.iterator](); }
+  toString() { return 'DefaultDict(' + this._map.size + ' entries)'; }
+}`,
+
+  Counter: `class Counter {
+  constructor(items) { this._counts = new Map(); if (items) { for (const item of items) { this._counts.set(item, (this._counts.get(item) || 0) + 1); } } }
+  count(item) { return this._counts.get(item) || 0; }
+  total() { let s = 0; for (const v of this._counts.values()) s += v; return s; }
+  most_common(n) { const sorted = [...this._counts.entries()].sort((a, b) => b[1] - a[1]); return n !== undefined ? sorted.slice(0, n) : sorted; }
+  keys() { return [...this._counts.keys()]; }
+  values() { return [...this._counts.values()]; }
+  entries() { return [...this._counts.entries()]; }
+  has(item) { return this._counts.has(item); }
+  get length() { return this._counts.size; }
+  [Symbol.iterator]() { return this._counts[Symbol.iterator](); }
+  toString() { return 'Counter(' + this._counts.size + ' items)'; }
+}`,
+
+  Deque: `class Deque {
+  constructor(items) { this._items = items ? [...items] : []; }
+  push_back(val) { return new Deque([...this._items, val]); }
+  push_front(val) { return new Deque([val, ...this._items]); }
+  pop_back() { if (this._items.length === 0) return [null, this]; return [this._items[this._items.length - 1], new Deque(this._items.slice(0, -1))]; }
+  pop_front() { if (this._items.length === 0) return [null, this]; return [this._items[0], new Deque(this._items.slice(1))]; }
+  peek_front() { return this._items.length > 0 ? this._items[0] : null; }
+  peek_back() { return this._items.length > 0 ? this._items[this._items.length - 1] : null; }
+  get length() { return this._items.length; }
+  toArray() { return [...this._items]; }
+  [Symbol.iterator]() { return this._items[Symbol.iterator](); }
+  toString() { return 'Deque(' + this._items.length + ' items)'; }
+}`,
+
+  collections: `const collections = Object.freeze({
+  OrderedDict, DefaultDict, Counter, Deque
+});`,
 };
 
 // All known builtin names for matching
 export const BUILTIN_NAMES = new Set(Object.keys(BUILTIN_FUNCTIONS));
 
+// ─── Stdlib Dependency Graph ──────────────────────────────────
+// Maps each builtin to the builtins it depends on (must be emitted first).
+// This replaces scattered ad-hoc dependency checks throughout the codebase.
+export const STDLIB_DEPS = {
+  // iter() requires the Seq class
+  iter: ['Seq'],
+  // collections namespace requires all collection classes
+  collections: ['OrderedDict', 'DefaultDict', 'Counter', 'Deque'],
+  // Table operations may use Table
+  describe: ['Table'],
+  // Some builtins reference Result/Option types (Ok, Err, Some, None)
+  // These are provided by RESULT_OPTION, not the builtin map, so no dep here
+  // Namespace modules that use builtins internally
+  json: ['Ok', 'Err'],
+  re: ['Ok', 'Err'],
+  dt: ['Ok', 'Err'],
+  fs: ['Ok', 'Err'],
+  url: ['Ok', 'Err'],
+  parse_url: ['Ok', 'Err'],
+  regex_match: ['Ok', 'Err'],
+  regex_capture: ['Ok', 'Err'],
+  json_parse: ['Ok', 'Err'],
+  date_parse: ['Ok', 'Err'],
+  read_text: ['Ok', 'Err'],
+  try_fn: ['Ok', 'Err'],
+  try_async: ['Ok', 'Err'],
+  // Seq uses Some/None
+  Seq: ['Some', 'None'],
+  // compare family
+  compare: ['Less', 'Equal', 'Greater'],
+  compare_by: ['Less', 'Equal', 'Greater'],
+  // mock/spy
+  create_mock: ['create_spy'],
+};
+
+// Resolve all transitive dependencies for a set of used names
+export function resolveStdlibDeps(usedNames) {
+  const resolved = new Set(usedNames);
+  const queue = [...usedNames];
+  while (queue.length > 0) {
+    const name = queue.pop();
+    const deps = STDLIB_DEPS[name];
+    if (deps) {
+      for (const dep of deps) {
+        if (!resolved.has(dep)) {
+          resolved.add(dep);
+          queue.push(dep);
+        }
+      }
+    }
+  }
+  return resolved;
+}
+
+// Topological sort: emit dependencies before dependents
+function _topoSort(names) {
+  const result = [];
+  const visited = new Set();
+  const visiting = new Set();
+
+  function visit(name) {
+    if (visited.has(name)) return;
+    if (visiting.has(name)) return; // circular — break
+    visiting.add(name);
+    const deps = STDLIB_DEPS[name];
+    if (deps) {
+      for (const dep of deps) {
+        if (names.has(dep)) visit(dep);
+      }
+    }
+    visiting.delete(name);
+    visited.add(name);
+    result.push(name);
+  }
+
+  for (const name of names) visit(name);
+  return result;
+}
+
 // Legacy compat: full stdlib as a single string (derived from BUILTIN_FUNCTIONS)
 // Only includes non-internal, non-table functions for backward compat with tests/playground
 const _LEGACY_NAMES = [
@@ -413,14 +952,18 @@ const _LEGACY_NAMES = [
   'keys', 'values', 'entries', 'merge', 'freeze', 'clone', 'sleep',
   'upper', 'lower', 'contains', 'starts_with', 'ends_with', 'chars', 'words',
   'lines', 'capitalize', 'title_case', 'snake_case', 'camel_case',
-  'assert_eq', 'assert_ne', 'assert',
+  'assert_eq', 'assert_ne', 'assert', 'assert_throws',
+  'create_spy', 'create_mock',
 ];
 export const BUILTINS = _LEGACY_NAMES.map(n => BUILTIN_FUNCTIONS[n]).join('\n');
 
 // Build stdlib containing only the functions that are actually used
 export function buildSelectiveStdlib(usedNames) {
+  // Resolve transitive dependencies and topologically sort
+  const withDeps = resolveStdlibDeps(usedNames);
+  const ordered = _topoSort(withDeps);
   const parts = [];
-  for (const name of usedNames) {
+  for (const name of ordered) {
     if (BUILTIN_FUNCTIONS[name]) {
       parts.push(BUILTIN_FUNCTIONS[name]);
     }