elid 0.3.0 → 0.3.1

package/elid.d.ts

@@ -1,35 +1,28 @@
 /* tslint:disable */
 /* eslint-disable */
 /**
- * Compute the OSA (Optimal String Alignment) distance between two strings.
+ * Compute the SimHash fingerprint of a string.
  *
- * Similar to Levenshtein but also considers transpositions as a single operation.
+ * 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 { osaDistance } from 'elid';
- *
- * const distance = osaDistance("ca", "ac");
- * console.log(distance); // 1 (transposition)
- * ```
- */
-export function osaDistance(a: string, b: string): number;
-/**
- * Compute the Levenshtein distance between two strings.
- *
- * Returns the minimum number of single-character edits needed to transform one string into another.
+ * import { simhash } from 'elid';
  *
- * # JavaScript Example
+ * const hash1 = simhash("iPhone 14");
+ * const hash2 = simhash("iPhone 15");
+ * const hash3 = simhash("Galaxy S23");
  *
- * ```javascript
- * import { levenshtein } from 'elid';
+ * // hash1 and hash2 will be numerically close
+ * // hash3 will be numerically distant
  *
- * const distance = levenshtein("kitten", "sitting");
- * console.log(distance); // 3
+ * // Store in database as bigint:
+ * // { name: "iPhone 14", simhash: hash1 }
  * ```
  */
-export function levenshtein(a: string, b: string): number;
+export function simhash(text: string): number;
 /**
  * Find all matches above a threshold score.
  *
@@ -47,130 +40,186 @@ export function levenshtein(a: string, b: string): number;
  */
 export function findMatchesAboveThreshold(query: string, candidates: string[], threshold: number): any;
 /**
- * Compute the Hamming distance between two SimHash values.
+ * Encode an embedding for cross-dimensional comparison.
  *
- * Returns the number of differing bits. Lower values = higher similarity.
+ * 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 { simhash, simhashDistance } from 'elid';
+ * import { encodeElidCrossDimensional, decodeElidToEmbedding } from 'elid';
  *
- * const hash1 = simhash("iPhone 14");
- * const hash2 = simhash("iPhone 15");
- * const distance = simhashDistance(hash1, hash2);
+ * // Different sized embeddings from different models
+ * const embedding256 = new Float64Array(256).fill(0.1);
+ * const embedding768 = new Float64Array(768).fill(0.1);
  *
- * console.log(distance); // Low number = similar
+ * // 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 simhashDistance(hash1: number, hash2: number): number;
+export function encodeElidCrossDimensional(embedding: Float64Array, common_dims: number): string;
 /**
- * Encode an embedding with a maximum output string length constraint.
+ * Find all hashes within a given distance threshold.
  *
- * Calculates the optimal precision and dimension settings to fit within
- * the specified character limit while maximizing fidelity.
+ * Useful for database queries - pre-compute hashes, then find similar ones.
+ *
+ * # JavaScript Example
+ *
+ * ```javascript
+ * import { simhash, findSimilarHashes } from 'elid';
+ *
+ * const candidates = ["iPhone 14 Pro", "iPhone 13", "Galaxy S23"];
+ * const hashes = candidates.map(s => simhash(s));
+ *
+ * const queryHash = simhash("iPhone 14");
+ * const matches = findSimilarHashes(queryHash, hashes, 10);
+ *
+ * console.log(matches); // [0, 1] - indices of similar items
+ * ```
+ */
+export function findSimilarHashes(query_hash: number, candidate_hashes: Float64Array, max_distance: number): Uint32Array;
+/**
+ * Compute the Jaro similarity between two strings.
+ *
+ * Returns a value between 0.0 (completely different) and 1.0 (identical).
+ * Particularly effective for short strings like names.
+ *
+ * # JavaScript Example
+ *
+ * ```javascript
+ * import { jaro } from 'elid';
+ *
+ * const similarity = jaro("martha", "marhta");
+ * console.log(similarity); // ~0.944
+ * ```
+ */
+export function jaro(a: string, b: string): number;
+/**
+ * Compute the best matching similarity between two strings.
+ *
+ * Runs multiple algorithms and returns the highest score.
+ *
+ * # JavaScript Example
+ *
+ * ```javascript
+ * import { bestMatch } from 'elid';
+ *
+ * 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.
+ *
+ * Converts a high-dimensional embedding (64-2048 dimensions) into a compact,
+ * sortable identifier. The ELID preserves locality properties for efficient
+ * similarity search.
  *
  * # Parameters
  *
  * - `embedding`: Float64 array of embedding values (64-2048 dimensions)
- * - `max_chars`: Maximum output string length in characters
+ * - `profile`: Encoding profile (Mini128, Morton10x10, or Hilbert10x10)
  *
  * # Returns
  *
- * A base32hex-encoded ELID string guaranteed to be <= max_chars in length.
+ * A base32hex-encoded ELID string suitable for storage and comparison.
  *
  * # 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
+ * import { encodeElid, ElidProfile } from 'elid';
  *
- * // Fit in 50 characters (more compression)
- * const shortElid = encodeElidMaxLength(embedding, 50);
+ * // OpenAI embeddings are 1536 dimensions
+ * const embedding = await getEmbedding("Hello world");
+ * const elid = encodeElid(embedding, ElidProfile.Mini128);
+ * console.log(elid); // "012345abcdef..."
  * ```
  */
-export function encodeElidMaxLength(embedding: Float64Array, max_chars: number): string;
+export function encodeElid(embedding: Float64Array, profile: ElidProfile): string;
 /**
- * Compute Levenshtein distance with custom options.
+ * Compute the normalized SimHash similarity between two strings.
+ *
+ * Returns a value between 0.0 (completely different) and 1.0 (identical).
  *
  * # JavaScript Example
  *
  * ```javascript
- * import { levenshteinWithOpts, SimilarityOptions } from 'elid';
+ * import { simhashSimilarity } from 'elid';
  *
- * const opts = new SimilarityOptions();
- * opts.setCaseSensitive(false);
- * opts.setTrimWhitespace(true);
+ * const similarity = simhashSimilarity("iPhone 14", "iPhone 15");
+ * console.log(similarity); // ~0.9 (very similar)
  *
- * const distance = levenshteinWithOpts("  HELLO  ", "hello", opts);
- * console.log(distance); // 0
+ * const similarity2 = simhashSimilarity("iPhone", "Galaxy");
+ * console.log(similarity2); // ~0.4 (different)
  * ```
  */
-export function levenshteinWithOpts(a: string, b: string, opts: SimilarityOptions): number;
+export function simhashSimilarity(a: string, b: string): number;
 /**
- * Check if an ELID can be decoded back to an embedding.
+ * Encode an embedding using lossless full vector encoding.
  *
- * Returns true if the ELID was encoded with a FullVector profile
- * (lossless, compressed, or max_length), false otherwise.
+ * Preserves the exact embedding values (32-bit float precision) and all dimensions.
+ * This produces the largest output but allows exact reconstruction.
  *
  * # Parameters
  *
- * - `elid_str`: A valid ELID string (base32hex encoded)
+ * - `embedding`: Float64 array of embedding values (64-2048 dimensions)
  *
  * # Returns
  *
- * `true` if decodeElidToEmbedding will return an embedding, `false` otherwise.
+ * A base32hex-encoded ELID string that can be decoded back to the original embedding.
  *
  * # JavaScript Example
  *
  * ```javascript
- * import { encodeElid, encodeElidLossless, isElidReversible, ElidProfile } from 'elid';
+ * import { encodeElidLossless, decodeElidToEmbedding } from 'elid';
  *
  * const embedding = new Float64Array(768).fill(0.1);
+ * const elid = encodeElidLossless(embedding);
  *
- * // 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
+ * // Later, recover the exact embedding
+ * const recovered = decodeElidToEmbedding(elid);
+ * // recovered is identical to embedding
  * ```
  */
-export function isElidReversible(elid_str: string): boolean;
+export function encodeElidLossless(embedding: Float64Array): string;
 /**
- * Compute the SimHash fingerprint of a string.
+ * Compute the normalized Levenshtein similarity between two strings.
  *
- * 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.
+ * Returns a value between 0.0 (completely different) and 1.0 (identical).
  *
  * # JavaScript Example
  *
  * ```javascript
- * import { simhash } from 'elid';
- *
- * const hash1 = simhash("iPhone 14");
- * const hash2 = simhash("iPhone 15");
- * const hash3 = simhash("Galaxy S23");
- *
- * // hash1 and hash2 will be numerically close
- * // hash3 will be numerically distant
+ * import { normalizedLevenshtein } from 'elid';
  *
- * // Store in database as bigint:
- * // { name: "iPhone 14", simhash: hash1 }
+ * const similarity = normalizedLevenshtein("hello", "hallo");
+ * console.log(similarity); // ~0.8
  * ```
  */
-export function simhash(text: string): number;
+export function normalizedLevenshtein(a: string, b: string): number;
 /**
- * Decode an ELID string to raw bytes.
+ * Decode an ELID string back to an embedding vector.
  *
- * Returns the raw byte representation of an ELID, including the header
- * and payload bytes. Useful for custom processing or debugging.
+ * 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
  *
@@ -178,18 +227,27 @@ export function simhash(text: string): number;
  *
  * # Returns
  *
- * A Uint8Array containing the raw bytes (header + payload).
+ * 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 { decodeElid } from 'elid';
+ * import { encodeElidLossless, decodeElidToEmbedding, isElidReversible } from 'elid';
  *
- * const bytes = decodeElid("012345abcdef...");
- * console.log(bytes); // Uint8Array [...]
+ * 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 decodeElid(elid_str: string): Uint8Array;
+export function decodeElidToEmbedding(elid_str: string): any;
 /**
  * Get metadata about a FullVector ELID.
  *
@@ -222,40 +280,92 @@ export function decodeElid(elid_str: string): Uint8Array;
  */
 export function getElidMetadata(elid_str: string): any;
 /**
- * Encode an embedding for cross-dimensional comparison.
+ * Decode an ELID string to raw bytes.
  *
- * Projects the embedding to a common dimension space, allowing comparison
- * between embeddings of different original dimensions (e.g., 256d vs 768d).
+ * 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
  *
- * - `embedding`: Float64 array of embedding values (64-2048 dimensions)
- * - `common_dims`: Target dimension space (all vectors projected here)
+ * - `elid_str`: A valid ELID string (base32hex encoded)
  *
  * # Returns
  *
- * A base32hex-encoded ELID string.
+ * `true` if decodeElidToEmbedding will return an embedding, `false` otherwise.
  *
  * # JavaScript Example
  *
  * ```javascript
- * import { encodeElidCrossDimensional, decodeElidToEmbedding } from 'elid';
+ * import { encodeElid, encodeElidLossless, isElidReversible, ElidProfile } from 'elid';
  *
- * // Different sized embeddings from different models
- * const embedding256 = new Float64Array(256).fill(0.1);
- * const embedding768 = new Float64Array(768).fill(0.1);
+ * const embedding = new Float64Array(768).fill(0.1);
  *
- * // Project both to 128-dim common space
- * const elid1 = encodeElidCrossDimensional(embedding256, 128);
- * const elid2 = encodeElidCrossDimensional(embedding768, 128);
+ * // Mini128 is NOT reversible
+ * const mini128Elid = encodeElid(embedding, ElidProfile.Mini128);
+ * console.log(isElidReversible(mini128Elid)); // false
  *
- * // Now they can be compared directly (both decode to 128 dims)
- * const dec1 = decodeElidToEmbedding(elid1);
- * const dec2 = decodeElidToEmbedding(elid2);
- * // Both have length 128
+ * // Lossless IS reversible
+ * const losslessElid = encodeElidLossless(embedding);
+ * console.log(isElidReversible(losslessElid)); // true
  * ```
  */
-export function encodeElidCrossDimensional(embedding: Float64Array, common_dims: number): string;
+export function isElidReversible(elid_str: string): boolean;
+/**
+ * Compute Levenshtein distance with custom options.
+ *
+ * # JavaScript Example
+ *
+ * ```javascript
+ * import { levenshteinWithOpts, SimilarityOptions } from 'elid';
+ *
+ * const opts = new SimilarityOptions();
+ * opts.setCaseSensitive(false);
+ * opts.setTrimWhitespace(true);
+ *
+ * const distance = levenshteinWithOpts("  HELLO  ", "hello", opts);
+ * console.log(distance); // 0
+ * ```
+ */
+export function levenshteinWithOpts(a: string, b: string, opts: SimilarityOptions): number;
 /**
  * Compute the Hamming distance between two ELID strings.
  *
@@ -308,164 +418,120 @@ export function elidHammingDistance(elid1: string, elid2: string): number;
  */
 export function findBestMatch(query: string, candidates: string[]): object;
 /**
- * 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
+ * Compute the OSA (Optimal String Alignment) distance between two strings.
  *
- * A base32hex-encoded ELID string.
+ * Similar to Levenshtein but also considers transpositions as a single operation.
  *
  * # 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);
+ * import { osaDistance } from 'elid';
  *
- * // 25% retention - smaller but less accurate
- * const smallElid = encodeElidCompressed(embedding, 0.25);
+ * const distance = osaDistance("ca", "ac");
+ * console.log(distance); // 1 (transposition)
  * ```
  */
-export function encodeElidCompressed(embedding: Float64Array, retention_pct: number): string;
+export function osaDistance(a: string, b: string): number;
 /**
- * Compute the Jaro similarity between two strings.
+ * Compute the Hamming distance between two SimHash values.
  *
- * Returns a value between 0.0 (completely different) and 1.0 (identical).
- * Particularly effective for short strings like names.
+ * Returns the number of differing bits. Lower values = higher similarity.
  *
  * # JavaScript Example
  *
  * ```javascript
- * import { jaro } from 'elid';
+ * import { simhash, simhashDistance } from 'elid';
  *
- * const similarity = jaro("martha", "marhta");
- * console.log(similarity); // ~0.944
+ * const hash1 = simhash("iPhone 14");
+ * const hash2 = simhash("iPhone 15");
+ * const distance = simhashDistance(hash1, hash2);
+ *
+ * console.log(distance); // Low number = similar
  * ```
  */
-export function jaro(a: string, b: string): number;
+export function simhashDistance(hash1: number, hash2: number): number;
 /**
- * Encode an embedding using lossless full vector encoding.
+ * Encode an embedding with percentage-based compression.
  *
- * Preserves the exact embedding values (32-bit float precision) and all dimensions.
- * This produces the largest output but allows exact reconstruction.
+ * 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 that can be decoded back to the original embedding.
+ * A base32hex-encoded ELID string.
  *
  * # JavaScript Example
  *
  * ```javascript
- * import { encodeElidLossless, decodeElidToEmbedding } from 'elid';
+ * import { encodeElidCompressed } from 'elid';
  *
  * 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
+ * // 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 encodeElidLossless(embedding: Float64Array): string;
+export function encodeElidCompressed(embedding: Float64Array, retention_pct: number): string;
 /**
- * Decode an ELID string back to an embedding vector.
+ * Encode an embedding with a maximum output string length constraint.
  *
- * 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.
+ * Calculates the optimal precision and dimension settings to fit within
+ * the specified character limit while maximizing fidelity.
  *
  * # Parameters
  *
- * - `elid_str`: A valid ELID string (base32hex encoded)
+ * - `embedding`: Float64 array of embedding values (64-2048 dimensions)
+ * - `max_chars`: Maximum output string length in characters
  *
  * # 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.
+ * A base32hex-encoded ELID string guaranteed to be <= max_chars in length.
  *
  * # JavaScript Example
  *
  * ```javascript
- * import { encodeElidLossless, decodeElidToEmbedding, isElidReversible } from 'elid';
+ * import { encodeElidMaxLength } 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;
-/**
- * Encode an embedding vector to an ELID string.
- *
- * Converts a high-dimensional embedding (64-2048 dimensions) into a compact,
- * sortable identifier. The ELID preserves locality properties for efficient
- * similarity search.
- *
- * # 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';
+ * // Fit in 100 characters (e.g., for database column constraints)
+ * const elid = encodeElidMaxLength(embedding, 100);
+ * console.log(elid.length <= 100); // true
  *
- * // OpenAI embeddings are 1536 dimensions
- * const embedding = await getEmbedding("Hello world");
- * const elid = encodeElid(embedding, ElidProfile.Mini128);
- * console.log(elid); // "012345abcdef..."
+ * // Fit in 50 characters (more compression)
+ * const shortElid = encodeElidMaxLength(embedding, 50);
  * ```
  */
-export function encodeElid(embedding: Float64Array, profile: ElidProfile): string;
+export function encodeElidMaxLength(embedding: Float64Array, max_chars: number): string;
 /**
- * Compute the normalized SimHash similarity between two strings.
+ * Compute the Jaro-Winkler similarity between two strings.
  *
  * Returns a value between 0.0 (completely different) and 1.0 (identical).
+ * Gives more favorable ratings to strings with common prefixes.
  *
  * # JavaScript Example
  *
  * ```javascript
- * import { simhashSimilarity } from 'elid';
- *
- * const similarity = simhashSimilarity("iPhone 14", "iPhone 15");
- * console.log(similarity); // ~0.9 (very similar)
+ * import { jaroWinkler } from 'elid';
  *
- * const similarity2 = simhashSimilarity("iPhone", "Galaxy");
- * console.log(similarity2); // ~0.4 (different)
+ * const similarity = jaroWinkler("martha", "marhta");
+ * console.log(similarity); // ~0.961
  * ```
  */
-export function simhashSimilarity(a: string, b: string): number;
+export function jaroWinkler(a: string, b: string): number;
 /**
  * Compute the Hamming distance between two strings.
  *
@@ -485,72 +551,6 @@ export function simhashSimilarity(a: string, b: string): number;
  * ```
  */
 export function hamming(a: string, b: string): number | undefined;
-/**
- * Compute the best matching similarity between two strings.
- *
- * Runs multiple algorithms and returns the highest score.
- *
- * # JavaScript Example
- *
- * ```javascript
- * import { bestMatch } from 'elid';
- *
- * const score = bestMatch("hello", "hallo");
- * console.log(score); // ~0.8
- * ```
- */
-export function bestMatch(a: string, b: string): number;
-/**
- * Compute the Jaro-Winkler similarity between two strings.
- *
- * Returns a value between 0.0 (completely different) and 1.0 (identical).
- * Gives more favorable ratings to strings with common prefixes.
- *
- * # JavaScript Example
- *
- * ```javascript
- * import { jaroWinkler } from 'elid';
- *
- * const similarity = jaroWinkler("martha", "marhta");
- * console.log(similarity); // ~0.961
- * ```
- */
-export function jaroWinkler(a: string, b: string): number;
-/**
- * Compute the normalized Levenshtein similarity between two strings.
- *
- * Returns a value between 0.0 (completely different) and 1.0 (identical).
- *
- * # JavaScript Example
- *
- * ```javascript
- * import { normalizedLevenshtein } from 'elid';
- *
- * const similarity = normalizedLevenshtein("hello", "hallo");
- * console.log(similarity); // ~0.8
- * ```
- */
-export function normalizedLevenshtein(a: string, b: string): number;
-/**
- * Find all hashes within a given distance threshold.
- *
- * Useful for database queries - pre-compute hashes, then find similar ones.
- *
- * # JavaScript Example
- *
- * ```javascript
- * import { simhash, findSimilarHashes } from 'elid';
- *
- * const candidates = ["iPhone 14 Pro", "iPhone 13", "Galaxy S23"];
- * const hashes = candidates.map(s => simhash(s));
- *
- * const queryHash = simhash("iPhone 14");
- * const matches = findSimilarHashes(queryHash, hashes, 10);
- *
- * console.log(matches); // [0, 1] - indices of similar items
- * ```
- */
-export function findSimilarHashes(query_hash: number, candidate_hashes: Float64Array, max_distance: number): Uint32Array;
 /**
  * Dimension handling mode for full vector encoding.
  *