tova 0.3.4 → 0.3.6

package/src/stdlib/inline.js

@@ -2,9 +2,52 @@
 // 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"); }, 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; } }); }
+export const RESULT_OPTION = `class _Ok { constructor(value) { this.value = value; } }
+_Ok.prototype.__tag = "Ok";
+_Ok.prototype.map = function(fn) { return new _Ok(fn(this.value)); };
+_Ok.prototype.flatMap = function(fn) { const r = fn(this.value); if (r && r.__tag) return r; throw new Error("flatMap callback must return Ok/Err"); };
+_Ok.prototype.andThen = _Ok.prototype.flatMap;
+_Ok.prototype.unwrap = function() { return this.value; };
+_Ok.prototype.unwrapOr = function(_) { return this.value; };
+_Ok.prototype.expect = function(_) { return this.value; };
+_Ok.prototype.isOk = function() { return true; };
+_Ok.prototype.isErr = function() { return false; };
+_Ok.prototype.mapErr = function(_) { return this; };
+_Ok.prototype.unwrapErr = function() { throw new Error("Called unwrapErr on Ok"); };
+_Ok.prototype.or = function(_) { return this; };
+_Ok.prototype.and = function(other) { return other; };
+_Ok.prototype.context = function(_) { return this; };
+function Ok(value) { return new _Ok(value); }
+class _Err { constructor(error) { this.error = error; } }
+_Err.prototype.__tag = "Err";
+_Err.prototype.map = function(_) { return this; };
+_Err.prototype.flatMap = function(_) { return this; };
+_Err.prototype.andThen = _Err.prototype.flatMap;
+_Err.prototype.unwrap = function() { throw new Error("Called unwrap on Err: " + (typeof this.error === "object" ? JSON.stringify(this.error) : this.error)); };
+_Err.prototype.unwrapOr = function(def) { return def; };
+_Err.prototype.expect = function(msg) { throw new Error(msg); };
+_Err.prototype.isOk = function() { return false; };
+_Err.prototype.isErr = function() { return true; };
+_Err.prototype.mapErr = function(fn) { return new _Err(fn(this.error)); };
+_Err.prototype.unwrapErr = function() { return this.error; };
+_Err.prototype.or = function(other) { return other; };
+_Err.prototype.and = function(_) { return this; };
+_Err.prototype.context = function(msg) { const inner = typeof this.error === "object" ? JSON.stringify(this.error) : String(this.error); return new _Err(msg + " \\u2192 caused by: " + inner); };
+function Err(error) { return new _Err(error); }
+class _Some { constructor(value) { this.value = value; } }
+_Some.prototype.__tag = "Some";
+_Some.prototype.map = function(fn) { return new _Some(fn(this.value)); };
+_Some.prototype.flatMap = function(fn) { const r = fn(this.value); if (r && r.__tag) return r; throw new Error("flatMap callback must return Some/None"); };
+_Some.prototype.andThen = _Some.prototype.flatMap;
+_Some.prototype.unwrap = function() { return this.value; };
+_Some.prototype.unwrapOr = function(_) { return this.value; };
+_Some.prototype.expect = function(_) { return this.value; };
+_Some.prototype.isSome = function() { return true; };
+_Some.prototype.isNone = function() { return false; };
+_Some.prototype.or = function(_) { return this; };
+_Some.prototype.and = function(other) { return other; };
+_Some.prototype.filter = function(pred) { return pred(this.value) ? this : None; };
+function Some(value) { return new _Some(value); }
 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) {
@@ -18,11 +61,11 @@ export const PROPAGATE = `function __propagate(val) {
 // Individual builtin functions for tree-shaking
 export const BUILTIN_FUNCTIONS = {
   print: `function print(...args) { console.log(...args); }`,
-  len: `function len(v) { if (v == null) return 0; if (typeof v === 'string' || Array.isArray(v)) return v.length; if (typeof v === 'object') return Object.keys(v).length; return 0; }`,
+  len: `function len(v) { if (v == null) return 0; if (typeof v === 'string' || Array.isArray(v) || ArrayBuffer.isView(v)) return v.length; if (typeof v === 'object') return Object.keys(v).length; return 0; }`,
   range: `function range(s, e, st) { if (e === undefined) { e = s; s = 0; } if (st === undefined) st = s < e ? 1 : -1; if (st === 0) return []; const r = []; if (st > 0) { for (let i = s; i < e; i += st) r.push(i); } else { for (let i = s; i > e; i += st) r.push(i); } return r; }`,
   enumerate: `function enumerate(a) { return a.map((v, i) => [i, v]); }`,
   sum: `function sum(a) { return a.reduce((x, y) => x + y, 0); }`,
-  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; }`,
+  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 if (c.length > 0 && typeof c[0] === 'number') { if (typeof __tova_native !== 'undefined' && __tova_native && c.length > 128) { const f = new Float64Array(c); __tova_native.tova_sort_f64(f, f.length); for (let i = 0; i < c.length; i++) c[i] = f[i]; } else if (c.length > 128) { const f = new Float64Array(c); f.sort(); for (let i = 0; i < c.length; i++) c[i] = f[i]; } else { c.sort((a, b) => a - b); } } 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) { 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; }`,
@@ -65,6 +108,34 @@ export const BUILTIN_FUNCTIONS = {
   freeze: `function freeze(obj) { return Object.freeze(obj); }`,
   clone: `function clone(obj) { return structuredClone(obj); }`,
   sleep: `function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }`,
+  parallel_map: `async function parallel_map(arr, fn, numWorkers) {
+  if (!arr || arr.length === 0) return [];
+  const cores = numWorkers || (typeof navigator !== 'undefined' ? navigator.hardwareConcurrency : 4) || 4;
+  const n = Math.min(cores, arr.length);
+  if (n <= 1 || arr.length < 4) return arr.map(fn);
+  if (!parallel_map._pool) {
+    const { Worker } = await import("worker_threads");
+    const wc = 'const{parentPort}=require("worker_threads");parentPort.on("message",m=>{const fn=(0,eval)("("+m.f+")");try{const r=m.c.map(fn);parentPort.postMessage({i:m.i,r})}catch(e){parentPort.postMessage({i:m.i,e:e.message})}})';
+    parallel_map._pool = Array.from({length: n}, () => { const w = new Worker(wc, {eval: true}); w.unref(); return w; });
+    parallel_map._cid = 0;
+  }
+  const pool = parallel_map._pool;
+  const cs = Math.ceil(arr.length / pool.length);
+  const fnStr = fn.toString();
+  const cid = ++parallel_map._cid;
+  const promises = [];
+  for (let ci = 0; ci < pool.length && ci * cs < arr.length; ci++) {
+    const chunk = arr.slice(ci * cs, (ci + 1) * cs);
+    const mid = cid * 1000 + ci;
+    promises.push(new Promise((resolve, reject) => {
+      const w = pool[ci];
+      const h = (msg) => { if (msg.i === mid) { w.removeListener("message", h); if (msg.e) reject(new Error(msg.e)); else resolve(msg.r); } };
+      w.on("message", h);
+      w.postMessage({i: mid, c: chunk, f: fnStr});
+    }));
+  }
+  return (await Promise.all(promises)).flat();
+}`,
   upper: `function upper(s) { return s.toUpperCase(); }`,
   lower: `function lower(s) { return s.toLowerCase(); }`,
   contains: `function contains(s, sub) { return s.includes(sub); }`,
@@ -173,6 +244,102 @@ Table.prototype = { get rows() { return this._rows.length; }, get columns() { re
   table_drop_duplicates: `function table_drop_duplicates(table, opts) { const by = opts && opts.by; const seen = new Set(); const rows = []; for (const row of table._rows) { const k = by ? (typeof by === 'function' ? String(by(row)) : String(row[by])) : JSON.stringify(row); if (!seen.has(k)) { seen.add(k); rows.push(row); } } return Table(rows, table._columns); }`,
   table_rename: `function table_rename(table, oldName, newName) { const cols = table._columns.map(c => c === oldName ? newName : c); const rows = table._rows.map(r => { const row = {}; for (const c of table._columns) row[c === oldName ? newName : c] = r[c]; return row; }); return Table(rows, cols); }`,
 
+  // ── Lazy Table Query Builder ────────────────────────
+  lazy: `function lazy(table) { return new LazyTable(table); }`,
+  collect: `function collect(v) { if (v instanceof LazyTable) return v.collect(); if (v && v._gen) return v.collect(); return v; }`,
+  LazyTable: `class LazyTable {
+  constructor(source) {
+    this._source = source;
+    this._steps = [];
+  }
+  _push(step) { const lt = new LazyTable(this._source); lt._steps = [...this._steps, step]; return lt; }
+  where(pred) { return this._push({ op: 'where', fn: pred }); }
+  select(...args) {
+    let cols;
+    if (args.length === 1 && args[0] && args[0].__exclude) {
+      cols = { exclude: new Set(Array.isArray(args[0].__exclude) ? args[0].__exclude : [args[0].__exclude]) };
+    } else { cols = args.filter(a => typeof a === 'string'); }
+    return this._push({ op: 'select', cols });
+  }
+  derive(derivations) { return this._push({ op: 'derive', derivations }); }
+  limit(n) { return this._push({ op: 'limit', n }); }
+  drop_duplicates(opts) { return this._push({ op: 'dedup', by: opts && opts.by }); }
+  rename(oldName, newName) { return this._push({ op: 'rename', oldName, newName }); }
+  sort_by(keyFn, opts) { return this._push({ op: 'sort', keyFn, desc: opts && opts.desc }); }
+  group_by(keyFn) {
+    const rows = this.collect()._rows;
+    const src = Table(rows, this._resolveColumns());
+    return table_group_by(src, keyFn);
+  }
+  _resolveColumns() {
+    let cols = [...this._source._columns];
+    for (const s of this._steps) {
+      if (s.op === 'select') {
+        cols = s.cols.exclude ? cols.filter(c => !s.cols.exclude.has(c)) : [...s.cols];
+      } else if (s.op === 'derive') {
+        for (const k of Object.keys(s.derivations)) { if (!cols.includes(k)) cols.push(k); }
+      } else if (s.op === 'rename') {
+        cols = cols.map(c => c === s.oldName ? s.newName : c);
+      }
+    }
+    return cols;
+  }
+  collect() {
+    let rows = this._source._rows;
+    let cols = [...this._source._columns];
+    for (const step of this._steps) {
+      switch (step.op) {
+        case 'where': rows = rows.filter(step.fn); break;
+        case 'select': {
+          const sc = step.cols.exclude ? cols.filter(c => !step.cols.exclude.has(c)) : step.cols;
+          rows = rows.map(r => { const row = {}; for (const c of sc) row[c] = r[c]; return row; });
+          cols = [...sc];
+          break;
+        }
+        case 'derive': {
+          for (const k of Object.keys(step.derivations)) { if (!cols.includes(k)) cols.push(k); }
+          rows = rows.map(r => { const row = { ...r }; for (const [k, fn] of Object.entries(step.derivations)) { row[k] = typeof fn === 'function' ? fn(r) : fn; } return row; });
+          break;
+        }
+        case 'limit': rows = rows.slice(0, step.n); break;
+        case 'dedup': {
+          const seen = new Set();
+          const filtered = [];
+          for (const row of rows) {
+            const k = step.by ? (typeof step.by === 'function' ? String(step.by(row)) : String(row[step.by])) : JSON.stringify(row);
+            if (!seen.has(k)) { seen.add(k); filtered.push(row); }
+          }
+          rows = filtered;
+          break;
+        }
+        case 'rename': {
+          cols = cols.map(c => c === step.oldName ? step.newName : c);
+          rows = rows.map(r => { const row = {}; for (const c of cols) row[c === step.newName ? step.newName : c] = r[c === step.newName ? step.oldName : c]; return row; });
+          break;
+        }
+        case 'sort': {
+          rows = [...rows].sort((a, b) => {
+            const ka = typeof step.keyFn === 'function' ? step.keyFn(a) : a[step.keyFn];
+            const kb = typeof step.keyFn === 'function' ? step.keyFn(b) : b[step.keyFn];
+            let c = ka < kb ? -1 : ka > kb ? 1 : 0;
+            return step.desc ? -c : c;
+          });
+          break;
+        }
+      }
+    }
+    return Table(rows, cols);
+  }
+  toArray() { return this.collect()._rows; }
+  toJSON() { return this.toArray(); }
+  get rows() { return this.collect()._rows.length; }
+  get columns() { return this._resolveColumns(); }
+  get shape() { const t = this.collect(); return [t._rows.length, t._columns.length]; }
+  toString() { return this.collect().toString(); }
+  _format(maxRows, title) { return this.collect()._format(maxRows, title); }
+  [Symbol.iterator]() { return this.collect()._rows[Symbol.iterator](); }
+}`,
+
   // ── Aggregation helpers ─────────────────────────────
   agg_sum: `function agg_sum(fn) { return (rows) => rows.reduce((a, r) => a + (typeof fn === 'function' ? fn(r) : r[fn]), 0); }`,
   agg_count: `function agg_count(fn) { if (!fn) return (rows) => rows.length; return (rows) => rows.filter(fn).length; }`,
@@ -236,25 +403,26 @@ Table.prototype = { get rows() { return this._rows.length; }, get columns() { re
   const lines = text.split('\\n').filter(l => l.trim());
   if (lines.length === 0) return Table([]);
   const parseLine = (line) => { const fields = []; let cur = ''; let inQ = false; for (let i = 0; i < line.length; i++) { const ch = line[i]; if (inQ) { if (ch === '"' && line[i+1] === '"') { cur += '"'; i++; } else if (ch === '"') { inQ = false; } else { cur += ch; } } else { if (ch === '"') inQ = true; else if (ch === delim) { fields.push(cur.trim()); cur = ''; } else { cur += ch; } } } fields.push(cur.trim()); return fields; };
+  const _reInt = /^-?\\d+$/; const _reFloat = /^-?\\d*\\.\\d+$/;
   let headers, ds; if (hasHeader) { headers = parseLine(lines[0]); ds = 1; } else { const fr = parseLine(lines[0]); headers = fr.map((_, i) => 'col_' + i); ds = 0; }
-  const rows = []; for (let i = ds; i < lines.length; i++) { const f = parseLine(lines[i]); const row = {}; for (let j = 0; j < headers.length; j++) { let v = f[j] ?? null; if (v !== null && v !== '') { if (/^-?\\d+$/.test(v)) v = parseInt(v, 10); else if (/^-?\\d*\\.\\d+$/.test(v)) v = parseFloat(v); else if (v === 'true') v = true; else if (v === 'false') v = false; else if (v === 'null' || v === 'nil') v = null; } else if (v === '') v = null; row[headers[j]] = v; } rows.push(row); }
+  const rows = []; for (let i = ds; i < lines.length; i++) { const f = parseLine(lines[i]); const row = {}; for (let j = 0; j < headers.length; j++) { let v = f[j] ?? null; if (v !== null && v !== '') { if (_reInt.test(v)) v = parseInt(v, 10); else if (_reFloat.test(v)) v = parseFloat(v); else if (v === 'true') v = true; else if (v === 'false') v = false; else if (v === 'null' || v === 'nil') v = null; } else if (v === '') v = null; row[headers[j]] = v; } rows.push(row); }
   return Table(rows, headers);
 }`,
   __parseJSONL: `function __parseJSONL(text) { return Table(text.split('\\n').filter(l => l.trim()).map(l => JSON.parse(l))); }`,
 
   // ── Table operation aliases (short names for pipe-friendly use) ──
-  where: `function where(tableOrArr, pred) { if (tableOrArr && tableOrArr._rows) return table_where(tableOrArr, pred); return tableOrArr.filter(pred); }`,
-  select: `function select(table, ...args) { return table_select(table, ...args); }`,
-  derive: `function derive(table, derivations) { return table_derive(table, derivations); }`,
+  where: `function where(tableOrArr, pred) { if (tableOrArr instanceof LazyTable) return tableOrArr.where(pred); if (tableOrArr && tableOrArr._rows) return table_where(tableOrArr, pred); return tableOrArr.filter(pred); }`,
+  select: `function select(table, ...args) { if (table instanceof LazyTable) return table.select(...args); return table_select(table, ...args); }`,
+  derive: `function derive(table, derivations) { if (table instanceof LazyTable) return table.derive(derivations); return table_derive(table, derivations); }`,
   agg: `function agg(grouped, aggregations) { return table_agg(grouped, aggregations); }`,
-  sort_by: `function sort_by(table, keyFn, opts) { return table_sort_by(table, keyFn, opts); }`,
-  limit: `function limit(table, n) { return table_limit(table, n); }`,
+  sort_by: `function sort_by(table, keyFn, opts) { if (table instanceof LazyTable) return table.sort_by(keyFn, opts); return table_sort_by(table, keyFn, opts); }`,
+  limit: `function limit(table, n) { if (table instanceof LazyTable) return table.limit(n); return table_limit(table, n); }`,
   pivot: `function pivot(table, opts) { return table_pivot(table, opts); }`,
   unpivot: `function unpivot(table, opts) { return table_unpivot(table, opts); }`,
   explode: `function explode(table, colFn) { return table_explode(table, colFn); }`,
   union: `function union(a, b) { if (a && a._rows) return table_union(a, b); return [...new Set([...a, ...b])]; }`,
-  drop_duplicates: `function drop_duplicates(table, opts) { return table_drop_duplicates(table, opts); }`,
-  rename: `function rename(table, oldName, newName) { return table_rename(table, oldName, newName); }`,
+  drop_duplicates: `function drop_duplicates(table, opts) { if (table instanceof LazyTable) return table.drop_duplicates(opts); return table_drop_duplicates(table, opts); }`,
+  rename: `function rename(table, oldName, newName) { if (table instanceof LazyTable) return table.rename(oldName, newName); return table_rename(table, oldName, newName); }`,
   mean: `function mean(v) { if (Array.isArray(v)) { return v.length === 0 ? 0 : v.reduce((a, b) => a + b, 0) / v.length; } return agg_mean(v); }`,
   median: `function median(v) { if (Array.isArray(v)) { if (v.length === 0) return null; const s = [...v].sort((a, b) => a - b); const m = Math.floor(s.length / 2); return s.length % 2 === 0 ? (s[m - 1] + s[m]) / 2 : s[m]; } return agg_median(v); }`,
 
@@ -332,13 +500,14 @@ Table.prototype = { get rows() { return this._rows.length; }, get columns() { re
   date_part: `function date_part(d, part) { if (typeof d === 'number') d = new Date(d); if (part === 'year') return d.getFullYear(); if (part === 'month') return d.getMonth() + 1; if (part === 'day') return d.getDate(); if (part === 'hour') return d.getHours(); if (part === 'minute') return d.getMinutes(); if (part === 'second') return d.getSeconds(); if (part === 'weekday') return d.getDay(); return null; }`,
   time_ago: `function 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'); }`,
 
-  // ── Regex ──────────────────────────────────────────────
-  regex_test: `function regex_test(s, pattern, flags) { return new RegExp(pattern, flags).test(s); }`,
-  regex_match: `function regex_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) }); }`,
-  regex_find_all: `function regex_find_all(s, pattern, flags) { const re = new RegExp(pattern, (flags || '') + (flags && flags.includes('g') ? '' : 'g')); const results = []; let m; while ((m = re.exec(s)) !== null) { results.push({ match: m[0], index: m.index, groups: m.slice(1) }); } return results; }`,
-  regex_replace: `function regex_replace(s, pattern, replacement, flags) { return s.replace(new RegExp(pattern, flags || 'g'), replacement); }`,
-  regex_split: `function regex_split(s, pattern, flags) { return s.split(new RegExp(pattern, flags)); }`,
-  regex_capture: `function regex_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); }`,
+  // ── Regex (with compiled regex cache) ─────────────────
+  __regex_cache: `const __reCache = new Map(); function __re(p, f) { const k = p + '\\0' + (f || ''); let r = __reCache.get(k); if (!r) { r = new RegExp(p, f); __reCache.set(k, r); if (__reCache.size > 1000) { const first = __reCache.keys().next().value; __reCache.delete(first); } } return r; }`,
+  regex_test: `function regex_test(s, pattern, flags) { return __re(pattern, flags).test(s); }`,
+  regex_match: `function regex_match(s, pattern, flags) { const m = s.match(__re(pattern, flags)); if (!m) return Err('No match'); return Ok({ match: m[0], index: m.index, groups: m.slice(1) }); }`,
+  regex_find_all: `function regex_find_all(s, pattern, flags) { const re = __re(pattern, (flags || '') + (flags && flags.includes('g') ? '' : 'g')); const results = []; let m; re.lastIndex = 0; while ((m = re.exec(s)) !== null) { results.push({ match: m[0], index: m.index, groups: m.slice(1) }); } return results; }`,
+  regex_replace: `function regex_replace(s, pattern, replacement, flags) { return s.replace(__re(pattern, flags || 'g'), replacement); }`,
+  regex_split: `function regex_split(s, pattern, flags) { return s.split(__re(pattern, flags)); }`,
+  regex_capture: `function regex_capture(s, pattern, flags) { const m = s.match(__re(pattern, flags)); if (!m) return Err('No match'); if (!m.groups) return Err('No named groups'); return Ok(m.groups); }`,
 
   // ── Validation ─────────────────────────────────────────
   is_email: `function is_email(s) { return /^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/.test(s); }`,
@@ -857,6 +1026,102 @@ Table.prototype = { get rows() { return this._rows.length; }, get columns() { re
   collections: `const collections = Object.freeze({
   OrderedDict, DefaultDict, Counter, Deque
 });`,
+
+  // ─── Typed numeric array functions for @fast mode ───────────────
+
+  typed_zeros: `function typed_zeros(n, Type) {
+  return new (Type || Float64Array)(n);
+}`,
+
+  typed_ones: `function typed_ones(n, Type) {
+  const out = new (Type || Float64Array)(n);
+  out.fill(1);
+  return out;
+}`,
+
+  typed_fill: `function typed_fill(arr, value) {
+  const out = new arr.constructor(arr.length);
+  out.fill(value);
+  return out;
+}`,
+
+  typed_range: `function typed_range(start, end, step) {
+  step = step || 1;
+  const n = Math.ceil((end - start) / step);
+  const arr = new Float64Array(n);
+  for (let i = 0; i < n; i++) arr[i] = start + i * step;
+  return arr;
+}`,
+
+  typed_linspace: `function typed_linspace(start, end, n) {
+  const out = new Float64Array(n);
+  if (n <= 1) { if (n === 1) out[0] = start; return out; }
+  const step = (end - start) / (n - 1);
+  for (let i = 0; i < n; i++) out[i] = start + i * step;
+  return out;
+}`,
+
+  typed_sum: `function typed_sum(arr) {
+  let s = 0, c = 0;
+  for (let i = 0; i < arr.length; i++) {
+    const y = arr[i] - c;
+    const t = s + y;
+    c = (t - s) - y;
+    s = t;
+  }
+  return s;
+}`,
+
+  typed_dot: `function typed_dot(a, b) {
+  const n = a.length;
+  let s = 0;
+  for (let i = 0; i < n; i++) s += a[i] * b[i];
+  return s;
+}`,
+
+  typed_norm: `function typed_norm(arr) {
+  let s = 0;
+  for (let i = 0; i < arr.length; i++) s += arr[i] * arr[i];
+  return Math.sqrt(s);
+}`,
+
+  typed_add: `function typed_add(a, b) {
+  const n = a.length;
+  const out = new a.constructor(n);
+  for (let i = 0; i < n; i++) out[i] = a[i] + b[i];
+  return out;
+}`,
+
+  typed_scale: `function typed_scale(arr, scalar) {
+  const out = new arr.constructor(arr.length);
+  for (let i = 0; i < arr.length; i++) out[i] = arr[i] * scalar;
+  return out;
+}`,
+
+  typed_map: `function typed_map(arr, fn) {
+  const out = new arr.constructor(arr.length);
+  for (let i = 0; i < arr.length; i++) out[i] = fn(arr[i], i);
+  return out;
+}`,
+
+  typed_reduce: `function typed_reduce(arr, fn, init) {
+  let acc = init;
+  for (let i = 0; i < arr.length; i++) acc = fn(acc, arr[i], i);
+  return acc;
+}`,
+
+  typed_sort: `function typed_sort(arr) {
+  if (arr instanceof Float64Array || arr instanceof Int32Array || arr instanceof Uint8Array ||
+      arr instanceof Float32Array || arr instanceof Int16Array || arr instanceof Uint16Array ||
+      arr instanceof Uint32Array || arr instanceof Int8Array) {
+    const out = new arr.constructor(arr);
+    out.sort();
+    return out;
+  }
+  const out = [...arr];
+  out.sort((a, b) => a - b);
+  return out;
+}`,
 };
 
 // All known builtin names for matching
@@ -881,13 +1146,21 @@ export const STDLIB_DEPS = {
   fs: ['Ok', 'Err'],
   url: ['Ok', 'Err'],
   parse_url: ['Ok', 'Err'],
-  regex_match: ['Ok', 'Err'],
-  regex_capture: ['Ok', 'Err'],
+  regex_test: ['__regex_cache'],
+  regex_match: ['Ok', 'Err', '__regex_cache'],
+  regex_find_all: ['__regex_cache'],
+  regex_replace: ['__regex_cache'],
+  regex_split: ['__regex_cache'],
+  regex_capture: ['Ok', 'Err', '__regex_cache'],
   json_parse: ['Ok', 'Err'],
   date_parse: ['Ok', 'Err'],
   read_text: ['Ok', 'Err'],
   try_fn: ['Ok', 'Err'],
   try_async: ['Ok', 'Err'],
+  // LazyTable requires Table and table_* functions
+  lazy: ['LazyTable', 'Table'],
+  collect: ['LazyTable'],
+  LazyTable: ['Table', 'table_where', 'table_group_by'],
   // Seq uses Some/None
   Seq: ['Some', 'None'],
   // compare family
@@ -954,6 +1227,7 @@ const _LEGACY_NAMES = [
   'lines', 'capitalize', 'title_case', 'snake_case', 'camel_case',
   'assert_eq', 'assert_ne', 'assert', 'assert_throws',
   'create_spy', 'create_mock',
+  'parallel_map',
 ];
 export const BUILTINS = _LEGACY_NAMES.map(n => BUILTIN_FUNCTIONS[n]).join('\n');
 
@@ -971,9 +1245,44 @@ export function buildSelectiveStdlib(usedNames) {
   return parts.join('\n');
 }
 
-// Full stdlib for runtime (REPL, run command)
+// Native FFI bridge initialization (server-side only, Bun runtime)
+// Lazily loads the Rust native library for high-performance stdlib operations
+// Async version for tova run (AsyncFunction context supports await)
+export const NATIVE_INIT = `var __tova_native = null;
+try {
+  if (typeof Bun !== 'undefined') {
+    const { dlopen: __dl, FFIType: __F } = await import('bun:ffi');
+    const __path = await import('path');
+    const __fs = await import('fs');
+    const __searchDirs = [
+      __path.join(__path.dirname(typeof __tova_filename !== 'undefined' ? __tova_filename : ''), 'native', 'target', 'release'),
+      __path.join(process.cwd(), 'native', 'target', 'release'),
+      __path.join(process.env.HOME || '', '.tova', 'lib'),
+    ];
+    const __libName = process.platform === 'darwin' ? 'libtova_native.dylib' : process.platform === 'win32' ? 'tova_native.dll' : 'libtova_native.so';
+    for (const __d of __searchDirs) {
+      const __p = __path.join(__d, __libName);
+      if (__fs.existsSync(__p)) {
+        const __lib = __dl(__p, {
+          tova_sort_f64: { args: [__F.ptr, __F.u64], returns: __F.void },
+          tova_sort_i64: { args: [__F.ptr, __F.u64], returns: __F.void },
+          tova_sum_f64: { args: [__F.ptr, __F.u64], returns: __F.f64 },
+          tova_min_f64: { args: [__F.ptr, __F.u64], returns: __F.f64 },
+          tova_max_f64: { args: [__F.ptr, __F.u64], returns: __F.f64 },
+        });
+        __tova_native = __lib.symbols;
+        break;
+      }
+    }
+  }
+} catch (__e) {}`;
+
+// Sync-safe version without await (for non-async contexts like tests, REPL eval)
+export const NATIVE_INIT_SYNC = `var __tova_native = null;`;
+
+// Full stdlib for runtime (REPL, run command) — sync-safe (no await)
 export function getFullStdlib() {
-  return `${buildSelectiveStdlib(BUILTIN_NAMES)}\n${RESULT_OPTION}\n${PROPAGATE}`;
+  return `${NATIVE_INIT_SYNC}\n${buildSelectiveStdlib(BUILTIN_NAMES)}\n${RESULT_OPTION}\n${PROPAGATE}`;
 }
 
 // Stdlib for client codegen (includes builtins + result/option + propagate)

package/src/stdlib/native-bridge.js

@@ -0,0 +1,150 @@
+// Tova Native FFI Bridge
+// Provides high-performance Rust-backed operations via Bun FFI
+// Falls back gracefully to pure JS when native library is unavailable
+
+let _lib = null;
+let _available = false;
+
+function _findLibrary() {
+  const { existsSync } = require('fs');
+  const { join, dirname } = require('path');
+
+  // Search paths for the native library
+  const names = process.platform === 'darwin'
+    ? ['libtova_native.dylib']
+    : process.platform === 'win32'
+      ? ['tova_native.dll']
+      : ['libtova_native.so'];
+
+  const searchDirs = [
+    // Relative to this file (src/stdlib/)
+    join(dirname(__filename), '..', '..', 'native', 'target', 'release'),
+    // Relative to bin/tova.js
+    join(dirname(__filename), '..', 'native', 'target', 'release'),
+    // System-wide install
+    join(process.env.HOME || '', '.tova', 'lib'),
+    // Next to the binary
+    dirname(process.argv[1] || ''),
+  ];
+
+  for (const dir of searchDirs) {
+    for (const name of names) {
+      const path = join(dir, name);
+      if (existsSync(path)) return path;
+    }
+  }
+  return null;
+}
+
+function _init() {
+  if (_lib !== null) return _available;
+
+  try {
+    const libPath = _findLibrary();
+    if (!libPath) {
+      _lib = false;
+      _available = false;
+      return false;
+    }
+
+    const { dlopen, FFIType } = require('bun:ffi');
+    _lib = dlopen(libPath, {
+      tova_sort_f64: {
+        args: [FFIType.ptr, FFIType.u64],
+        returns: FFIType.void,
+      },
+      tova_sort_i64: {
+        args: [FFIType.ptr, FFIType.u64],
+        returns: FFIType.void,
+      },
+      tova_unique_sorted_i64: {
+        args: [FFIType.ptr, FFIType.u64],
+        returns: FFIType.u64,
+      },
+      tova_unique_sorted_f64: {
+        args: [FFIType.ptr, FFIType.u64],
+        returns: FFIType.u64,
+      },
+      tova_sum_f64: {
+        args: [FFIType.ptr, FFIType.u64],
+        returns: FFIType.f64,
+      },
+      tova_min_f64: {
+        args: [FFIType.ptr, FFIType.u64],
+        returns: FFIType.f64,
+      },
+      tova_max_f64: {
+        args: [FFIType.ptr, FFIType.u64],
+        returns: FFIType.f64,
+      },
+    });
+    _available = true;
+    return true;
+  } catch (e) {
+    _lib = false;
+    _available = false;
+    return false;
+  }
+}
+
+/**
+ * Sort an array of numbers using Rust radix sort.
+ * Returns a new sorted array. Falls back to JS sort if native unavailable.
+ * Only used for arrays above the threshold (overhead of copying to/from TypedArray).
+ */
+export function nativeSortNumbers(arr) {
+  if (!_init()) return null; // fallback signal
+
+  const len = arr.length;
+  const buf = new Float64Array(len);
+  for (let i = 0; i < len; i++) buf[i] = arr[i];
+
+  _lib.symbols.tova_sort_f64(buf, len);
+
+  const result = new Array(len);
+  for (let i = 0; i < len; i++) result[i] = buf[i];
+  return result;
+}
+
+/**
+ * Sort a Float64Array in-place using Rust radix sort.
+ */
+export function nativeSortF64(buf) {
+  if (!_init()) return false;
+  _lib.symbols.tova_sort_f64(buf, buf.length);
+  return true;
+}
+
+/**
+ * Sum an array of numbers using Rust Kahan summation.
+ */
+export function nativeSum(arr) {
+  if (!_init()) return null;
+  const buf = new Float64Array(arr);
+  return _lib.symbols.tova_sum_f64(buf, buf.length);
+}
+
+/**
+ * Find min of numeric array using Rust.
+ */
+export function nativeMin(arr) {
+  if (!_init()) return null;
+  const buf = new Float64Array(arr);
+  return _lib.symbols.tova_min_f64(buf, buf.length);
+}
+
+/**
+ * Find max of numeric array using Rust.
+ */
+export function nativeMax(arr) {
+  if (!_init()) return null;
+  const buf = new Float64Array(arr);
+  return _lib.symbols.tova_max_f64(buf, buf.length);
+}
+
+/**
+ * Check if native library is available.
+ */
+export function isNativeAvailable() {
+  return _init();
+}

package/src/version.js

@@ -1,2 +1,2 @@
 // Auto-generated by scripts/embed-runtime.js — do not edit
-export const VERSION = "0.3.4";
+export const VERSION = "0.3.6";