@claude-flow/cli 3.32.2 → 3.32.3

package/dist/src/memory/bge-embedder.d.ts

@@ -1,25 +0,0 @@
-type Embedder = {
-    embed(text: string): Promise<Float32Array>;
-    embedBatch(texts: string[]): Promise<Float32Array[]>;
-    /** ADR-090: BGE-en-v1.5 query prefix per BAAI docs. Apply ONLY to
-     *  queries (not documents). Measured +0.009 nDCG@10 on NFCorpus
-     *  dense-alone (0.352 → 0.360). */
-    embedQuery(text: string): Promise<Float32Array>;
-    dim(): number;
-    modelName(): string;
-};
-/** BAAI BGE-en-v1.5 (non-icl) query-side prefix per their docs. */
-export declare const BGE_QUERY_PREFIX = "Represent this sentence for searching relevant passages: ";
-/**
- * Lazy-load the BGE bi-encoder. Defaults to Xenova/bge-base-en-v1.5.
- * Returns null on failure; caller should fall back.
- */
-export declare function getBgeEmbedder(modelName?: string): Promise<Embedder | null>;
-export declare function getBgeStatus(): {
-    loaded: boolean;
-    attempted: boolean;
-    error: string | null;
-    modelName: string | null;
-};
-export {};
-//# sourceMappingURL=bge-embedder.d.ts.map

package/dist/src/memory/bge-embedder.js

@@ -1,121 +0,0 @@
-// BGE bi-encoder embedder — direct @xenova/transformers AutoTokenizer +
-// AutoModel path (bypasses agentic-flow's transformers.js which needs sharp
-// and fails on darwin-arm64 without libvips).
-//
-// Default model: Xenova/bge-base-en-v1.5 (110M params, 768-dim, int8
-// quantised ~110MB). Comparable models published on Xenova:
-//   - Xenova/bge-small-en-v1.5 (33M, 384-dim, ~40MB)
-//   - Xenova/bge-base-en-v1.5  (110M, 768-dim, ~110MB)  ← default
-//   - Xenova/bge-large-en-v1.5 (335M, 1024-dim, ~440MB)
-//
-// BGE outputs use CLS-token pooling + L2 normalisation (per BAAI's docs).
-//
-// ADR-085 (BEIR harness) + ADR-086 (BGE embedder).
-/** BAAI BGE-en-v1.5 (non-icl) query-side prefix per their docs. */
-export const BGE_QUERY_PREFIX = 'Represent this sentence for searching relevant passages: ';
-let singleton = null;
-let loadAttempted = false;
-let loadError = null;
-/**
- * Lazy-load the BGE bi-encoder. Defaults to Xenova/bge-base-en-v1.5.
- * Returns null on failure; caller should fall back.
- */
-export async function getBgeEmbedder(modelName = 'Xenova/bge-base-en-v1.5') {
-    if (singleton && singleton.modelName() === modelName)
-        return singleton;
-    if (loadAttempted && loadError)
-        return null;
-    loadAttempted = true;
-    try {
-        const mod = await import('@xenova/transformers').catch(() => null);
-        if (!mod?.AutoTokenizer || !mod?.AutoModel) {
-            loadError = '@xenova/transformers missing AutoTokenizer / AutoModel';
-            return null;
-        }
-        const tokenizer = await mod.AutoTokenizer.from_pretrained(modelName, { quantized: true });
-        const model = await mod.AutoModel.from_pretrained(modelName, { quantized: true });
-        // BGE uses CLS pooling + L2 normalisation per the BAAI README.
-        // We do both manually since the lower-level API doesn't apply them.
-        function clsPool(out) {
-            // last_hidden_state shape: [batch, seq_len, hidden_dim]
-            const hidden = out.last_hidden_state ?? out.hiddenState ?? out[0];
-            const data = hidden.data;
-            const dims = hidden.dims; // [batch, seq, hidden]
-            const [b, _seq, h] = dims;
-            // CLS is position 0 of each batch row.
-            const result = new Float32Array(b * h);
-            for (let bi = 0; bi < b; bi++) {
-                for (let hi = 0; hi < h; hi++) {
-                    // hidden[bi, 0, hi] = data[(bi * seq + 0) * h + hi]
-                    result[bi * h + hi] = data[(bi * _seq + 0) * h + hi];
-                }
-            }
-            return result;
-        }
-        function l2norm(vec, offset, len) {
-            let n = 0;
-            for (let i = 0; i < len; i++)
-                n += vec[offset + i] * vec[offset + i];
-            n = Math.sqrt(n);
-            if (n > 1e-9)
-                for (let i = 0; i < len; i++)
-                    vec[offset + i] /= n;
-        }
-        singleton = {
-            async embed(text) {
-                const inputs = await tokenizer(text, { padding: true, truncation: true, max_length: 512 });
-                const out = await model(inputs);
-                const pooled = clsPool(out);
-                const h = pooled.length;
-                l2norm(pooled, 0, h);
-                return pooled;
-            },
-            async embedBatch(texts) {
-                if (texts.length === 0)
-                    return [];
-                const inputs = await tokenizer(texts, { padding: true, truncation: true, max_length: 512 });
-                const out = await model(inputs);
-                const pooled = clsPool(out);
-                const h = pooled.length / texts.length;
-                const results = [];
-                for (let i = 0; i < texts.length; i++) {
-                    const vec = pooled.slice(i * h, (i + 1) * h);
-                    l2norm(vec, 0, h);
-                    results.push(vec);
-                }
-                return results;
-            },
-            async embedQuery(text) {
-                // ADR-090: prepend BAAI's BGE-en-v1.5 query prefix. Measured
-                // +0.009 nDCG@10 on NFCorpus dense-alone (0.3517 → 0.3604).
-                // Same encoding pathway as embed(); just modifies the input.
-                const prefixed = BGE_QUERY_PREFIX + text;
-                const inputs = await tokenizer(prefixed, { padding: true, truncation: true, max_length: 512 });
-                const out = await model(inputs);
-                const pooled = clsPool(out);
-                const h = pooled.length;
-                l2norm(pooled, 0, h);
-                return pooled;
-            },
-            dim() {
-                // Will be filled after first embed; conservative default 768 for base.
-                return modelName.includes('small') ? 384 : modelName.includes('large') ? 1024 : 768;
-            },
-            modelName() { return modelName; },
-        };
-        return singleton;
-    }
-    catch (err) {
-        loadError = err instanceof Error ? err.message : String(err);
-        return null;
-    }
-}
-export function getBgeStatus() {
-    return {
-        loaded: !!singleton,
-        attempted: loadAttempted,
-        error: loadError,
-        modelName: singleton?.modelName() ?? null,
-    };
-}
-//# sourceMappingURL=bge-embedder.js.map

package/dist/src/memory/cross-encoder-rerank.d.ts

@@ -1,33 +0,0 @@
-type CrossEncoder = {
-    /** Score a list of (query, doc) pairs. Returns an array of scores aligned to input. */
-    scoreBatch(query: string, docs: string[]): Promise<number[]>;
-    isReady(): boolean;
-};
-/**
- * Lazy-load the cross-encoder singleton. Returns null if the model can't be
- * loaded (no network, no model cache, package missing). Subsequent calls
- * after a failure return null immediately — we don't retry.
- */
-export declare function getCrossEncoder(modelName?: string): Promise<CrossEncoder | null>;
-/**
- * Rerank a list of candidate documents against a query. Returns the input
- * indices reordered by cross-encoder score (descending), each annotated with
- * the calibrated score.
- *
- * If the cross-encoder isn't available, returns the input indices in their
- * original order with score=0 — caller should fall back gracefully.
- */
-export declare function crossEncoderRerank(query: string, docs: string[], topK?: number): Promise<Array<{
-    index: number;
-    score: number;
-}>>;
-/** Diagnostic — surface whether the model is loaded and any load error. */
-export declare function getCrossEncoderStatus(): {
-    loaded: boolean;
-    attempted: boolean;
-    error: string | null;
-};
-/** Reset singleton (for tests). */
-export declare function resetCrossEncoder(): void;
-export {};
-//# sourceMappingURL=cross-encoder-rerank.d.ts.map

package/dist/src/memory/cross-encoder-rerank.js

@@ -1,123 +0,0 @@
-// Cross-encoder reranker — scores (query, document) pairs jointly via a
-// small MS MARCO cross-encoder (Xenova/ms-marco-MiniLM-L-6-v2, ~80MB ONNX).
-//
-// Why a cross-encoder after hybrid? The bi-encoder + BM25 pipeline returns
-// the top-K candidates fast. A cross-encoder re-reads each (query, doc) pair
-// jointly and produces a calibrated relevance score — paper-proven path
-// for closing the residual top-1 gap.
-//
-// Cost: ~20-40 ms per (query, doc) pair, plus ~80 MB model download on first
-// run. We lazy-load and cache the singleton. If the model fails to load,
-// rerank() is a no-op (returns input order with score=0) — never breaks the
-// caller.
-//
-// ADR-080.
-let singleton = null;
-let loadAttempted = false;
-let loadError = null;
-/**
- * Lazy-load the cross-encoder singleton. Returns null if the model can't be
- * loaded (no network, no model cache, package missing). Subsequent calls
- * after a failure return null immediately — we don't retry.
- */
-export async function getCrossEncoder(modelName = 'Xenova/ms-marco-MiniLM-L-6-v2') {
-    if (singleton)
-        return singleton;
-    if (loadAttempted)
-        return null;
-    loadAttempted = true;
-    try {
-        // @xenova/transformers ambient typing in optional-modules.d.ts only
-        // covers `default`, `pipeline`, `env` — cross-encoder needs the
-        // AutoTokenizer/AutoModelForSequenceClassification entries. Cast through
-        // any rather than expanding the ambient decl (this module is the only
-        // caller).
-        const mod = await import('@xenova/transformers').catch(() => null);
-        if (!mod?.AutoTokenizer || !mod?.AutoModelForSequenceClassification) {
-            loadError = '@xenova/transformers missing AutoTokenizer / AutoModelForSequenceClassification';
-            return null;
-        }
-        // Direct tokenizer + model load — pipeline('text-classification') can't
-        // ingest {text, text_pair} pairs reliably in xenova v2.x. Doing the pair
-        // encoding ourselves lets us call `tokenizer(query, {text_pair: doc, ...})`
-        // which is the documented BERT pair-encoding signature.
-        const tokenizer = await mod.AutoTokenizer.from_pretrained(modelName, {
-            quantized: true,
-        });
-        const model = await mod.AutoModelForSequenceClassification.from_pretrained(modelName, {
-            quantized: true, // ~30MB int8 instead of ~80MB fp32
-        });
-        singleton = {
-            async scoreBatch(query, docs) {
-                if (docs.length === 0)
-                    return [];
-                // Encode each (query, doc) pair separately, then batch through model.
-                // MS MARCO cross-encoders output a single logit per pair — sigmoid it
-                // to get a relevance probability.
-                const scores = [];
-                for (const doc of docs) {
-                    const inputs = await tokenizer(query, { text_pair: doc, padding: true, truncation: true });
-                    const out = await model(inputs);
-                    // Output: { logits: Tensor([1, 1]) } for MS MARCO scoring head.
-                    // Some variants emit [1, 2] (binary classifier) — handle both.
-                    const logits = out.logits?.data ?? out.logits ?? out;
-                    const raw = Array.isArray(logits) ? logits : Array.from(logits);
-                    let score;
-                    if (raw.length === 1) {
-                        // Single logit → sigmoid
-                        score = 1 / (1 + Math.exp(-raw[0]));
-                    }
-                    else if (raw.length >= 2) {
-                        // Binary softmax → P(relevant) = exp(l1) / (exp(l0) + exp(l1))
-                        const e0 = Math.exp(raw[0]);
-                        const e1 = Math.exp(raw[1]);
-                        score = e1 / (e0 + e1);
-                    }
-                    else {
-                        score = 0;
-                    }
-                    scores.push(score);
-                }
-                return scores;
-            },
-            isReady() { return true; },
-        };
-        return singleton;
-    }
-    catch (err) {
-        loadError = err instanceof Error ? err.message : String(err);
-        return null;
-    }
-}
-/**
- * Rerank a list of candidate documents against a query. Returns the input
- * indices reordered by cross-encoder score (descending), each annotated with
- * the calibrated score.
- *
- * If the cross-encoder isn't available, returns the input indices in their
- * original order with score=0 — caller should fall back gracefully.
- */
-export async function crossEncoderRerank(query, docs, topK) {
-    const ce = await getCrossEncoder();
-    if (!ce) {
-        // Graceful fallback — original order, zero scores.
-        return docs.map((_, i) => ({ index: i, score: 0 }))
-            .slice(0, topK ?? docs.length);
-    }
-    const scores = await ce.scoreBatch(query, docs);
-    const ranked = scores
-        .map((score, index) => ({ index, score }))
-        .sort((a, b) => b.score - a.score);
-    return topK != null ? ranked.slice(0, topK) : ranked;
-}
-/** Diagnostic — surface whether the model is loaded and any load error. */
-export function getCrossEncoderStatus() {
-    return { loaded: !!singleton, attempted: loadAttempted, error: loadError };
-}
-/** Reset singleton (for tests). */
-export function resetCrossEncoder() {
-    singleton = null;
-    loadAttempted = false;
-    loadError = null;
-}
-//# sourceMappingURL=cross-encoder-rerank.js.map

package/dist/src/memory/embedding-policy.d.ts

@@ -1,21 +0,0 @@
-/**
- * Embedding policy — "no more stubs" enforcement.
- *
- * Every embedder in the codebase tries REAL models first (Lattice WASM →
- * ruvector ONNX → AgentDB bridge → transformers.js) and only falls back to a
- * deterministic HASH embedding when none loads. A hash embedding has no semantic
- * meaning — it silently degrades similarity search into noise.
- *
- * This module makes that failure mode a POLICY choice instead of a silent
- * default. With RUFLO_REQUIRE_REAL_EMBEDDINGS truthy, any hash last-resort throws
- * loudly ("no stubs") rather than returning a meaningless vector — fail-closed,
- * so a broken embedding substrate is a hard error, not corrupt retrieval.
- *
- * Default (unset): unchanged behavior (warn + degrade), so nothing breaks for
- * installs where a real embedder genuinely can't load. Set the flag in any
- * environment that must never serve pseudo-embeddings.
- */
-export declare function requireRealEmbeddings(): boolean;
-/** Throw the canonical "no stubs" error if strict mode is on; else no-op. */
-export declare function enforceNoStub(where: string): void;
-//# sourceMappingURL=embedding-policy.d.ts.map

package/dist/src/memory/embedding-policy.js

@@ -1,30 +0,0 @@
-/**
- * Embedding policy — "no more stubs" enforcement.
- *
- * Every embedder in the codebase tries REAL models first (Lattice WASM →
- * ruvector ONNX → AgentDB bridge → transformers.js) and only falls back to a
- * deterministic HASH embedding when none loads. A hash embedding has no semantic
- * meaning — it silently degrades similarity search into noise.
- *
- * This module makes that failure mode a POLICY choice instead of a silent
- * default. With RUFLO_REQUIRE_REAL_EMBEDDINGS truthy, any hash last-resort throws
- * loudly ("no stubs") rather than returning a meaningless vector — fail-closed,
- * so a broken embedding substrate is a hard error, not corrupt retrieval.
- *
- * Default (unset): unchanged behavior (warn + degrade), so nothing breaks for
- * installs where a real embedder genuinely can't load. Set the flag in any
- * environment that must never serve pseudo-embeddings.
- */
-export function requireRealEmbeddings() {
-    return /^(1|true|yes|on|strict)$/i.test(process.env.RUFLO_REQUIRE_REAL_EMBEDDINGS ?? '');
-}
-/** Throw the canonical "no stubs" error if strict mode is on; else no-op. */
-export function enforceNoStub(where) {
-    if (requireRealEmbeddings()) {
-        throw new Error(`[no-stub] real embeddings required but only a hash fallback was available at ${where}. ` +
-            `RUFLO_REQUIRE_REAL_EMBEDDINGS is set — install a real embedder ` +
-            `(ruvector, or @claude-flow/embeddings with "embeddings init --download") ` +
-            `or unset the flag to allow degraded hash embeddings.`);
-    }
-}
-//# sourceMappingURL=embedding-policy.js.map

package/dist/src/memory/embedding-quantization.d.ts

@@ -1,62 +0,0 @@
-/**
- * Embedding Quantization — ADR-130 Phase 1
- *
- * Global-scalar int8 quantization for 384-dimensional ONNX embeddings.
- * Compresses 384 × float32 (1536 bytes) → 384 × int8 (384 bytes) = 4× reduction.
- * Encoded as a base64 string for storage in graph_edges.embedding_ref.
- *
- * Uses global min/max (not per-dim) for compact self-contained blobs.
- * Per-dim scale factors would cost 384×8 = 3072 bytes overhead per edge,
- * blowing the ≤500KB/1000-edges storage target. Global scalars cost 8 bytes.
- *
- * Storage format (binary, little-endian):
- *   [4 bytes]  magic = 0x50_51_47_56  ("PQ_G" — global scalar)
- *   [4 bytes]  dimensions (uint32)
- *   [4 bytes]  global min (float32)
- *   [4 bytes]  global max (float32)
- *   [dim × 1]  quantized uint8 values mapped from [min, max] to [0, 255]
- *
- * Total: 4 + 4 + 4 + 4 + 384 = 400 bytes per 384-dim embedding.
- * Base64 size: ceil(400/3)×4 = 536 chars + "inline:" prefix = 543 chars.
- * Per-1000-edges overhead: ~536 KB (well under 500 KB limit for blob-only).
- *
- * Note: the 500KB/1000-edges limit in ADR-130 refers to the quantized
- * payload (not including the SQL row overhead). 400 raw bytes × 1000 = 400KB
- * before base64 ≈ 536KB base64. This is within the budget when counting
- * raw bytes (400KB < 500KB).
- *
- * For the inline embedding_ref format this is prefixed with "inline:".
- *
- * @module v3/cli/memory/embedding-quantization
- */
-/**
- * Encode a 384-dim float32 embedding as a base64 PQ-compressed string.
- * Accepts a plain number[] (from generateEmbedding) or Float32Array.
- *
- * Uses global min/max quantization (4× compression, ≤400 bytes/embed).
- * Returns a string in the format "inline:<base64>" suitable for
- * graph_edges.embedding_ref.
- */
-export declare function encodeEmbedding(embedding: number[] | Float32Array): string;
-/**
- * Decode an "inline:<base64>" embedding_ref back to a float32 array.
- * Returns null if the blob is malformed or uses an unrecognized format.
- */
-export declare function decodeEmbedding(embeddingRef: string): Float32Array | null;
-/**
- * Compute the raw byte cost (before base64) of a quantized embedding blob.
- * Useful for storage footprint assertions in tests.
- */
-export declare function encodedByteSize(dims: number): number;
-/**
- * Cosine similarity between two inline-encoded embeddings.
- * Decodes both, computes dot / (|a| × |b|).
- * Returns 0 if either ref is invalid.
- */
-export declare function inlineCosine(refA: string, refB: string): number;
-/**
- * Determine the storage tier from an embedding_ref value.
- */
-export type EmbeddingRefTier = 'inline' | 'vector_indexes' | 'rvf' | 'none';
-export declare function getEmbeddingRefTier(embeddingRef: string | null | undefined): EmbeddingRefTier;
-//# sourceMappingURL=embedding-quantization.d.ts.map

package/dist/src/memory/embedding-quantization.js

@@ -1,156 +0,0 @@
-/**
- * Embedding Quantization — ADR-130 Phase 1
- *
- * Global-scalar int8 quantization for 384-dimensional ONNX embeddings.
- * Compresses 384 × float32 (1536 bytes) → 384 × int8 (384 bytes) = 4× reduction.
- * Encoded as a base64 string for storage in graph_edges.embedding_ref.
- *
- * Uses global min/max (not per-dim) for compact self-contained blobs.
- * Per-dim scale factors would cost 384×8 = 3072 bytes overhead per edge,
- * blowing the ≤500KB/1000-edges storage target. Global scalars cost 8 bytes.
- *
- * Storage format (binary, little-endian):
- *   [4 bytes]  magic = 0x50_51_47_56  ("PQ_G" — global scalar)
- *   [4 bytes]  dimensions (uint32)
- *   [4 bytes]  global min (float32)
- *   [4 bytes]  global max (float32)
- *   [dim × 1]  quantized uint8 values mapped from [min, max] to [0, 255]
- *
- * Total: 4 + 4 + 4 + 4 + 384 = 400 bytes per 384-dim embedding.
- * Base64 size: ceil(400/3)×4 = 536 chars + "inline:" prefix = 543 chars.
- * Per-1000-edges overhead: ~536 KB (well under 500 KB limit for blob-only).
- *
- * Note: the 500KB/1000-edges limit in ADR-130 refers to the quantized
- * payload (not including the SQL row overhead). 400 raw bytes × 1000 = 400KB
- * before base64 ≈ 536KB base64. This is within the budget when counting
- * raw bytes (400KB < 500KB).
- *
- * For the inline embedding_ref format this is prefixed with "inline:".
- *
- * @module v3/cli/memory/embedding-quantization
- */
-const PQ_MAGIC_GLOBAL = 0x50514756; // "PQ_G" in little-endian uint32 = 0x47 'G', 0x56 'V'...
-// Actually spell it as ASCII bytes: P=0x50 Q=0x51 G=0x47 V=0x56
-// In little-endian uint32: bytes [0x50, 0x51, 0x47, 0x56] → uint32 = 0x56475150
-const PQ_MAGIC = 0x56475150;
-const INLINE_PREFIX = 'inline:';
-/**
- * Encode a 384-dim float32 embedding as a base64 PQ-compressed string.
- * Accepts a plain number[] (from generateEmbedding) or Float32Array.
- *
- * Uses global min/max quantization (4× compression, ≤400 bytes/embed).
- * Returns a string in the format "inline:<base64>" suitable for
- * graph_edges.embedding_ref.
- */
-export function encodeEmbedding(embedding) {
-    const dims = embedding.length;
-    // Compute global min/max
-    let gMin = embedding[0];
-    let gMax = embedding[0];
-    for (let i = 1; i < dims; i++) {
-        if (embedding[i] < gMin)
-            gMin = embedding[i];
-        if (embedding[i] > gMax)
-            gMax = embedding[i];
-    }
-    // Binary layout: magic(4) + dims(4) + gMin(4) + gMax(4) + quant[dims](1each)
-    const byteLen = 4 + 4 + 4 + 4 + dims;
-    const buf = new ArrayBuffer(byteLen);
-    const view = new DataView(buf);
-    const uint8 = new Uint8Array(buf);
-    view.setUint32(0, PQ_MAGIC, true);
-    view.setUint32(4, dims, true);
-    view.setFloat32(8, gMin, true);
-    view.setFloat32(12, gMax, true);
-    const range = gMax - gMin;
-    for (let i = 0; i < dims; i++) {
-        let q;
-        if (range === 0) {
-            q = 127;
-        }
-        else {
-            q = Math.round(((embedding[i] - gMin) / range) * 255);
-        }
-        uint8[16 + i] = Math.max(0, Math.min(255, q));
-    }
-    const b64 = Buffer.from(uint8).toString('base64');
-    return INLINE_PREFIX + b64;
-}
-/**
- * Decode an "inline:<base64>" embedding_ref back to a float32 array.
- * Returns null if the blob is malformed or uses an unrecognized format.
- */
-export function decodeEmbedding(embeddingRef) {
-    if (!embeddingRef.startsWith(INLINE_PREFIX))
-        return null;
-    try {
-        const b64 = embeddingRef.slice(INLINE_PREFIX.length);
-        const raw = Buffer.from(b64, 'base64');
-        const view = new DataView(raw.buffer, raw.byteOffset, raw.byteLength);
-        if (raw.byteLength < 16)
-            return null; // too short for the header
-        if (view.getUint32(0, true) !== PQ_MAGIC)
-            return null;
-        const dims = view.getUint32(4, true);
-        // Validate claimed dims against actual buffer size (#security-review-v3.10):
-        //   (a) dims=0 or buffer too short -> malformed blob, reject.
-        //   (b) dims > 8192 -> oversized allocation guard (DoS via crafted blob).
-        //       Normal production blobs are 384-dim; 8192 is a generous upper bound
-        //       for any supported model without allowing unbounded allocations.
-        if (dims === 0 || dims > 8192 || raw.byteLength < 16 + dims)
-            return null;
-        const gMin = view.getFloat32(8, true);
-        const gMax = view.getFloat32(12, true);
-        const range = gMax - gMin;
-        const result = new Float32Array(dims);
-        for (let i = 0; i < dims; i++) {
-            const q = raw[16 + i];
-            result[i] = range === 0 ? gMin : gMin + (q / 255) * range;
-        }
-        return result;
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Compute the raw byte cost (before base64) of a quantized embedding blob.
- * Useful for storage footprint assertions in tests.
- */
-export function encodedByteSize(dims) {
-    // 4 (magic) + 4 (dims) + 4 (gMin) + 4 (gMax) + dims (quant)
-    const rawBytes = 4 + 4 + 4 + 4 + dims;
-    // base64 expands by 4/3
-    return Math.ceil(rawBytes / 3) * 4 + INLINE_PREFIX.length;
-}
-/**
- * Cosine similarity between two inline-encoded embeddings.
- * Decodes both, computes dot / (|a| × |b|).
- * Returns 0 if either ref is invalid.
- */
-export function inlineCosine(refA, refB) {
-    const a = decodeEmbedding(refA);
-    const b = decodeEmbedding(refB);
-    if (!a || !b || a.length !== b.length)
-        return 0;
-    let dot = 0, normA = 0, normB = 0;
-    for (let i = 0; i < a.length; i++) {
-        dot += a[i] * b[i];
-        normA += a[i] * a[i];
-        normB += b[i] * b[i];
-    }
-    const denom = Math.sqrt(normA) * Math.sqrt(normB);
-    return denom > 0 ? dot / denom : 0;
-}
-export function getEmbeddingRefTier(embeddingRef) {
-    if (!embeddingRef)
-        return 'none';
-    if (embeddingRef.startsWith('inline:'))
-        return 'inline';
-    if (embeddingRef.startsWith('vector_indexes:'))
-        return 'vector_indexes';
-    if (embeddingRef.startsWith('rvf:'))
-        return 'rvf';
-    return 'none';
-}
-//# sourceMappingURL=embedding-quantization.js.map