@hviana/sema 0.1.5 → 0.1.6

package/dist/src/geometry.js

@@ -30,7 +30,7 @@ import { sema } from "./sema.js";
  *  longer than the perception quantum must use the scale-aware
  *  {@link identityBar}, which converts the tolerated fraction into bytes. */
 export function mergeThreshold(D) {
-  return 1 - 1 / Math.sqrt(D);
+    return 1 - 1 / Math.sqrt(D);
 }
 /** The scale-aware IDENTITY bar for a whole-span resonance claim over a span
  *  of `len` bytes.  Under the linear fold a cosine reads "fraction of aligned
@@ -46,7 +46,7 @@ export function mergeThreshold(D) {
  *  the tolerated fraction into tolerated bytes.  Derived from W, D and the
  *  span; never tuned. */
 export function identityBar(D, maxGroup, len) {
-  return Math.max(mergeThreshold(D), 1 - maxGroup / Math.max(1, len));
+    return Math.max(mergeThreshold(D), 1 - maxGroup / Math.max(1, len));
 }
 /** The reach bar: half a river quantum, derived from the fold's own geometry.
  *  A branch folds up to `maxGroup` children, so two forms that differ in ONE
@@ -59,7 +59,7 @@ export function identityBar(D, maxGroup, len) {
  *  — further than any single-child variant — and the system returns null rather
  *  than fabricate an answer from an unrelated form.  Derived, never tuned. */
 export function reachThreshold(maxGroup) {
-  return 1 - 1 / (2 * maxGroup);
+    return 1 - 1 / (2 * maxGroup);
 }
 /** The estimator's own noise floor: 1/√D — ONE standard deviation of the
  *  cosine between two independent random vectors in D dimensions (the same σ
@@ -71,7 +71,7 @@ export function reachThreshold(maxGroup) {
  *  minimal "above noise" bar, one σ, not the stricter 3σ relatedness bar.
  *  Derived, never tuned. */
 export function estimatorNoise(D) {
-  return 1 / Math.sqrt(D);
+    return 1 / Math.sqrt(D);
 }
 /** The statistical-significance bar for whole-query resonance: 3/√D.
  *  In D dimensions the expected cosine of two independent random vectors is 0
@@ -81,7 +81,7 @@ export function estimatorNoise(D) {
  *  sub-region resonance) is skipped: there is no evidence the query belongs to
  *  the same distribution as the stored content.  Derived, never tuned. */
 export function significanceBar(D) {
-  return 3 / Math.sqrt(D);
+    return 3 / Math.sqrt(D);
 }
 /** The concept (halo) threshold: the cosine above which two nodes share a
  *  distributional concept.  A halo is a superposition of episode signatures in
@@ -93,7 +93,7 @@ export function significanceBar(D) {
  *  3% of 0.5 — existing behavior is preserved while threshold and D move
  *  together.  Derived, never tuned. */
 export function conceptThreshold(D) {
-  return 0.5 + 0.5 / Math.sqrt(D);
+    return 0.5 + 0.5 / Math.sqrt(D);
 }
 /** The HALF-DOMINANCE predicate: whether a part covering `partLen` of a
  *  whole of `wholeLen` covers STRICTLY more than half of it.  A span that
@@ -104,7 +104,7 @@ export function conceptThreshold(D) {
  *  already unusable there) and stays inline where it is documented.
  *  Derived from the structural midpoint, never tuned. */
 export function dominates(partLen, wholeLen) {
-  return partLen * 2 > wholeLen;
+    return partLen * 2 > wholeLen;
 }
 /** The consensus-vote significance floor: ln(N) + 1/2, where N is the number
  *  of learnt contexts (edge sources).  A single region's IDF-weighted vote for
@@ -116,7 +116,7 @@ export function dominates(partLen, wholeLen) {
  *  further point of attention.  Defined once here so the two can never
  *  drift apart.  Derived from N, never tuned. */
 export function consensusFloor(N) {
-  return Math.log(N) + 1 / 2;
+    return Math.log(N) + 1 / 2;
 }
 /** The coverage bar for the reach (interior) index, when vector-similarity
  *  gating is used.  Returns the concept threshold — the structural midpoint
@@ -128,7 +128,7 @@ export function consensusFloor(N) {
  *  replaces runtime coverage gating with a batch pass that removes
  *  structurally-isolated entries.  Derived, never tuned. */
 export function coverageBar(_maxGroup, D) {
-  return conceptThreshold(D);
+    return conceptThreshold(D);
 }
 // ---- folding ----
 //
@@ -160,302 +160,271 @@ export function coverageBar(_maxGroup, D) {
  *  well — only a lone singleton passes through — guaranteeing progress when
  *  the caller detected a stall. */
 function foldSlice(space, items, start, count, out, force) {
-  const mg = space.maxGroup;
-  const D = space.D;
-  const complete = count - (count % mg);
-  const foldAt = (at, size) => {
-    const gist = new Float32Array(D);
-    const kids = new Array(size);
-    let len = 0;
-    for (let k = 0; k < size; k++) {
-      const f = items[at + k];
-      const seat = space.seats[k].fwd;
-      const v = f.tree.v;
-      // Fused permute-and-accumulate — same FP ops, same order as the old
-      // permuteInto + addInto pair, with no scratch buffer.
-      for (let d = 0; d < D; d++) {
-        gist[d] += v[seat[d]];
-      }
-      kids[k] = f.tree;
-      len += f.len;
-    }
-    out.push({ tree: sema(gist, null, kids), len });
-  };
-  for (let i = 0; i < complete; i += mg) {
-    foldAt(start + i, mg);
-  }
-  const leftover = count - complete;
-  if (leftover === 0) {
-    return;
-  }
-  if (force && leftover >= 2) {
-    foldAt(start + complete, leftover);
-  } else {
-    for (let i = complete; i < count; i++) {
-      out.push(items[start + i]);
-    }
-  }
+    const mg = space.maxGroup;
+    const D = space.D;
+    const complete = count - (count % mg);
+    const foldAt = (at, size) => {
+        const gist = new Float32Array(D);
+        const kids = new Array(size);
+        let len = 0;
+        for (let k = 0; k < size; k++) {
+            const f = items[at + k];
+            const seat = space.seats[k].fwd;
+            const v = f.tree.v;
+            // Fused permute-and-accumulate — same FP ops, same order as the old
+            // permuteInto + addInto pair, with no scratch buffer.
+            for (let d = 0; d < D; d++)
+                gist[d] += v[seat[d]];
+            kids[k] = f.tree;
+            len += f.len;
+        }
+        out.push({ tree: sema(gist, null, kids), len });
+    };
+    for (let i = 0; i < complete; i += mg)
+        foldAt(start + i, mg);
+    const leftover = count - complete;
+    if (leftover === 0)
+        return;
+    if (force && leftover >= 2)
+        foldAt(start + complete, leftover);
+    else
+        for (let i = complete; i < count; i++)
+            out.push(items[start + i]);
 }
 function riverFold(space, row, stableBytes) {
-  if (row.length === 0) {
-    const z = new Float32Array(space.D);
-    return { tree: sema(z, new Uint8Array(0), null), len: 0 };
-  }
-  let level = row;
-  while (level.length > 1) {
-    // Find the item index where accumulated bytes reaches stableBytes.
-    let boundary = level.length;
-    if (stableBytes > 0) {
-      let acc = 0;
-      for (let i = 0; i < level.length; i++) {
-        acc += level[i].len;
-        if (acc >= stableBytes) {
-          boundary = i + 1;
-          break;
-        }
-      }
-    }
-    const next = [];
-    if (boundary < level.length) {
-      // Prefix folds independently of the suffix — structural stability.
-      foldSlice(space, level, 0, boundary, next, false);
-      foldSlice(space, level, boundary, level.length - boundary, next, false);
-    } else {
-      foldSlice(space, level, 0, level.length, next, false);
+    if (row.length === 0) {
+        const z = new Float32Array(space.D);
+        return { tree: sema(z, new Uint8Array(0), null), len: 0 };
     }
-    if (next.length === level.length) {
-      // Stuck — every group was incomplete.  Force-fold to break the stall.
-      const forced = [];
-      foldSlice(space, next, 0, next.length, forced, true);
-      level = forced;
-    } else {
-      level = next;
+    let level = row;
+    while (level.length > 1) {
+        // Find the item index where accumulated bytes reaches stableBytes.
+        let boundary = level.length;
+        if (stableBytes > 0) {
+            let acc = 0;
+            for (let i = 0; i < level.length; i++) {
+                acc += level[i].len;
+                if (acc >= stableBytes) {
+                    boundary = i + 1;
+                    break;
+                }
+            }
+        }
+        const next = [];
+        if (boundary < level.length) {
+            // Prefix folds independently of the suffix — structural stability.
+            foldSlice(space, level, 0, boundary, next, false);
+            foldSlice(space, level, boundary, level.length - boundary, next, false);
+        }
+        else {
+            foldSlice(space, level, 0, level.length, next, false);
+        }
+        if (next.length === level.length) {
+            // Stuck — every group was incomplete.  Force-fold to break the stall.
+            const forced = [];
+            foldSlice(space, next, 0, next.length, forced, true);
+            level = forced;
+        }
+        else {
+            level = next;
+        }
     }
-  }
-  // LINEAR fold — this root normalize is the ONLY normalize of the entire
-  // fold; every intermediate gist stays unnormalized (see the folding
-  // header).  Skipped for a single-leaf input: that root IS the shared
-  // alphabet vector (already unit), and normalizing in place would mutate the
-  // alphabet itself.
-  if (row.length > 1) {
-    normalize(level[0].tree.v);
-  }
-  return level[0];
+    // LINEAR fold — this root normalize is the ONLY normalize of the entire
+    // fold; every intermediate gist stays unnormalized (see the folding
+    // header).  Skipped for a single-leaf input: that root IS the shared
+    // alphabet vector (already unit), and normalizing in place would mutate the
+    // alphabet itself.
+    if (row.length > 1)
+        normalize(level[0].tree.v);
+    return level[0];
 }
 // ---- public API ----
 function bytesToLeaves(alphabet, bytes) {
-  return Array.from(bytes, (b, i) => {
-    const v = alphabet.vecs[b];
-    return { tree: sema(v, bytes.slice(i, i + 1), null), len: 1 };
-  });
+    return Array.from(bytes, (b, i) => {
+        const v = alphabet.vecs[b];
+        return { tree: sema(v, bytes.slice(i, i + 1), null), len: 1 };
+    });
 }
 /** Find the longest prefix of `bytes` whose leaf-id signature matches a
  *  known branch via `lookup`.  Returns the byte-length of that prefix, or 0. */
 export function knownPrefixLength(bytes, leafAt, lookup) {
-  const leafIds = [];
-  for (let i = 0; i < bytes.length; i++) {
-    const lid = leafAt(i);
-    if (lid === null) {
-      break;
+    const leafIds = [];
+    for (let i = 0; i < bytes.length; i++) {
+        const lid = leafAt(i);
+        if (lid === null)
+            break;
+        leafIds.push(lid);
     }
-    leafIds.push(lid);
-  }
-  // Match the longest PROPER prefix — a full-length match means the entire
-  // input already exists as a stored form (e.g. the flat leaf-id branch
-  // stored alongside the structural root).  That would hide the true split
-  // point and prevent the river from producing the same tree it folded
-  // during training, so the structural recognition cannot find the right
-  // forms.  A proper prefix guarantees at least two regions.
-  for (let len = bytes.length - 1; len >= 2; len--) {
-    if (lookup(leafIds.slice(0, len)) !== null) {
-      return len;
+    // Match the longest PROPER prefix — a full-length match means the entire
+    // input already exists as a stored form (e.g. the flat leaf-id branch
+    // stored alongside the structural root).  That would hide the true split
+    // point and prevent the river from producing the same tree it folded
+    // during training, so the structural recognition cannot find the right
+    // forms.  A proper prefix guarantees at least two regions.
+    for (let len = bytes.length - 1; len >= 2; len--) {
+        if (lookup(leafIds.slice(0, len)) !== null)
+            return len;
     }
-  }
-  return 0;
+    return 0;
 }
 /** Bytes → Sema tree.  `leafAt` and `lookup` are store capabilities for
  *  detecting previously-stored prefixes so the river can split at the
  *  correct boundary.  Pass them through from `perceive`; the geometry
  *  computes the stable prefix internally. */
 export function bytesToTree(space, alphabet, bytes, leafAt, lookup) {
-  if (bytes.length === 0) {
-    return sema(alphabet.vecs[0], new Uint8Array(0), null);
-  }
-  const sb = (leafAt && lookup) ? knownPrefixLength(bytes, leafAt, lookup) : 0;
-  return riverFold(
-    space,
-    bytesToLeaves(alphabet, bytes),
-    sb > 0 ? sb : bytes.length,
-  ).tree;
+    if (bytes.length === 0) {
+        return sema(alphabet.vecs[0], new Uint8Array(0), null);
+    }
+    const sb = (leafAt && lookup) ? knownPrefixLength(bytes, leafAt, lookup) : 0;
+    return riverFold(space, bytesToLeaves(alphabet, bytes), sb > 0 ? sb : bytes.length).tree;
 }
 /** Plain bytes→tree (identical to capability-less {@link bytesToTree}) that
  *  also RETURNS its pyramid, reusing `prev` — the pyramid of a PROPER
  *  prefix of `bytes` (caller guarantees content match and
  *  prev.bytes < bytes.length). */
 export function bytesToTreePyramid(space, alphabet, bytes, prev) {
-  if (bytes.length === 0) {
-    return {
-      tree: sema(alphabet.vecs[0], new Uint8Array(0), null),
-      pyramid: { levels: [], bytes: 0 },
-    };
-  }
-  const mg = space.maxGroup;
-  const reusable = (L) => {
-    // prev's TOPMOST level holds its normalized ROOT — reusable blocks must
-    // be raw interiors, so the top level is always excluded.
-    if (!prev || L > prev.levels.length - 2) {
-      return null;
+    if (bytes.length === 0) {
+        return {
+            tree: sema(alphabet.vecs[0], new Uint8Array(0), null),
+            pyramid: { levels: [], bytes: 0 },
+        };
     }
-    return prev.levels[L];
-  };
-  // Level 0: reuse the prefix's leaf items wholesale (all are full blocks).
-  const lv0 = reusable(0);
-  const row = lv0
-    ? [...lv0, ...bytesToLeaves(alphabet, bytes.subarray(prev.bytes))]
-    : bytesToLeaves(alphabet, bytes);
-  const levels = [row];
-  let level = row;
-  let L = 0;
-  while (level.length > 1) {
-    let next = [];
-    // Reuse the leading FULL blocks of prev's level L+1 (len == mg^(L+1),
-    // wholly inside the prefix); the rule below folds the rest from this
-    // level's items exactly as the from-scratch fold would.
-    const blockLen = mg ** (L + 1);
-    let reused = 0;
-    const cand = reusable(L + 1);
-    if (cand) {
-      const maxFull = Math.floor(prev.bytes / blockLen);
-      while (
-        reused < maxFull && reused < cand.length &&
-        cand[reused].len === blockLen
-      ) {
-        reused++;
-      }
-      for (let i = 0; i < reused; i++) {
-        next.push(cand[i]);
-      }
-    }
-    foldSlice(
-      space,
-      level,
-      reused * mg,
-      level.length - reused * mg,
-      next,
-      false,
-    );
-    if (next.length === level.length) {
-      // Stuck — same force-fold as riverFold (reuse cannot cause it: any
-      // reused block replaces a whole folded group, so reused > 0 implies
-      // progress).
-      const forced = [];
-      foldSlice(space, next, 0, next.length, forced, true);
-      next = forced;
+    const mg = space.maxGroup;
+    const reusable = (L) => {
+        // prev's TOPMOST level holds its normalized ROOT — reusable blocks must
+        // be raw interiors, so the top level is always excluded.
+        if (!prev || L > prev.levels.length - 2)
+            return null;
+        return prev.levels[L];
+    };
+    // Level 0: reuse the prefix's leaf items wholesale (all are full blocks).
+    const lv0 = reusable(0);
+    const row = lv0
+        ? [...lv0, ...bytesToLeaves(alphabet, bytes.subarray(prev.bytes))]
+        : bytesToLeaves(alphabet, bytes);
+    const levels = [row];
+    let level = row;
+    let L = 0;
+    while (level.length > 1) {
+        let next = [];
+        // Reuse the leading FULL blocks of prev's level L+1 (len == mg^(L+1),
+        // wholly inside the prefix); the rule below folds the rest from this
+        // level's items exactly as the from-scratch fold would.
+        const blockLen = mg ** (L + 1);
+        let reused = 0;
+        const cand = reusable(L + 1);
+        if (cand) {
+            const maxFull = Math.floor(prev.bytes / blockLen);
+            while (reused < maxFull && reused < cand.length &&
+                cand[reused].len === blockLen)
+                reused++;
+            for (let i = 0; i < reused; i++)
+                next.push(cand[i]);
+        }
+        foldSlice(space, level, reused * mg, level.length - reused * mg, next, false);
+        if (next.length === level.length) {
+            // Stuck — same force-fold as riverFold (reuse cannot cause it: any
+            // reused block replaces a whole folded group, so reused > 0 implies
+            // progress).
+            const forced = [];
+            foldSlice(space, next, 0, next.length, forced, true);
+            next = forced;
+        }
+        levels.push(next);
+        level = next;
+        L++;
     }
-    levels.push(next);
-    level = next;
-    L++;
-  }
-  if (row.length > 1) {
-    normalize(level[0].tree.v);
-  }
-  return {
-    tree: level[0].tree,
-    pyramid: { levels, bytes: bytes.length },
-  };
+    if (row.length > 1)
+        normalize(level[0].tree.v);
+    return {
+        tree: level[0].tree,
+        pyramid: { levels, bytes: bytes.length },
+    };
 }
 // ---- n-D Hilbert curve ----
 function gridDims(grid) {
-  if (grid.dims && grid.dims.length > 0) {
-    return grid.dims.slice();
-  }
-  const dims = [grid.height, grid.width];
-  if (grid.channels > 1) {
-    dims.push(grid.channels);
-  }
-  return dims;
+    if (grid.dims && grid.dims.length > 0)
+        return grid.dims.slice();
+    const dims = [grid.height, grid.width];
+    if (grid.channels > 1)
+        dims.push(grid.channels);
+    return dims;
 }
 function hilbertPoint(index, n, bits) {
-  const x = new Array(n).fill(0);
-  for (let b = 0; b < bits; b++) {
-    for (let d = 0; d < n; d++) {
-      const bit = (index >>> (b * n + (n - 1 - d))) & 1;
-      x[d] |= bit << b;
+    const x = new Array(n).fill(0);
+    for (let b = 0; b < bits; b++) {
+        for (let d = 0; d < n; d++) {
+            const bit = (index >>> (b * n + (n - 1 - d))) & 1;
+            x[d] |= bit << b;
+        }
     }
-  }
-  const N = 1 << bits;
-  let t = x[n - 1] >> 1;
-  for (let i = n - 1; i > 0; i--) {
-    x[i] ^= x[i - 1];
-  }
-  x[0] ^= t;
-  for (let q = 2; q !== N; q <<= 1) {
-    const p = q - 1;
-    for (let i = n - 1; i >= 0; i--) {
-      if (x[i] & q) {
-        x[0] ^= p;
-      } else {
-        t = (x[0] ^ x[i]) & p;
-        x[0] ^= t;
-        x[i] ^= t;
-      }
+    const N = 1 << bits;
+    let t = x[n - 1] >> 1;
+    for (let i = n - 1; i > 0; i--)
+        x[i] ^= x[i - 1];
+    x[0] ^= t;
+    for (let q = 2; q !== N; q <<= 1) {
+        const p = q - 1;
+        for (let i = n - 1; i >= 0; i--) {
+            if (x[i] & q)
+                x[0] ^= p;
+            else {
+                t = (x[0] ^ x[i]) & p;
+                x[0] ^= t;
+                x[i] ^= t;
+            }
+        }
     }
-  }
-  return x;
+    return x;
 }
 export function hilbertBytes(grid) {
-  const dims = gridDims(grid);
-  const n = dims.length;
-  if (n === 0 || grid.data.length === 0) {
-    return new Uint8Array(0);
-  }
-  if (n === 1) {
-    return grid.data.slice(0, dims[0]);
-  }
-  const maxAxis = Math.max(...dims);
-  const bits = Math.max(1, Math.ceil(Math.log2(maxAxis)));
-  const side = 1 << bits;
-  const total = Math.pow(side, n);
-  const stride = new Array(n);
-  stride[n - 1] = 1;
-  for (let d = n - 2; d >= 0; d--) {
-    stride[d] = stride[d + 1] * dims[d + 1];
-  }
-  const out = [];
-  for (let h = 0; h < total; h++) {
-    const pt = hilbertPoint(h, n, bits);
-    let inside = true, flat = 0;
-    for (let d = 0; d < n; d++) {
-      if (pt[d] >= dims[d]) {
-        inside = false;
-        break;
-      }
-      flat += pt[d] * stride[d];
-    }
-    if (inside) {
-      out.push(grid.data[flat]);
+    const dims = gridDims(grid);
+    const n = dims.length;
+    if (n === 0 || grid.data.length === 0)
+        return new Uint8Array(0);
+    if (n === 1)
+        return grid.data.slice(0, dims[0]);
+    const maxAxis = Math.max(...dims);
+    const bits = Math.max(1, Math.ceil(Math.log2(maxAxis)));
+    const side = 1 << bits;
+    const total = Math.pow(side, n);
+    const stride = new Array(n);
+    stride[n - 1] = 1;
+    for (let d = n - 2; d >= 0; d--)
+        stride[d] = stride[d + 1] * dims[d + 1];
+    const out = [];
+    for (let h = 0; h < total; h++) {
+        const pt = hilbertPoint(h, n, bits);
+        let inside = true, flat = 0;
+        for (let d = 0; d < n; d++) {
+            if (pt[d] >= dims[d]) {
+                inside = false;
+                break;
+            }
+            flat += pt[d] * stride[d];
+        }
+        if (inside)
+            out.push(grid.data[flat]);
     }
-  }
-  return Uint8Array.from(out);
+    return Uint8Array.from(out);
 }
 export function gridToTree(space, alphabet, grid) {
-  return bytesToTree(space, alphabet, hilbertBytes(grid));
+    return bytesToTree(space, alphabet, hilbertBytes(grid));
 }
 export function stackGrids(frames) {
-  if (frames.length === 0) {
-    return { width: 0, height: 0, channels: 0, data: new Uint8Array(0) };
-  }
-  const frameDims = gridDims(frames[0]);
-  const per = frames[0].data.length;
-  const data = new Uint8Array(per * frames.length);
-  for (let i = 0; i < frames.length; i++) {
-    data.set(frames[i].data, i * per);
-  }
-  return {
-    width: 0,
-    height: 0,
-    channels: 0,
-    dims: [frames.length, ...frameDims],
-    data,
-  };
+    if (frames.length === 0) {
+        return { width: 0, height: 0, channels: 0, data: new Uint8Array(0) };
+    }
+    const frameDims = gridDims(frames[0]);
+    const per = frames[0].data.length;
+    const data = new Uint8Array(per * frames.length);
+    for (let i = 0; i < frames.length; i++)
+        data.set(frames[i].data, i * per);
+    return {
+        width: 0,
+        height: 0,
+        channels: 0,
+        dims: [frames.length, ...frameDims],
+        data,
+    };
 }

package/dist/src/index.d.ts

@@ -10,21 +10,6 @@ export * from "./store-sqlite.js";
 export * from "./config.js";
 export * from "./extension.js";
 export * from "./ingest-cache.js";
-export {
-  Heap,
-  HnswIndex,
-  Prng,
-  RaBitQuantizer,
-  VectorDatabase,
-} from "./rabitq-hnsw/src/index.js";
-export type {
-  DatabaseOptions,
-  ExternalId,
-  HnswParams,
-  KnnHit,
-  QueryContext,
-  QueryResult,
-  RaBitQOptions,
-  StorageStats,
-} from "./rabitq-hnsw/src/index.js";
+export { IvfIndex, Prng, RaBitQuantizer, VectorDatabase, } from "./rabitq-ivf/src/index.js";
+export type { DatabaseOptions, ExternalId, IvfConfig, IvfHit, QueryContext, QueryResult, RaBitQOptions, StorageStats, } from "./rabitq-ivf/src/index.js";
 export * from "./derive/src/index.js";

package/dist/src/index.js

@@ -12,16 +12,6 @@ export * from "./store-sqlite.js";
 export * from "./config.js";
 export * from "./extension.js";
 export * from "./ingest-cache.js";
-// rabitq-hnsw is re-exported selectively: its `Store`, `NodeRec`, and
-// `StoreConfig` are internal names that collide with sema's own top-level
-// `store.js` / `config.js` exports, and sema code that needs the rabitq ones
-// imports them from the subpath directly. Re-export the public vector-DB
-// surface under the sema root, omitting the three colliding names.
-export {
-  Heap,
-  HnswIndex,
-  Prng,
-  RaBitQuantizer,
-  VectorDatabase,
-} from "./rabitq-hnsw/src/index.js";
+// rabitq-ivf: the partitioned (IVF) vector index over 1-bit RaBitQ codes.
+export { IvfIndex, Prng, RaBitQuantizer, VectorDatabase, } from "./rabitq-ivf/src/index.js";
 export * from "./derive/src/index.js";