@hviana/sema 0.1.3 → 0.1.5

package/dist/src/rabitq-hnsw/src/heap.d.ts

@@ -7,16 +7,16 @@
  * allocation in the search hot path.
  */
 export declare class Heap {
-    readonly keys: number[];
-    readonly vals: number[];
-    private readonly minHeap;
-    constructor(minHeap: boolean);
-    get size(): number;
-    clear(): void;
-    topKey(): number;
-    topVal(): number;
-    /** true if `a` belongs closer to the root than `b`. */
-    private higher;
-    push(key: number, val: number): void;
-    pop(): void;
+  readonly keys: number[];
+  readonly vals: number[];
+  private readonly minHeap;
+  constructor(minHeap: boolean);
+  get size(): number;
+  clear(): void;
+  topKey(): number;
+  topVal(): number;
+  /** true if `a` belongs closer to the root than `b`. */
+  private higher;
+  push(key: number, val: number): void;
+  pop(): void;
 }

package/dist/src/rabitq-hnsw/src/heap.js

@@ -7,83 +7,88 @@
  * allocation in the search hot path.
  */
 export class Heap {
-    keys = [];
-    vals = [];
-    minHeap;
-    constructor(minHeap) {
-        this.minHeap = minHeap;
+  keys = [];
+  vals = [];
+  minHeap;
+  constructor(minHeap) {
+    this.minHeap = minHeap;
+  }
+  get size() {
+    return this.keys.length;
+  }
+  clear() {
+    this.keys.length = 0;
+    this.vals.length = 0;
+  }
+  topKey() {
+    return this.keys[0];
+  }
+  topVal() {
+    return this.vals[0];
+  }
+  /** true if `a` belongs closer to the root than `b`. */
+  higher(a, b) {
+    return this.minHeap ? a < b : a > b;
+  }
+  push(key, val) {
+    const keys = this.keys;
+    const vals = this.vals;
+    let i = keys.length;
+    keys.push(key);
+    vals.push(val);
+    while (i > 0) {
+      const parent = (i - 1) >> 1;
+      if (this.higher(keys[i], keys[parent])) {
+        const tk = keys[i];
+        keys[i] = keys[parent];
+        keys[parent] = tk;
+        const tv = vals[i];
+        vals[i] = vals[parent];
+        vals[parent] = tv;
+        i = parent;
+      } else {
+        break;
+      }
     }
-    get size() {
-        return this.keys.length;
+  }
+  pop() {
+    const keys = this.keys;
+    const vals = this.vals;
+    const n = keys.length;
+    if (n === 0) {
+      return;
     }
-    clear() {
-        this.keys.length = 0;
-        this.vals.length = 0;
+    const lastKey = keys[n - 1];
+    const lastVal = vals[n - 1];
+    keys.pop();
+    vals.pop();
+    const m = keys.length;
+    if (m === 0) {
+      return;
     }
-    topKey() {
-        return this.keys[0];
-    }
-    topVal() {
-        return this.vals[0];
-    }
-    /** true if `a` belongs closer to the root than `b`. */
-    higher(a, b) {
-        return this.minHeap ? a < b : a > b;
-    }
-    push(key, val) {
-        const keys = this.keys;
-        const vals = this.vals;
-        let i = keys.length;
-        keys.push(key);
-        vals.push(val);
-        while (i > 0) {
-            const parent = (i - 1) >> 1;
-            if (this.higher(keys[i], keys[parent])) {
-                const tk = keys[i];
-                keys[i] = keys[parent];
-                keys[parent] = tk;
-                const tv = vals[i];
-                vals[i] = vals[parent];
-                vals[parent] = tv;
-                i = parent;
-            }
-            else
-                break;
-        }
-    }
-    pop() {
-        const keys = this.keys;
-        const vals = this.vals;
-        const n = keys.length;
-        if (n === 0)
-            return;
-        const lastKey = keys[n - 1];
-        const lastVal = vals[n - 1];
-        keys.pop();
-        vals.pop();
-        const m = keys.length;
-        if (m === 0)
-            return;
-        keys[0] = lastKey;
-        vals[0] = lastVal;
-        let i = 0;
-        while (true) {
-            const left = 2 * i + 1;
-            const right = left + 1;
-            let best = i;
-            if (left < m && this.higher(keys[left], keys[best]))
-                best = left;
-            if (right < m && this.higher(keys[right], keys[best]))
-                best = right;
-            if (best === i)
-                break;
-            const tk = keys[i];
-            keys[i] = keys[best];
-            keys[best] = tk;
-            const tv = vals[i];
-            vals[i] = vals[best];
-            vals[best] = tv;
-            i = best;
-        }
+    keys[0] = lastKey;
+    vals[0] = lastVal;
+    let i = 0;
+    while (true) {
+      const left = 2 * i + 1;
+      const right = left + 1;
+      let best = i;
+      if (left < m && this.higher(keys[left], keys[best])) {
+        best = left;
+      }
+      if (right < m && this.higher(keys[right], keys[best])) {
+        best = right;
+      }
+      if (best === i) {
+        break;
+      }
+      const tk = keys[i];
+      keys[i] = keys[best];
+      keys[best] = tk;
+      const tv = vals[i];
+      vals[i] = vals[best];
+      vals[best] = tv;
+      i = best;
     }
+  }
 }

package/dist/src/rabitq-hnsw/src/hnsw.d.ts

@@ -1,16 +1,16 @@
 import { RaBitQuantizer } from "./rabitq.js";
 import { Store } from "./store.js";
 export interface HnswParams {
-    M: number;
-    efConstruction: number;
-    efSearch: number;
-    seed: number;
+  M: number;
+  efConstruction: number;
+  efSearch: number;
+  seed: number;
 }
 export interface KnnHit {
-    /** external (user) id */
-    id: number;
-    /** estimated cosine distance (1 - cosine) */
-    distance: number;
+  /** external (user) id */
+  id: number;
+  /** estimated cosine distance (1 - cosine) */
+  distance: number;
 }
 /**
  * Hierarchical Navigable Small World graph (Malkov & Yashunin, 2018) backed by
@@ -27,99 +27,99 @@ export interface KnnHit {
  * access to the original vectors.
  */
 export declare class HnswIndex {
-    readonly M: number;
-    readonly Mmax0: number;
-    readonly efConstruction: number;
-    private readonly mL;
-    private readonly quantizer;
-    private readonly store;
-    private readonly seed;
-    private readonly levelRng;
-    private entry;
-    private maxLevel;
-    private live;
-    private total;
-    private _efSearch;
-    private readonly working;
-    private readonly visited;
-    private visitedTag;
-    private visitedEpoch;
-    private seenTag;
-    private markVisited;
-    private readonly candHeap;
-    private readonly resHeap;
-    private readonly singleEp;
-    private readonly idxScratch;
-    private readonly distScratch;
-    private readonly freshScratch;
-    private qCtx;
-    private refBytes;
-    private building;
-    lastQueryDistComps: number;
-    /** Storage row reads issued by the most recent query (cache-independent). */
-    lastQueryStorageReads: number;
-    constructor(quantizer: RaBitQuantizer, store: Store, params: HnswParams);
-    get size(): number;
-    get physicalSize(): number;
-    get bytesPerVector(): number;
-    get efSearch(): number;
-    set efSearch(v: number);
-    private persistState;
-    private randomLevel;
-    /**
-     * Fetch a node record into the operation's working set. The first touch in an
-     * op is a storage read; later touches in the same op reuse it. The set is
-     * cleared per op and bounded by efConstruction / efSearch, so storage reads
-     * per op equal the number of *distinct* nodes the op visits -- minimal, and
-     * independent of any cache.
-     */
-    private node;
-    /** Prefetch several nodes into the working set with ONE batched storage
-     *  read for the misses.  Point queries per neighbour made statement
-     *  dispatch — not distance arithmetic — the dominant cost of a large
-     *  build; the batch keeps `reads` accounting identical per row. */
-    private fetchNodes;
-    /** Distance from the current source (query vector or reference code) to a node. */
-    private distOf;
-    /** Code-to-code distance between two stored nodes (graph wiring only). */
-    private codeDist;
-    /**
-     * SEARCH-LAYER (Algorithm 2). Frontier in `candHeap`, bounded result set in
-     * `resHeap` (non-deleted only). Deleted nodes are traversed for routing but
-     * never returned. `visited` is a per-call set sized by the nodes seen here.
-     */
-    private searchLayer;
-    /** Greedy single-best descent from `fromLayer` down to (but not into) `toLayer`. */
-    private greedyDescend;
-    /**
-     * SELECT-NEIGHBORS-HEURISTIC (Algorithm 4) on codes. Picks up to `M` diverse
-     * neighbours from `candIds`, preferring those closer to `base` than to any
-     * already-chosen neighbour, then fills remaining slots with the closest
-     * leftovers (keep-pruned connections). Appends to `out`.
-     */
-    private selectNeighbors;
-    /**
-     * Insert a vector's code under external id `ext`; returns the internal node id.
-     * All graph reads/writes go through the store; the caller owns the transaction.
-     */
-    insert(ext: number, code: Uint8Array, efC?: number): number;
-    /** k-NN with a full-precision query vector (accurate estimator). */
-    searchKnn(vec: ArrayLike<number>, k: number, ef?: number): KnnHit[];
-    /** k-NN with an already-quantized code (sign-bit Hamming / angular distance). */
-    searchKnnByCode(codeBytes: Uint8Array, k: number, ef?: number): KnnHit[];
-    private collectKnn;
-    /** Tombstone a live node by internal id. Caller owns the transaction. */
-    remove(id: number): boolean;
-    /**
-     * Reclaim tombstones with a graph-preserving splice (see
-     * {@link Store.spliceCompact}): live nodes keep their internal ids and their
-     * wiring; each dead neighbour is replaced by its own live neighbours.  Codes
-     * are untouched, so the index loses nothing beyond what deletion itself
-     * removes.  The previous implementation replayed every live code through a
-     * full HNSW insert — O(live · ef · log N) storage reads, HOURS on a trained
-     * multi-million-node store, inside one WAL-bloating transaction.  The splice
-     * is a streaming pass with batched commits, then a VACUUM to return the
-     * freed pages.
-     */
-    compact(): void;
+  readonly M: number;
+  readonly Mmax0: number;
+  readonly efConstruction: number;
+  private readonly mL;
+  private readonly quantizer;
+  private readonly store;
+  private readonly seed;
+  private readonly levelRng;
+  private entry;
+  private maxLevel;
+  private live;
+  private total;
+  private _efSearch;
+  private readonly working;
+  private readonly visited;
+  private visitedTag;
+  private visitedEpoch;
+  private seenTag;
+  private markVisited;
+  private readonly candHeap;
+  private readonly resHeap;
+  private readonly singleEp;
+  private readonly idxScratch;
+  private readonly distScratch;
+  private readonly freshScratch;
+  private qCtx;
+  private refBytes;
+  private building;
+  lastQueryDistComps: number;
+  /** Storage row reads issued by the most recent query (cache-independent). */
+  lastQueryStorageReads: number;
+  constructor(quantizer: RaBitQuantizer, store: Store, params: HnswParams);
+  get size(): number;
+  get physicalSize(): number;
+  get bytesPerVector(): number;
+  get efSearch(): number;
+  set efSearch(v: number);
+  private persistState;
+  private randomLevel;
+  /**
+   * Fetch a node record into the operation's working set. The first touch in an
+   * op is a storage read; later touches in the same op reuse it. The set is
+   * cleared per op and bounded by efConstruction / efSearch, so storage reads
+   * per op equal the number of *distinct* nodes the op visits -- minimal, and
+   * independent of any cache.
+   */
+  private node;
+  /** Prefetch several nodes into the working set with ONE batched storage
+   *  read for the misses.  Point queries per neighbour made statement
+   *  dispatch — not distance arithmetic — the dominant cost of a large
+   *  build; the batch keeps `reads` accounting identical per row. */
+  private fetchNodes;
+  /** Distance from the current source (query vector or reference code) to a node. */
+  private distOf;
+  /** Code-to-code distance between two stored nodes (graph wiring only). */
+  private codeDist;
+  /**
+   * SEARCH-LAYER (Algorithm 2). Frontier in `candHeap`, bounded result set in
+   * `resHeap` (non-deleted only). Deleted nodes are traversed for routing but
+   * never returned. `visited` is a per-call set sized by the nodes seen here.
+   */
+  private searchLayer;
+  /** Greedy single-best descent from `fromLayer` down to (but not into) `toLayer`. */
+  private greedyDescend;
+  /**
+   * SELECT-NEIGHBORS-HEURISTIC (Algorithm 4) on codes. Picks up to `M` diverse
+   * neighbours from `candIds`, preferring those closer to `base` than to any
+   * already-chosen neighbour, then fills remaining slots with the closest
+   * leftovers (keep-pruned connections). Appends to `out`.
+   */
+  private selectNeighbors;
+  /**
+   * Insert a vector's code under external id `ext`; returns the internal node id.
+   * All graph reads/writes go through the store; the caller owns the transaction.
+   */
+  insert(ext: number, code: Uint8Array, efC?: number): number;
+  /** k-NN with a full-precision query vector (accurate estimator). */
+  searchKnn(vec: ArrayLike<number>, k: number, ef?: number): KnnHit[];
+  /** k-NN with an already-quantized code (sign-bit Hamming / angular distance). */
+  searchKnnByCode(codeBytes: Uint8Array, k: number, ef?: number): KnnHit[];
+  private collectKnn;
+  /** Tombstone a live node by internal id. Caller owns the transaction. */
+  remove(id: number): boolean;
+  /**
+   * Reclaim tombstones with a graph-preserving splice (see
+   * {@link Store.spliceCompact}): live nodes keep their internal ids and their
+   * wiring; each dead neighbour is replaced by its own live neighbours.  Codes
+   * are untouched, so the index loses nothing beyond what deletion itself
+   * removes.  The previous implementation replayed every live code through a
+   * full HNSW insert — O(live · ef · log N) storage reads, HOURS on a trained
+   * multi-million-node store, inside one WAL-bloating transaction.  The splice
+   * is a streaming pass with batched commits, then a VACUUM to return the
+   * freed pages.
+   */
+  compact(): void;
 }