@hviana/sema 0.1.3 → 0.1.5

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

@@ -1,5 +1,10 @@
 export { VectorDatabase } from "./database.js";
-export type { DatabaseOptions, ExternalId, QueryResult, StorageStats, } from "./database.js";
+export type {
+  DatabaseOptions,
+  ExternalId,
+  QueryResult,
+  StorageStats,
+} from "./database.js";
 export { HnswIndex } from "./hnsw.js";
 export type { HnswParams, KnnHit } from "./hnsw.js";
 export { RaBitQuantizer } from "./rabitq.js";

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

@@ -6,14 +6,14 @@
  * regenerated after (de)serialization without storing large matrices.
  */
 export declare class Prng {
-    private state;
-    constructor(seed: number);
-    /** Uniform float in [0, 1). */
-    next(): number;
-    /** Uniform integer in [0, n). */
-    int(n: number): number;
-    /** Current internal state (one uint32), for persisting/resuming the stream. */
-    snapshot(): number;
-    /** Resume the stream from a previously snapshotted state. */
-    restore(state: number): void;
+  private state;
+  constructor(seed: number);
+  /** Uniform float in [0, 1). */
+  next(): number;
+  /** Uniform integer in [0, n). */
+  int(n: number): number;
+  /** Current internal state (one uint32), for persisting/resuming the stream. */
+  snapshot(): number;
+  /** Resume the stream from a previously snapshotted state. */
+  restore(state: number): void;
 }

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

@@ -6,31 +6,33 @@
  * regenerated after (de)serialization without storing large matrices.
  */
 export class Prng {
-    state;
-    constructor(seed) {
-        this.state = seed >>> 0;
-        if (this.state === 0)
-            this.state = 0x9e3779b9;
+  state;
+  constructor(seed) {
+    this.state = seed >>> 0;
+    if (this.state === 0) {
+      this.state = 0x9e3779b9;
     }
-    /** Uniform float in [0, 1). */
-    next() {
-        let t = (this.state = (this.state + 0x6d2b79f5) | 0);
-        t = Math.imul(t ^ (t >>> 15), t | 1);
-        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
-        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
-    }
-    /** Uniform integer in [0, n). */
-    int(n) {
-        return (this.next() * n) | 0;
-    }
-    /** Current internal state (one uint32), for persisting/resuming the stream. */
-    snapshot() {
-        return this.state >>> 0;
-    }
-    /** Resume the stream from a previously snapshotted state. */
-    restore(state) {
-        this.state = state >>> 0;
-        if (this.state === 0)
-            this.state = 0x9e3779b9;
+  }
+  /** Uniform float in [0, 1). */
+  next() {
+    let t = (this.state = (this.state + 0x6d2b79f5) | 0);
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  }
+  /** Uniform integer in [0, n). */
+  int(n) {
+    return (this.next() * n) | 0;
+  }
+  /** Current internal state (one uint32), for persisting/resuming the stream. */
+  snapshot() {
+    return this.state >>> 0;
+  }
+  /** Resume the stream from a previously snapshotted state. */
+  restore(state) {
+    this.state = state >>> 0;
+    if (this.state === 0) {
+      this.state = 0x9e3779b9;
     }
+  }
 }

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

@@ -1,24 +1,24 @@
 export interface QueryContext {
-    vmin: number;
-    delta: number;
-    sumQInt: number;
-    /**
-     * Per-query lookup table of length nbytes*256. `qlut[p*256 + b]` is the sum of
-     * the quantised query values at the (up to 8) coordinates whose code bits are
-     * set in byte value `b` at code-byte position `p`. The query/code inner product
-     * for a stored code is then sum over its bytes of qlut[p*256 + codeByte_p].
-     */
-    qlut: Uint8Array | Uint16Array;
-    /** number of bytes per code (paddedDim / 8). */
-    nbytes: number;
-    /** true when the (centered) query has zero norm. */
-    zero: boolean;
+  vmin: number;
+  delta: number;
+  sumQInt: number;
+  /**
+   * Per-query lookup table of length nbytes*256. `qlut[p*256 + b]` is the sum of
+   * the quantised query values at the (up to 8) coordinates whose code bits are
+   * set in byte value `b` at code-byte position `p`. The query/code inner product
+   * for a stored code is then sum over its bytes of qlut[p*256 + codeByte_p].
+   */
+  qlut: Uint8Array | Uint16Array;
+  /** number of bytes per code (paddedDim / 8). */
+  nbytes: number;
+  /** true when the (centered) query has zero norm. */
+  zero: boolean;
 }
 export interface RaBitQOptions {
-    queryBits?: number;
-    rounds?: number;
-    seed?: number;
-    centroid?: ArrayLike<number>;
+  queryBits?: number;
+  rounds?: number;
+  seed?: number;
+  centroid?: ArrayLike<number>;
 }
 /**
  * 1-bit RaBitQ quantizer (cosine) -- the ONLY representation of a vector kept by
@@ -41,55 +41,55 @@ export interface RaBitQOptions {
  * Theoretical Error Bound for Approximate Nearest Neighbor Search", SIGMOD 2024.
  */
 export declare class RaBitQuantizer {
-    readonly dim: number;
-    readonly paddedDim: number;
-    readonly codeWords: number;
-    readonly queryBits: number;
-    readonly rounds: number;
-    readonly seed: number;
-    readonly centroid: Float64Array;
-    private readonly sqrtD;
-    private readonly maxQInt;
-    private readonly signs;
-    private readonly scratch;
-    /** Fixed cosine inner-product scale (= 1 / E[L1] of a rotated unit vector). */
-    readonly cosFactor: number;
-    private readonly nbytes;
-    /** coordinate index sitting at byte position p, bit k -> bitCoord[p*8 + k]. */
-    private readonly bitCoord;
-    /** true when the largest possible LUT entry overflows a Uint8. */
-    private readonly lutWide;
-    constructor(dim: number, opts?: RaBitQOptions);
-    /** In-place fast Walsh-Hadamard transform; `a.length` must be a power of two. */
-    private fwht;
-    /** Apply the orthogonal rotation in place (a.length === paddedDim). */
-    private rotate;
-    /** Encode a raw vector into its 1-bit sign code (the whole representation). */
-    encode(vec: ArrayLike<number>): Uint32Array;
-    /** Pre-process a full-precision query into the structure consumed by `estimate`. */
-    prepareQuery(vec: ArrayLike<number>): QueryContext;
-    /**
-     * Estimate the cosine distance (1 - cosine) between a stored code and a
-     * full-precision query, reading the code's bytes against the query's byte LUT.
-     * The code's set-bit count is tallied in the same byte scan, so nothing beyond
-     * the code itself is needed.
-     *
-     * `codeBytes` is a Uint8 view of the packed code buffer and `byteOffset` is the
-     * code's start byte (id * paddedDim/8).
-     */
-    estimate(codeBytes: Uint8Array, byteOffset: number, q: QueryContext): number;
-    /**
-     * Cosine distance (1 - cosine, in [0, 2]) between two packed codes, computed
-     * directly from the BLOB bytes via their sign-bit Hamming distance — no word
-     * reinterpretation, so it is endianness-agnostic. Identical codes score 0.
-     *
-     * This is the distance used to build the graph (code vs code) and to answer a
-     * query given an already-quantized code. It is coarser than `estimate`, where
-     * one side is full precision.
-     */
-    codeDistanceBytes(a: Uint8Array, b: Uint8Array): number;
-    /** Pack a code (codeWords 32-bit words) into its little-endian BLOB bytes. */
-    codeToBytes(code: ArrayLike<number>): Uint8Array;
-    /** Reinterpret a code BLOB as a copy of codeWords 32-bit words. */
-    bytesToCode(bytes: Uint8Array): Uint32Array;
+  readonly dim: number;
+  readonly paddedDim: number;
+  readonly codeWords: number;
+  readonly queryBits: number;
+  readonly rounds: number;
+  readonly seed: number;
+  readonly centroid: Float64Array;
+  private readonly sqrtD;
+  private readonly maxQInt;
+  private readonly signs;
+  private readonly scratch;
+  /** Fixed cosine inner-product scale (= 1 / E[L1] of a rotated unit vector). */
+  readonly cosFactor: number;
+  private readonly nbytes;
+  /** coordinate index sitting at byte position p, bit k -> bitCoord[p*8 + k]. */
+  private readonly bitCoord;
+  /** true when the largest possible LUT entry overflows a Uint8. */
+  private readonly lutWide;
+  constructor(dim: number, opts?: RaBitQOptions);
+  /** In-place fast Walsh-Hadamard transform; `a.length` must be a power of two. */
+  private fwht;
+  /** Apply the orthogonal rotation in place (a.length === paddedDim). */
+  private rotate;
+  /** Encode a raw vector into its 1-bit sign code (the whole representation). */
+  encode(vec: ArrayLike<number>): Uint32Array;
+  /** Pre-process a full-precision query into the structure consumed by `estimate`. */
+  prepareQuery(vec: ArrayLike<number>): QueryContext;
+  /**
+   * Estimate the cosine distance (1 - cosine) between a stored code and a
+   * full-precision query, reading the code's bytes against the query's byte LUT.
+   * The code's set-bit count is tallied in the same byte scan, so nothing beyond
+   * the code itself is needed.
+   *
+   * `codeBytes` is a Uint8 view of the packed code buffer and `byteOffset` is the
+   * code's start byte (id * paddedDim/8).
+   */
+  estimate(codeBytes: Uint8Array, byteOffset: number, q: QueryContext): number;
+  /**
+   * Cosine distance (1 - cosine, in [0, 2]) between two packed codes, computed
+   * directly from the BLOB bytes via their sign-bit Hamming distance — no word
+   * reinterpretation, so it is endianness-agnostic. Identical codes score 0.
+   *
+   * This is the distance used to build the graph (code vs code) and to answer a
+   * query given an already-quantized code. It is coarser than `estimate`, where
+   * one side is full precision.
+   */
+  codeDistanceBytes(a: Uint8Array, b: Uint8Array): number;
+  /** Pack a code (codeWords 32-bit words) into its little-endian BLOB bytes. */
+  codeToBytes(code: ArrayLike<number>): Uint8Array;
+  /** Reinterpret a code BLOB as a copy of codeWords 32-bit words. */
+  bytesToCode(bytes: Uint8Array): Uint32Array;
 }