vectrojs 0.0.1 → 0.1.1

package/src/textmap.mjs

@@ -0,0 +1,159 @@
+// Functions of whole values, text ones above all (SQL's UPPER, SUBSTR, ||,
+// CAST(x AS VARCHAR), text CASE...): a JavaScript function of the inputs'
+// values, run once per distinct combination of them rather than per row (a
+// category column's labels are few), its answers spread back to the rows.
+// Text answers become a category column whose labels live in `state`
+// ({ dict, codes }), which only grows: chunk after chunk of a dataset, the
+// same text keeps the same code.
+import { decodeOne } from './pack.mjs';
+import { decodeString } from './csv-kernel.mjs';
+
+// Each row's value of a column as a small whole number (its id), and the
+// value of each id: text as strings ('' for missing), numbers and dates as
+// numbers (NaN for missing).
+function idsOf(engine, c, n, f32) {
+  const d = engine.live(c.data), ids = new Int32Array(n);
+  if (c.dict) {
+    const K = c.dict.length;
+    for (let i = 0; i < n; i++) { const v = c.enc ? decodeOne(c.enc, d[i], f32) : d[i]; ids[i] = v === v ? v : K; }
+    return { ids, size: K + 1, value: (id) => (id < K ? c.dict[id] : '') };
+  }
+  if (c.strings) {
+    const bytes = engine.live(c.strings), seen = new Map(), vals = [];
+    for (let i = 0; i < n; i++) {
+      const v = d[i], s = v === v ? decodeString(bytes, v) ?? '' : '';
+      let id = seen.get(s);
+      if (id === undefined) { id = vals.length; vals.push(s); seen.set(s, id); }
+      ids[i] = id;
+    }
+    return { ids, size: Math.max(1, vals.length), value: (id) => vals[id] };
+  }
+  const x = c.enc ? Float64Array.from({ length: n }, (_, i) => decodeOne(c.enc, d[i], f32)) : d;
+  let lo = Infinity, hi = -Infinity, whole = true;
+  for (let i = 0; i < n; i++) { const v = x[i]; if (v !== v) continue; if (v < lo) lo = v; if (v > hi) hi = v; if (whole && v !== Math.floor(v)) whole = false; }
+  if (lo === Infinity) { ids.fill(0); return { ids, size: 1, value: () => NaN }; }
+  if (whole && hi - lo < 2 ** 22) { // small whole numbers: the id is the value (from the least); missing last
+    const miss = hi - lo + 1;
+    for (let i = 0; i < n; i++) { const v = x[i]; ids[i] = v === v ? v - lo : miss; }
+    return { ids, size: miss + 1, value: (id) => (id === miss ? NaN : (id + lo === 0 ? 0 : id + lo)) };
+  }
+  const seen = new Map(), vals = [];
+  for (let i = 0; i < n; i++) {
+    const v = x[i], k = v === v ? (v === 0 ? 0 : v) : NaN; // (-0 and 0 are one value; NaN keys a Map fine)
+    let id = seen.get(k);
+    if (id === undefined) { id = vals.length; vals.push(k); seen.set(k, id); }
+    ids[i] = id;
+  }
+  return { ids, size: Math.max(1, vals.length), value: (id) => vals[id] };
+}
+
+// A column read as ids without a pass of its own, when it can be: id = value -
+// lo (category codes, or whole numbers in a small range), missing -> miss.
+// range: [min, max, values not whole] of a number column (from the engine), or none
+function directOf(engine, c, n, f32, range) {
+  if (c.strings || c.enc) return null;
+  const d = engine.live(c.data).subarray(0, n);
+  if (c.dict) { const K = c.dict.length; return { d, lo: 0, size: K + 1, miss: K, value: (id) => (id < K ? c.dict[id] : '') }; }
+  let [lo, hi, frac] = range ?? [Infinity, -Infinity, 0];
+  if (!range) for (let i = 0; i < n; i++) { const v = d[i]; if (v !== v) continue; if (v < lo) lo = v; if (v > hi) hi = v; if (v !== Math.floor(v)) frac++; }
+  if (!(lo <= hi) || frac || hi - lo >= 2 ** 22) return null;
+  const miss = hi - lo + 1;
+  if (c.numbered) return { d, lo, size: miss + 1, miss, value: (id) => (id === miss ? NaN : c.numbered(id + lo)) }; // (group numbers of the values)
+  return { d, lo, size: miss + 1, miss, value: (id) => (id === miss ? NaN : id + lo === 0 ? 0 : id + lo) };
+}
+
+// dst[i] = fn(values of row i): codes (text, labels added to state) or numbers.
+export function textmapRows(engine, cols, n, f32, fn, text, state, dst, ranges = []) {
+  const codeOf = (r) => {
+    const s = r === null || r === undefined || (typeof r === 'number' && r !== r) ? '' : String(r);
+    let code = state.codes.get(s);
+    if (code === undefined) { code = state.dict.length; state.dict.push(s); state.codes.set(s, code); }
+    return code;
+  };
+  const answer = text ? codeOf : (r) => (typeof r === 'number' ? r : r === null || r === undefined || r === '' ? NaN : Number(r));
+  if (!cols.length) { dst.fill(answer(fn()), 0, n); return; }
+  const direct = cols.map((c, k) => directOf(engine, c, n, f32, ranges[k]));
+  if (cols.length === 1) { // one input: each value once, then a lookup per row
+    let x = direct[0];
+    if (!x) { const r = idsOf(engine, cols[0], n, f32); x = { d: r.ids, lo: 0, size: r.size, miss: -1, value: r.value }; } // (ids: never missing)
+    const seen = new Uint8Array(x.size + 1), res = new Float64Array(x.size + 1);
+    markIds(x.d, x.lo, x.miss, seen, n);
+    for (let id = 0; id < seen.length; id++) if (seen[id]) res[id] = answer(fn(x.value(id)));
+    spreadIds(x.d, x.lo, x.miss, res, dst, n);
+    return;
+  }
+  const product = direct.every(Boolean) ? direct.reduce((a, x) => a * x.size, 1) : Infinity;
+  if (product <= 2 ** 22) { // every input direct and few combinations: the combination as one number, read as it goes
+    const slot = new Int32Array(product).fill(-1), res = [];
+    const strides = direct.map((_, k) => direct.slice(k + 1).reduce((a, x) => a * x.size, 1));
+    const [a, b] = direct, sa = strides[0];
+    if (direct.length === 2) {
+      markPairs(a.d, a.lo, a.miss, b.d, b.lo, b.miss, sa, slot, n); // (slot: each pair's first row)
+      const byKey = new Float64Array(product), id = (x, v) => (v === v ? v - x.lo : x.miss);
+      for (let key = 0; key < product; key++) { const i = slot[key]; if (i >= 0) byKey[key] = answer(fn(a.value(id(a, a.d[i])), b.value(id(b, b.d[i])))); }
+      spreadPairs(a.d, a.lo, a.miss, b.d, b.lo, b.miss, sa, byKey, dst, n);
+      return;
+    }
+    for (let i = 0; i < n; i++) {
+      let key;
+      if (direct.length === 2) { const u = a.d[i], w = b.d[i]; key = ((u === u ? u - a.lo : a.miss) * sa + (w === w ? w - b.lo : b.miss)) | 0; }
+      else { key = 0; for (let k = 0; k < direct.length; k++) { const v = direct[k].d[i]; key += (v === v ? v - direct[k].lo : direct[k].miss) * strides[k]; } key |= 0; }
+      let j = slot[key];
+      if (j < 0) {
+        j = slot[key] = res.length;
+        res.push(answer(fn(...direct.map((x) => { const v = x.d[i]; return x.value(v === v ? v - x.lo : x.miss); }))));
+      }
+      dst[i] = res[j];
+    }
+    return;
+  }
+  dst.set(rowsByCombination(engine, cols, n, f32, fn, answer));
+}
+
+// (hot loops as small functions with no calls inside: a callback there,
+// a new one each time, would make V8 throw the compiled loop away)
+function markIds(d, lo, miss, seen, n) { for (let i = 0; i < n; i++) { const v = d[i]; seen[v === v ? (v - lo) | 0 : miss] = 1; } }
+function spreadIds(d, lo, miss, res, dst, n) { for (let i = 0; i < n; i++) { const v = d[i]; dst[i] = res[v === v ? (v - lo) | 0 : miss]; } }
+function markPairs(ad, alo, amiss, bd, blo, bmiss, sa, first, n) {
+  for (let i = 0; i < n; i++) {
+    const u = ad[i], w = bd[i], x = u === u ? (u - alo) | 0 : amiss, y = w === w ? (w - blo) | 0 : bmiss, key = x * sa + y;
+    if (first[key] < 0) first[key] = i;
+  }
+}
+function spreadPairs(ad, alo, amiss, bd, blo, bmiss, sa, byKey, dst, n) {
+  for (let i = 0; i < n; i++) { const u = ad[i], w = bd[i], x = u === u ? (u - alo) | 0 : amiss, y = w === w ? (w - blo) | 0 : bmiss; dst[i] = byKey[x * sa + y]; }
+}
+
+// several inputs, any kind: one number per row for its combination (mixed
+// radix, renumbered when it would grow too big), each distinct one once
+function rowsByCombination(engine, cols, n, f32, fn, answer) {
+  const out = new Float64Array(n);
+  const ins = cols.map((c) => idsOf(engine, c, n, f32));
+  // several: one number per row for its combination (mixed radix, renumbered
+  // when it would grow too big), then each distinct combination once
+  let comb = Float64Array.from(ins[0].ids), size = ins[0].size;
+  const renumber = () => {
+    const m = new Map();
+    for (let i = 0; i < n; i++) { let id = m.get(comb[i]); if (id === undefined) { id = m.size; m.set(comb[i], id); } comb[i] = id; }
+    size = Math.max(1, m.size);
+  };
+  for (let k = 1; k < ins.length; k++) {
+    if (size * ins[k].size > 2 ** 52) renumber();
+    const { ids, size: s } = ins[k];
+    for (let i = 0; i < n; i++) comb[i] = comb[i] * s + ids[i];
+    size *= s;
+  }
+  const dense = size <= 2 ** 24 ? new Int32Array(size).fill(-1) : null, map = dense ? null : new Map();
+  const res = [];
+  for (let i = 0; i < n; i++) {
+    const key = comb[i];
+    let j = dense ? dense[key] : map.get(key);
+    if (j === undefined || j < 0) {
+      j = res.length;
+      res.push(answer(fn(...ins.map((x) => x.value(x.ids[i])))));
+      if (dense) dense[key] = j; else map.set(key, j);
+    }
+    out[i] = res[j];
+  }
+  return out;
+}

package/src/vectors.mjs

@@ -0,0 +1,138 @@
+// Vector search: nearest embeddings to a query, exact (no approximate index),
+// on every core.
+//
+//   const index = await VectorIndex.create(engine, {
+//     vectors,                      // n embeddings: number[][] or one flat Float32Array (n * dim)
+//     dim: 384,
+//     metric: 'cosine',             // 'cosine' (default) | 'dot' | 'l2'
+//     columns: { id, title, year }, // anything to return or filter on
+//   });
+//   await index.searchAsync(query, { k: 10, filter: 'year >= 2020' });
+//   // -> [{ id, title, year, score }, ...] best first
+//
+// Embeddings are stored as columns of a float32 table (v0 … v{dim-1}), so the
+// score is an ordinary fused expression, q0*v0 + q1*v1 + …, computed 24
+// dimensions per pass with the query as scalars, then top(k). That makes
+// filters, split tables (Web Workers on any page) and edge runtimes work with
+// no extra code. cosine: vectors and query are normalized, score = dot
+// (higher is closer). l2: score = squared distance (lower is closer).
+const DIMS_PER_PASS = 24; // a pass reads 24 vector columns + the running sum
+const METRICS = new Set(['cosine', 'dot', 'l2']);
+
+export class VectorIndex {
+  constructor(table, { dim, metric, names }) {
+    this.table = table;
+    this.dim = dim;
+    this.metric = metric;
+    this.names = names; // the non-vector columns returned with each hit
+  }
+
+  // engine: a normal Engine (Node, browser, portable) or a SplitEngine.
+  static async create(engine, { vectors, dim, metric = 'cosine', columns = {} }) {
+    if (!METRICS.has(metric)) throw new Error(`vectro: metric must be 'cosine', 'dot' or 'l2', got "${metric}"`);
+    if (!(dim >= 1)) throw new Error('vectro: VectorIndex needs dim, the length of each embedding');
+    const flat = flatten(vectors, dim);
+    const n = flat.length / dim;
+    for (const [name, values] of Object.entries(columns)) {
+      if (/^v\d+$/.test(name) || name.startsWith('__np_')) throw new Error(`vectro: column name "${name}" is reserved for vectors`);
+      if (values.length !== n) throw new RangeError(`vectro: column "${name}" has ${values.length} values, expected ${n} (one per vector)`);
+    }
+    const cols = { ...columns };
+    const vcols = Array.from({ length: dim }, () => new Float32Array(n));
+    const norm2 = new Float32Array(n);
+    for (let i = 0; i < n; i++) {
+      let s = 0;
+      for (let j = 0; j < dim; j++) s += flat[i * dim + j] ** 2;
+      const scale = metric === 'cosine' && s > 0 ? 1 / Math.sqrt(s) : 1;
+      for (let j = 0; j < dim; j++) vcols[j][i] = flat[i * dim + j] * scale;
+      norm2[i] = metric === 'cosine' ? 1 : s;
+    }
+    vcols.forEach((c, j) => { cols[`v${j}`] = c; });
+    if (metric === 'l2') cols.__np_norm2 = norm2;
+    const table = typeof engine.tableAsync === 'function'
+      ? await engine.tableAsync(cols, { type: Float32Array })
+      : engine.table(cols, { type: Float32Array });
+    return new VectorIndex(table, { dim, metric, names: Object.keys(columns) });
+  }
+
+  get length() { return this.table.length; }
+
+  // The k closest vectors to `query` (among rows matching `filter`), best first.
+  async searchAsync(query, { k = 10, filter = null, params = {} } = {}) {
+    const q = Array.from(query);
+    if (q.length !== this.dim) throw new RangeError(`vectro: query has ${q.length} values, the index has dim ${this.dim}`);
+    const view = filter ? this.table.filter(filter, params) : this.table;
+    const opts = { k, metric: this.metric, dim: this.dim, names: this.names };
+    // split tables: every worker searches its own rows in one round trip
+    if (typeof view.vectorSearchAsync === 'function') return view.vectorSearchAsync(q, opts);
+    return searchTable(view, q, opts);
+  }
+
+  async dispose() { await this.table.dispose(); }
+}
+
+function flatten(vectors, dim) {
+  if (ArrayBuffer.isView(vectors)) {
+    if (vectors.length % dim) throw new RangeError(`vectro: ${vectors.length} values is not a whole number of ${dim}-dimension vectors`);
+    return vectors;
+  }
+  const flat = new Float32Array(vectors.length * dim);
+  vectors.forEach((v, i) => {
+    if (v.length !== dim) throw new RangeError(`vectro: vector ${i} has ${v.length} values, expected ${dim}`);
+    flat.set(v, i * dim);
+  });
+  return flat;
+}
+
+// Search one table (or filtered view): running dot product, DIMS_PER_PASS
+// dimensions per pass, then top k over a narrow view (not the vectors).
+export async function searchTable(view, query, { k, metric, dim, names }) {
+  const q = Float64Array.from(query);
+  if (metric === 'cosine') {
+    const len = Math.hypot(...q);
+    if (len > 0) for (let j = 0; j < q.length; j++) q[j] /= len;
+  }
+  const made = [];
+  try {
+    let prev = null;
+    for (let j0 = 0, pass = 0; j0 < dim; j0 += DIMS_PER_PASS, pass++) {
+      const terms = [], scalars = {};
+      for (let j = j0; j < Math.min(dim, j0 + DIMS_PER_PASS); j++) {
+        terms.push(`__np_q${j - j0} * v${j}`);
+        scalars[`__np_q${j - j0}`] = q[j];
+      }
+      const name = `__np_dot${pass}`;
+      view = await view.deriveAsync(name, prev ? `${prev} + ${terms.join(' + ')}` : terms.join(' + '), scalars);
+      made.push(view);
+      prev = name;
+    }
+    let key, scoreCol = prev;
+    if (metric === 'l2') {
+      view = await view.deriveAsync('__np_score', `__np_norm2 - 2 * ${prev} + __np_qq`, { __np_qq: q.reduce((a, x) => a + x * x, 0) });
+      made.push(view);
+      key = scoreCol = '__np_score';
+    } else {
+      key = `-${prev}`;
+    }
+    const best = await view.select(...names, scoreCol).topAsync(k, key);
+    try {
+      return best.toRows().map((r) => {
+        const hit = {};
+        for (const name of names) hit[name] = r[name];
+        hit.score = metric === 'l2' ? Math.max(0, r[scoreCol]) : r[scoreCol];
+        return hit;
+      });
+    } finally {
+      best.dispose();
+    }
+  } finally {
+    for (const t of made.reverse()) await t.dispose();
+  }
+}
+
+// Merge per-worker hits (each best first) into the overall best k.
+export function mergeHits(lists, k, metric) {
+  const all = lists.flat();
+  const better = metric === 'l2' ? (a, b) => a.score - b.score : (a, b) => b.score - a.score;
+  return all.sort(better).slice(0, k);
+}

package/src/wasm.mjs

@@ -0,0 +1,254 @@
+// Generates the SIMD kernels as a WebAssembly binary at startup, so the
+// package needs no compiler toolchain. Only the handful of instructions the
+// kernels use are encoded here.
+
+export const I32 = 0x7f, F32 = 0x7d, F64 = 0x7c, V128 = 0x7b;
+
+function uleb(n) {
+  const out = [];
+  do {
+    let b = n & 0x7f;
+    n >>>= 7;
+    if (n) b |= 0x80;
+    out.push(b);
+  } while (n);
+  return out;
+}
+
+function sleb(n) {
+  const out = [];
+  for (;;) {
+    const b = n & 0x7f;
+    n >>= 7;
+    if ((n === 0 && !(b & 0x40)) || (n === -1 && b & 0x40)) { out.push(b); return out; }
+    out.push(b | 0x80);
+  }
+}
+
+const bytesOf = (Type, v) => [...new Uint8Array(new Type([v]).buffer)];
+const name = (s) => { const b = [...new TextEncoder().encode(s)]; return [...uleb(b.length), ...b]; };
+const vec = (items) => [...uleb(items.length), ...items.flat()];
+const section = (id, content) => [id, ...uleb(content.length), ...content];
+
+// ---- instructions -----------------------------------------------------------
+export const get = (i) => [0x20, ...uleb(i)];
+export const set = (i) => [0x21, ...uleb(i)];
+export const i32c = (v) => [0x41, ...sleb(v)];
+export const block = [0x02, 0x40], loop = [0x03, 0x40], end = [0x0b];
+export const br = (l) => [0x0c, ...uleb(l)];
+export const brIf = (l) => [0x0d, ...uleb(l)];
+export const i32add = [0x6a], i32mul = [0x6c], i32and = [0x71], i32geu = [0x4f], i32wrapI64 = [0xa7];
+export const simd = (code, ...imm) => [0xfd, ...uleb(code), ...imm];
+export const memarg = (align, offset) => [...uleb(align), ...uleb(offset)];
+export const vload = (off) => simd(0x00, ...memarg(0, off));
+export const vstore = (off) => simd(0x0b, ...memarg(0, off));
+
+// Per element type: scalar opcodes and their SIMD (128-bit) equivalents.
+export const TY = {
+  f64: {
+    val: F64, bytes: 8, lanes: 2, cnst: (v) => [0x44, ...bytesOf(Float64Array, v)],
+    load: [0x2b, ...memarg(3, 0)], store: [0x39, ...memarg(3, 0)],
+    add: [0xa0], mul: [0xa2], min: [0xa4], max: [0xa5], gt: [0x64], toF64: [],
+    vsplat: simd(0x14), vlane: (l) => simd(0x21, l),
+    vadd: simd(0xf0), vmul: simd(0xf2), vmin: simd(0xf4), vmax: simd(0xf5), vgt: simd(0x4a),
+    // comparison masks are 64-bit integer lanes
+    mlanes: 2, msub: simd(0xd1), madd: simd(0xce), mlane: (l) => [...simd(0x1d, l), ...i32wrapI64],
+  },
+  f32: {
+    val: F32, bytes: 4, lanes: 4, cnst: (v) => [0x43, ...bytesOf(Float32Array, v)],
+    load: [0x2a, ...memarg(2, 0)], store: [0x38, ...memarg(2, 0)],
+    add: [0x92], mul: [0x94], min: [0x96], max: [0x97], gt: [0x5e], toF64: [0xbb],
+    vsplat: simd(0x13), vlane: (l) => simd(0x1f, l),
+    vadd: simd(0xe4), vmul: simd(0xe6), vmin: simd(0xe8), vmax: simd(0xe9), vgt: simd(0x44),
+    mlanes: 4, msub: simd(0xb1), madd: simd(0xae), mlane: (l) => simd(0x1b, l),
+  },
+};
+
+export class Fn {
+  constructor(exportName, params, results) {
+    this.exportName = exportName;
+    this.params = params;
+    this.results = results;
+    this.locals = [];
+    this.code = [];
+  }
+  local(type) { this.locals.push(type); return this.params.length + this.locals.length - 1; }
+  emit(...parts) { for (const p of parts) this.code.push(...p); }
+}
+
+// Loop skeleton shared by every kernel. `ptrs` advance together; the main loop
+// handles U vectors (U*16 bytes) per iteration, then a scalar loop does the
+// leftover elements.
+// strides: bytes per row of each pointer (default: the element type's; packed
+// columns use fewer, see pack.mjs).
+export function loops(f, ty, { ptrs, n, U, body, between = () => {}, tail, strides = null }) {
+  const vend = f.local(I32), stop = f.local(I32);
+  const perIter = ty.lanes * U;
+  const stride = (i) => strides?.[i] ?? ty.bytes;
+  f.emit(get(n), i32c(~(perIter - 1)), i32and, i32c(stride(0)), i32mul, get(ptrs[0]), i32add, set(vend));
+  f.emit(get(n), i32c(stride(0)), i32mul, get(ptrs[0]), i32add, set(stop));
+  f.emit(block, loop, get(ptrs[0]), get(vend), i32geu, brIf(1));
+  body();
+  ptrs.forEach((p, i) => f.emit(get(p), i32c(stride(i) * perIter), i32add, set(p)));
+  f.emit(br(0), end, end);
+  between();
+  f.emit(block, loop, get(ptrs[0]), get(stop), i32geu, brIf(1));
+  tail();
+  ptrs.forEach((p, i) => f.emit(get(p), i32c(stride(i)), i32add, set(p)));
+  f.emit(br(0), end, end);
+}
+
+// sum / min / max with 4 independent vector accumulators, so the CPU can run
+// several additions at once instead of waiting on each one.
+function reduction(t, kind) {
+  const ty = TY[t];
+  const f = new Fn(`${kind}_${t}`, [I32, I32], [F64]);
+  const [p, n] = [0, 1];
+  const U = 4;
+  const acc = Array.from({ length: U }, () => f.local(V128));
+  const s = f.local(ty.val);
+  const identity = kind === 'sum' ? 0 : kind === 'min' ? Infinity : -Infinity;
+  const vop = ty[{ sum: 'vadd', min: 'vmin', max: 'vmax' }[kind]];
+  const sop = ty[{ sum: 'add', min: 'min', max: 'max' }[kind]];
+  for (const a of acc) f.emit(ty.cnst(identity), ty.vsplat, set(a));
+  loops(f, ty, {
+    ptrs: [p], n, U,
+    body: () => acc.forEach((a, k) => f.emit(get(a), get(p), vload(16 * k), vop, set(a))),
+    between: () => {
+      f.emit(get(acc[0]), get(acc[1]), vop, get(acc[2]), get(acc[3]), vop, vop, set(acc[0]));
+      f.emit(get(acc[0]), ty.vlane(0));
+      for (let l = 1; l < ty.lanes; l++) f.emit(get(acc[0]), ty.vlane(l), sop);
+      f.emit(set(s));
+    },
+    tail: () => f.emit(get(s), get(p), ty.load, sop, set(s)),
+  });
+  f.emit(get(s), ty.toF64);
+  return f;
+}
+
+function dot(t) {
+  const ty = TY[t];
+  const f = new Fn(`dot_${t}`, [I32, I32, I32], [F64]);
+  const [pa, pb, n] = [0, 1, 2];
+  const U = 4;
+  const acc = Array.from({ length: U }, () => f.local(V128));
+  const s = f.local(ty.val);
+  for (const a of acc) f.emit(ty.cnst(0), ty.vsplat, set(a));
+  loops(f, ty, {
+    ptrs: [pa, pb], n, U,
+    body: () => acc.forEach((a, k) => f.emit(get(a), get(pa), vload(16 * k), get(pb), vload(16 * k), ty.vmul, ty.vadd, set(a))),
+    between: () => {
+      f.emit(get(acc[0]), get(acc[1]), ty.vadd, get(acc[2]), get(acc[3]), ty.vadd, ty.vadd, set(acc[0]));
+      f.emit(get(acc[0]), ty.vlane(0));
+      for (let l = 1; l < ty.lanes; l++) f.emit(get(acc[0]), ty.vlane(l), ty.add);
+      f.emit(set(s));
+    },
+    tail: () => f.emit(get(s), get(pa), ty.load, get(pb), ty.load, ty.mul, ty.add, set(s)),
+  });
+  f.emit(get(s), ty.toF64);
+  return f;
+}
+
+// Count elements > x. A SIMD compare gives all-ones (-1) per matching lane,
+// so subtracting the mask adds 1 to each lane's counter.
+function countGreater(t) {
+  const ty = TY[t];
+  const f = new Fn(`countgt_${t}`, [I32, I32, ty.val], [I32]);
+  const [p, n, x] = [0, 1, 2];
+  const U = 4;
+  const vx = f.local(V128), c = f.local(I32);
+  const acc = Array.from({ length: U }, () => f.local(V128));
+  f.emit(get(x), ty.vsplat, set(vx));
+  for (const a of acc) f.emit(i32c(0), simd(0x11), set(a)); // i32x4.splat(0) = all-zero vector
+  loops(f, ty, {
+    ptrs: [p], n, U,
+    body: () => acc.forEach((a, k) => f.emit(get(a), get(p), vload(16 * k), get(vx), ty.vgt, ty.msub, set(a))),
+    between: () => {
+      f.emit(get(acc[0]), get(acc[1]), ty.madd, get(acc[2]), get(acc[3]), ty.madd, ty.madd, set(acc[0]));
+      f.emit(get(acc[0]), ty.mlane(0));
+      for (let l = 1; l < ty.mlanes; l++) f.emit(get(acc[0]), ty.mlane(l), i32add);
+      f.emit(set(c));
+    },
+    tail: () => f.emit(get(c), get(p), ty.load, get(x), ty.gt, i32add, set(c)),
+  });
+  f.emit(get(c));
+  return f;
+}
+
+// out = a + b
+function add(t) {
+  const ty = TY[t];
+  const f = new Fn(`add_${t}`, [I32, I32, I32, I32], []);
+  const [pa, pb, po, n] = [0, 1, 2, 3];
+  const U = 2;
+  loops(f, ty, {
+    ptrs: [pa, pb, po], n, U,
+    body: () => { for (let k = 0; k < U; k++) f.emit(get(po), get(pa), vload(16 * k), get(pb), vload(16 * k), ty.vadd, vstore(16 * k)); },
+    tail: () => f.emit(get(po), get(pa), ty.load, get(pb), ty.load, ty.add, ty.store),
+  });
+  return f;
+}
+
+// out = a * k + c
+function scale(t) {
+  const ty = TY[t];
+  const f = new Fn(`scale_${t}`, [I32, I32, I32, ty.val, ty.val], []);
+  const [pa, po, n, k, c] = [0, 1, 2, 3, 4];
+  const U = 2;
+  const vk = f.local(V128), vc = f.local(V128);
+  f.emit(get(k), ty.vsplat, set(vk), get(c), ty.vsplat, set(vc));
+  loops(f, ty, {
+    ptrs: [pa, po], n, U,
+    body: () => { for (let j = 0; j < U; j++) f.emit(get(po), get(pa), vload(16 * j), get(vk), ty.vmul, get(vc), ty.vadd, vstore(16 * j)); },
+    tail: () => f.emit(get(po), get(pa), ty.load, get(k), ty.mul, get(c), ty.add, ty.store),
+  });
+  return f;
+}
+
+// float32 sums are left to JS: a 4-lane float32 accumulator loses too much
+// precision over millions of values (it would need pairwise summation).
+export function kernelFns() {
+  return [
+    reduction('f64', 'sum'), reduction('f64', 'min'), reduction('f64', 'max'),
+    reduction('f32', 'min'), reduction('f32', 'max'),
+    dot('f64'), countGreater('f64'), countGreater('f32'),
+    add('f64'), add('f32'), scale('f64'), scale('f32'),
+  ];
+}
+
+export function buildKernels(shared = true) {
+  return buildModule(kernelFns(), shared);
+}
+
+// Assemble functions into a module that imports env.memory: shared memory
+// when threads use it, plain memory for single-thread and edge builds.
+export function buildModule(fns, shared = true) {
+  const types = [];
+  const typeIndex = fns.map((f) => {
+    const sig = [0x60, ...vec(f.params.map((x) => [x])), ...vec(f.results.map((x) => [x]))];
+    let i = types.findIndex((t) => t.join() === sig.join());
+    if (i < 0) { types.push(sig); i = types.length - 1; }
+    return i;
+  });
+
+  const importMemory = [...name('env'), ...name('memory'), 0x02, shared ? 0x03 : 0x01, ...uleb(1), ...uleb(65536)]; // max 4GB
+  const bodies = fns.map((f) => {
+    const groups = [];
+    for (const t of f.locals) {
+      const last = groups[groups.length - 1];
+      if (last && last[1] === t) last[0]++;
+      else groups.push([1, t]);
+    }
+    const body = [...vec(groups.map(([count, t]) => [...uleb(count), t])), ...f.code, ...end];
+    return [...uleb(body.length), ...body];
+  });
+
+  return new Uint8Array([
+    0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00,
+    ...section(1, vec(types)),
+    ...section(2, vec([importMemory])),
+    ...section(3, vec(typeIndex.map((i) => uleb(i)))),
+    ...section(7, vec(fns.map((f, i) => [...name(f.exportName), 0x00, ...uleb(i)]))),
+    ...section(10, vec(bodies)),
+  ]);
+}