@dreamlake/dreamdb 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2271 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Dataset: () => Dataset,
+  MULTIHASH_BYTES: () => MULTIHASH_BYTES,
+  MemoryBackend: () => MemoryBackend,
+  S3Backend: () => S3Backend,
+  SCALAR_ENCODING_MAP: () => SCALAR_ENCODING_MAP,
+  Schema: () => Schema,
+  Space: () => Space,
+  base32ToBytes: () => base32ToBytes,
+  bitsFromProjections: () => bitsFromProjections,
+  bitsToBase2: () => bitsToBase2,
+  buildPqCosineDecoder: () => buildPqCosineDecoder,
+  buildRabitqCosineDecoder: () => buildRabitqCosineDecoder,
+  bytesToBase32: () => bytesToBase32,
+  chacha20Stream: () => chacha20Stream,
+  decodeBucketAnchorsOnly: () => decodeBucketAnchorsOnly,
+  decodeBucketRecords: () => decodeBucketRecords,
+  decodeCbor: () => decodeCbor,
+  deriveHyperplanesLshCosine: () => deriveHyperplanesLshCosine,
+  deriveRotationMatrix: () => deriveRotationMatrix,
+  dotF32: () => dotF32,
+  dotL2Normalized: () => dotL2Normalized,
+  encodeCbor: () => encodeCbor,
+  modalityForField: () => modalityForField,
+  multiProbeKeys: () => multiProbeKeys,
+  normalizeL2: () => normalizeL2,
+  normalizeL2F32: () => normalizeL2F32,
+  parseSpaceUri: () => parseSpaceUri,
+  peekBucketHeader: () => peekBucketHeader,
+  projectionsLshCosine: () => projectionsLshCosine,
+  scalarModalityFragment: () => scalarModalityFragment
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/cbor.ts
+function decodeCbor(bytes) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const r = { off: 0 };
+  return readValue(view, bytes, r);
+}
+function encodeCbor(value) {
+  const parts = [];
+  encodeValue(value, parts);
+  let totalLen = 0;
+  for (const p of parts) totalLen += p.length;
+  const out = new Uint8Array(totalLen);
+  let off = 0;
+  for (const p of parts) {
+    out.set(p, off);
+    off += p.length;
+  }
+  return out;
+}
+function encodeValue(value, parts) {
+  if (value === null) {
+    parts.push(new Uint8Array([246]));
+    return;
+  }
+  if (value === void 0) {
+    parts.push(new Uint8Array([247]));
+    return;
+  }
+  if (value === true) {
+    parts.push(new Uint8Array([245]));
+    return;
+  }
+  if (value === false) {
+    parts.push(new Uint8Array([244]));
+    return;
+  }
+  if (typeof value === "number") {
+    if (Number.isInteger(value) && value >= 0 && value <= Number.MAX_SAFE_INTEGER) {
+      encodeUint(0, value, parts);
+    } else if (Number.isInteger(value) && value < 0 && value >= -Number.MAX_SAFE_INTEGER) {
+      encodeUint(1, -1 - value, parts);
+    } else {
+      const buf = new Uint8Array(9);
+      buf[0] = 251;
+      const dv = new DataView(buf.buffer);
+      dv.setFloat64(1, value);
+      parts.push(buf);
+    }
+    return;
+  }
+  if (typeof value === "bigint") {
+    if (value >= 0n) {
+      encodeUint64(0, value, parts);
+    } else {
+      encodeUint64(1, -1n - value, parts);
+    }
+    return;
+  }
+  if (typeof value === "string") {
+    const encoded = new TextEncoder().encode(value);
+    encodeUint(3, encoded.length, parts);
+    parts.push(encoded);
+    return;
+  }
+  if (value instanceof Uint8Array) {
+    encodeUint(2, value.length, parts);
+    parts.push(new Uint8Array(value));
+    return;
+  }
+  if (Array.isArray(value)) {
+    encodeUint(4, value.length, parts);
+    for (const item of value) {
+      encodeValue(item, parts);
+    }
+    return;
+  }
+  if (typeof value === "object") {
+    const keys = Object.keys(value);
+    encodeUint(5, keys.length, parts);
+    for (const k of keys) {
+      encodeValue(k, parts);
+      encodeValue(value[k], parts);
+    }
+    return;
+  }
+}
+function encodeUint(majorType, n, parts) {
+  const mt = majorType << 5;
+  if (n < 24) {
+    parts.push(new Uint8Array([mt | n]));
+  } else if (n < 256) {
+    parts.push(new Uint8Array([mt | 24, n]));
+  } else if (n < 65536) {
+    const buf = new Uint8Array(3);
+    buf[0] = mt | 25;
+    buf[1] = n >> 8 & 255;
+    buf[2] = n & 255;
+    parts.push(buf);
+  } else if (n < 4294967296) {
+    const buf = new Uint8Array(5);
+    buf[0] = mt | 26;
+    const dv = new DataView(buf.buffer);
+    dv.setUint32(1, n);
+    parts.push(buf);
+  } else {
+    encodeUint64(majorType, BigInt(n), parts);
+  }
+}
+function encodeUint64(majorType, n, parts) {
+  const mt = majorType << 5;
+  const buf = new Uint8Array(9);
+  buf[0] = mt | 27;
+  const dv = new DataView(buf.buffer);
+  dv.setBigUint64(1, n);
+  parts.push(buf);
+}
+function readValue(view, bytes, r) {
+  const ib = bytes[r.off++];
+  const mt = ib >> 5;
+  const ai = ib & 31;
+  const arg = readArg(view, bytes, r, ai);
+  switch (mt) {
+    case 0:
+      return typeof arg === "bigint" ? arg <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(arg) : arg : arg;
+    case 1:
+      if (typeof arg === "bigint") {
+        const val = -1n - arg;
+        return val >= BigInt(Number.MIN_SAFE_INTEGER) ? Number(val) : val;
+      }
+      return -1 - Number(arg);
+    case 2: {
+      const len = Number(arg);
+      const out = bytes.slice(r.off, r.off + len);
+      r.off += len;
+      return out;
+    }
+    case 3: {
+      const len = Number(arg);
+      const sl = bytes.subarray(r.off, r.off + len);
+      r.off += len;
+      return new TextDecoder().decode(sl);
+    }
+    case 4: {
+      const len = Number(arg);
+      const arr = [];
+      for (let i = 0; i < len; i++) arr.push(readValue(view, bytes, r));
+      return arr;
+    }
+    case 5: {
+      const len = Number(arg);
+      const obj = {};
+      for (let i = 0; i < len; i++) {
+        const k = readValue(view, bytes, r);
+        const v = readValue(view, bytes, r);
+        obj[String(k)] = v;
+      }
+      return obj;
+    }
+    case 7: {
+      if (ai === 20) return false;
+      if (ai === 21) return true;
+      if (ai === 22) return null;
+      if (ai === 23) return void 0;
+      if (ai === 26) return view.getFloat32(r.off - 4);
+      if (ai === 27) return view.getFloat64(r.off - 8);
+      if (ai === 25) {
+        const raw = Number(arg);
+        const sign = raw >> 15 & 1;
+        const exp = raw >> 10 & 31;
+        const frac = raw & 1023;
+        let val;
+        if (exp === 0) {
+          val = frac === 0 ? 0 : Math.pow(2, -24) * frac;
+        } else if (exp === 31) {
+          val = frac === 0 ? Infinity : NaN;
+        } else {
+          val = Math.pow(2, exp - 25) * (1024 + frac);
+        }
+        return sign ? -val : val;
+      }
+      throw new Error(`CBOR simple ${ai} not supported`);
+    }
+    default:
+      throw new Error(`CBOR major type ${mt} not supported`);
+  }
+}
+function readArg(view, bytes, r, ai) {
+  if (ai < 24) return ai;
+  if (ai === 24) return bytes[r.off++];
+  if (ai === 25) {
+    const v = view.getUint16(r.off);
+    r.off += 2;
+    return v;
+  }
+  if (ai === 26) {
+    const v = view.getUint32(r.off);
+    r.off += 4;
+    return v;
+  }
+  if (ai === 27) {
+    const v = view.getBigUint64(r.off);
+    r.off += 8;
+    return v;
+  }
+  throw new Error(`CBOR additional-info ${ai} not supported`);
+}
+
+// src/uri.ts
+var MULTIHASH_BYTES = 33;
+var BASE32_ALPHABET = "abcdefghijklmnopqrstuvwxyz234567";
+var BASE32_DECODE_MAP = /* @__PURE__ */ new Map();
+for (let i = 0; i < BASE32_ALPHABET.length; i++) {
+  BASE32_DECODE_MAP.set(BASE32_ALPHABET[i], i);
+}
+function bytesToBase32(bytes) {
+  let bits = 0;
+  let value = 0;
+  let out = "";
+  for (const b of bytes) {
+    value = value << 8 | b;
+    bits += 8;
+    while (bits >= 5) {
+      bits -= 5;
+      out += BASE32_ALPHABET[value >> bits & 31];
+    }
+  }
+  if (bits > 0) out += BASE32_ALPHABET[value << 5 - bits & 31];
+  return out;
+}
+function base32ToBytes(str) {
+  const lower = str.toLowerCase();
+  let bits = 0;
+  let value = 0;
+  const out = [];
+  for (const ch of lower) {
+    const v = BASE32_DECODE_MAP.get(ch);
+    if (v === void 0) throw new Error(`Invalid base32 character: '${ch}'`);
+    value = value << 5 | v;
+    bits += 5;
+    while (bits >= 8) {
+      bits -= 8;
+      out.push(value >> bits & 255);
+    }
+  }
+  return new Uint8Array(out);
+}
+function parseSpaceUri(uri) {
+  const u = new URL(uri);
+  const parts = u.pathname.replace(/^\/+/, "").split("/");
+  if (parts.length < 2) {
+    throw new Error(
+      `Space URI missing /refs/<name> or /manifests/<hash> suffix: ${uri}`
+    );
+  }
+  const id = parts.pop();
+  const marker = parts.pop();
+  let kind;
+  if (marker === "refs") kind = "ref";
+  else if (marker === "manifests") kind = "manifest";
+  else
+    throw new Error(
+      `Space URI: expected /refs/ or /manifests/, got /${marker}/: ${uri}`
+    );
+  const connectorBase = `${u.origin}/${parts.join("/")}`.replace(/\/$/, "");
+  return { connectorBase, kind, id };
+}
+function scalarModalityFragment(valueType) {
+  const map = {
+    categorical: "cat",
+    bool: "bool",
+    int: "i64",
+    float: "f64",
+    string: "str",
+    timestamp: "ts"
+  };
+  return map[valueType.toLowerCase()] || "str";
+}
+function modalityForField(field) {
+  if (field.kind === "image") return `image.${field.mime}`;
+  if (field.kind === "video") return `video.${field.mime}`;
+  if (field.kind === "audio") return `audio.${field.mime}`;
+  if (field.kind === "embedding") return `embedding.f32.dim=${field.dim}.bucketed`;
+  if (field.kind === "scalar") {
+    const vt = field.value_type || field.valueType || "str";
+    const enc = scalarModalityFragment(vt);
+    return `scalar.${enc}.field=${field.name}`;
+  }
+  return null;
+}
+
+// src/backend.ts
+var S3Backend = class {
+  baseUrl;
+  constructor(baseUrl) {
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+  }
+  async get(path, opts) {
+    const url = `${this.baseUrl}/${path}`;
+    const fetchOpts = {};
+    if (opts?.noCache) {
+      fetchOpts.cache = "no-store";
+    }
+    const r = await fetch(url, fetchOpts);
+    if (!r.ok) throw new Error(`GET ${url}: HTTP ${r.status}`);
+    return new Uint8Array(await r.arrayBuffer());
+  }
+  async put(path, data, opts) {
+    const url = `${this.baseUrl}/${path}`;
+    const headers = {};
+    if (opts?.contentType) {
+      headers["Content-Type"] = opts.contentType;
+    } else {
+      headers["Content-Type"] = "application/octet-stream";
+    }
+    const r = await fetch(url, {
+      method: "PUT",
+      headers,
+      body: data
+    });
+    if (!r.ok) throw new Error(`PUT ${url}: HTTP ${r.status}`);
+    return path;
+  }
+  async list(prefix) {
+    const url = `${this.baseUrl}?list-type=2&prefix=${encodeURIComponent(prefix)}`;
+    const r = await fetch(url);
+    if (!r.ok) throw new Error(`LIST ${url}: HTTP ${r.status}`);
+    const text = await r.text();
+    const keys = [];
+    const regex = /<Key>([^<]+)<\/Key>/g;
+    let match;
+    while ((match = regex.exec(text)) !== null) {
+      keys.push(match[1]);
+    }
+    return keys;
+  }
+  async delete(path) {
+    const url = `${this.baseUrl}/${path}`;
+    const r = await fetch(url, { method: "DELETE" });
+    if (!r.ok) throw new Error(`DELETE ${url}: HTTP ${r.status}`);
+  }
+};
+var MemoryBackend = class {
+  store = /* @__PURE__ */ new Map();
+  async get(path, _opts) {
+    const data = this.store.get(path);
+    if (!data) throw new Error(`MemoryBackend: key not found: ${path}`);
+    return data;
+  }
+  async put(path, data, _opts) {
+    this.store.set(path, new Uint8Array(data));
+    return path;
+  }
+  async list(prefix) {
+    const keys = [];
+    for (const k of this.store.keys()) {
+      if (k.startsWith(prefix)) keys.push(k);
+    }
+    return keys.sort();
+  }
+  async delete(path) {
+    this.store.delete(path);
+  }
+  /** Check whether a key exists. */
+  has(path) {
+    return this.store.has(path);
+  }
+  /** Get the number of stored objects. */
+  get size() {
+    return this.store.size;
+  }
+  /** Clear all stored objects. */
+  clear() {
+    this.store.clear();
+  }
+};
+
+// src/query.ts
+function rotl(a, b) {
+  return (a << b | a >>> 32 - b) >>> 0;
+}
+function add32(a, b) {
+  return a + b >>> 0;
+}
+function quarterRound(s, ai, bi, ci, di) {
+  s[ai] = add32(s[ai], s[bi]);
+  s[di] = rotl(s[di] ^ s[ai], 16);
+  s[ci] = add32(s[ci], s[di]);
+  s[bi] = rotl(s[bi] ^ s[ci], 12);
+  s[ai] = add32(s[ai], s[bi]);
+  s[di] = rotl(s[di] ^ s[ai], 8);
+  s[ci] = add32(s[ci], s[di]);
+  s[bi] = rotl(s[bi] ^ s[ci], 7);
+}
+function chacha20Block(keyU32, nonceU32, counter) {
+  const s = new Uint32Array(16);
+  s[0] = 1634760805;
+  s[1] = 857760878;
+  s[2] = 2036477234;
+  s[3] = 1797285236;
+  for (let i = 0; i < 8; i++) s[4 + i] = keyU32[i];
+  s[12] = counter >>> 0;
+  s[13] = nonceU32[0];
+  s[14] = nonceU32[1];
+  s[15] = nonceU32[2];
+  const ws = new Uint32Array(s);
+  for (let i = 0; i < 10; i++) {
+    quarterRound(ws, 0, 4, 8, 12);
+    quarterRound(ws, 1, 5, 9, 13);
+    quarterRound(ws, 2, 6, 10, 14);
+    quarterRound(ws, 3, 7, 11, 15);
+    quarterRound(ws, 0, 5, 10, 15);
+    quarterRound(ws, 1, 6, 11, 12);
+    quarterRound(ws, 2, 7, 8, 13);
+    quarterRound(ws, 3, 4, 9, 14);
+  }
+  const out = new Uint8Array(64);
+  for (let i = 0; i < 16; i++) {
+    const w = add32(ws[i], s[i]);
+    out[i * 4 + 0] = w & 255;
+    out[i * 4 + 1] = w >>> 8 & 255;
+    out[i * 4 + 2] = w >>> 16 & 255;
+    out[i * 4 + 3] = w >>> 24 & 255;
+  }
+  return out;
+}
+function chacha20Stream(seedBytes32) {
+  if (seedBytes32.length !== 32) throw new Error("ChaCha20 seed must be 32 bytes");
+  const keyU32 = new Uint32Array(8);
+  for (let i = 0; i < 8; i++) {
+    keyU32[i] = seedBytes32[i * 4] | seedBytes32[i * 4 + 1] << 8 | seedBytes32[i * 4 + 2] << 16 | seedBytes32[i * 4 + 3] << 24;
+    keyU32[i] = keyU32[i] >>> 0;
+  }
+  const nonceU32 = new Uint32Array(3);
+  let counter = 0;
+  let block = null;
+  let pos = 64;
+  return {
+    fill(out) {
+      let written = 0;
+      while (written < out.length) {
+        if (pos >= 64) {
+          block = chacha20Block(keyU32, nonceU32, counter++);
+          pos = 0;
+        }
+        const take = Math.min(out.length - written, 64 - pos);
+        for (let i = 0; i < take; i++) out[written + i] = block[pos + i];
+        written += take;
+        pos += take;
+      }
+    }
+  };
+}
+function normalizeL2F32(v) {
+  let sumSq = 0;
+  for (let i = 0; i < v.length; i++) {
+    const x = Math.fround(v[i]);
+    sumSq = Math.fround(sumSq + Math.fround(x * x));
+  }
+  if (!isFinite(sumSq) || sumSq === 0) return null;
+  const norm = Math.fround(Math.sqrt(sumSq));
+  const out = new Float32Array(v.length);
+  for (let i = 0; i < v.length; i++) out[i] = Math.fround(v[i] / norm);
+  return out;
+}
+function normalizeL2(v) {
+  let sum = 0;
+  for (let i = 0; i < v.length; i++) sum += v[i] * v[i];
+  const n = Math.sqrt(sum);
+  if (n === 0) {
+    const out2 = new Float32Array(v.length);
+    for (let i = 0; i < v.length; i++) out2[i] = v[i];
+    return out2;
+  }
+  const out = new Float32Array(v.length);
+  for (let i = 0; i < v.length; i++) out[i] = v[i] / n;
+  return out;
+}
+function dotF32(a, b) {
+  let acc = 0;
+  for (let i = 0; i < a.length; i++) {
+    const prod = Math.fround(Math.fround(a[i]) * Math.fround(b[i]));
+    acc = Math.fround(acc + prod);
+  }
+  return acc;
+}
+function dotL2Normalized(a, b) {
+  let sum = 0;
+  for (let i = 0; i < a.length; i++) sum += a[i] * b[i];
+  return sum;
+}
+function deriveHyperplanesLshCosine(seedBytes32, dim, bits) {
+  const stream = chacha20Stream(seedBytes32);
+  const out = new Float32Array(dim * bits);
+  const buf = new Uint8Array(dim * 4);
+  for (let plane = 0; plane < bits; plane++) {
+    let attempts = 0;
+    while (attempts < 1024) {
+      stream.fill(buf);
+      const g = new Float32Array(dim);
+      const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+      for (let i = 0; i < dim; i++) {
+        const n = view.getInt32(i * 4, true);
+        g[i] = Math.fround(n / 2147483648);
+      }
+      const h = normalizeL2F32(g);
+      if (h) {
+        for (let i = 0; i < dim; i++) out[plane * dim + i] = h[i];
+        break;
+      }
+      attempts++;
+    }
+    if (attempts >= 1024) throw new Error(`hyperplane ${plane} ChaCha20 retry exhausted`);
+  }
+  return out;
+}
+function projectionsLshCosine(qNormalized, hyperplanes, dim, bits) {
+  const projections = new Float32Array(bits);
+  for (let b = 0; b < bits; b++) {
+    const plane = hyperplanes.subarray(b * dim, (b + 1) * dim);
+    projections[b] = dotF32(qNormalized, plane);
+  }
+  return projections;
+}
+function bitsFromProjections(projections) {
+  const bits = new Array(projections.length);
+  for (let i = 0; i < projections.length; i++) bits[i] = projections[i] >= 0;
+  return bits;
+}
+function bitsToBase2(bits) {
+  let s = "";
+  for (const b of bits) s += b ? "1" : "0";
+  return s;
+}
+function flippedKey(bits, flipIdxs) {
+  const copy = bits.slice();
+  for (const i of flipIdxs) copy[i] = !copy[i];
+  return bitsToBase2(copy);
+}
+function multiProbeKeys(projections, probeCount, maxHamming) {
+  const n = projections.length;
+  const absP = new Float32Array(n);
+  for (let i = 0; i < n; i++) absP[i] = Math.abs(projections[i]);
+  const primary = bitsFromProjections(projections);
+  const primaryKey = bitsToBase2(primary);
+  if (probeCount <= 1) return [primaryKey];
+  const candidates = [];
+  for (let i = 0; i < n; i++) candidates.push({ score: absP[i], flips: [i] });
+  if (maxHamming >= 2) {
+    for (let i = 0; i < n; i++)
+      for (let j = i + 1; j < n; j++)
+        candidates.push({ score: absP[i] + absP[j], flips: [i, j] });
+  }
+  if (maxHamming >= 3) {
+    for (let i = 0; i < n; i++)
+      for (let j = i + 1; j < n; j++)
+        for (let k = j + 1; k < n; k++)
+          candidates.push({ score: absP[i] + absP[j] + absP[k], flips: [i, j, k] });
+  }
+  if (maxHamming >= 4) {
+    for (let i = 0; i < n; i++)
+      for (let j = i + 1; j < n; j++)
+        for (let k = j + 1; k < n; k++)
+          for (let l = k + 1; l < n; l++)
+            candidates.push({
+              score: absP[i] + absP[j] + absP[k] + absP[l],
+              flips: [i, j, k, l]
+            });
+  }
+  candidates.sort((a, b) => a.score - b.score);
+  const keys = [primaryKey];
+  for (const c of candidates) {
+    if (keys.length >= probeCount) break;
+    keys.push(flippedKey(primary, c.flips));
+  }
+  return keys;
+}
+function deriveRotationMatrix(seedBytes32, dim) {
+  const stream = chacha20Stream(seedBytes32);
+  const m = new Float32Array(dim * dim);
+  const buf = new Uint8Array(dim * dim * 4);
+  stream.fill(buf);
+  const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+  for (let i = 0; i < dim * dim; i++) {
+    const n = view.getInt32(i * 4, true);
+    m[i] = Math.fround(n / 2147483648);
+  }
+  for (let j = 0; j < dim; j++) {
+    for (let i = 0; i < j; i++) {
+      let coeff = 0;
+      for (let kk = 0; kk < dim; kk++) {
+        coeff = Math.fround(coeff + Math.fround(m[j * dim + kk] * m[i * dim + kk]));
+      }
+      for (let kk = 0; kk < dim; kk++) {
+        m[j * dim + kk] = Math.fround(m[j * dim + kk] - Math.fround(coeff * m[i * dim + kk]));
+      }
+    }
+    let sq = 0;
+    for (let kk = 0; kk < dim; kk++) {
+      sq = Math.fround(sq + Math.fround(m[j * dim + kk] * m[j * dim + kk]));
+    }
+    if (sq > 0) {
+      const inv = Math.fround(1 / Math.fround(Math.sqrt(sq)));
+      for (let kk = 0; kk < dim; kk++) {
+        m[j * dim + kk] = Math.fround(m[j * dim + kk] * inv);
+      }
+    } else {
+      m[j * dim + j] = 1;
+    }
+  }
+  return m;
+}
+function buildPqCosineDecoder(vcCborBytes) {
+  const obj = decodeCbor(vcCborBytes);
+  if (!obj || obj.algorithm !== "dreamdb.pq-cosine") {
+    throw new Error(`expected dreamdb.pq-cosine, got ${obj && obj.algorithm}`);
+  }
+  const dim = Number(obj.dim);
+  const params = obj.params;
+  if (!params || !(params.codebooks instanceof Uint8Array)) {
+    throw new Error("pq-cosine params missing codebooks bytes");
+  }
+  const m = Number(params.m);
+  const k = Number(params.k);
+  const codebookBytes = params.codebooks;
+  const dsub = dim / m;
+  if (dsub !== Math.floor(dsub)) {
+    throw new Error(`dim=${dim} not divisible by m=${m}`);
+  }
+  if (codebookBytes.length !== m * k * dsub * 4) {
+    throw new Error(
+      `codebook bytes ${codebookBytes.length} != m(${m}) * k(${k}) * dsub(${dsub}) * 4`
+    );
+  }
+  const codebooksAligned = new Uint8Array(codebookBytes.length);
+  codebooksAligned.set(codebookBytes);
+  const codebookF32 = new Float32Array(codebooksAligned.buffer);
+  return {
+    algorithm: "dreamdb.pq-cosine",
+    dim,
+    recordCodeBytes: m,
+    decode(codes) {
+      if (codes.length !== m) {
+        throw new Error(`codes length ${codes.length} != m=${m}`);
+      }
+      const out = new Float32Array(dim);
+      for (let s = 0; s < m; s++) {
+        const codeByte = codes[s];
+        const srcOff = s * k * dsub + codeByte * dsub;
+        const dstOff = s * dsub;
+        for (let d = 0; d < dsub; d++) {
+          out[dstOff + d] = codebookF32[srcOff + d];
+        }
+      }
+      return out;
+    }
+  };
+}
+function buildRabitqCosineDecoder(vcCborBytes) {
+  const obj = decodeCbor(vcCborBytes);
+  if (!obj || obj.algorithm !== "dreamdb.rabitq-cosine") {
+    throw new Error(`expected dreamdb.rabitq-cosine, got ${obj && obj.algorithm}`);
+  }
+  const dim = Number(obj.dim);
+  const params = obj.params;
+  if (!params || !(params.rotation_seed instanceof Uint8Array)) {
+    throw new Error("rabitq-cosine params missing rotation_seed bytes");
+  }
+  if (params.rotation_seed.length !== 32) {
+    throw new Error(`rotation_seed must be 32 bytes; got ${params.rotation_seed.length}`);
+  }
+  const bitsPerDim = Number(params.bits_per_dim || 1);
+  if (bitsPerDim !== 1) {
+    throw new Error(`rabitq-cosine bits_per_dim=${bitsPerDim} not supported (v0 ships 1 only)`);
+  }
+  const withCorrection = params.with_correction_factors === true;
+  const payloadBytes = Math.ceil(dim / 8);
+  const codeBytesExpected = withCorrection ? payloadBytes + 4 : payloadBytes;
+  const rotation = deriveRotationMatrix(params.rotation_seed, dim);
+  const constScale = 1 / Math.sqrt(dim);
+  function readPerRecordScale(codeBytes) {
+    const off = codeBytes.byteOffset + payloadBytes;
+    const dv = new DataView(codeBytes.buffer, off, 4);
+    return dv.getFloat32(0, true);
+  }
+  return {
+    algorithm: "dreamdb.rabitq-cosine",
+    dim,
+    recordCodeBytes: codeBytesExpected,
+    rotateQuery(qNorm) {
+      const out = new Float32Array(dim);
+      for (let i = 0; i < dim; i++) {
+        let acc = 0;
+        const base = i * dim;
+        for (let k = 0; k < dim; k++) {
+          acc = Math.fround(acc + Math.fround(rotation[base + k] * qNorm[k]));
+        }
+        out[i] = acc;
+      }
+      return out;
+    },
+    adcScore(rotatedQuery, codeBytes) {
+      let sum = 0;
+      for (let i = 0; i < dim; i++) {
+        const bit = codeBytes[i >>> 3] >>> (i & 7) & 1;
+        const signed = bit === 1 ? rotatedQuery[i] : -rotatedQuery[i];
+        sum = Math.fround(sum + signed);
+      }
+      const scale = withCorrection ? readPerRecordScale(codeBytes) : constScale;
+      return Math.fround(sum * scale);
+    },
+    decode(codeBytes) {
+      if (codeBytes.length !== codeBytesExpected) {
+        throw new Error(
+          `rabitq codes len ${codeBytes.length} != expected ${codeBytesExpected}`
+        );
+      }
+      const scale = withCorrection ? readPerRecordScale(codeBytes) : constScale;
+      const uhat = new Float32Array(dim);
+      for (let i = 0; i < dim; i++) {
+        const bit = codeBytes[i >>> 3] >>> (i & 7) & 1;
+        uhat[i] = bit === 1 ? scale : -scale;
+      }
+      const out = new Float32Array(dim);
+      for (let j = 0; j < dim; j++) {
+        let acc = 0;
+        for (let i = 0; i < dim; i++) {
+          acc = Math.fround(acc + Math.fround(rotation[i * dim + j] * uhat[i]));
+        }
+        out[j] = acc;
+      }
+      return out;
+    }
+  };
+}
+function decodeBucketRecords(bytes, expectRecordSize, dim) {
+  if (bytes.length < 160) throw new Error("bucket too small for header");
+  if (bytes[0] !== 86 || bytes[1] !== 66 || bytes[2] !== 85 || bytes[3] !== 85) {
+    throw new Error("bucket bad magic");
+  }
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const recordSize = view.getUint32(8, false);
+  const recordCount = view.getUint32(12, false);
+  const headerSize = view.getUint32(16, false);
+  if (headerSize !== 160 && headerSize !== 200) {
+    throw new Error(`bucket header_size=${headerSize} unsupported (expect 160 or 200)`);
+  }
+  if (recordSize !== expectRecordSize) {
+    throw new Error(`bucket record_size=${recordSize} != expected ${expectRecordSize}`);
+  }
+  const isCompressed = headerSize === 200;
+  const out = [];
+  for (let i = 0; i < recordCount; i++) {
+    const off = headerSize + i * recordSize;
+    const hi = view.getUint32(off, false);
+    const lo = view.getUint32(off + 4, false);
+    const anchor = Number(BigInt(hi) << 32n | BigInt(lo));
+    const recordPayload = bytes.subarray(off + 8, off + recordSize);
+    if (isCompressed) {
+      out.push({ anchor, ordinal: i, codes: new Uint8Array(recordPayload) });
+    } else {
+      const vec = new Float32Array(dim);
+      const vecView = new DataView(
+        recordPayload.buffer,
+        recordPayload.byteOffset,
+        recordPayload.byteLength
+      );
+      for (let j = 0; j < dim; j++) vec[j] = vecView.getFloat32(j * 4, true);
+      out.push({ anchor, ordinal: i, vec });
+    }
+  }
+  return out;
+}
+function decodeBucketAnchorsOnly(bytes) {
+  if (bytes.length < 160) throw new Error("bucket too small for header");
+  if (bytes[0] !== 86 || bytes[1] !== 66 || bytes[2] !== 85 || bytes[3] !== 85) {
+    throw new Error("bucket bad magic");
+  }
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const recordSize = view.getUint32(8, false);
+  const recordCount = view.getUint32(12, false);
+  const headerSize = view.getUint32(16, false);
+  if (headerSize !== 160 && headerSize !== 200) {
+    throw new Error(`bucket header_size=${headerSize} unsupported (expect 160 or 200)`);
+  }
+  const out = [];
+  for (let i = 0; i < recordCount; i++) {
+    const off = headerSize + i * recordSize;
+    const hi = view.getUint32(off, false);
+    const lo = view.getUint32(off + 4, false);
+    out.push(Number(BigInt(hi) << 32n | BigInt(lo)));
+  }
+  return out;
+}
+function peekBucketHeader(bytes) {
+  if (bytes.length < 160) throw new Error("bucket too small for header");
+  if (bytes[0] !== 86 || bytes[1] !== 66 || bytes[2] !== 85 || bytes[3] !== 85) {
+    throw new Error("bucket bad magic");
+  }
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const recordSize = view.getUint32(8, false);
+  const recordCount = view.getUint32(12, false);
+  const headerSize = view.getUint32(16, false);
+  return {
+    recordSize,
+    recordCount,
+    headerSize,
+    isCompressed: headerSize === 200,
+    vectorCompressorHash: headerSize === 200 && bytes.length >= 86 + 33 ? bytes.subarray(86, 86 + 33) : null
+  };
+}
+
+// src/space.ts
+var Space = class _Space {
+  connectorBase;
+  manifestHash;
+  manifest;
+  refName;
+  backend;
+  // Caches
+  _siCache = /* @__PURE__ */ new Map();
+  _vcCache = /* @__PURE__ */ new Map();
+  _lastQueryStats = null;
+  constructor(opts) {
+    this.connectorBase = opts.connectorBase;
+    this.manifestHash = opts.manifestHash;
+    this.manifest = opts.manifest;
+    this.refName = opts.refName;
+    this.backend = opts.backend || null;
+  }
+  /**
+   * Open a Space from a space URI.
+   * If a Backend is provided, it is used; otherwise fetch-based HTTP access.
+   */
+  static async fromUri(uri, backend) {
+    const u = new URL(uri);
+    const parts = u.pathname.replace(/^\/+/, "").split("/");
+    if (parts.length < 2) {
+      throw new Error(`Space URI missing /refs/<name> or /manifests/<hash> suffix: ${uri}`);
+    }
+    const id = parts.pop();
+    const marker = parts.pop();
+    let kind;
+    if (marker === "refs") kind = "ref";
+    else if (marker === "manifests") kind = "manifest";
+    else throw new Error(`Space URI: expected /refs/ or /manifests/, got /${marker}/: ${uri}`);
+    const connectorBase = `${u.origin}/${parts.join("/")}`.replace(/\/$/, "");
+    let manifestHash;
+    let refName = null;
+    const fetchFn = async (path, noCache = false) => {
+      if (backend) return backend.get(path, { noCache });
+      const url = `${connectorBase}/${path}`;
+      const fetchOpts = noCache ? { cache: "no-store" } : {};
+      const r = await fetch(url, fetchOpts);
+      if (!r.ok) throw new Error(`GET ${url}: HTTP ${r.status}`);
+      return new Uint8Array(await r.arrayBuffer());
+    };
+    if (kind === "ref") {
+      refName = id;
+      const refBytes = await fetchFn(`refs/${id}`, true);
+      if (refBytes.length !== MULTIHASH_BYTES) {
+        throw new Error(`ref body not ${MULTIHASH_BYTES} bytes: got ${refBytes.length}`);
+      }
+      manifestHash = bytesToBase32(refBytes);
+    } else {
+      manifestHash = id;
+    }
+    const manifestBytes = await fetchFn(`manifests/${manifestHash}`);
+    const manifest = decodeCbor(manifestBytes);
+    return new _Space({ connectorBase, manifestHash, manifest, refName, backend });
+  }
+  /** Get the timeline ID (base32 hash of the first timeline entry). */
+  timelineId() {
+    const t = this.manifest.timelines;
+    if (!t || !Array.isArray(t) || t.length === 0) {
+      throw new Error("Manifest has no timelines[]");
+    }
+    return bytesToBase32(t[0]);
+  }
+  /**
+   * Map each Manifest Track to the Schema-declared field name.
+   * Returns a parallel array to manifest.tracks.
+   */
+  _fieldNamesForTracks() {
+    const tracks = this.manifest.tracks;
+    if (!Array.isArray(tracks)) return [];
+    const out = new Array(tracks.length).fill(null);
+    const registry = this.manifest.registry;
+    const sch = registry?.["dreamdb.schema"];
+    const fields = sch && Array.isArray(sch.fields) ? sch.fields : null;
+    if (!fields) return out;
+    const expectedModalityFor = (f) => {
+      return modalityForField({
+        kind: f.kind,
+        mime: f.mime,
+        dim: f.dim ? Number(f.dim) : void 0,
+        name: f.name,
+        value_type: f.value_type
+      });
+    };
+    const queues = /* @__PURE__ */ new Map();
+    for (let i = 0; i < tracks.length; i++) {
+      const m = tracks[i].modality;
+      if (!queues.has(m)) queues.set(m, []);
+      queues.get(m).push(i);
+    }
+    for (const f of fields) {
+      const want = expectedModalityFor(f);
+      if (!want) continue;
+      const q = queues.get(want);
+      if (!q || q.length === 0) continue;
+      const idx = q.shift();
+      out[idx] = f.name;
+    }
+    return out;
+  }
+  /** List resolved tracks from this Manifest. */
+  tracks() {
+    const out = [];
+    const ts = this.manifest.tracks;
+    if (!Array.isArray(ts)) return out;
+    const fieldNames = this._fieldNamesForTracks();
+    for (let i = 0; i < ts.length; i++) {
+      const t = ts[i];
+      const field = fieldNames[i] || null;
+      out.push({
+        modality: t.modality,
+        field,
+        key: field || t.modality,
+        kind: t.kind,
+        role: t.role,
+        address: bytesToBase32(t.address),
+        timeline: bytesToBase32(t.timeline),
+        coverage: t.coverage
+      });
+    }
+    return out;
+  }
+  /** Find a Track by key (field name or modality). */
+  trackFor(keyOrModality) {
+    return this.tracks().find(
+      (t) => t.key === keyOrModality || t.modality === keyOrModality
+    );
+  }
+  /** Walk the Manifest DAG and return history entries. */
+  async history(maxDepth = 50) {
+    const out = [];
+    let curHash = this.manifestHash;
+    let cur = this.manifest;
+    while (curHash && out.length < maxDepth) {
+      out.push({
+        manifestHash: curHash,
+        ts: typeof cur.ts === "bigint" ? Number(cur.ts) : Number(cur.ts || 0),
+        writer: cur.writer || "(unknown)",
+        tracks: Array.isArray(cur.tracks) ? cur.tracks.map((t) => ({
+          modality: t.modality,
+          address: bytesToBase32(t.address)
+        })) : [],
+        parents: Array.isArray(cur.parents) ? cur.parents.length : 0
+      });
+      const parents = cur.parents || [];
+      if (parents.length === 0) break;
+      const parentHash = bytesToBase32(parents[0]);
+      try {
+        const parentBytes = await this._fetchBytes(`manifests/${parentHash}`);
+        cur = decodeCbor(parentBytes);
+        curHash = parentHash;
+      } catch (e) {
+        out[out.length - 1].truncatedAt = e.message;
+        break;
+      }
+    }
+    return out;
+  }
+  /** Get the last query's statistics. */
+  get lastQueryStats() {
+    return this._lastQueryStats;
+  }
+  // ---- Vector query ----
+  async queryVector(field, queryVec, opts = {}) {
+    const topK = typeof opts === "number" ? opts : opts.topK || 10;
+    const probeCountOverride = typeof opts === "object" && opts.probeCount ? opts.probeCount : null;
+    const maxHamming = typeof opts === "object" && opts.maxHamming ? opts.maxHamming : 2;
+    const track = this._embeddingTrackFor(field);
+    if (!track) throw new Error(`no embedding Track found for field "${field}"`);
+    const dimMatch = /\.dim=(\d+)\./.exec(track.modality);
+    if (!dimMatch) throw new Error(`embedding Track modality lacks dim=N: ${track.modality}`);
+    const dim = parseInt(dimMatch[1], 10);
+    if (queryVec.length !== dim) {
+      throw new Error(`query vec dim ${queryVec.length} != Track dim ${dim}`);
+    }
+    const compressorDecoder = await this._fetchVectorCompressor(track.modality);
+    const recordSize = compressorDecoder ? 8 + compressorDecoder.recordCodeBytes : 8 + dim * 4;
+    const trackBytes = await this._fetchBytes(
+      `${track.timeline}/${track.modality}/track/${track.address}`
+    );
+    const trackObj = decodeCbor(trackBytes);
+    const objIndex = trackObj.object_index;
+    if (!Array.isArray(objIndex)) {
+      throw new Error("queryVector: paged Track index not supported in TS yet");
+    }
+    const dispatcher = await this._fetchSpatialDispatcher(track.modality);
+    let probeCount = probeCountOverride;
+    if (probeCount == null) {
+      if (dispatcher && dispatcher.algorithm === "dreamdb.ivf-cosine") {
+        probeCount = Math.max(8, Math.ceil(dispatcher.k / 16));
+      } else {
+        probeCount = 64;
+      }
+    }
+    let probeKeySet = null;
+    if (dispatcher) {
+      const qNormForDispatch = normalizeL2F32(
+        queryVec instanceof Float32Array ? queryVec : new Float32Array(queryVec)
+      );
+      if (!qNormForDispatch)
+        throw new Error("queryVector: query vector has zero norm");
+      const probeKeys = dispatcher.probeKeys(
+        qNormForDispatch,
+        probeCount,
+        maxHamming
+      );
+      probeKeySet = new Set(probeKeys);
+    }
+    let entriesToFetch = probeKeySet ? objIndex.filter(
+      (e) => probeKeySet.has(e[0])
+    ) : objIndex;
+    const dispatchedCount = entriesToFetch.length;
+    if (probeKeySet && entriesToFetch.length === 0) {
+      entriesToFetch = objIndex;
+    }
+    this._lastQueryStats = {
+      bucketsTotal: objIndex.length,
+      bucketsProbed: dispatchedCount,
+      fellBackToBruteForce: probeKeySet !== null && dispatchedCount === 0
+    };
+    const qNorm = normalizeL2(
+      queryVec instanceof Float32Array ? queryVec : new Float32Array(queryVec)
+    );
+    let rotatedQuery = null;
+    if (compressorDecoder && compressorDecoder.algorithm === "dreamdb.rabitq-cosine" && compressorDecoder.rotateQuery) {
+      rotatedQuery = compressorDecoder.rotateQuery(qNorm);
+    }
+    const candidates = [];
+    for (const e of entriesToFetch) {
+      const entry = e;
+      const spatialKey = entry[0];
+      const bucketAddr = bytesToBase32(entry[4]);
+      let vsHashB32 = null;
+      if (entry.length >= 7 && entry[6] instanceof Uint8Array) {
+        vsHashB32 = bytesToBase32(entry[6]);
+      }
+      const body = await this._fetchBytes(
+        `${track.timeline}/${track.modality}/${spatialKey}/${bucketAddr}`
+      );
+      for (const rec of decodeBucketRecords(body, recordSize, dim)) {
+        let score;
+        if (rec.vec) {
+          score = dotL2Normalized(qNorm, normalizeL2(rec.vec));
+        } else if (rec.codes && rotatedQuery && compressorDecoder?.adcScore) {
+          score = compressorDecoder.adcScore(rotatedQuery, rec.codes);
+        } else if (rec.codes && compressorDecoder) {
+          const candidate = compressorDecoder.decode(rec.codes);
+          score = dotL2Normalized(qNorm, normalizeL2(candidate));
+        } else {
+          continue;
+        }
+        candidates.push({
+          anchor: rec.anchor,
+          score,
+          vsHashB32,
+          recordOrdinal: rec.ordinal
+        });
+      }
+    }
+    candidates.sort((a, b) => b.score - a.score);
+    const T = Math.min(candidates.length, 5 * topK);
+    const survivors = candidates.slice(0, T);
+    const rerankableByHash = /* @__PURE__ */ new Map();
+    let rerankSkippedNoHash = 0;
+    for (const s of survivors) {
+      if (s.vsHashB32) {
+        if (!rerankableByHash.has(s.vsHashB32))
+          rerankableByHash.set(s.vsHashB32, []);
+        rerankableByHash.get(s.vsHashB32).push(s);
+      } else {
+        rerankSkippedNoHash++;
+      }
+    }
+    const vsRecordSize = dim * 4;
+    const VS_HEADER_SIZE = 128;
+    for (const [vsHashB32, group] of rerankableByHash) {
+      let vsBytes;
+      try {
+        vsBytes = await this._fetchBytes(
+          `${track.timeline}/${track.modality}/vectors/${vsHashB32}`
+        );
+      } catch {
+        rerankSkippedNoHash += group.length;
+        continue;
+      }
+      const vsView = new DataView(
+        vsBytes.buffer,
+        vsBytes.byteOffset,
+        vsBytes.byteLength
+      );
+      for (const s of group) {
+        const off = VS_HEADER_SIZE + s.recordOrdinal * vsRecordSize;
+        if (off + vsRecordSize > vsBytes.length) {
+          rerankSkippedNoHash++;
+          continue;
+        }
+        const rawVec = new Float32Array(dim);
+        for (let j = 0; j < dim; j++) {
+          rawVec[j] = vsView.getFloat32(off + j * 4, true);
+        }
+        s.score = dotL2Normalized(qNorm, normalizeL2(rawVec));
+      }
+    }
+    survivors.sort((a, b) => b.score - a.score);
+    const finalTop = survivors.slice(0, topK).map((s) => ({
+      anchor: s.anchor,
+      score: s.score
+    }));
+    this._lastQueryStats = {
+      ...this._lastQueryStats,
+      candidatesScored: candidates.length,
+      topT: T,
+      rerankFetchCount: rerankableByHash.size,
+      rerankSkippedNoHash
+    };
+    return finalTop;
+  }
+  // ---- Internal helpers ----
+  _embeddingTrackFor(field) {
+    const tracks = this.tracks().filter(
+      (t) => t.modality.startsWith("embedding.")
+    );
+    if (tracks.length === 0) return null;
+    if (tracks.length === 1) return tracks[0];
+    return tracks.find((t) => t.key === field || t.modality.includes(field)) || tracks[0];
+  }
+  async _fetchBytes(path) {
+    if (this.backend) {
+      return this.backend.get(path);
+    }
+    const url = `${this.connectorBase}/${path}`;
+    const r = await fetch(url);
+    if (!r.ok) throw new Error(`GET ${url}: HTTP ${r.status}`);
+    return new Uint8Array(await r.arrayBuffer());
+  }
+  async _fetchSpatialDispatcher(modality) {
+    if (this._siCache.has(modality)) return this._siCache.get(modality);
+    const registry = this.manifest.registry;
+    if (!registry || typeof registry !== "object") {
+      this._siCache.set(modality, null);
+      return null;
+    }
+    const regEntry = registry[modality];
+    if (!regEntry || typeof regEntry !== "object") {
+      this._siCache.set(modality, null);
+      return null;
+    }
+    const hashesArr = regEntry.spatial_index || regEntry.spatial_index_hashes;
+    if (!Array.isArray(hashesArr) || hashesArr.length === 0) {
+      this._siCache.set(modality, null);
+      return null;
+    }
+    const siHashBytes = hashesArr[0];
+    const siHashB32 = bytesToBase32(siHashBytes);
+    let siBytes;
+    try {
+      siBytes = await this._fetchBytes(`spatial-index/${siHashB32}`);
+    } catch {
+      this._siCache.set(modality, null);
+      return null;
+    }
+    const siObj = decodeCbor(siBytes);
+    const dim = Number(siObj.dim);
+    const bits = Number(siObj.bits);
+    let dispatcher = null;
+    if (siObj.algorithm === "dreamdb.lsh-cosine") {
+      const params = siObj.params;
+      let hyperplanes;
+      if (params.explicit_hyperplanes) {
+        const hpBytes = params.explicit_hyperplanes;
+        const view = new DataView(
+          hpBytes.buffer,
+          hpBytes.byteOffset,
+          hpBytes.byteLength
+        );
+        hyperplanes = new Float32Array(dim * bits);
+        for (let i = 0; i < dim * bits; i++)
+          hyperplanes[i] = view.getFloat32(i * 4, true);
+      } else if (params.seed) {
+        hyperplanes = deriveHyperplanesLshCosine(
+          params.seed,
+          dim,
+          bits
+        );
+      } else {
+        this._siCache.set(modality, null);
+        return null;
+      }
+      dispatcher = {
+        algorithm: "dreamdb.lsh-cosine",
+        dim,
+        bits,
+        probeKeys(qNorm, probeCount, maxHamming) {
+          const projections = projectionsLshCosine(
+            qNorm,
+            hyperplanes,
+            dim,
+            bits
+          );
+          return multiProbeKeys(projections, probeCount, maxHamming);
+        }
+      };
+    } else if (siObj.algorithm === "dreamdb.ivf-cosine") {
+      const k = Number(siObj.params.k);
+      const centroidBytes = siObj.params.centroids;
+      if (!(centroidBytes instanceof Uint8Array) || centroidBytes.length !== k * dim * 4) {
+        this._siCache.set(modality, null);
+        return null;
+      }
+      const aligned = new Uint8Array(centroidBytes.length);
+      aligned.set(centroidBytes);
+      const centroidsF32 = new Float32Array(aligned.buffer);
+      dispatcher = {
+        algorithm: "dreamdb.ivf-cosine",
+        dim,
+        bits,
+        k,
+        probeKeys(qNorm, probeCount, _maxHamming) {
+          const nprobe = Math.min(probeCount, k);
+          const scores = new Array(k);
+          for (let i = 0; i < k; i++) {
+            let acc = 0;
+            const base = i * dim;
+            for (let d = 0; d < dim; d++) {
+              acc = Math.fround(
+                acc + Math.fround(qNorm[d] * centroidsF32[base + d])
+              );
+            }
+            scores[i] = [acc, i];
+          }
+          scores.sort((a, b) => b[0] - a[0]);
+          const out = [];
+          for (let i = 0; i < nprobe; i++) {
+            const id = scores[i][1];
+            let key = "";
+            for (let b = bits - 1; b >= 0; b--) {
+              key += id >> b & 1 ? "1" : "0";
+            }
+            out.push(key);
+          }
+          return out;
+        }
+      };
+    }
+    this._siCache.set(modality, dispatcher);
+    return dispatcher;
+  }
+  async _fetchVectorCompressor(modality) {
+    if (this._vcCache.has(modality)) return this._vcCache.get(modality);
+    const registry = this.manifest.registry;
+    if (!registry || typeof registry !== "object") {
+      this._vcCache.set(modality, null);
+      return null;
+    }
+    const regEntry = registry[modality];
+    if (!regEntry || typeof regEntry !== "object") {
+      this._vcCache.set(modality, null);
+      return null;
+    }
+    const vcHashBytes = regEntry.vector_compressor;
+    if (!(vcHashBytes instanceof Uint8Array)) {
+      this._vcCache.set(modality, null);
+      return null;
+    }
+    const vcHashB32 = bytesToBase32(vcHashBytes);
+    let vcBytes;
+    try {
+      vcBytes = await this._fetchBytes(`vector-compressor/${vcHashB32}`);
+    } catch {
+      this._vcCache.set(modality, null);
+      return null;
+    }
+    const peek = decodeCbor(vcBytes);
+    let decoder;
+    if (peek && peek.algorithm === "dreamdb.pq-cosine") {
+      decoder = buildPqCosineDecoder(vcBytes);
+    } else if (peek && peek.algorithm === "dreamdb.rabitq-cosine") {
+      decoder = buildRabitqCosineDecoder(vcBytes);
+    } else {
+      this._vcCache.set(modality, null);
+      return null;
+    }
+    decoder.algorithm = peek.algorithm || decoder.algorithm;
+    if (peek.algorithm === "dreamdb.pq-cosine") {
+      decoder.recordCodeBytes = Number(
+        peek.params.m
+      );
+    } else {
+      const payload = Math.ceil(Number(peek.dim) / 8);
+      const corrected = peek.params && peek.params.with_correction_factors === true;
+      decoder.recordCodeBytes = corrected ? payload + 4 : payload;
+    }
+    this._vcCache.set(modality, decoder);
+    return decoder;
+  }
+};
+
+// src/dataset.ts
+var Schema = class {
+  fields = [];
+  addImage(name, opts = {}) {
+    this.fields.push({
+      kind: "image",
+      name,
+      mime: opts.mime || "jpeg",
+      required: opts.required !== false,
+      chunkSize: opts.chunkSize,
+      packItems: opts.packItems
+    });
+    return this;
+  }
+  addAudio(name, opts = {}) {
+    this.fields.push({
+      kind: "audio",
+      name,
+      mime: opts.mime || "wav",
+      required: opts.required !== false,
+      chunkSize: opts.chunkSize,
+      packItems: opts.packItems
+    });
+    return this;
+  }
+  addVideo(name, opts = {}) {
+    this.fields.push({
+      kind: "video",
+      name,
+      mime: opts.mime || "mp4",
+      required: opts.required !== false,
+      chunkSize: opts.chunkSize,
+      packItems: opts.packItems
+    });
+    return this;
+  }
+  addEmbedding(name, opts) {
+    this.fields.push({
+      kind: "embedding",
+      name,
+      dim: opts.dim,
+      algorithm: opts.algorithm || "dreamdb.lsh-cosine",
+      required: opts.required !== false,
+      lshBits: opts.lshBits,
+      compressor: opts.compressor,
+      spatialIndex: opts.spatialIndex,
+      rerank: opts.rerank || false
+    });
+    return this;
+  }
+  addScalarCategorical(name, opts = {}) {
+    this.fields.push({
+      kind: "scalar",
+      name,
+      valueType: "categorical",
+      required: opts.required !== false
+    });
+    return this;
+  }
+  addScalarBool(name, opts = {}) {
+    this.fields.push({
+      kind: "scalar",
+      name,
+      valueType: "bool",
+      required: opts.required !== false
+    });
+    return this;
+  }
+  addScalarInt(name, opts = {}) {
+    this.fields.push({
+      kind: "scalar",
+      name,
+      valueType: "int",
+      required: opts.required !== false
+    });
+    return this;
+  }
+  addScalarFloat(name, opts = {}) {
+    this.fields.push({
+      kind: "scalar",
+      name,
+      valueType: "float",
+      required: opts.required !== false
+    });
+    return this;
+  }
+  addScalarString(name, opts = {}) {
+    this.fields.push({
+      kind: "scalar",
+      name,
+      valueType: "string",
+      required: opts.required !== false
+    });
+    return this;
+  }
+  addScalarTimestamp(name, opts = {}) {
+    this.fields.push({
+      kind: "scalar",
+      name,
+      valueType: "timestamp",
+      required: opts.required !== false
+    });
+    return this;
+  }
+  /** Serialize the schema to CBOR-encodable object. */
+  toCbor() {
+    const fields = this.fields.map((f) => {
+      const obj = { kind: f.kind, name: f.name };
+      if (f.kind === "image" || f.kind === "audio" || f.kind === "video") {
+        obj.mime = f.mime;
+        obj.required = f.required;
+      } else if (f.kind === "embedding") {
+        obj.dim = f.dim;
+        obj.algorithm = f.algorithm;
+        obj.required = f.required;
+        obj.rerank = f.rerank;
+      } else if (f.kind === "scalar") {
+        obj.value_type = f.valueType;
+        obj.required = f.required;
+      }
+      return obj;
+    });
+    return { fields };
+  }
+};
+var Dataset = class _Dataset {
+  backend;
+  _refName;
+  _manifestHash;
+  _timelineHash;
+  _schema;
+  constructor(backend, refName, manifestHash, timelineHash, schema) {
+    this.backend = backend;
+    this._refName = refName;
+    this._manifestHash = manifestHash;
+    this._timelineHash = timelineHash;
+    this._schema = schema;
+  }
+  // ---- Construction ----
+  static async create(name, schema, backendUrl) {
+    const backend = resolveBackend(backendUrl);
+    const timelineBytes = hashFromString(`timeline:${name}`);
+    const timelineHash = bytesToBase32(timelineBytes);
+    const tracks = [];
+    for (const field of schema.fields) {
+      const modality = modalityForField({
+        kind: field.kind,
+        mime: field.kind === "image" || field.kind === "audio" || field.kind === "video" ? field.mime : void 0,
+        dim: field.kind === "embedding" ? field.dim : void 0,
+        name: field.name,
+        valueType: field.kind === "scalar" ? field.valueType : void 0
+      });
+      if (!modality) continue;
+      const emptyTrackObj = { object_index: [] };
+      const trackObjBytes = encodeCbor(emptyTrackObj);
+      const trackHash = contentHash(trackObjBytes);
+      const trackHashB32 = bytesToBase32(trackHash);
+      await backend.put(
+        `${timelineHash}/${modality}/track/${trackHashB32}`,
+        trackObjBytes
+      );
+      tracks.push({
+        modality,
+        kind: field.kind === "embedding" ? "spatial_bucket" : field.kind === "scalar" ? "scalar_bucket" : "fragment",
+        role: "data",
+        address: trackHash,
+        timeline: timelineBytes,
+        coverage: null
+      });
+    }
+    const manifest = {
+      timelines: [timelineBytes],
+      tracks,
+      ts: BigInt(Date.now()) * 1000000n,
+      writer: "dreamdb-ts/0.1.0",
+      registry: {
+        "dreamdb.schema": schema.toCbor()
+      }
+    };
+    const manifestBytes = encodeCbor(manifest);
+    const manifestHash = contentHash(manifestBytes);
+    const manifestHashB32 = bytesToBase32(manifestHash);
+    await backend.put(`manifests/${manifestHashB32}`, manifestBytes);
+    await backend.put(`refs/${name}`, manifestHash);
+    return new _Dataset(backend, name, manifestHashB32, timelineHash, schema);
+  }
+  static async open(name, schema, backendUrl = "") {
+    const backend = resolveBackend(backendUrl);
+    const refBytes = await backend.get(`refs/${name}`);
+    if (refBytes.length !== MULTIHASH_BYTES) {
+      throw new Error(`ref body not ${MULTIHASH_BYTES} bytes: got ${refBytes.length}`);
+    }
+    const manifestHash = bytesToBase32(refBytes);
+    const manifestBytes = await backend.get(`manifests/${manifestHash}`);
+    const manifest = decodeCbor(manifestBytes);
+    const timelines = manifest.timelines;
+    if (!timelines || !Array.isArray(timelines) || timelines.length === 0) {
+      throw new Error("Manifest has no timelines[]");
+    }
+    const timelineHash = bytesToBase32(timelines[0]);
+    let resolvedSchema;
+    if (schema) {
+      resolvedSchema = schema;
+    } else {
+      const registry = manifest.registry;
+      const schemaCbor = registry?.["dreamdb.schema"];
+      if (schemaCbor && Array.isArray(schemaCbor.fields)) {
+        resolvedSchema = schemaFromCbor(schemaCbor);
+      } else {
+        resolvedSchema = new Schema();
+      }
+    }
+    return new _Dataset(backend, name, manifestHash, timelineHash, resolvedSchema);
+  }
+  // ---- Inspection ----
+  refName() {
+    return this._refName;
+  }
+  currentManifest() {
+    return this._manifestHash;
+  }
+  timeline() {
+    return this._timelineHash;
+  }
+  schema() {
+    return this._schema;
+  }
+  async history(maxDepth = 50) {
+    const out = [];
+    let curHash = this._manifestHash;
+    while (curHash && out.length < maxDepth) {
+      let manifestBytes;
+      try {
+        manifestBytes = await this.backend.get(`manifests/${curHash}`);
+      } catch {
+        break;
+      }
+      const m = decodeCbor(manifestBytes);
+      out.push({
+        manifest: curHash,
+        ts_ns: typeof m.ts === "bigint" ? Number(m.ts) : Number(m.ts || 0),
+        writer: m.writer || "(unknown)",
+        parents_count: Array.isArray(m.parents) ? m.parents.length : 0,
+        tracks_count: Array.isArray(m.tracks) ? m.tracks.length : 0
+      });
+      const parents = m.parents;
+      if (!parents || parents.length === 0) break;
+      curHash = bytesToBase32(parents[0]);
+    }
+    return out;
+  }
+  async listRefs() {
+    const keys = await this.backend.list("refs/");
+    return keys.map((k) => k.replace(/^refs\//, "")).sort();
+  }
+  async count() {
+    let n = 0;
+    for await (const batch of this._iterStreamImpl(4096)) {
+      n += batch._time_anchors.length;
+    }
+    return n;
+  }
+  // ---- Write path ----
+  async appendMany(samples) {
+    if (samples.length === 0) return 0;
+    const manifestBytes = await this.backend.get(`manifests/${this._manifestHash}`);
+    const manifest = decodeCbor(manifestBytes);
+    const tracks = manifest.tracks;
+    const hasExplicitAnchors = "_anchor" in samples[0];
+    const baseUs = Date.now() * 1e3;
+    const anchors = samples.map((s, i) => {
+      if (hasExplicitAnchors) {
+        return s._anchor;
+      }
+      return baseUs + i;
+    });
+    const newTracks = [];
+    for (let ti = 0; ti < tracks.length; ti++) {
+      const track = tracks[ti];
+      const modality = track.modality;
+      const field = this._schema.fields.find((f) => {
+        const expectedMod = modalityForField({
+          kind: f.kind,
+          mime: f.kind === "image" || f.kind === "audio" || f.kind === "video" ? f.mime : void 0,
+          dim: f.kind === "embedding" ? f.dim : void 0,
+          name: f.name,
+          valueType: f.kind === "scalar" ? f.valueType : void 0
+        });
+        return expectedMod === modality;
+      });
+      if (!field) {
+        newTracks.push(track);
+        continue;
+      }
+      const trackAddr = bytesToBase32(track.address);
+      const trackBytes = await this.backend.get(
+        `${this._timelineHash}/${modality}/track/${trackAddr}`
+      );
+      const trackObj = decodeCbor(trackBytes);
+      const objIndex = trackObj.object_index || [];
+      if (field.kind === "image" || field.kind === "audio" || field.kind === "video") {
+        const newEntries = [...objIndex];
+        for (let i = 0; i < samples.length; i++) {
+          const value = samples[i][field.name];
+          if (value === null || value === void 0) continue;
+          const data = value instanceof Uint8Array ? value : new Uint8Array(value);
+          const fragHash = contentHash(data);
+          const fragHashB32 = bytesToBase32(fragHash);
+          await this.backend.put(
+            `${this._timelineHash}/${modality}/0000000000000000/${fragHashB32}`,
+            data
+          );
+          newEntries.push([
+            BigInt(anchors[i]),
+            BigInt(anchors[i]),
+            data.length,
+            fragHash
+          ]);
+        }
+        const newTrackObj = { object_index: newEntries };
+        const newTrackBytes = encodeCbor(newTrackObj);
+        const newTrackHash = contentHash(newTrackBytes);
+        const newTrackHashB32 = bytesToBase32(newTrackHash);
+        await this.backend.put(
+          `${this._timelineHash}/${modality}/track/${newTrackHashB32}`,
+          newTrackBytes
+        );
+        newTracks.push({ ...track, address: newTrackHash });
+      } else if (field.kind === "embedding") {
+        const embField = field;
+        const dim = embField.dim;
+        const lshBits = embField.lshBits || 12;
+        const bucketGroups = /* @__PURE__ */ new Map();
+        for (let i = 0; i < samples.length; i++) {
+          const value = samples[i][field.name];
+          if (value === null || value === void 0) continue;
+          const vec = value instanceof Float32Array ? Array.from(value) : value;
+          const normVec = normalizeL2(new Float32Array(vec));
+          let key = "";
+          for (let b = 0; b < lshBits; b++) {
+            key += normVec[b % dim] >= 0 ? "1" : "0";
+          }
+          if (!bucketGroups.has(key)) bucketGroups.set(key, []);
+          bucketGroups.get(key).push({ anchor: anchors[i], vec });
+        }
+        const newEntries = [...objIndex];
+        for (const [spatialKey, records] of bucketGroups) {
+          const recordSize = 8 + dim * 4;
+          const headerSize = 160;
+          const totalSize = headerSize + records.length * recordSize;
+          const bucket = new Uint8Array(totalSize);
+          const bucketView = new DataView(bucket.buffer);
+          bucket[0] = 86;
+          bucket[1] = 66;
+          bucket[2] = 85;
+          bucket[3] = 85;
+          bucketView.setUint32(4, 1, false);
+          bucketView.setUint32(8, recordSize, false);
+          bucketView.setUint32(12, records.length, false);
+          bucketView.setUint32(16, headerSize, false);
+          for (let ri = 0; ri < records.length; ri++) {
+            const off = headerSize + ri * recordSize;
+            const anchor = records[ri].anchor;
+            const anchorBig = BigInt(anchor);
+            bucketView.setUint32(off, Number(anchorBig >> 32n), false);
+            bucketView.setUint32(off + 4, Number(anchorBig & 0xffffffffn), false);
+            for (let d = 0; d < dim; d++) {
+              bucketView.setFloat32(off + 8 + d * 4, records[ri].vec[d], true);
+            }
+          }
+          const bucketHash = contentHash(bucket);
+          const bucketHashB32 = bytesToBase32(bucketHash);
+          await this.backend.put(
+            `${this._timelineHash}/${modality}/${spatialKey}/${bucketHashB32}`,
+            bucket
+          );
+          const tAnchors = records.map((r) => r.anchor).sort((a, b) => a - b);
+          newEntries.push([
+            spatialKey,
+            BigInt(tAnchors[0]),
+            BigInt(tAnchors[tAnchors.length - 1]),
+            totalSize,
+            bucketHash
+          ]);
+        }
+        const newTrackObj = { object_index: newEntries };
+        const newTrackBytes = encodeCbor(newTrackObj);
+        const newTrackHash = contentHash(newTrackBytes);
+        const newTrackHashB32 = bytesToBase32(newTrackHash);
+        await this.backend.put(
+          `${this._timelineHash}/${modality}/track/${newTrackHashB32}`,
+          newTrackBytes
+        );
+        newTracks.push({ ...track, address: newTrackHash });
+      } else if (field.kind === "scalar") {
+        const valGroups = /* @__PURE__ */ new Map();
+        for (let i = 0; i < samples.length; i++) {
+          const value = samples[i][field.name];
+          if (value === null || value === void 0) continue;
+          const key = String(value);
+          if (!valGroups.has(key)) valGroups.set(key, []);
+          valGroups.get(key).push(anchors[i]);
+        }
+        const newEntries = [...objIndex];
+        for (const [valueStr, anchorList] of valGroups) {
+          const anchorsCbor = anchorList.map((a) => BigInt(a));
+          const bucketBytes = encodeCbor(anchorsCbor);
+          const bucketHash = contentHash(bucketBytes);
+          const bucketHashB32 = bytesToBase32(bucketHash);
+          await this.backend.put(
+            `${this._timelineHash}/${modality}/bucket/${bucketHashB32}`,
+            bucketBytes
+          );
+          const valueCbor = parseScalarString(valueStr, field.valueType);
+          const valueCborBytes = encodeCbor(valueCbor);
+          const sortedAnchors = anchorList.sort((a, b) => a - b);
+          newEntries.push([
+            valueCborBytes,
+            BigInt(sortedAnchors[0]),
+            BigInt(sortedAnchors[sortedAnchors.length - 1]),
+            bucketHash
+          ]);
+        }
+        const newTrackObj = { object_index: newEntries };
+        const newTrackBytes = encodeCbor(newTrackObj);
+        const newTrackHash = contentHash(newTrackBytes);
+        const newTrackHashB32 = bytesToBase32(newTrackHash);
+        await this.backend.put(
+          `${this._timelineHash}/${modality}/track/${newTrackHashB32}`,
+          newTrackBytes
+        );
+        newTracks.push({ ...track, address: newTrackHash });
+      } else {
+        newTracks.push(track);
+      }
+    }
+    const oldManifestHash = base32ToBytes(this._manifestHash);
+    const parentBytes = new Uint8Array(MULTIHASH_BYTES);
+    parentBytes.set(oldManifestHash.subarray(0, MULTIHASH_BYTES));
+    const newManifest = {
+      timelines: manifest.timelines,
+      tracks: newTracks,
+      parents: [parentBytes],
+      ts: BigInt(Date.now()) * 1000000n,
+      writer: "dreamdb-ts/0.1.0",
+      registry: manifest.registry || {}
+    };
+    const newManifestBytes = encodeCbor(newManifest);
+    const newManifestHash = contentHash(newManifestBytes);
+    const newManifestHashB32 = bytesToBase32(newManifestHash);
+    await this.backend.put(`manifests/${newManifestHashB32}`, newManifestBytes);
+    await this.backend.put(`refs/${this._refName}`, newManifestHash);
+    this._manifestHash = newManifestHashB32;
+    return samples.length;
+  }
+  // ---- Read path ----
+  async iterVector(field, query, topK, batchSize = 64, opts = {}) {
+    const manifestBytes = await this.backend.get(`manifests/${this._manifestHash}`);
+    const manifest = decodeCbor(manifestBytes);
+    const tracks = manifest.tracks;
+    const embField = this._schema.fields.find(
+      (f) => f.kind === "embedding" && f.name === field
+    );
+    if (!embField) throw new Error(`no embedding field "${field}" in schema`);
+    const modality = modalityForField({
+      kind: embField.kind,
+      dim: embField.dim,
+      name: embField.name
+    });
+    const dim = embField.dim;
+    const track = tracks.find((t) => t.modality === modality);
+    if (!track) throw new Error(`no Track for modality ${modality}`);
+    const trackAddr = bytesToBase32(track.address);
+    const trackBytes = await this.backend.get(
+      `${this._timelineHash}/${modality}/track/${trackAddr}`
+    );
+    const trackObj = decodeCbor(trackBytes);
+    const objIndex = trackObj.object_index;
+    if (!Array.isArray(objIndex) || objIndex.length === 0) return [];
+    const qNorm = normalizeL2(
+      query instanceof Float32Array ? query : new Float32Array(query)
+    );
+    const recordSize = 8 + dim * 4;
+    const candidates = [];
+    for (const entry of objIndex) {
+      const e = entry;
+      const spatialKey = e[0];
+      const bucketAddr = bytesToBase32(e[4]);
+      const body = await this.backend.get(
+        `${this._timelineHash}/${modality}/${spatialKey}/${bucketAddr}`
+      );
+      const view = new DataView(body.buffer, body.byteOffset, body.byteLength);
+      const headerSize = view.getUint32(16, false);
+      const recordCount = view.getUint32(12, false);
+      const actualRecordSize = view.getUint32(8, false);
+      for (let i = 0; i < recordCount; i++) {
+        const off = headerSize + i * actualRecordSize;
+        const hi = view.getUint32(off, false);
+        const lo = view.getUint32(off + 4, false);
+        const anchor = Number(BigInt(hi) << 32n | BigInt(lo));
+        const vec = new Float32Array(dim);
+        for (let d = 0; d < dim; d++) {
+          vec[d] = view.getFloat32(off + 8 + d * 4, true);
+        }
+        const normVec = normalizeL2(vec);
+        const score = dotL2Normalized(qNorm, normVec);
+        candidates.push({ anchor, score, vec });
+      }
+    }
+    candidates.sort((a, b) => b.score - a.score);
+    let topCandidates = candidates.slice(0, topK);
+    if (opts.whereEq && Object.keys(opts.whereEq).length > 0) {
+      const anchorLabels = await this._resolveScalarLabels(
+        manifest,
+        tracks,
+        opts.whereEq
+      );
+      topCandidates = topCandidates.filter((c) => {
+        for (const [filterField, filterValue] of Object.entries(opts.whereEq)) {
+          const labelMap = anchorLabels.get(filterField);
+          if (!labelMap) return false;
+          const anchorVal = labelMap.get(c.anchor);
+          if (anchorVal === void 0 || String(anchorVal) !== String(filterValue))
+            return false;
+        }
+        return true;
+      });
+    }
+    const blobFields = this._schema.fields.filter(
+      (f) => f.kind === "image" || f.kind === "audio" || f.kind === "video"
+    );
+    const scalarFields = this._schema.fields.filter((f) => f.kind === "scalar");
+    const resultAnchors = new Set(topCandidates.map((c) => c.anchor));
+    const blobData = /* @__PURE__ */ new Map();
+    for (const bf of blobFields) {
+      const bfMod = modalityForField({
+        kind: bf.kind,
+        mime: bf.mime,
+        name: bf.name
+      });
+      const bfTrack = tracks.find((t) => t.modality === bfMod);
+      if (!bfTrack) continue;
+      const bfAddr = bytesToBase32(bfTrack.address);
+      const bfTrackBytes = await this.backend.get(
+        `${this._timelineHash}/${bfMod}/track/${bfAddr}`
+      );
+      const bfTrackObj = decodeCbor(bfTrackBytes);
+      const bfObjIndex = bfTrackObj.object_index;
+      if (!Array.isArray(bfObjIndex)) continue;
+      const fieldData = /* @__PURE__ */ new Map();
+      for (const entry of bfObjIndex) {
+        const e = entry;
+        const tStart = Number(e[0]);
+        if (!resultAnchors.has(tStart)) continue;
+        const fragHash = bytesToBase32(e[3]);
+        try {
+          const fragBytes = await this.backend.get(
+            `${this._timelineHash}/${bfMod}/0000000000000000/${fragHash}`
+          );
+          fieldData.set(tStart, fragBytes);
+        } catch {
+        }
+      }
+      blobData.set(bf.name, fieldData);
+    }
+    const scalarData = /* @__PURE__ */ new Map();
+    for (const sf of scalarFields) {
+      const sfMod = modalityForField({
+        kind: sf.kind,
+        name: sf.name,
+        valueType: sf.valueType
+      });
+      const sfTrack = tracks.find((t) => t.modality === sfMod);
+      if (!sfTrack) continue;
+      const sfAddr = bytesToBase32(sfTrack.address);
+      const sfTrackBytes = await this.backend.get(
+        `${this._timelineHash}/${sfMod}/track/${sfAddr}`
+      );
+      const sfTrackObj = decodeCbor(sfTrackBytes);
+      const sfObjIndex = sfTrackObj.object_index;
+      if (!Array.isArray(sfObjIndex)) continue;
+      const fieldData = /* @__PURE__ */ new Map();
+      for (const entry of sfObjIndex) {
+        const e = entry;
+        const valueCborBytes = e[0];
+        const value = decodeCbor(valueCborBytes);
+        const bucketHash = bytesToBase32(e[3]);
+        try {
+          const bucketBytes = await this.backend.get(
+            `${this._timelineHash}/${sfMod}/bucket/${bucketHash}`
+          );
+          const anchorArray = decodeCbor(bucketBytes);
+          if (Array.isArray(anchorArray)) {
+            for (const a of anchorArray) {
+              const anchor = Number(a);
+              if (resultAnchors.has(anchor)) {
+                fieldData.set(anchor, value);
+              }
+            }
+          }
+        } catch {
+        }
+      }
+      scalarData.set(sf.name, fieldData);
+    }
+    const batches = [];
+    for (let i = 0; i < topCandidates.length; i += batchSize) {
+      const slice = topCandidates.slice(i, i + batchSize);
+      const batch = {
+        _time_anchors: slice.map((c) => c.anchor),
+        [field]: slice.map((c) => Array.from(c.vec))
+      };
+      for (const bf of blobFields) {
+        const fieldMap = blobData.get(bf.name);
+        batch[bf.name] = slice.map(
+          (c) => fieldMap?.get(c.anchor) ?? null
+        );
+      }
+      for (const sf of scalarFields) {
+        const fieldMap = scalarData.get(sf.name);
+        batch[sf.name] = slice.map(
+          (c) => fieldMap?.get(c.anchor) ?? null
+        );
+      }
+      batches.push(batch);
+    }
+    return batches;
+  }
+  // ---- Streaming iteration ----
+  async *_iterStreamImpl(batchSize) {
+    const manifestBytes = await this.backend.get(`manifests/${this._manifestHash}`);
+    const manifest = decodeCbor(manifestBytes);
+    const tracks = manifest.tracks;
+    const embField = this._schema.fields.find(
+      (f) => f.kind === "embedding"
+    );
+    if (!embField) return;
+    const modality = modalityForField({
+      kind: embField.kind,
+      dim: embField.dim,
+      name: embField.name
+    });
+    const dim = embField.dim;
+    const track = tracks.find((t) => t.modality === modality);
+    if (!track) return;
+    const trackAddr = bytesToBase32(track.address);
+    const trackBytes = await this.backend.get(
+      `${this._timelineHash}/${modality}/track/${trackAddr}`
+    );
+    const trackObj = decodeCbor(trackBytes);
+    const objIndex = trackObj.object_index;
+    if (!Array.isArray(objIndex)) return;
+    let buffer = [];
+    for (const entry of objIndex) {
+      const e = entry;
+      const spatialKey = e[0];
+      const bucketAddr = bytesToBase32(e[4]);
+      const body = await this.backend.get(
+        `${this._timelineHash}/${modality}/${spatialKey}/${bucketAddr}`
+      );
+      const view = new DataView(body.buffer, body.byteOffset, body.byteLength);
+      const headerSize = view.getUint32(16, false);
+      const recordCount = view.getUint32(12, false);
+      const recordSize = view.getUint32(8, false);
+      for (let i = 0; i < recordCount; i++) {
+        const off = headerSize + i * recordSize;
+        const hi = view.getUint32(off, false);
+        const lo = view.getUint32(off + 4, false);
+        const anchor = Number(BigInt(hi) << 32n | BigInt(lo));
+        buffer.push(anchor);
+        if (buffer.length >= batchSize) {
+          yield { _time_anchors: buffer };
+          buffer = [];
+        }
+      }
+    }
+    if (buffer.length > 0) {
+      yield { _time_anchors: buffer };
+    }
+  }
+  async iterStream(batchSize = 256) {
+    const batches = [];
+    for await (const batch of this._iterStreamImpl(batchSize)) {
+      batches.push(batch);
+    }
+    return batches;
+  }
+  // ---- Versioning ----
+  async snapshot(label) {
+    const manifestHash = base32ToBytes(this._manifestHash);
+    const refBytes = new Uint8Array(MULTIHASH_BYTES);
+    refBytes.set(manifestHash.subarray(0, MULTIHASH_BYTES));
+    await this.backend.put(`refs/${label}`, refBytes);
+    return {
+      label,
+      manifest: this._manifestHash,
+      timeline: this._timelineHash
+    };
+  }
+  async branch(newName) {
+    const manifestHash = base32ToBytes(this._manifestHash);
+    const refBytes = new Uint8Array(MULTIHASH_BYTES);
+    refBytes.set(manifestHash.subarray(0, MULTIHASH_BYTES));
+    await this.backend.put(`refs/${newName}`, refBytes);
+    return new _Dataset(
+      this.backend,
+      newName,
+      this._manifestHash,
+      this._timelineHash,
+      this._schema
+    );
+  }
+  // ---- Scalar resolution helper ----
+  async _resolveScalarLabels(manifest, tracks, whereEq) {
+    const result = /* @__PURE__ */ new Map();
+    for (const [filterField, _filterValue] of Object.entries(whereEq)) {
+      const sf = this._schema.fields.find(
+        (f) => f.kind === "scalar" && f.name === filterField
+      );
+      if (!sf) continue;
+      const sfMod = modalityForField({
+        kind: sf.kind,
+        name: sf.name,
+        valueType: sf.valueType
+      });
+      const sfTrack = tracks.find((t) => t.modality === sfMod);
+      if (!sfTrack) continue;
+      const sfAddr = bytesToBase32(sfTrack.address);
+      const sfTrackBytes = await this.backend.get(
+        `${this._timelineHash}/${sfMod}/track/${sfAddr}`
+      );
+      const sfTrackObj = decodeCbor(sfTrackBytes);
+      const sfObjIndex = sfTrackObj.object_index;
+      if (!Array.isArray(sfObjIndex)) continue;
+      const fieldData = /* @__PURE__ */ new Map();
+      for (const entry of sfObjIndex) {
+        const e = entry;
+        const valueCborBytes = e[0];
+        const value = decodeCbor(valueCborBytes);
+        const bucketHash = bytesToBase32(e[3]);
+        try {
+          const bucketBytes = await this.backend.get(
+            `${this._timelineHash}/${sfMod}/bucket/${bucketHash}`
+          );
+          const anchorArray = decodeCbor(bucketBytes);
+          if (Array.isArray(anchorArray)) {
+            for (const a of anchorArray) {
+              fieldData.set(Number(a), value);
+            }
+          }
+        } catch {
+        }
+      }
+      result.set(filterField, fieldData);
+    }
+    return result;
+  }
+};
+function resolveBackend(url) {
+  if (url === "memory://" || url === "") {
+    return new MemoryBackend();
+  }
+  if (url.startsWith("file://")) {
+    throw new Error("file:// backend not supported in the TypeScript SDK (browser-first)");
+  }
+  return new S3Backend(url);
+}
+function contentHash(data) {
+  const hash = new Uint8Array(MULTIHASH_BYTES);
+  hash[0] = 30;
+  hash[1] = 31;
+  const FNV_OFFSET = 0xcbf29ce484222325n;
+  const FNV_PRIME = 0x100000001b3n;
+  let h = FNV_OFFSET;
+  for (let i = 0; i < data.length; i++) {
+    h = h ^ BigInt(data[i]);
+    h = h * FNV_PRIME & 0xffffffffffffffffn;
+  }
+  const buf = new DataView(new ArrayBuffer(8));
+  buf.setBigUint64(0, h);
+  for (let i = 0; i < 31; i++) {
+    const byteIdx = i % 8;
+    const seed = new Uint8Array(new ArrayBuffer(8));
+    new DataView(seed.buffer).setBigUint64(0, h);
+    hash[2 + i] = seed[byteIdx] ^ i * 158 + 55 & 255;
+    h = h * FNV_PRIME + BigInt(i) & 0xffffffffffffffffn;
+  }
+  return hash;
+}
+function hashFromString(s) {
+  const encoded = new TextEncoder().encode(s);
+  return contentHash(encoded);
+}
+function parseScalarString(s, valueType) {
+  switch (valueType) {
+    case "bool":
+      return s === "true";
+    case "int":
+      return parseInt(s, 10);
+    case "float":
+      return parseFloat(s);
+    default:
+      return s;
+  }
+}
+function schemaFromCbor(obj) {
+  const schema = new Schema();
+  const fields = obj.fields;
+  if (!Array.isArray(fields)) return schema;
+  for (const f of fields) {
+    const kind = f.kind;
+    const name = f.name;
+    if (kind === "image") {
+      schema.addImage(name, {
+        mime: f.mime || "jpeg",
+        required: f.required !== false
+      });
+    } else if (kind === "audio") {
+      schema.addAudio(name, {
+        mime: f.mime || "wav",
+        required: f.required !== false
+      });
+    } else if (kind === "video") {
+      schema.addVideo(name, {
+        mime: f.mime || "mp4",
+        required: f.required !== false
+      });
+    } else if (kind === "embedding") {
+      schema.addEmbedding(name, {
+        dim: Number(f.dim),
+        algorithm: f.algorithm || "dreamdb.lsh-cosine",
+        required: f.required !== false,
+        rerank: f.rerank === true
+      });
+    } else if (kind === "scalar") {
+      const vt = f.value_type || "categorical";
+      switch (vt) {
+        case "categorical":
+          schema.addScalarCategorical(name);
+          break;
+        case "bool":
+          schema.addScalarBool(name);
+          break;
+        case "int":
+          schema.addScalarInt(name);
+          break;
+        case "float":
+          schema.addScalarFloat(name);
+          break;
+        case "string":
+          schema.addScalarString(name);
+          break;
+        case "timestamp":
+          schema.addScalarTimestamp(name);
+          break;
+      }
+    }
+  }
+  return schema;
+}
+
+// src/types.ts
+var SCALAR_ENCODING_MAP = {
+  categorical: "cat",
+  bool: "bool",
+  int: "i64",
+  float: "f64",
+  string: "str",
+  timestamp: "ts"
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Dataset,
+  MULTIHASH_BYTES,
+  MemoryBackend,
+  S3Backend,
+  SCALAR_ENCODING_MAP,
+  Schema,
+  Space,
+  base32ToBytes,
+  bitsFromProjections,
+  bitsToBase2,
+  buildPqCosineDecoder,
+  buildRabitqCosineDecoder,
+  bytesToBase32,
+  chacha20Stream,
+  decodeBucketAnchorsOnly,
+  decodeBucketRecords,
+  decodeCbor,
+  deriveHyperplanesLshCosine,
+  deriveRotationMatrix,
+  dotF32,
+  dotL2Normalized,
+  encodeCbor,
+  modalityForField,
+  multiProbeKeys,
+  normalizeL2,
+  normalizeL2F32,
+  parseSpaceUri,
+  peekBucketHeader,
+  projectionsLshCosine,
+  scalarModalityFragment
+});
+//# sourceMappingURL=index.cjs.map