@hviana/sema 0.1.4 → 0.1.5

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,271 +160,302 @@ 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 (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;
+  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 (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;
-        leafIds.push(lid);
+  const leafIds = [];
+  for (let i = 0; i < bytes.length; i++) {
+    const lid = leafAt(i);
+    if (lid === null) {
+      break;
     }
-    // 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;
+    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;
     }
-    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;
-        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++;
-    }
-    if (row.length > 1)
-        normalize(level[0].tree.v);
+  if (bytes.length === 0) {
     return {
-        tree: level[0].tree,
-        pyramid: { levels, bytes: bytes.length },
+      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;
+    }
+    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++;
+  }
+  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,6 +10,21 @@ 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 {
+  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 * from "./derive/src/index.js";

package/dist/src/index.js

@@ -17,5 +17,11 @@ export * from "./ingest-cache.js";
 // `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";
+export {
+  Heap,
+  HnswIndex,
+  Prng,
+  RaBitQuantizer,
+  VectorDatabase,
+} from "./rabitq-hnsw/src/index.js";
 export * from "./derive/src/index.js";