elid 0.2.1 → 0.3.1

package/elid.d.ts

@@ -1,147 +1,204 @@
 /* tslint:disable */
 /* eslint-disable */
 /**
- * Compute the normalized SimHash similarity between two strings.
+ * Compute the SimHash fingerprint of a string.
  *
- * Returns a value between 0.0 (completely different) and 1.0 (identical).
+ * Returns a 64-bit hash where similar strings produce similar numbers.
+ * Use this for database queries by storing the hash and querying by numeric range.
  *
  * # JavaScript Example
  *
  * ```javascript
- * import { simhashSimilarity } from 'elid';
+ * import { simhash } from 'elid';
  *
- * const similarity = simhashSimilarity("iPhone 14", "iPhone 15");
- * console.log(similarity); // ~0.9 (very similar)
+ * const hash1 = simhash("iPhone 14");
+ * const hash2 = simhash("iPhone 15");
+ * const hash3 = simhash("Galaxy S23");
  *
- * const similarity2 = simhashSimilarity("iPhone", "Galaxy");
- * console.log(similarity2); // ~0.4 (different)
+ * // hash1 and hash2 will be numerically close
+ * // hash3 will be numerically distant
+ *
+ * // Store in database as bigint:
+ * // { name: "iPhone 14", simhash: hash1 }
  * ```
  */
-export function simhashSimilarity(a: string, b: string): number;
+export function simhash(text: string): number;
 /**
- * Compute the Jaro-Winkler similarity between two strings.
+ * Find all matches above a threshold score.
  *
- * Returns a value between 0.0 (completely different) and 1.0 (identical).
- * Gives more favorable ratings to strings with common prefixes.
+ * Returns an array of objects with index and score for all candidates above the threshold.
  *
  * # JavaScript Example
  *
  * ```javascript
- * import { jaroWinkler } from 'elid';
+ * import { findMatchesAboveThreshold } from 'elid';
  *
- * const similarity = jaroWinkler("martha", "marhta");
- * console.log(similarity); // ~0.961
+ * const candidates = ["apple", "application", "apply", "banana"];
+ * const matches = findMatchesAboveThreshold("app", candidates, 0.5);
+ * console.log(matches); // [{ index: 0, score: 0.907 }, { index: 1, score: 0.830 }, ...]
  * ```
  */
-export function jaroWinkler(a: string, b: string): number;
+export function findMatchesAboveThreshold(query: string, candidates: string[], threshold: number): any;
 /**
- * Compute the Hamming distance between two strings.
+ * Encode an embedding for cross-dimensional comparison.
  *
- * Returns the number of positions at which the characters differ.
- * Returns null if strings have different lengths.
+ * Projects the embedding to a common dimension space, allowing comparison
+ * between embeddings of different original dimensions (e.g., 256d vs 768d).
+ *
+ * # Parameters
+ *
+ * - `embedding`: Float64 array of embedding values (64-2048 dimensions)
+ * - `common_dims`: Target dimension space (all vectors projected here)
+ *
+ * # Returns
+ *
+ * A base32hex-encoded ELID string.
  *
  * # JavaScript Example
  *
  * ```javascript
- * import { hamming } from 'elid';
+ * import { encodeElidCrossDimensional, decodeElidToEmbedding } from 'elid';
  *
- * const distance = hamming("karolin", "kathrin");
- * console.log(distance); // 3
+ * // Different sized embeddings from different models
+ * const embedding256 = new Float64Array(256).fill(0.1);
+ * const embedding768 = new Float64Array(768).fill(0.1);
  *
- * const invalid = hamming("hello", "world!");
- * console.log(invalid); // null
+ * // Project both to 128-dim common space
+ * const elid1 = encodeElidCrossDimensional(embedding256, 128);
+ * const elid2 = encodeElidCrossDimensional(embedding768, 128);
+ *
+ * // Now they can be compared directly (both decode to 128 dims)
+ * const dec1 = decodeElidToEmbedding(elid1);
+ * const dec2 = decodeElidToEmbedding(elid2);
+ * // Both have length 128
  * ```
  */
-export function hamming(a: string, b: string): number | undefined;
+export function encodeElidCrossDimensional(embedding: Float64Array, common_dims: number): string;
 /**
- * Compute the SimHash fingerprint of a string.
+ * Find all hashes within a given distance threshold.
  *
- * Returns a 64-bit hash where similar strings produce similar numbers.
- * Use this for database queries by storing the hash and querying by numeric range.
+ * Useful for database queries - pre-compute hashes, then find similar ones.
  *
  * # JavaScript Example
  *
  * ```javascript
- * import { simhash } from 'elid';
+ * import { simhash, findSimilarHashes } from 'elid';
  *
- * const hash1 = simhash("iPhone 14");
- * const hash2 = simhash("iPhone 15");
- * const hash3 = simhash("Galaxy S23");
+ * const candidates = ["iPhone 14 Pro", "iPhone 13", "Galaxy S23"];
+ * const hashes = candidates.map(s => simhash(s));
  *
- * // hash1 and hash2 will be numerically close
- * // hash3 will be numerically distant
+ * const queryHash = simhash("iPhone 14");
+ * const matches = findSimilarHashes(queryHash, hashes, 10);
  *
- * // Store in database as bigint:
- * // { name: "iPhone 14", simhash: hash1 }
+ * console.log(matches); // [0, 1] - indices of similar items
  * ```
  */
-export function simhash(text: string): number;
+export function findSimilarHashes(query_hash: number, candidate_hashes: Float64Array, max_distance: number): Uint32Array;
 /**
- * Compute the Levenshtein distance between two strings.
+ * Compute the Jaro similarity between two strings.
  *
- * Returns the minimum number of single-character edits needed to transform one string into another.
+ * Returns a value between 0.0 (completely different) and 1.0 (identical).
+ * Particularly effective for short strings like names.
  *
  * # JavaScript Example
  *
  * ```javascript
- * import { levenshtein } from 'elid';
+ * import { jaro } from 'elid';
  *
- * const distance = levenshtein("kitten", "sitting");
- * console.log(distance); // 3
+ * const similarity = jaro("martha", "marhta");
+ * console.log(similarity); // ~0.944
  * ```
  */
-export function levenshtein(a: string, b: string): number;
+export function jaro(a: string, b: string): number;
 /**
- * Find all hashes within a given distance threshold.
+ * Compute the best matching similarity between two strings.
  *
- * Useful for database queries - pre-compute hashes, then find similar ones.
+ * Runs multiple algorithms and returns the highest score.
  *
  * # JavaScript Example
  *
  * ```javascript
- * import { simhash, findSimilarHashes } from 'elid';
+ * import { bestMatch } from 'elid';
  *
- * const candidates = ["iPhone 14 Pro", "iPhone 13", "Galaxy S23"];
- * const hashes = candidates.map(s => simhash(s));
+ * const score = bestMatch("hello", "hallo");
+ * console.log(score); // ~0.8
+ * ```
+ */
+export function bestMatch(a: string, b: string): number;
+/**
+ * Encode an embedding vector to an ELID string.
  *
- * const queryHash = simhash("iPhone 14");
- * const matches = findSimilarHashes(queryHash, hashes, 10);
+ * Converts a high-dimensional embedding (64-2048 dimensions) into a compact,
+ * sortable identifier. The ELID preserves locality properties for efficient
+ * similarity search.
  *
- * console.log(matches); // [0, 1] - indices of similar items
+ * # Parameters
+ *
+ * - `embedding`: Float64 array of embedding values (64-2048 dimensions)
+ * - `profile`: Encoding profile (Mini128, Morton10x10, or Hilbert10x10)
+ *
+ * # Returns
+ *
+ * A base32hex-encoded ELID string suitable for storage and comparison.
+ *
+ * # JavaScript Example
+ *
+ * ```javascript
+ * import { encodeElid, ElidProfile } from 'elid';
+ *
+ * // OpenAI embeddings are 1536 dimensions
+ * const embedding = await getEmbedding("Hello world");
+ * const elid = encodeElid(embedding, ElidProfile.Mini128);
+ * console.log(elid); // "012345abcdef..."
  * ```
  */
-export function findSimilarHashes(query_hash: number, candidate_hashes: Float64Array, max_distance: number): Uint32Array;
+export function encodeElid(embedding: Float64Array, profile: ElidProfile): string;
 /**
- * Find all matches above a threshold score.
+ * Compute the normalized SimHash similarity between two strings.
  *
- * Returns an array of objects with index and score for all candidates above the threshold.
+ * Returns a value between 0.0 (completely different) and 1.0 (identical).
  *
  * # JavaScript Example
  *
  * ```javascript
- * import { findMatchesAboveThreshold } from 'elid';
+ * import { simhashSimilarity } from 'elid';
  *
- * const candidates = ["apple", "application", "apply", "banana"];
- * const matches = findMatchesAboveThreshold("app", candidates, 0.5);
- * console.log(matches); // [{ index: 0, score: 0.907 }, { index: 1, score: 0.830 }, ...]
+ * const similarity = simhashSimilarity("iPhone 14", "iPhone 15");
+ * console.log(similarity); // ~0.9 (very similar)
+ *
+ * const similarity2 = simhashSimilarity("iPhone", "Galaxy");
+ * console.log(similarity2); // ~0.4 (different)
  * ```
  */
-export function findMatchesAboveThreshold(query: string, candidates: string[], threshold: number): any;
+export function simhashSimilarity(a: string, b: string): number;
 /**
- * Compute the OSA (Optimal String Alignment) distance between two strings.
+ * Encode an embedding using lossless full vector encoding.
  *
- * Similar to Levenshtein but also considers transpositions as a single operation.
+ * Preserves the exact embedding values (32-bit float precision) and all dimensions.
+ * This produces the largest output but allows exact reconstruction.
+ *
+ * # Parameters
+ *
+ * - `embedding`: Float64 array of embedding values (64-2048 dimensions)
+ *
+ * # Returns
+ *
+ * A base32hex-encoded ELID string that can be decoded back to the original embedding.
  *
  * # JavaScript Example
  *
  * ```javascript
- * import { osaDistance } from 'elid';
+ * import { encodeElidLossless, decodeElidToEmbedding } from 'elid';
  *
- * const distance = osaDistance("ca", "ac");
- * console.log(distance); // 1 (transposition)
+ * const embedding = new Float64Array(768).fill(0.1);
+ * const elid = encodeElidLossless(embedding);
+ *
+ * // Later, recover the exact embedding
+ * const recovered = decodeElidToEmbedding(elid);
+ * // recovered is identical to embedding
  * ```
  */
-export function osaDistance(a: string, b: string): number;
+export function encodeElidLossless(embedding: Float64Array): string;
 /**
  * Compute the normalized Levenshtein similarity between two strings.
  *
@@ -157,6 +214,141 @@ export function osaDistance(a: string, b: string): number;
  * ```
  */
 export function normalizedLevenshtein(a: string, b: string): number;
+/**
+ * Decode an ELID string back to an embedding vector.
+ *
+ * Only works for ELIDs encoded with a FullVector profile (lossless,
+ * compressed, or max_length). Returns null for non-reversible profiles
+ * like Mini128, Morton, or Hilbert.
+ *
+ * # Parameters
+ *
+ * - `elid_str`: A valid ELID string (base32hex encoded)
+ *
+ * # Returns
+ *
+ * A Float64Array containing the decoded embedding, or null if the ELID
+ * is not reversible.
+ *
+ * Note: If dimension reduction was used during encoding, the decoded
+ * embedding will be in the reduced dimension space, not the original.
+ *
+ * # JavaScript Example
+ *
+ * ```javascript
+ * import { encodeElidLossless, decodeElidToEmbedding, isElidReversible } from 'elid';
+ *
+ * const embedding = new Float64Array(768).fill(0.1);
+ * const elid = encodeElidLossless(embedding);
+ *
+ * if (isElidReversible(elid)) {
+ *     const recovered = decodeElidToEmbedding(elid);
+ *     console.log(recovered.length); // 768
+ * }
+ * ```
+ */
+export function decodeElidToEmbedding(elid_str: string): any;
+/**
+ * Get metadata about a FullVector ELID.
+ *
+ * Returns an object containing information about how the ELID was encoded,
+ * including original dimensions, precision, and dimension mode.
+ *
+ * # Parameters
+ *
+ * - `elid_str`: A valid ELID string (base32hex encoded)
+ *
+ * # Returns
+ *
+ * An object with metadata fields, or null if not a FullVector ELID.
+ *
+ * # JavaScript Example
+ *
+ * ```javascript
+ * import { encodeElidCompressed, getElidMetadata } from 'elid';
+ *
+ * const embedding = new Float64Array(768).fill(0.1);
+ * const elid = encodeElidCompressed(embedding, 0.5);
+ *
+ * const meta = getElidMetadata(elid);
+ * if (meta) {
+ *     console.log(meta.originalDims);  // 768
+ *     console.log(meta.encodedDims);   // depends on compression
+ *     console.log(meta.isLossless);    // false
+ * }
+ * ```
+ */
+export function getElidMetadata(elid_str: string): any;
+/**
+ * Decode an ELID string to raw bytes.
+ *
+ * Returns the raw byte representation of an ELID, including the header
+ * and payload bytes. Useful for custom processing or debugging.
+ *
+ * # Parameters
+ *
+ * - `elid_str`: A valid ELID string (base32hex encoded)
+ *
+ * # Returns
+ *
+ * A Uint8Array containing the raw bytes (header + payload).
+ *
+ * # JavaScript Example
+ *
+ * ```javascript
+ * import { decodeElid } from 'elid';
+ *
+ * const bytes = decodeElid("012345abcdef...");
+ * console.log(bytes); // Uint8Array [...]
+ * ```
+ */
+export function decodeElid(elid_str: string): Uint8Array;
+/**
+ * Compute the Levenshtein distance between two strings.
+ *
+ * Returns the minimum number of single-character edits needed to transform one string into another.
+ *
+ * # JavaScript Example
+ *
+ * ```javascript
+ * import { levenshtein } from 'elid';
+ *
+ * const distance = levenshtein("kitten", "sitting");
+ * console.log(distance); // 3
+ * ```
+ */
+export function levenshtein(a: string, b: string): number;
+/**
+ * Check if an ELID can be decoded back to an embedding.
+ *
+ * Returns true if the ELID was encoded with a FullVector profile
+ * (lossless, compressed, or max_length), false otherwise.
+ *
+ * # Parameters
+ *
+ * - `elid_str`: A valid ELID string (base32hex encoded)
+ *
+ * # Returns
+ *
+ * `true` if decodeElidToEmbedding will return an embedding, `false` otherwise.
+ *
+ * # JavaScript Example
+ *
+ * ```javascript
+ * import { encodeElid, encodeElidLossless, isElidReversible, ElidProfile } from 'elid';
+ *
+ * const embedding = new Float64Array(768).fill(0.1);
+ *
+ * // Mini128 is NOT reversible
+ * const mini128Elid = encodeElid(embedding, ElidProfile.Mini128);
+ * console.log(isElidReversible(mini128Elid)); // false
+ *
+ * // Lossless IS reversible
+ * const losslessElid = encodeElidLossless(embedding);
+ * console.log(isElidReversible(losslessElid)); // true
+ * ```
+ */
+export function isElidReversible(elid_str: string): boolean;
 /**
  * Compute Levenshtein distance with custom options.
  *
@@ -175,20 +367,71 @@ export function normalizedLevenshtein(a: string, b: string): number;
  */
 export function levenshteinWithOpts(a: string, b: string, opts: SimilarityOptions): number;
 /**
- * Compute the best matching similarity between two strings.
+ * Compute the Hamming distance between two ELID strings.
  *
- * Runs multiple algorithms and returns the highest score.
+ * Returns the number of differing bits between two Mini128 ELIDs.
+ * This distance is proportional to the angular distance between the
+ * original embeddings (lower = more similar).
+ *
+ * # Requirements
+ *
+ * Both ELIDs must use the Mini128 profile.
+ *
+ * # Parameters
+ *
+ * - `elid1`: First ELID string
+ * - `elid2`: Second ELID string
+ *
+ * # Returns
+ *
+ * Hamming distance (0-128). 0 means identical, 128 means completely different.
  *
  * # JavaScript Example
  *
  * ```javascript
- * import { bestMatch } from 'elid';
+ * import { encodeElid, elidHammingDistance, ElidProfile } from 'elid';
  *
- * const score = bestMatch("hello", "hallo");
- * console.log(score); // ~0.8
+ * const elid1 = encodeElid(embedding1, ElidProfile.Mini128);
+ * const elid2 = encodeElid(embedding2, ElidProfile.Mini128);
+ *
+ * const distance = elidHammingDistance(elid1, elid2);
+ * if (distance < 20) {
+ *     console.log("Very similar embeddings!");
+ * }
  * ```
  */
-export function bestMatch(a: string, b: string): number;
+export function elidHammingDistance(elid1: string, elid2: string): number;
+/**
+ * Find the best match for a query string in an array of candidates.
+ *
+ * Returns an object with the index and similarity score of the best match.
+ *
+ * # JavaScript Example
+ *
+ * ```javascript
+ * import { findBestMatch } from 'elid';
+ *
+ * const candidates = ["apple", "application", "apply"];
+ * const result = findBestMatch("app", candidates);
+ * console.log(result); // { index: 0, score: 0.907 }
+ * ```
+ */
+export function findBestMatch(query: string, candidates: string[]): object;
+/**
+ * Compute the OSA (Optimal String Alignment) distance between two strings.
+ *
+ * Similar to Levenshtein but also considers transpositions as a single operation.
+ *
+ * # JavaScript Example
+ *
+ * ```javascript
+ * import { osaDistance } from 'elid';
+ *
+ * const distance = osaDistance("ca", "ac");
+ * console.log(distance); // 1 (transposition)
+ * ```
+ */
+export function osaDistance(a: string, b: string): number;
 /**
  * Compute the Hamming distance between two SimHash values.
  *
@@ -208,37 +451,196 @@ export function bestMatch(a: string, b: string): number;
  */
 export function simhashDistance(hash1: number, hash2: number): number;
 /**
- * Compute the Jaro similarity between two strings.
+ * Encode an embedding with percentage-based compression.
+ *
+ * The retention percentage (0.0-1.0) controls how much information is preserved:
+ * - 1.0 = lossless (Full32 precision, all dimensions)
+ * - 0.5 = half precision and/or half dimensions
+ * - 0.25 = quarter precision and/or quarter dimensions
+ *
+ * The algorithm optimizes for dimension reduction first (which preserves
+ * more geometric relationships) before reducing precision.
+ *
+ * # Parameters
+ *
+ * - `embedding`: Float64 array of embedding values (64-2048 dimensions)
+ * - `retention_pct`: Information retention percentage (0.0-1.0)
+ *
+ * # Returns
+ *
+ * A base32hex-encoded ELID string.
+ *
+ * # JavaScript Example
+ *
+ * ```javascript
+ * import { encodeElidCompressed } from 'elid';
+ *
+ * const embedding = new Float64Array(768).fill(0.1);
+ *
+ * // 50% retention - good balance of size and fidelity
+ * const elid = encodeElidCompressed(embedding, 0.5);
+ *
+ * // 25% retention - smaller but less accurate
+ * const smallElid = encodeElidCompressed(embedding, 0.25);
+ * ```
+ */
+export function encodeElidCompressed(embedding: Float64Array, retention_pct: number): string;
+/**
+ * Encode an embedding with a maximum output string length constraint.
+ *
+ * Calculates the optimal precision and dimension settings to fit within
+ * the specified character limit while maximizing fidelity.
+ *
+ * # Parameters
+ *
+ * - `embedding`: Float64 array of embedding values (64-2048 dimensions)
+ * - `max_chars`: Maximum output string length in characters
+ *
+ * # Returns
+ *
+ * A base32hex-encoded ELID string guaranteed to be <= max_chars in length.
+ *
+ * # JavaScript Example
+ *
+ * ```javascript
+ * import { encodeElidMaxLength } from 'elid';
+ *
+ * const embedding = new Float64Array(768).fill(0.1);
+ *
+ * // Fit in 100 characters (e.g., for database column constraints)
+ * const elid = encodeElidMaxLength(embedding, 100);
+ * console.log(elid.length <= 100); // true
+ *
+ * // Fit in 50 characters (more compression)
+ * const shortElid = encodeElidMaxLength(embedding, 50);
+ * ```
+ */
+export function encodeElidMaxLength(embedding: Float64Array, max_chars: number): string;
+/**
+ * Compute the Jaro-Winkler similarity between two strings.
  *
  * Returns a value between 0.0 (completely different) and 1.0 (identical).
- * Particularly effective for short strings like names.
+ * Gives more favorable ratings to strings with common prefixes.
  *
  * # JavaScript Example
  *
  * ```javascript
- * import { jaro } from 'elid';
+ * import { jaroWinkler } from 'elid';
  *
- * const similarity = jaro("martha", "marhta");
- * console.log(similarity); // ~0.944
+ * const similarity = jaroWinkler("martha", "marhta");
+ * console.log(similarity); // ~0.961
  * ```
  */
-export function jaro(a: string, b: string): number;
+export function jaroWinkler(a: string, b: string): number;
 /**
- * Find the best match for a query string in an array of candidates.
+ * Compute the Hamming distance between two strings.
  *
- * Returns an object with the index and similarity score of the best match.
+ * Returns the number of positions at which the characters differ.
+ * Returns null if strings have different lengths.
  *
  * # JavaScript Example
  *
  * ```javascript
- * import { findBestMatch } from 'elid';
+ * import { hamming } from 'elid';
  *
- * const candidates = ["apple", "application", "apply"];
- * const result = findBestMatch("app", candidates);
- * console.log(result); // { index: 0, score: 0.907 }
+ * const distance = hamming("karolin", "kathrin");
+ * console.log(distance); // 3
+ *
+ * const invalid = hamming("hello", "world!");
+ * console.log(invalid); // null
  * ```
  */
-export function findBestMatch(query: string, candidates: string[]): object;
+export function hamming(a: string, b: string): number | undefined;
+/**
+ * Dimension handling mode for full vector encoding.
+ *
+ * Controls whether to preserve original dimensions, reduce them,
+ * or project to a common space for cross-dimensional comparison.
+ *
+ * # JavaScript Example
+ *
+ * ```javascript
+ * import { ElidDimensionMode, encodeElidFullVector } from 'elid';
+ *
+ * // Preserve all dimensions
+ * // Reduce to fewer dimensions for smaller output
+ * // Common space for comparing different-sized embeddings
+ * ```
+ */
+export enum ElidDimensionMode {
+  /**
+   * Preserve all original dimensions (no projection)
+   */
+  Preserve = 0,
+  /**
+   * Reduce dimensions using random projection
+   */
+  Reduce = 1,
+  /**
+   * Project to common space for cross-dimensional comparison
+   */
+  Common = 2,
+}
+/**
+ * ELID encoding profile for vector embeddings.
+ *
+ * Choose a profile based on your use case:
+ * - `Mini128`: Fast 128-bit SimHash, good for similarity via Hamming distance
+ * - `Morton10x10`: Z-order curve encoding, good for range queries
+ * - `Hilbert10x10`: Hilbert curve encoding, best locality preservation
+ *
+ * # JavaScript Example
+ *
+ * ```javascript
+ * import { ElidProfile, encodeElid } from 'elid';
+ *
+ * const embedding = new Float64Array(768).fill(0.1);
+ * const elid = encodeElid(embedding, ElidProfile.Mini128);
+ * ```
+ */
+export enum ElidProfile {
+  /**
+   * 128-bit SimHash (cosine similarity via Hamming distance)
+   */
+  Mini128 = 0,
+  /**
+   * Morton/Z-order curve encoding (10 dims, 10 bits each)
+   */
+  Morton10x10 = 1,
+  /**
+   * Hilbert curve encoding (10 dims, 10 bits each)
+   */
+  Hilbert10x10 = 2,
+}
+/**
+ * Precision options for full vector encoding.
+ *
+ * Controls how many bits are used to represent each dimension value.
+ * Higher precision means more accurate reconstruction but larger output.
+ *
+ * # JavaScript Example
+ *
+ * ```javascript
+ * import { ElidVectorPrecision, encodeElidWithPrecision } from 'elid';
+ *
+ * const embedding = new Float64Array(768).fill(0.1);
+ * // Full32 = lossless, Half16 = smaller with minimal error
+ * ```
+ */
+export enum ElidVectorPrecision {
+  /**
+   * Full 32-bit float (lossless, 4 bytes per dimension)
+   */
+  Full32 = 0,
+  /**
+   * 16-bit half-precision float (2 bytes per dimension)
+   */
+  Half16 = 1,
+  /**
+   * 8-bit quantized (1 byte per dimension, ~1% error)
+   */
+  Quant8 = 2,
+}
 /**
  * Options for configuring string similarity algorithms
  */