@adhd/sox-embedding-provider 0.1.0

package/dist/embedWorker.js

@@ -0,0 +1,326 @@
+/**
+ * Shared worker thread for @huggingface/transformers-based ONNX inference —
+ * cross-encoder rerank and NLI verify.
+ *
+ * Runs in isolation from the main thread (BL-11 boundary) — onnxruntime-node's
+ * thread pool never shares a thread context with better-sqlite3 + sqlite-vec.
+ *
+ * Supports two operation types:
+ *   1. Cross-encoder rerank — 'init' (type: 'rerank'), 'rerank', 'rerankBatch'
+ *   2. NLI verification     — 'init' (type: 'verify'), 'verify'
+ *
+ * Protocol:
+ *   request:  { id, type: 'init',          type: 'rerank', modelId: string }
+ *   request:  { id, type: 'init',          type: 'verify', modelId: string, modelVersion: string }
+ *   request:  { id, type: 'rerank',        query: string, candidates: Array<{id, text}> }
+ *   request:  { id, type: 'rerankBatch',   queries: string[], candidateSets: ... }
+ *   request:  { id, type: 'verify',        jobId: string, claimText: string, sourceText: string }
+ *   response: { id, initOk: true, dim }
+ *   response: { id, scores: number[] }
+ *   response: { id, allScores: number[][] }
+ *   response: { id, result: { entailment, confidence, ... } }
+ *   response: { id, error: string }
+ *   internal: { __shutdown: true }
+ *
+ * ── BL-238/BL-171 ── This worker is the ONE place cross-encoder rerank and
+ * NLI verify (both `@huggingface/transformers`, onnxruntime-node@1.24.3) run,
+ * loaded into exactly ONE process-wide `worker_threads.Worker` (constructed
+ * exclusively by `sharedOnnxWorker.ts`'s `getSharedOnnxWorker()` singleton —
+ * never directly by `@adhd/sox-hybrid-search`'s cross-encoder or
+ * `@adhd/sox-claim-verification`'s worker proxy).
+ *
+ * Root cause #1 (cross-isolate, whole-process fatal — the reason there must
+ * be only ONE onnxruntime-bearing `worker_threads.Worker`, proven via a
+ * from-scratch minimal repro, no test harness, no mocks): onnxruntime-node's
+ * native N-API addon fatally crashes the ENTIRE process — not just the
+ * offending worker — with
+ *
+ *   FATAL ERROR: HandleScope::HandleScope Entering the V8 API without
+ *   proper locking in place
+ *     ... Napi::FunctionReference::New(...)
+ *     ... OrtValueToNapiValue(Napi::Env, Ort::Value&&)
+ *     ... InferenceSessionWrap::Run(...)
+ *
+ * whenever 2+ *separate* `worker_threads.Worker` instances (i.e. 2+ separate
+ * V8 isolates) each hold an active onnxruntime-node `InferenceSession` and
+ * run inference concurrently — reproduced even with TWO workers using the
+ * exact SAME onnxruntime-node version, so this is a genuine thread-safety
+ * limitation of the addon itself, not an ABI/version-mismatch issue (see root
+ * `BACKLOG.md` BL-238 for the full repro matrix).
+ *
+ * fastembed (onnxruntime-node@1.21.0) is DELIBERATELY NOT hosted in this
+ * worker, for a SECOND, independent reason (root cause #2): even a single
+ * shared worker hosting BOTH onnxruntime-node@1.21.0 (fastembed) AND
+ * onnxruntime-node@1.24.3 (transformers) — loaded strictly sequentially, with
+ * every JS `await` fully resolved before the next `init` begins (proven via
+ * instrumented tracing showing zero JS-level overlap between the two
+ * `init`s) — still deterministically threw `std::bad_alloc` the moment
+ * fastembed initialised second. That means the two onnxruntime-node major
+ * versions leave lingering native state (e.g. background native thread-pool
+ * teardown) not synchronized by the JS Promise resolving — a hazard below
+ * what JS-level scheduling/serialization can observe or prevent. Only a real
+ * OS process boundary is proven safe for fastembed; see
+ * `fastembedProcessHost.ts` / `sharedFastembedProcess.ts` for where fastembed
+ * actually runs (its own dedicated child PROCESS, never a
+ * `worker_threads.Worker`, never sharing an address space with this worker).
+ *
+ * Fix: every rerank/verify consumer routes through
+ * `getSharedOnnxWorker().request(...)` instead of constructing its own
+ * `Worker`; every fastembed consumer routes through
+ * `getSharedFastembedProcess().request(...)` instead of constructing its own
+ * `Worker`/process. There is never a second onnxruntime-bearing WORKER THREAD
+ * alive in the process, and fastembed never shares a thread (or process) with
+ * this worker at all — both crash classes above are structurally impossible,
+ * not merely statistically less likely.
+ */
+import { parentPort } from 'node:worker_threads';
+// ── Rerank (cross-encoder) — real ONNX inference ──────────────────────────────
+//
+// Cross-encoder scoring uses a sequence-classification ONNX model run through
+// @huggingface/transformers (which drives onnxruntime-node under the hood on
+// Node — the same "load ONNX in a worker thread" pattern as fastembed above,
+// BL-11). `modelId` is a logical name resolved to a concrete HuggingFace ONNX
+// repo; unknown ids pass through unchanged so any Xenova-converted
+// cross-encoder repo can be wired directly.
+//
+// Primary: MS-MARCO MiniLM cross-encoder (relevance regression — single
+// logit per query/candidate pair, squashed to [0,1] via sigmoid so "higher
+// score = more relevant" per the CrossEncoder contract).
+const RERANK_MODEL_MAP = {
+    MiniCheck: 'Xenova/ms-marco-MiniLM-L-6-v2',
+    'ms-marco-MiniLM-L-6-v2': 'Xenova/ms-marco-MiniLM-L-6-v2',
+    'cross-encoder/ms-marco-MiniLM-L-6-v2': 'Xenova/ms-marco-MiniLM-L-6-v2',
+};
+let _rerankResolvedModelId = '';
+let _rerankTokenizer = null;
+let _rerankModel = null;
+let _rerankLoadPromise = null;
+async function setRerankModel(modelId) {
+    const resolved = RERANK_MODEL_MAP[modelId] ?? modelId;
+    if (_rerankModel && _rerankResolvedModelId === resolved)
+        return;
+    if (_rerankLoadPromise && _rerankResolvedModelId === resolved)
+        return _rerankLoadPromise;
+    _rerankResolvedModelId = resolved;
+    _rerankLoadPromise = (async () => {
+        const { AutoTokenizer, AutoModelForSequenceClassification } = await import('@huggingface/transformers');
+        _rerankTokenizer = await AutoTokenizer.from_pretrained(resolved);
+        _rerankModel = (await AutoModelForSequenceClassification.from_pretrained(resolved, {
+            dtype: 'q8',
+        }));
+    })();
+    try {
+        await _rerankLoadPromise;
+    }
+    finally {
+        _rerankLoadPromise = null;
+    }
+}
+async function computeRerankScores(query, candidates) {
+    if (!_rerankTokenizer || !_rerankModel) {
+        throw new Error('Rerank model not initialized — send init{initType:"rerank"} first');
+    }
+    if (candidates.length === 0)
+        return [];
+    const queries = new Array(candidates.length).fill(query);
+    const texts = candidates.map((c) => c.text);
+    const features = _rerankTokenizer(queries, {
+        text_pair: texts,
+        padding: true,
+        truncation: true,
+    });
+    const output = (await _rerankModel(features));
+    const rows = output.logits.tolist();
+    return rows.map((row) => sigmoid(row[0] ?? 0));
+}
+function sigmoid(x) {
+    return 1 / (1 + Math.exp(-x));
+}
+// ── Verify (NLI) — real ONNX inference ─────────────────────────────────────────
+//
+// NLI verification uses a 3-way entailment/contradiction/neutral cross-encoder
+// (SPEC accuracy-optimized family: cross-encoder/nli-deberta-v3-*). The
+// premise is the source passage, the hypothesis is the claim. Softmax over
+// the model's own `id2label` (never hardcoded ordering) yields entailment +
+// confidence; `entailment`/`contradiction`/`neutral` are mapped onto the
+// frozen wire vocabulary `'entails'|'contradicts'|'neutral'`.
+const VERIFY_MODEL_MAP = {
+    MiniCheck: 'Xenova/nli-deberta-v3-xsmall',
+    'nli-deberta-v3-xsmall': 'Xenova/nli-deberta-v3-xsmall',
+    'cross-encoder/nli-deberta-v3-xsmall': 'Xenova/nli-deberta-v3-xsmall',
+};
+const NLI_LABEL_MAP = {
+    entailment: 'entails',
+    contradiction: 'contradicts',
+    neutral: 'neutral',
+};
+let _verifyResolvedModelId = '';
+let _verifyTokenizer = null;
+let _verifyModel = null;
+let _verifyId2Label = {};
+let _verifyLoadPromise = null;
+async function setVerifyModel(modelId, _modelVersion) {
+    const resolved = VERIFY_MODEL_MAP[modelId] ?? modelId;
+    if (_verifyModel && _verifyResolvedModelId === resolved)
+        return;
+    if (_verifyLoadPromise && _verifyResolvedModelId === resolved)
+        return _verifyLoadPromise;
+    _verifyResolvedModelId = resolved;
+    _verifyLoadPromise = (async () => {
+        const { AutoTokenizer, AutoModelForSequenceClassification } = await import('@huggingface/transformers');
+        _verifyTokenizer = await AutoTokenizer.from_pretrained(resolved);
+        const model = await AutoModelForSequenceClassification.from_pretrained(resolved, {
+            dtype: 'q8',
+        });
+        _verifyModel = model;
+        const config = model
+            .config;
+        _verifyId2Label = { ...(config?.id2label ?? {}) };
+    })();
+    try {
+        await _verifyLoadPromise;
+    }
+    finally {
+        _verifyLoadPromise = null;
+    }
+}
+async function computeVerification(claimText, sourceText) {
+    const start = Date.now();
+    if (!_verifyTokenizer || !_verifyModel) {
+        throw new Error('Verify model not initialized — send init{initType:"verify"} first');
+    }
+    // Premise = source (what we're checking against), hypothesis = claim.
+    const features = _verifyTokenizer([sourceText], {
+        text_pair: [claimText],
+        padding: true,
+        truncation: true,
+    });
+    const output = (await _verifyModel(features));
+    const row = output.logits.tolist()[0] ?? [];
+    const probs = softmax(row);
+    let bestIdx = 0;
+    for (let i = 1; i < probs.length; i++) {
+        const candidate = probs[i];
+        const current = probs[bestIdx];
+        if (candidate !== undefined && (current === undefined || candidate > current))
+            bestIdx = i;
+    }
+    const rawLabel = _verifyId2Label[bestIdx] ?? 'neutral';
+    const entailment = NLI_LABEL_MAP[rawLabel] ?? 'neutral';
+    const confidence = probs[bestIdx] ?? 0;
+    return { entailment, confidence, timingMs: Date.now() - start };
+}
+function softmax(logits) {
+    if (logits.length === 0)
+        return [];
+    const max = Math.max(...logits);
+    const exps = logits.map((v) => Math.exp(v - max));
+    const sum = exps.reduce((a, b) => a + b, 0);
+    return exps.map((v) => v / sum);
+}
+// ── Main message handler ──────────────────────────────────────────────────────
+//
+// Requests are processed by a single, strictly serialized async queue
+// (`_queue`) rather than fired-and-forgotten independently. Rerank and verify
+// share the same onnxruntime-node@1.24.3 addon (proven safe to run
+// concurrently — see BACKLOG.md BL-238 repro (a)/(d): 2x transformers.js
+// workers, and rerank+verify together, both coexist cleanly), so this is
+// defense-in-depth rather than a required fix for THIS worker specifically;
+// it costs nothing (both workloads are CPU-bound single-model calls) and
+// keeps this worker's request handling consistent with
+// `fastembedProcessHost.ts`'s own serialized queue.
+if (!parentPort) {
+    throw new Error('embedWorker must be run as a worker_thread, not directly');
+}
+let _queue = Promise.resolve();
+/** Enqueue a request handler so it runs strictly after every previously queued one. */
+function enqueue(task) {
+    _queue = _queue.then(task, task);
+}
+async function handleMessage(msg) {
+    // ── Init variants ────────────────────────────────────────────────────────────
+    if (msg.type === 'init' && msg.initType === 'rerank') {
+        try {
+            await setRerankModel(msg.modelId);
+            parentPort.postMessage({ id: msg.id, initOk: true, dim: 0 });
+        }
+        catch (e) {
+            parentPort.postMessage({
+                id: msg.id,
+                error: String(e instanceof Error ? e.message : e),
+            });
+        }
+        return;
+    }
+    if (msg.type === 'init' && msg.initType === 'verify') {
+        try {
+            await setVerifyModel(msg.modelId, msg.modelVersion);
+            parentPort.postMessage({ id: msg.id, initOk: true, dim: 0 });
+        }
+        catch (e) {
+            parentPort.postMessage({
+                id: msg.id,
+                error: String(e instanceof Error ? e.message : e),
+            });
+        }
+        return;
+    }
+    // ── Rerank (cross-encoder) ──────────────────────────────────────────────────
+    if (msg.type === 'rerank') {
+        try {
+            const scores = await computeRerankScores(msg.query, msg.candidates);
+            parentPort.postMessage({ id: msg.id, scores });
+        }
+        catch (err) {
+            parentPort.postMessage({
+                id: msg.id,
+                error: String(err instanceof Error ? err.message : err),
+            });
+        }
+        return;
+    }
+    if (msg.type === 'rerankBatch') {
+        try {
+            const allScores = await Promise.all(msg.queries.map((q, i) => {
+                const set = msg.candidateSets[i];
+                if (!set)
+                    return Promise.resolve([]);
+                return computeRerankScores(q, set);
+            }));
+            parentPort.postMessage({ id: msg.id, allScores });
+        }
+        catch (err) {
+            parentPort.postMessage({
+                id: msg.id,
+                error: String(err instanceof Error ? err.message : err),
+            });
+        }
+        return;
+    }
+    // ── Verify (NLI) ─────────────────────────────────────────────────────────────
+    if (msg.type === 'verify') {
+        try {
+            const result = await computeVerification(msg.claimText, msg.sourceText);
+            parentPort.postMessage({ id: msg.id, result });
+        }
+        catch (err) {
+            parentPort.postMessage({
+                id: msg.id,
+                error: String(err instanceof Error ? err.message : err),
+            });
+        }
+        return;
+    }
+}
+parentPort.on('message', (msg) => {
+    if ('__shutdown' in msg) {
+        try {
+            parentPort.close();
+        }
+        catch { /* ignore */ }
+        process.exit(0);
+        return;
+    }
+    enqueue(() => handleMessage(msg));
+});
+//# sourceMappingURL=embedWorker.js.map

package/dist/embedWorker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"embedWorker.js","sourceRoot":"","sources":["../src/embedWorker.ts"],"names":[],"mappings":"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"}

package/dist/fastembed.d.ts

@@ -0,0 +1,62 @@
+import type { EmbeddingHealth, EmbeddingProvider, EmbeddingProviderMetadata, EmbedRole, FastEmbedModelConfig } from './index.js';
+declare const MODEL_CONFIGS: Record<string, FastEmbedModelConfig>;
+/** @deprecated Use MODEL_CONFIGS[modelId].dim instead. */
+declare const MODEL_DIMS: Record<string, number>;
+/** @deprecated Use MODEL_CONFIGS[modelId].maxTokens instead. */
+declare const MODEL_MAX_TOKENS: Record<string, number>;
+declare const DEFAULT_MODEL = "bge-base-en-v1.5";
+declare const DEFAULT_BATCH_SIZE = 256;
+/**
+ * Real ONNX embedding provider using fastembed-js.
+ *
+ * Runs inference in a dedicated child PROCESS (BL-238/BL-171), never the
+ * main thread and never a `worker_threads.Worker` shared with
+ * `@huggingface/transformers`-based inference (rerank/verify) — see
+ * `sharedFastembedProcess.ts` / `fastembedProcessHost.ts` for the full
+ * root-cause writeup on why fastembed's onnxruntime-node@1.21.0 cannot
+ * safely share a thread with onnxruntime-node@1.24.3, even sequentially.
+ */
+export declare class FastembedProvider implements EmbeddingProvider {
+    readonly metadata: EmbeddingProviderMetadata;
+    private model;
+    private cacheDir;
+    private shared;
+    private ready;
+    private readyPromise;
+    private embedDim;
+    private maxTokensVal;
+    private _lastError;
+    constructor(model: string, dimensions: number, cacheDir: string);
+    health(): EmbeddingHealth;
+    embedSingle(text: string, _role?: EmbedRole): Promise<Float32Array>;
+    embedBatch(texts: string[], opts?: {
+        role?: EmbedRole;
+        batchSize?: number;
+    }): AsyncIterable<Float32Array>;
+    warmUp(texts: string[]): Promise<void>;
+    /**
+     * Rough token estimation: ~4 characters per token.
+     * Used for chunk-then-mean-pool boundary detection.
+     */
+    private estimateTokens;
+    /**
+     * Split text into chunks that fit within maxTokens.
+     * Splits on whitespace boundaries near the token limit for clean breaks.
+     */
+    private chunkText;
+    /**
+     * Mean-pool multiple embedding vectors into one.
+     * All vectors must have the same length.
+     */
+    private meanPool;
+    /**
+     * Lazily initialise this provider's model on the shared ONNX worker.
+     * Idempotent: concurrent callers await the same in-flight init.
+     */
+    private ensureReady;
+    private initModel;
+    private sendBatch;
+    private toFloat32Normalised;
+}
+export { MODEL_CONFIGS, MODEL_DIMS, MODEL_MAX_TOKENS, DEFAULT_MODEL, DEFAULT_BATCH_SIZE };
+//# sourceMappingURL=fastembed.d.ts.map

package/dist/fastembed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fastembed.d.ts","sourceRoot":"","sources":["../src/fastembed.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,yBAAyB,EAAE,SAAS,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAejI,QAAA,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAoCvD,CAAC;AAEF,0DAA0D;AAC1D,QAAA,MAAM,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAEtC,CAAC;AAEF,gEAAgE;AAChE,QAAA,MAAM,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAE5C,CAAC;AAEF,QAAA,MAAM,aAAa,qBAAqB,CAAC;AACzC,QAAA,MAAM,kBAAkB,MAAM,CAAC;AAE/B;;;;;;;;;GASG;AACH,qBAAa,iBAAkB,YAAW,iBAAiB;IACzD,QAAQ,CAAC,QAAQ,EAAE,yBAAyB,CAAC;IAC7C,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,QAAQ,CAAS;IAKzB,OAAO,CAAC,MAAM,CAA6D;IAC3E,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,YAAY,CAA8B;IAClD,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,YAAY,CAAO;IAC3B,OAAO,CAAC,UAAU,CAAuB;gBAE7B,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;IAgB/D,MAAM,IAAI,eAAe;IAkBnB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,SAAS,GAAG,OAAO,CAAC,YAAY,CAAC;IAkBlE,UAAU,CACf,KAAK,EAAE,MAAM,EAAE,EACf,IAAI,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,SAAS,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,GAC9C,aAAa,CAAC,YAAY,CAAC;IAuBxB,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAO5C;;;OAGG;IACH,OAAO,CAAC,cAAc;IAItB;;;OAGG;IACH,OAAO,CAAC,SAAS;IAmBjB;;;OAGG;IACH,OAAO,CAAC,QAAQ;IA0BhB;;;OAGG;IACH,OAAO,CAAC,WAAW;YAQL,SAAS;YAqBT,SAAS;IAKvB,OAAO,CAAC,mBAAmB;CAc5B;AAED,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,gBAAgB,EAAE,aAAa,EAAE,kBAAkB,EAAE,CAAC"}

package/dist/fastembed.js

@@ -0,0 +1,259 @@
+import { warmupTimeoutMs } from './index.js';
+import { getSharedFastembedProcess } from './sharedFastembedProcess.js';
+const MODEL_CONFIGS = {
+    'bge-small-en-v1.5': {
+        modelId: 'bge-small-en-v1.5',
+        hfRepoId: 'fast-bge-small-en-v1.5',
+        dim: 384,
+        maxTokens: 512,
+        description: 'BGE Small English v1.5 — lightweight 384-dim embedding, ~33M params',
+    },
+    'bge-base-en-v1.5': {
+        modelId: 'bge-base-en-v1.5',
+        hfRepoId: 'fast-bge-base-en-v1.5',
+        dim: 768,
+        maxTokens: 512,
+        description: 'BGE Base English v1.5 — balanced 768-dim embedding, ~110M params',
+    },
+    'multilingual-e5-large': {
+        modelId: 'multilingual-e5-large',
+        hfRepoId: 'fast-multilingual-e5-large',
+        dim: 1024,
+        maxTokens: 512,
+        description: 'Multilingual E5 Large — 1024-dim, 100+ languages, ~335M params',
+    },
+    'bge-m3': {
+        modelId: 'bge-m3',
+        hfRepoId: 'BAAI/bge-m3',
+        dim: 1024,
+        maxTokens: 8192,
+        description: 'BGE-M3 — 570M params, 8192-token context, 100+ languages, ONNX INT8',
+    },
+    'codexembed-400m': {
+        modelId: 'codexembed-400m',
+        hfRepoId: 'microsoft/codexembed-400m',
+        dim: 1024,
+        maxTokens: 8192,
+        description: 'CodeXEmbed-400M — code-only CPU, ~1.6GB RAM, 8192-token context',
+    },
+};
+/** @deprecated Use MODEL_CONFIGS[modelId].dim instead. */
+const MODEL_DIMS = Object.fromEntries(Object.entries(MODEL_CONFIGS).map(([id, cfg]) => [id, cfg.dim]));
+/** @deprecated Use MODEL_CONFIGS[modelId].maxTokens instead. */
+const MODEL_MAX_TOKENS = Object.fromEntries(Object.entries(MODEL_CONFIGS).map(([id, cfg]) => [id, cfg.maxTokens]));
+const DEFAULT_MODEL = 'bge-base-en-v1.5';
+const DEFAULT_BATCH_SIZE = 256;
+/**
+ * Real ONNX embedding provider using fastembed-js.
+ *
+ * Runs inference in a dedicated child PROCESS (BL-238/BL-171), never the
+ * main thread and never a `worker_threads.Worker` shared with
+ * `@huggingface/transformers`-based inference (rerank/verify) — see
+ * `sharedFastembedProcess.ts` / `fastembedProcessHost.ts` for the full
+ * root-cause writeup on why fastembed's onnxruntime-node@1.21.0 cannot
+ * safely share a thread with onnxruntime-node@1.24.3, even sequentially.
+ */
+export class FastembedProvider {
+    metadata;
+    model;
+    cacheDir;
+    // BL-238/BL-171 fix: delegate ALL fastembed ONNX inference to the
+    // process-wide shared fastembed CHILD PROCESS singleton instead of
+    // spawning our own `Worker`/process — see `sharedFastembedProcess.ts` for
+    // the full root-cause writeup.
+    shared = getSharedFastembedProcess();
+    ready = false;
+    readyPromise = null;
+    embedDim = 0;
+    maxTokensVal = 512;
+    _lastError = null;
+    constructor(model, dimensions, cacheDir) {
+        this.model = model;
+        this.cacheDir = cacheDir;
+        this.embedDim = dimensions;
+        const cfg = MODEL_CONFIGS[model];
+        this.maxTokensVal = cfg?.maxTokens ?? 512;
+        this.metadata = {
+            modelId: model,
+            dimensions,
+            maxTokens: this.maxTokensVal,
+            isRemote: false,
+            isDeterministic: false,
+            providerUri: `local:onnx:${model}`,
+        };
+    }
+    health() {
+        let state = 'uninitialized';
+        if (this._lastError) {
+            state = 'error';
+        }
+        else if (this.ready) {
+            state = 'real';
+        }
+        else if (this.readyPromise) {
+            state = 'warming';
+        }
+        return {
+            configured: `fastembed:${this.model}`,
+            active: this.ready ? this.metadata.modelId : null,
+            state,
+            dimensions: this.embedDim || this.metadata.dimensions,
+            last_error: this._lastError,
+        };
+    }
+    async embedSingle(text, _role) {
+        // Chunk-then-mean-pool for text exceeding maxTokens (D7: no truncation)
+        if (this.estimateTokens(text) > this.maxTokensVal) {
+            const chunks = this.chunkText(text, this.maxTokensVal);
+            const embeddings = [];
+            await this.ensureReady();
+            for (const chunk of chunks) {
+                const res = await this.shared.request({ type: 'embed', text: chunk });
+                embeddings.push(this.toFloat32Normalised(res.embedding));
+            }
+            return this.meanPool(embeddings);
+        }
+        await this.ensureReady();
+        const res = await this.shared.request({ type: 'embed', text });
+        return this.toFloat32Normalised(res.embedding);
+    }
+    async *embedBatch(texts, opts) {
+        void opts?.role;
+        await this.ensureReady();
+        const batchSize = opts?.batchSize ?? DEFAULT_BATCH_SIZE;
+        for (let i = 0; i < texts.length; i += batchSize) {
+            const batch = texts.slice(i, i + batchSize);
+            // Check if any text in the batch exceeds maxTokens
+            const needsChunking = batch.some((t) => this.estimateTokens(t) > this.maxTokensVal);
+            if (needsChunking) {
+                // Process each text individually with chunk-then-mean-pool
+                for (const text of batch) {
+                    yield await this.embedSingle(text, opts?.role);
+                }
+            }
+            else {
+                const embeddings = await this.sendBatch(batch);
+                for (const vec of embeddings) {
+                    yield this.toFloat32Normalised(vec);
+                }
+            }
+        }
+    }
+    async warmUp(texts) {
+        // No-op: isDeterministic is false, cache would be unreliable.
+        // Real warmup requires the worker to be initialized, which happens
+        // lazily on the first embedSingle/embedBatch call.
+        void texts;
+    }
+    /**
+     * Rough token estimation: ~4 characters per token.
+     * Used for chunk-then-mean-pool boundary detection.
+     */
+    estimateTokens(text) {
+        return Math.ceil(text.length / 4);
+    }
+    /**
+     * Split text into chunks that fit within maxTokens.
+     * Splits on whitespace boundaries near the token limit for clean breaks.
+     */
+    chunkText(text, maxTokens) {
+        const maxChars = maxTokens * 4;
+        if (text.length <= maxChars)
+            return [text];
+        const chunks = [];
+        let start = 0;
+        while (start < text.length) {
+            let end = Math.min(start + maxChars, text.length);
+            // Back up to nearest whitespace if not at end of text
+            if (end < text.length) {
+                const lastSpace = text.lastIndexOf(' ', end);
+                if (lastSpace > start)
+                    end = lastSpace;
+            }
+            chunks.push(text.slice(start, end));
+            start = end;
+        }
+        return chunks;
+    }
+    /**
+     * Mean-pool multiple embedding vectors into one.
+     * All vectors must have the same length.
+     */
+    meanPool(vectors) {
+        if (vectors.length === 0)
+            return new Float32Array(0);
+        if (vectors.length === 1)
+            return vectors[0];
+        const dim = vectors[0].length;
+        const pooled = new Float32Array(dim);
+        for (const vec of vectors) {
+            for (let i = 0; i < dim; i++) {
+                pooled[i] += vec[i];
+            }
+        }
+        const n = vectors.length;
+        for (let i = 0; i < dim; i++) {
+            pooled[i] = pooled[i] / n;
+        }
+        // Normalise the pooled vector
+        let norm = 0;
+        for (let i = 0; i < dim; i++) {
+            norm += pooled[i] * pooled[i];
+        }
+        norm = Math.sqrt(norm) || 1;
+        for (let i = 0; i < dim; i++) {
+            pooled[i] = pooled[i] / norm;
+        }
+        return pooled;
+    }
+    /**
+     * Lazily initialise this provider's model on the shared ONNX worker.
+     * Idempotent: concurrent callers await the same in-flight init.
+     */
+    ensureReady() {
+        if (this.ready)
+            return Promise.resolve();
+        if (!this.readyPromise) {
+            this.readyPromise = this.initModel();
+        }
+        return this.readyPromise;
+    }
+    async initModel() {
+        try {
+            const res = await this.shared.request({ type: 'init', model: this.model, cacheDir: this.cacheDir }, warmupTimeoutMs());
+            if (res.dim > 0) {
+                this.embedDim = res.dim;
+            }
+            this.ready = true;
+            this._lastError = null;
+        }
+        catch (e) {
+            const err = e instanceof Error ? e : new Error(String(e));
+            this._lastError = err.message;
+            // Allow a subsequent call to retry initialisation rather than being
+            // permanently stuck on a failed readyPromise.
+            this.readyPromise = null;
+            throw err;
+        }
+    }
+    async sendBatch(texts) {
+        const res = await this.shared.request({ type: 'embedBatch', texts });
+        return res.embeddings;
+    }
+    toFloat32Normalised(raw) {
+        const dim = this.embedDim || raw.length;
+        const vec = new Float32Array(dim);
+        let norm = 0;
+        for (let i = 0; i < dim && i < raw.length; i++) {
+            vec[i] = raw[i] ?? 0;
+            norm += vec[i] * vec[i];
+        }
+        norm = Math.sqrt(norm) || 1;
+        for (let i = 0; i < dim; i++) {
+            vec[i] = vec[i] / norm;
+        }
+        return vec;
+    }
+}
+export { MODEL_CONFIGS, MODEL_DIMS, MODEL_MAX_TOKENS, DEFAULT_MODEL, DEFAULT_BATCH_SIZE };
+//# sourceMappingURL=fastembed.js.map