vectrojs 0.0.1 → 0.1.1

package/src/bitpack.mjs

@@ -0,0 +1,135 @@
+// Bit-packed codes, for datasets on disk. Packed columns (pack.mjs) keep
+// their codes in 1, 2 or 4 bytes so the kernels can read them directly; on
+// disk each code takes only the bits it needs (a quantity 1..9: 4 bits, a
+// price in cents up to 999.99: 17), so a query reads fewer bytes. Reading a
+// chunk unpacks them back to bytes on every thread.
+//
+// A column's codes are stored as (code - base) in `bits` bits, little-endian
+// in 32-bit words; with missing values, the all-ones value means missing.
+
+import { I32, Fn, buildModule, get, set, i32c, block, loop, end, br, brIf, i32add, i32geu, i32wrapI64, memarg } from './wasm.mjs';
+
+const I64 = 0x7e;
+const I64_EXTEND_U = [0xad], I64_MUL = [0x7e], I64_SHR_U = [0x88], I64_AND = [0x83], I64_SHL = [0x86], I64_SUB = [0x7d], I64_EQ = [0x51];
+const I64_LOAD = [0x29, 0, 0], SELECT = [0x1b];
+const STORE = { 1: [0x3a, 0, 0], 2: [0x3b, 1, 0], 4: [0x36, 2, 0] }; // i32.store8 / store16 / store
+const SHIFT = { 1: 0, 2: 1, 4: 2 };
+
+// The fewest bits that hold 0..max (1..32).
+export function bitsFor(max) {
+  let b = 1;
+  while (b < 32 && max >= 2 ** b) b++;
+  return b;
+}
+
+// How a column's codes would be stored: { bits, base, missing } where
+// `missing` is the codes' NaN code if any row has it; or null when packing to
+// the bit saves nothing over `byteBits`.
+export function bitPlan(codes, n, nanCode, byteBits) {
+  let lo = Infinity, hi = -Infinity, missing = false;
+  for (let i = 0; i < n; i++) {
+    const c = codes[i];
+    if (c === nanCode) { missing = true; continue; }
+    if (c < lo) lo = c;
+    if (c > hi) hi = c;
+  }
+  if (lo === Infinity) lo = hi = 0;
+  const bits = bitsFor(hi - lo + (missing ? 1 : 0));
+  return bits < byteBits ? { bits, base: lo, missing: missing ? nanCode : null } : null;
+}
+
+// codes[0..n) as bytes (whole 32-bit words).
+export function packBits(codes, n, { bits, base, missing }) {
+  const words = new Uint32Array(Math.ceil((n * bits) / 32));
+  const ones = bits === 32 ? 0xffffffff : 2 ** bits - 1;
+  for (let i = 0, pos = 0; i < n; i++, pos += bits) {
+    const c = codes[i];
+    const v = missing !== null && c === missing ? ones : c - base;
+    const w = pos >>> 5, sh = pos & 31;
+    words[w] |= v << sh;
+    if (sh + bits > 32) words[w + 1] |= v >>> (32 - sh);
+  }
+  return new Uint8Array(words.buffer);
+}
+
+// The same in reverse, in plain JS (engines without compiled kernels).
+export function unpackBits(bytes, n, { bits, base, missing }, out) {
+  const words = new Uint32Array(bytes.buffer, bytes.byteOffset, bytes.byteLength >>> 2);
+  const ones = bits === 32 ? 0xffffffff : 2 ** bits - 1;
+  for (let i = 0, pos = 0; i < n; i++, pos += bits) {
+    const w = pos >>> 5, sh = pos & 31;
+    let v = words[w] >>> sh;
+    if (sh + bits > 32) v |= words[w + 1] << (32 - sh);
+    v = bits === 32 ? v >>> 0 : (v & ones) >>> 0;
+    out[i] = missing !== null && v === ones ? missing : v + base;
+  }
+}
+
+// unpack(start, end, unit, src, dst, base, hasMissing, missingCode):
+// dst[i] = the code of row i, for i in [start, end), as `width`-byte
+// integers, for codes of `bits` bits (compiled in). Eight rows always take
+// `bits` bytes, so within a group of eight every row's byte offset and shift
+// are constants: the body is unrolled (a 64-bit load, shift, mask, store per
+// row). Rows before the first whole group and after the last take a general
+// loop.
+export function unpackModule(width, bits, shared) {
+  const f = new Fn('k', [I32, I32, I32, I32, I32, I32, I32, I32], []);
+  const [start, stop, , src, dst, base, hasMissing, missingCode] = [0, 1, 2, 3, 4, 5, 6, 7];
+  const i = f.local(I32), pos = f.local(I64), v = f.local(I64), at = f.local(I32), out = f.local(I32), limit = f.local(I32);
+  const mask = i64c(BigInt(2 ** bits - 1));
+  const store = (offset) => [STORE[width][0], STORE[width][1], ...memarg(0, offset).slice(1)];
+  // [address on the stack] value (i64, shifted) -> masked; missing mapped; stored
+  const finish = (offset) => [...mask, ...I64_AND, ...set(v),
+    ...get(missingCode), ...get(v), ...i32wrapI64, ...get(base), ...i32add,
+    ...get(v), ...mask, ...I64_EQ, ...get(hasMissing), 0x71, ...SELECT, ...store(offset)];
+  const general = (lim) => [...block, ...loop, ...get(i), ...get(lim), ...i32geu, ...brIf(1),
+    ...get(i), ...i32c(SHIFT[width]), 0x74, ...get(dst), ...i32add, // address of dst[i]
+    ...get(i), ...I64_EXTEND_U, ...i64c(BigInt(bits)), ...I64_MUL, ...set(pos), // bit position
+    ...get(src), ...get(pos), 0x42, 3, ...I64_SHR_U, ...i32wrapI64, ...i32add, ...I64_LOAD,
+    ...get(pos), 0x42, 7, ...I64_AND, ...I64_SHR_U, ...finish(0),
+    ...get(i), ...i32c(1), ...i32add, ...set(i), ...br(0), ...end, ...end];
+  // head: rows up to the first multiple of 8 (or the end)
+  f.emit(get(start), set(i));
+  f.emit(get(start), i32c(7), i32add, i32c(-8), [0x71], set(limit));
+  f.emit(get(limit), get(stop), get(limit), get(stop), [0x49], SELECT, set(limit)); // min (i32.lt_u)
+  f.emit(general(limit));
+  // whole groups of eight: at = src + i / 8 * bits, out = dst + i * width
+  f.emit(get(stop), i32c(-8), [0x71], set(limit));
+  f.emit(get(i), i32c(3), [0x76], i32c(bits), [0x6c], get(src), i32add, set(at));
+  f.emit(get(i), i32c(SHIFT[width]), [0x74], get(dst), i32add, set(out));
+  f.emit(block, loop, get(i), get(limit), i32geu, brIf(1));
+  for (let j = 0; j < 8; j++) {
+    const b = j * bits;
+    f.emit(get(out), get(at), [0x29, ...memarg(0, b >> 3)], [0x42, b & 7], I64_SHR_U, finish(j * width));
+  }
+  f.emit(get(at), i32c(bits), i32add, set(at), get(out), i32c(8 * width), i32add, set(out), get(i), i32c(8), i32add, set(i), br(0), end, end);
+  // tail
+  f.emit(general(stop));
+  return buildModule([f], shared);
+}
+
+function i64c(x) { // i64.const, signed LEB128
+  const o = [0x42];
+  for (;;) {
+    const b = Number(x & 0x7fn);
+    x >>= 7n;
+    if ((x === 0n && !(b & 0x40)) || (x === -1n && b & 0x40)) { o.push(b); return o; }
+    o.push(b | 0x80);
+  }
+}
+
+// seq(start, end, unit, dst, first, step): dst[i] = first + i * step as
+// `width`-byte integers (a column that counts up at a fixed step, rebuilt on
+// every thread; first already includes the piece's first row).
+export function seqModule(width, shared) {
+  const f = new Fn('k', [I32, I32, I32, I32, I32, I32], []);
+  const [start, stop, , dst, first, step] = [0, 1, 2, 3, 4, 5];
+  const i = f.local(I32), v = f.local(I32), out = f.local(I32);
+  f.emit(get(start), set(i));
+  f.emit(get(i), get(step), [0x6c], get(first), i32add, set(v));
+  f.emit(get(i), i32c(SHIFT[width]), [0x74], get(dst), i32add, set(out));
+  f.emit(block, loop, get(i), get(stop), i32geu, brIf(1));
+  f.emit(get(out), get(v), STORE[width]);
+  f.emit(get(v), get(step), i32add, set(v), get(out), i32c(width), i32add, set(out), get(i), i32c(1), i32add, set(i), br(0), end, end);
+  return buildModule([f], shared);
+}

package/src/browser.mjs

@@ -0,0 +1,129 @@
+// Browser entry. On cross-origin-isolated pages (served with
+//   Cross-Origin-Opener-Policy: same-origin
+//   Cross-Origin-Embedder-Policy: require-corp)
+// the engine runs Web Workers on every core: the async API (aggAsync,
+// groupBy().aggAsync, collectAsync, ...) spreads queries across them while the
+// page stays responsive. Sync calls still work, on the page's thread only
+// (the page's main thread is not allowed to block and wait for workers).
+// Other pages get the single-thread engine, which needs no headers.
+//
+//   import { Engine } from 'vectrojs/browser';
+//   const engine = new Engine();
+//   const orders = await engine.loadCSV('/orders.csv');
+//   await orders.filter("region == 'EU'").sumAsync('price * qty');
+import { Engine as CoreEngine } from './engine.mjs';
+import { openDatasetAsync, writeDatasetAsync, csvToDatasetAsync, createDatasetAsync } from './dataset.mjs';
+import { writableFile, storedFiles, storedFile, removeStored, storageAvailable, opfsTemp } from './files-browser.mjs';
+import { setTempStorage } from './dataset.mjs';
+if (storageAvailable()) setTempStorage(opfsTemp); // (huge group-bys, sorts and joins spill to browser storage)
+
+export const browserPlatform = {
+  canBlock: false,
+  cpus: () => navigator.hardwareConcurrency || 4,
+  spawn(workerData) {
+    const { port1, port2 } = new MessageChannel();
+    const worker = new Worker(new URL('./worker-browser.mjs', import.meta.url), { type: 'module' });
+    worker.postMessage({ ...workerData, port: port2 }, [port2]);
+    // Messages from the worker arrive asynchronously; keep them until read.
+    port1.inbox = [];
+    port1.waiters = [];
+    port1.onmessage = (ev) => {
+      port1.inbox.push(ev.data);
+      for (const w of port1.waiters.splice(0)) w();
+    };
+    return { worker, port: port1 };
+  },
+  // A message that has already arrived, or undefined.
+  receive: (port) => (port.inbox.length ? { message: port.inbox.shift() } : undefined),
+  // Resolves when any of the ports receives a message.
+  nextMessage: (ports) => new Promise((resolve) => { for (const p of ports) p.waiters.push(resolve); }),
+};
+
+export const threadsAvailable = () => Boolean(globalThis.crossOriginIsolated) && typeof SharedArrayBuffer === 'function';
+
+export class Engine extends CoreEngine {
+  // spin: 0, workers sleep as soon as a task is done. Spinning only pays off
+  // when the caller blocks (Node); a page awaits anyway, and in Safari seven
+  // spinning workers starved the page: 4x slower queries, 9-40 ms stalls.
+  constructor(opts = {}) {
+    super({ platform: threadsAvailable() ? browserPlatform : null, spin: 0, ...opts });
+  }
+
+  // Fetch a CSV and parse it (on the workers when there are any).
+  async loadCSV(url, opts) {
+    const res = await fetch(url);
+    if (!res.ok) throw new Error(`vectro: ${url}: HTTP ${res.status}`);
+    return this.parseCSVAsync(new Uint8Array(await res.arrayBuffer()), opts);
+  }
+
+  // A dataset (a .vectro table of any size, see dataset.mjs) from a File the
+  // user picked or dropped, a Blob, or a URL (read with HTTP range requests):
+  // only the parts a query needs are read. Query it with the async calls.
+  //   const orders = await engine.openDataset(input.files[0]);
+  //   await sql('SELECT region, COUNT(*) FROM orders GROUP BY region', { orders }).toRowsAsync();
+  openDataset(source) { return openDatasetAsync(this, source); }
+
+  // Writing datasets in the browser: into its file storage (OPFS) by name,
+  // or to a file the user chose (a FileSystemFileHandle), or memoryFile().
+  // Big inputs stream: each chunk is on disk before the next is made.
+  //   await engine.csvToDataset(droppedCsvFile, 'orders.vectro');   // a CSV of any size
+  //   await engine.writeDataset('eu.vectro', orders.filter("region == 'EU'"));
+  //   const orders = await engine.openStoredDataset('orders.vectro');
+  async writeDataset(target, source, opts) { return writeDatasetAsync(this, await target_(target, opts), source, opts); }
+  async csvToDataset(csv, target, opts) { return csvToDatasetAsync(this, csv, await target_(target, opts), opts); }
+  // A writer: appendAsync(table or columns) as often as needed, then closeAsync().
+  async createDataset(target, opts) { return createDatasetAsync(this, await target_(target, opts), opts); }
+  async storedDatasets() { return (await storedFiles()).filter((f) => f.name.endsWith('.vectro')); }
+  async openStoredDataset(name) { return openDatasetAsync(this, await storedFile(name)); }
+  storedDatasetFile(name) { return storedFile(name); } // (a File: to download, or to open)
+  removeStoredDataset(name) { return removeStored(name); }
+}
+
+// a name in browser storage or a FileSystemFileHandle -> a writable file; file objects as they are
+const target_ = (t, opts) => (typeof t === 'string' || typeof t?.createWritable === 'function' ? writableFile(t, { append: opts?.append }) : t);
+
+// ---- split tables: multi-core on pages WITHOUT isolation headers ------------
+// No shared memory: each Web Worker owns a slice of every table and answers
+// for it; the page combines the partial results (see split.mjs). Async API only.
+//
+//   import { SplitEngine } from 'vectrojs/browser';
+//   const engine = new SplitEngine();                 // one worker per core
+//   const orders = await engine.loadCSV('/orders.csv');
+//   await orders.filter("region == 'EU'").sumAsync('price * qty');
+import { SplitEngine as BaseSplitEngine } from './split.mjs';
+
+export function spawnSplitWorker() {
+  const w = new Worker(new URL('./split-worker.mjs', import.meta.url), { type: 'module' });
+  return {
+    post: (msg, transfer) => w.postMessage(msg, transfer ?? []),
+    onMessage: (fn) => { w.onmessage = (ev) => fn(ev.data); },
+    onError: (fn) => {
+      w.onerror = (ev) => { ev.preventDefault?.(); fn(new Error(ev.message || 'worker error')); };
+      w.onmessageerror = () => fn(new Error('a message from the worker could not be read'));
+    },
+    terminate: () => w.terminate(),
+  };
+}
+
+export class SplitEngine extends BaseSplitEngine {
+  constructor(opts = {}) {
+    super({ workers: navigator.hardwareConcurrency || 4, spawn: spawnSplitWorker, ...opts });
+  }
+
+  async loadCSV(url, opts) {
+    const res = await fetch(url);
+    if (!res.ok) throw new Error(`vectro: ${url}: HTTP ${res.status}`);
+    return this.parseCSVAsync(new Uint8Array(await res.arrayBuffer()), opts);
+  }
+}
+
+export { canCompileWasm } from './engine.mjs';
+export { Table } from './table.mjs';
+
+export { VectorIndex } from './vectors.mjs';
+export { BatchEncoder, FrameReader, encodeSchema, encodeEnd } from './frames.mjs';
+export { readArrow, writeArrow, ArrowReader, ArrowEncoder } from './arrow.mjs';
+export { DistinctSketch } from './sketch.mjs';
+export { sql } from './sql.mjs';
+export { Dataset, openDatasetAsync, blobFile, urlFile, writeDatasetAsync, csvToDatasetAsync, createDatasetAsync } from './dataset.mjs';
+export { memoryFile, writableFile, storageAvailable } from './files-browser.mjs';

package/src/bytes.mjs

@@ -0,0 +1,60 @@
+// Text and byte helpers that work everywhere: Node's Buffer when it exists
+// (fast, and accepts shared memory), standard TextDecoder otherwise.
+
+const NodeBuffer = globalThis.Buffer;
+const decoders = { utf8: new TextDecoder('utf-8'), latin1: new TextDecoder('latin1') };
+const encoder = new TextEncoder();
+const isShared = (buf) => typeof SharedArrayBuffer === 'function' && buf instanceof SharedArrayBuffer;
+
+// Decode bytes [s, e) of a Uint8Array.
+export function decode(u8, s, e, enc = 'utf8') {
+  if (NodeBuffer) return NodeBuffer.from(u8.buffer, u8.byteOffset, u8.length).toString(enc, s, e);
+  const part = u8.subarray(s, e);
+  return decoders[enc].decode(isShared(u8.buffer) ? part.slice() : part); // TextDecoder refuses shared memory
+}
+
+export const encode = (str) => encoder.encode(str);
+
+// Node's Buffer.indexOf uses memchr/memmem and is ~6x faster than
+// TypedArray.indexOf, so it's used whenever Buffer exists.
+const asBuffer = (u8) => NodeBuffer.from(u8.buffer, u8.byteOffset, u8.length);
+
+// First index of `byte` in [s, e), or -1.
+export function indexOfByte(u8, byte, s, e = u8.length) {
+  const i = NodeBuffer ? asBuffer(u8).indexOf(byte, s) : u8.indexOf(byte, s);
+  return i !== -1 && i < e ? i : -1;
+}
+
+// Number of times `byte` occurs in [s, e).
+export function countByte(u8, byte, s, e) {
+  let n = 0;
+  if (NodeBuffer) {
+    const b = asBuffer(u8);
+    for (let i = b.indexOf(byte, s); i !== -1 && i < e; i = b.indexOf(byte, i + 1)) n++;
+  } else {
+    for (let i = s; i < e; i++) if (u8[i] === byte) n++;
+  }
+  return n;
+}
+
+// Occurrences of the byte pattern starting inside [s, e) (overlapping matches count).
+export function countPattern(u8, pat, s, e) {
+  const m = pat.length;
+  if (m === 0) return 0;
+  let n = 0;
+  if (NodeBuffer) {
+    const hi = Math.min(u8.length, e + m - 1);
+    if (hi <= s) return 0;
+    const b = NodeBuffer.from(u8.buffer, u8.byteOffset + s, hi - s), p = NodeBuffer.from(pat.buffer, pat.byteOffset, m);
+    for (let i = b.indexOf(p, 0); i !== -1 && i < e - s; i = b.indexOf(p, i + 1)) n++;
+    return n;
+  }
+  const first = pat[0], last = Math.min(e - 1, u8.length - m);
+  for (let i = s; i <= last; i++) {
+    if (u8[i] !== first) continue;
+    let k = 1;
+    while (k < m && u8[i + k] === pat[k]) k++;
+    if (k === m) n++;
+  }
+  return n;
+}

package/src/csv-kernel.mjs

@@ -0,0 +1,205 @@
+// CSV parsing that runs on every thread. The file's bytes are in shared
+// memory; each unit of work is one chunk that starts at a row boundary.
+
+import { decode, countByte } from './bytes.mjs';
+
+const NL = 10, CR = 13, QUOTE = 34, SPACE = 32, MINUS = 45, PLUS = 43, DOT = 46;
+
+// Free-text values are stored as one number: byte offset * 2^20 + length,
+// with bit 19 marking a quoted value that contains "" escapes.
+export const STR_SHIFT = 2 ** 20, STR_ESCAPED = 2 ** 19, STR_MAX_LEN = 2 ** 19 - 1;
+export function decodeString(bytes, v) {
+  if (Number.isNaN(v)) return '';
+  const start = Math.floor(v / STR_SHIFT);
+  let len = v - start * STR_SHIFT;
+  const escaped = len >= STR_ESCAPED;
+  if (escaped) len -= STR_ESCAPED;
+  const s = decode(bytes, start, start + len);
+  return escaped ? s.replaceAll('""', '"') : s;
+}
+
+// Dictionary keyed by raw bytes, so repeated values never become JS strings:
+// a string is made once per distinct value per chunk. `unescape` turns the
+// raw bytes of an escaped value into its text (CSV: "" -> ").
+export class ByteDict {
+  constructor(bytes, unescape = (str) => str.replaceAll('""', '"')) {
+    this.bytes = bytes;
+    this.unescape = unescape;
+    this.cap = 64;
+    this.slots = new Int32Array(this.cap).fill(-1);
+    this.hashes = new Uint32Array(this.cap);
+    this.starts = [];
+    this.lens = [];
+    this.strings = [];
+  }
+  code(s, e, escaped) {
+    const b = this.bytes;
+    let h = 2166136261;
+    for (let i = s; i < e; i++) h = Math.imul(h ^ b[i], 16777619);
+    h >>>= 0;
+    const mask = this.cap - 1;
+    for (let slot = h & mask; ; slot = (slot + 1) & mask) {
+      const c = this.slots[slot];
+      if (c === -1) return this.#insert(slot, h, s, e, escaped);
+      if (this.hashes[slot] === h && this.lens[c] === e - s && this.#same(this.starts[c], s, e - s)) return c;
+    }
+  }
+  #same(a, b, len) {
+    const x = this.bytes;
+    for (let i = 0; i < len; i++) if (x[a + i] !== x[b + i]) return false;
+    return true;
+  }
+  #insert(slot, h, s, e, escaped) {
+    const code = this.strings.length;
+    const str = decode(this.bytes, s, e);
+    this.strings.push(escaped ? this.unescape(str) : str);
+    this.starts.push(s);
+    this.lens.push(e - s);
+    this.slots[slot] = code;
+    this.hashes[slot] = h;
+    if (this.strings.length * 2 > this.cap) this.#grow();
+    return code;
+  }
+  #grow() {
+    const old = { slots: this.slots, hashes: this.hashes };
+    this.cap *= 2;
+    this.slots = new Int32Array(this.cap).fill(-1);
+    this.hashes = new Uint32Array(this.cap);
+    const mask = this.cap - 1;
+    for (let i = 0; i < old.slots.length; i++) {
+      const c = old.slots[i];
+      if (c === -1) continue;
+      let slot = old.hashes[i] & mask;
+      while (this.slots[slot] !== -1) slot = (slot + 1) & mask;
+      this.slots[slot] = c;
+      this.hashes[slot] = old.hashes[i];
+    }
+  }
+}
+const POW10 = Array.from({ length: 23 }, (_, i) => 10 ** i);
+
+// Count quote characters (mode 0) or rows (mode 1) in chunk u.
+// Rows are newlines outside quotes, plus a final line without a newline.
+export function csvScan(u, A, sc) {
+  const bytes = A[0], bounds = A[1];
+  const start = bounds[u], end = bounds[u + 1];
+  if (end <= start) return 0;
+  const mode = sc[0], hasQuotes = sc[1];
+  if (mode === 0) return countByte(bytes, QUOTE, start, end);
+  let rows;
+  if (!hasQuotes) {
+    rows = countByte(bytes, NL, start, end); // native indexOf speed
+  } else {
+    rows = 0;
+    let inQuotes = false;
+    for (let i = start; i < end; i++) {
+      const c = bytes[i];
+      if (c === QUOTE) inQuotes = !inQuotes;
+      else if (c === NL && !inQuotes) rows++;
+    }
+  }
+  return bytes[end - 1] === NL ? rows : rows + 1;
+}
+
+// Parse chunk u straight into the output columns.
+// A = [bytes, bounds, rowStarts, fieldMap, kinds, ...columns]
+//   fieldMap[f] = output column for field f (-1 = skip)
+//   kinds[o] = 0 number, 1 category (dictionary codes), 2 free text (byte refs)
+// sc = [delimiter, number of fields]
+// Text columns get chunk-local codes; emit() reports each chunk's dictionary
+// so the caller can renumber them into one shared dictionary.
+export function csvParse(u, A, sc, emit) {
+  const bytes = A[0], bounds = A[1], rowStarts = A[2], fieldMap = A[3], kinds = A[4];
+  const cols = [];
+  for (let o = 0; o < kinds.length; o++) cols.push(A[5 + o]);
+  const delim = sc[0], nFields = sc[1];
+  const dicts = Array.from(kinds, (k) => (k === 1 ? new ByteDict(bytes) : null));
+  const end = bounds[u + 1];
+  let i = bounds[u], row = rowStarts[u];
+
+  while (i < end) {
+    let f = 0;
+    for (;;) {
+      let s, e, escaped = false;
+      if (i < end && bytes[i] === QUOTE) {
+        s = ++i;
+        for (;;) {
+          if (i >= end) { e = i; break; }
+          if (bytes[i] === QUOTE) {
+            if (bytes[i + 1] === QUOTE) { escaped = true; i += 2; continue; }
+            e = i++;
+            break;
+          }
+          i++;
+        }
+        while (i < end && bytes[i] !== delim && bytes[i] !== NL) i++;
+      } else {
+        s = i;
+        while (i < end) { const c = bytes[i]; if (c === delim || c === NL) break; i++; }
+        e = i;
+        if (e > s && bytes[e - 1] === CR) e--;
+      }
+      const o = f < nFields ? fieldMap[f] : -1;
+      if (o >= 0) {
+        const kind = kinds[o];
+        if (kind === 0) cols[o][row] = parseNumber(bytes, s, e);
+        else if (kind === 1) cols[o][row] = dicts[o].code(s, e, escaped);
+        else {
+          if (e - s > STR_MAX_LEN) throw new RangeError(`vectro: a text value in row ${row + 1} is longer than ${STR_MAX_LEN} bytes`);
+          cols[o][row] = s * STR_SHIFT + (e - s) + (escaped ? STR_ESCAPED : 0);
+        }
+      }
+      f++;
+      if (i < end && bytes[i] === delim) { i++; continue; }
+      break;
+    }
+    // missing trailing fields
+    for (; f < nFields; f++) {
+      const o = fieldMap[f];
+      if (o < 0) continue;
+      if (kinds[o] === 1) cols[o][row] = dicts[o].code(0, 0, false); // empty text
+      else cols[o][row] = NaN; // number, or free text (decodes to '')
+    }
+    i++; // past the newline
+    row++;
+  }
+  dicts.forEach((d, o) => { if (d) emit({ kind: 'csvdict', unit: u, col: o, strings: d.strings }); });
+}
+
+// Exact decimal parsing for plain numbers (Clinger's fast path: an integer of
+// at most 2^53 times or divided by an exact power of ten is correctly rounded,
+// so the result is identical to Number()). Anything else goes to Number().
+export function parseNumber(b, s, e) {
+  while (s < e && b[s] === SPACE) s++;
+  while (e > s && (b[e - 1] === SPACE || b[e - 1] === CR)) e--;
+  if (s === e) return NaN;
+  let i = s, neg = false;
+  if (b[i] === MINUS) { neg = true; i++; } else if (b[i] === PLUS) i++;
+  let m = 0, digits = 0, exp = 0, c;
+  while (i < e && (c = b[i] - 48) >= 0 && c <= 9) { m = m * 10 + c; digits++; i++; }
+  if (i < e && b[i] === DOT) {
+    i++;
+    while (i < e && (c = b[i] - 48) >= 0 && c <= 9) { m = m * 10 + c; digits++; exp--; i++; }
+  }
+  if (i < e && (b[i] | 32) === 101) { // e / E
+    i++;
+    let eneg = false, ev = 0, edigits = 0;
+    if (b[i] === MINUS) { eneg = true; i++; } else if (b[i] === PLUS) i++;
+    while (i < e && (c = b[i] - 48) >= 0 && c <= 9) { ev = ev * 10 + c; edigits++; i++; }
+    if (!edigits) return slowNumber(b, s, e);
+    exp += eneg ? -ev : ev;
+  }
+  if (i !== e || digits === 0 || m > 9007199254740991) return slowNumber(b, s, e);
+  let v;
+  if (exp === 0) v = m;
+  else if (exp > 0 && exp <= 22) v = m * POW10[exp];
+  else if (exp < 0 && exp >= -22) v = m / POW10[-exp];
+  else return slowNumber(b, s, e);
+  return neg ? -v : v;
+}
+
+function slowNumber(b, s, e) {
+  const str = decode(b, s, e, 'latin1');
+  const v = Number(str);
+  return str.trim() === '' ? NaN : v;
+}