@wei840222/qmd 2026.8.23

package/dist/embedding/identity.js

@@ -0,0 +1,321 @@
+import { createHash } from "node:crypto";
+export class EmbeddingIdentityStateError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = "EmbeddingIdentityStateError";
+        this.code = code;
+    }
+}
+function hasVerifiableStoredIdentity(row) {
+    if (!/^[0-9a-f]{64}$/.test(row.fingerprint))
+        return false;
+    if (createHash("sha256").update(row.canonical_material).digest("hex") !== row.fingerprint) {
+        return false;
+    }
+    try {
+        const material = JSON.parse(row.canonical_material);
+        return typeof material === "object" && material !== null && !Array.isArray(material);
+    }
+    catch {
+        return false;
+    }
+}
+export function createEmbeddingIdentity(input) {
+    if (input.providerId.trim() === "" || input.model.trim() === "" || input.canonicalMaterial === "") {
+        throw new EmbeddingIdentityStateError("INVALID_IDENTITY", "Embedding identity fields must not be empty.");
+    }
+    if (!Number.isInteger(input.dimension) || input.dimension < 1) {
+        throw new EmbeddingIdentityStateError("INVALID_IDENTITY", "Embedding identity dimension must be positive.");
+    }
+    const fingerprint = createHash("sha256").update(input.canonicalMaterial).digest("hex");
+    return Object.freeze({ ...input, fingerprint });
+}
+export function ensureEmbeddingIdentitySchema(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS embedding_index_state (
+      singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+      fingerprint TEXT NOT NULL,
+      provider_id TEXT NOT NULL,
+      model TEXT NOT NULL,
+      dimension INTEGER NOT NULL CHECK (dimension > 0),
+      remote INTEGER NOT NULL CHECK (remote IN (0, 1)),
+      canonical_material TEXT NOT NULL,
+      status TEXT NOT NULL CHECK (status IN ('building', 'ready', 'incompatible')),
+      generation INTEGER NOT NULL CHECK (generation > 0),
+      lease_owner TEXT,
+      lease_expires_at INTEGER,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+    const schema = db.prepare(`
+    SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'embedding_index_state'
+  `).get();
+    if (schema && !schema.sql.includes("'incompatible'")) {
+        db.transaction(() => {
+            db.exec(`ALTER TABLE embedding_index_state RENAME TO embedding_index_state_legacy`);
+            db.exec(`
+        CREATE TABLE embedding_index_state (
+          singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+          fingerprint TEXT NOT NULL,
+          provider_id TEXT NOT NULL,
+          model TEXT NOT NULL,
+          dimension INTEGER NOT NULL CHECK (dimension > 0),
+          remote INTEGER NOT NULL CHECK (remote IN (0, 1)),
+          canonical_material TEXT NOT NULL,
+          status TEXT NOT NULL CHECK (status IN ('building', 'ready', 'incompatible')),
+          generation INTEGER NOT NULL CHECK (generation > 0),
+          lease_owner TEXT,
+          lease_expires_at INTEGER,
+          updated_at INTEGER NOT NULL
+        )
+      `);
+            db.exec(`
+        INSERT INTO embedding_index_state(
+          singleton, fingerprint, provider_id, model, dimension, remote,
+          canonical_material, status, generation, lease_owner, lease_expires_at, updated_at
+        )
+        SELECT singleton, fingerprint, provider_id, model, dimension, remote,
+          canonical_material, status, generation, lease_owner, lease_expires_at, updated_at
+        FROM embedding_index_state_legacy
+      `);
+            db.exec(`DROP TABLE embedding_index_state_legacy`);
+        })();
+    }
+    const row = readState(db);
+    if (row && row.status !== "incompatible" && !hasVerifiableStoredIdentity(row)) {
+        db.prepare(`
+      UPDATE embedding_index_state
+      SET status = 'incompatible', lease_owner = NULL, lease_expires_at = NULL,
+          updated_at = ?
+      WHERE singleton = 1
+    `).run(Date.now());
+    }
+}
+function readState(db) {
+    return db.prepare(`
+    SELECT fingerprint, provider_id, model, dimension, remote, canonical_material,
+           status, generation, lease_owner, lease_expires_at
+    FROM embedding_index_state
+    WHERE singleton = 1
+  `).get();
+}
+function rowIdentity(row) {
+    return Object.freeze({
+        fingerprint: row.fingerprint,
+        providerId: row.provider_id,
+        model: row.model,
+        dimension: row.dimension,
+        remote: row.remote === 1,
+        canonicalMaterial: row.canonical_material,
+    });
+}
+export function readStoredEmbeddingIdentity(db) {
+    ensureEmbeddingIdentitySchema(db);
+    const row = readState(db);
+    return row ? rowIdentity(row) : undefined;
+}
+function embeddingRowsExist(db) {
+    const row = db.prepare("SELECT EXISTS(SELECT 1 FROM content_vectors LIMIT 1) AS present").get();
+    const vecTable = db.prepare(`
+    SELECT EXISTS(
+      SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'vectors_vec'
+    ) AS present
+  `).get();
+    return row.present === 1 || vecTable.present === 1;
+}
+export function inspectEmbeddingIndexState(db, expected, now = Date.now()) {
+    ensureEmbeddingIdentitySchema(db);
+    const row = readState(db);
+    if (!row) {
+        return { status: embeddingRowsExist(db) ? "mismatch" : "empty" };
+    }
+    const identity = rowIdentity(row);
+    if (row.status === "incompatible") {
+        return { status: "incompatible", identity, generation: row.generation };
+    }
+    if (row.fingerprint !== expected.fingerprint) {
+        return { status: "mismatch", identity, generation: row.generation };
+    }
+    if (row.status === "ready") {
+        return { status: "ready", identity, generation: row.generation };
+    }
+    if (row.lease_owner && row.lease_expires_at !== null && row.lease_expires_at > now) {
+        return {
+            status: "building",
+            identity,
+            ownerId: row.lease_owner,
+            generation: row.generation,
+            leaseExpiresAt: row.lease_expires_at,
+        };
+    }
+    return { status: "partial", identity, generation: row.generation };
+}
+function validateLeaseOptions(options) {
+    if (options.ownerId.trim() === "" || !Number.isFinite(options.now)
+        || !Number.isFinite(options.leaseMs) || options.leaseMs <= 0) {
+        throw new EmbeddingIdentityStateError("INVALID_LEASE", "Embedding build lease options are invalid.");
+    }
+}
+function clearEmbeddingData(db) {
+    db.prepare("DELETE FROM content_vectors").run();
+    db.exec("DROP TABLE IF EXISTS vectors_vec");
+}
+function ensureEmbeddingVectorTable(db, dimension) {
+    const table = db.prepare(`
+    SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'vectors_vec'
+  `).get();
+    if (table) {
+        const storedDimension = table.sql.match(/float\[(\d+)\]/)?.[1];
+        const hasHashSeq = table.sql.includes("hash_seq");
+        const hasCollection = table.sql.includes("collection");
+        const hasCosine = table.sql.includes("distance_metric=cosine");
+        if (storedDimension === String(dimension)
+            && hasHashSeq
+            && hasCollection
+            && hasCosine) {
+            return;
+        }
+        if (storedDimension === String(dimension) && hasHashSeq && !hasCollection) {
+            // Auto-migrate legacy table without collection column
+            try {
+                db.exec("CREATE TEMP TABLE _qmd_migrate_vecs (hash_seq TEXT, embedding BLOB)");
+                db.exec("INSERT INTO _qmd_migrate_vecs SELECT hash_seq, embedding FROM vectors_vec");
+                db.exec("DROP TABLE vectors_vec");
+                db.exec(`CREATE VIRTUAL TABLE vectors_vec USING vec0(hash_seq TEXT PRIMARY KEY, collection TEXT, embedding float[${dimension}] distance_metric=cosine)`);
+                db.exec(`
+          INSERT INTO vectors_vec (hash_seq, collection, embedding)
+          SELECT
+            t.hash_seq,
+            COALESCE((
+              SELECT d.collection
+              FROM content_vectors cv
+              JOIN documents d ON d.hash = cv.hash AND d.active = 1
+              WHERE (cv.hash || '_' || cv.seq) = t.hash_seq
+              LIMIT 1
+            ), ''),
+            t.embedding
+          FROM _qmd_migrate_vecs t
+        `);
+                db.exec("DROP TABLE IF EXISTS _qmd_migrate_vecs");
+                return;
+            }
+            catch {
+                db.exec("DROP TABLE IF EXISTS _qmd_migrate_vecs");
+                db.exec("DROP TABLE IF EXISTS vectors_vec");
+            }
+        }
+        else {
+            throw new EmbeddingIdentityStateError("IDENTITY_MISMATCH", "Stored vector table schema does not match the active embedding identity.");
+        }
+    }
+    db.exec(`
+    CREATE VIRTUAL TABLE vectors_vec USING vec0(
+      hash_seq TEXT PRIMARY KEY,
+      collection TEXT,
+      embedding float[${dimension}] distance_metric=cosine
+    )
+  `);
+}
+export function beginEmbeddingBuild(db, identity, options) {
+    validateLeaseOptions(options);
+    ensureEmbeddingIdentitySchema(db);
+    db.exec("BEGIN IMMEDIATE");
+    try {
+        options.beforeMutation?.();
+        let row = readState(db);
+        const hasEmbeddingData = embeddingRowsExist(db);
+        const mismatch = row
+            ? row.status === "incompatible" || row.fingerprint !== identity.fingerprint
+            : hasEmbeddingData;
+        if (mismatch && options.requireForceForIdentityChange && !options.forceRebuild) {
+            throw new EmbeddingIdentityStateError("IDENTITY_MISMATCH", "Remote embedding identity changes require both force and destructive rebuild authorization.");
+        }
+        if (mismatch || options.forceRebuild) {
+            if (!options.allowDestructiveRebuild) {
+                throw new EmbeddingIdentityStateError("IDENTITY_MISMATCH", "Stored embedding identity does not match the active provider.");
+            }
+            clearEmbeddingData(db);
+            db.prepare("DELETE FROM embedding_index_state WHERE singleton = 1").run();
+            row = undefined;
+        }
+        // Vector table creation is part of publication state, not a follow-up.
+        // If this fails, any destructive reset and the new lease roll back together.
+        ensureEmbeddingVectorTable(db, identity.dimension);
+        options.afterVectorTablePrepared?.();
+        if (row?.lease_owner && row.lease_expires_at !== null
+            && row.lease_expires_at > options.now && row.lease_owner !== options.ownerId) {
+            throw new EmbeddingIdentityStateError("LEASE_BUSY", `Embedding build lease is owned by ${row.lease_owner}.`);
+        }
+        const mode = row ? "resume" : "rebuild";
+        const preservePublishedReady = row?.status === "ready" && !mismatch && !options.forceRebuild;
+        const generation = (row?.generation ?? 0) + 1;
+        const leaseExpiresAt = options.now + options.leaseMs;
+        db.prepare(`
+      INSERT INTO embedding_index_state(
+        singleton, fingerprint, provider_id, model, dimension, remote,
+        canonical_material, status, generation, lease_owner, lease_expires_at, updated_at
+      ) VALUES (1, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(singleton) DO UPDATE SET
+        fingerprint = excluded.fingerprint,
+        provider_id = excluded.provider_id,
+        model = excluded.model,
+        dimension = excluded.dimension,
+        remote = excluded.remote,
+        canonical_material = excluded.canonical_material,
+        status = excluded.status,
+        generation = excluded.generation,
+        lease_owner = excluded.lease_owner,
+        lease_expires_at = excluded.lease_expires_at,
+        updated_at = excluded.updated_at
+    `).run(identity.fingerprint, identity.providerId, identity.model, identity.dimension, identity.remote ? 1 : 0, identity.canonicalMaterial, preservePublishedReady ? "ready" : "building", generation, options.ownerId, leaseExpiresAt, options.now);
+        db.exec("COMMIT");
+        return Object.freeze({
+            fingerprint: identity.fingerprint,
+            ownerId: options.ownerId,
+            generation,
+            leaseExpiresAt,
+            mode,
+        });
+    }
+    catch (error) {
+        db.exec("ROLLBACK");
+        throw error;
+    }
+}
+function updateOwnedLease(db, lease, sql, params) {
+    const result = db.prepare(sql).run(...params, lease.fingerprint, lease.ownerId, lease.generation);
+    if (result.changes !== 1) {
+        throw new EmbeddingIdentityStateError("LEASE_LOST", "Embedding build lease is no longer owned by this operation.");
+    }
+}
+export function renewEmbeddingBuildLease(db, lease, now, leaseMs) {
+    if (!Number.isFinite(leaseMs) || leaseMs <= 0) {
+        throw new EmbeddingIdentityStateError("INVALID_LEASE", "Embedding lease duration must be positive.");
+    }
+    const leaseExpiresAt = now + leaseMs;
+    updateOwnedLease(db, lease, `
+    UPDATE embedding_index_state
+    SET lease_expires_at = ?, updated_at = ?
+    WHERE singleton = 1 AND lease_expires_at > ?
+      AND fingerprint = ? AND lease_owner = ? AND generation = ?
+  `, [leaseExpiresAt, now, now]);
+    return Object.freeze({ ...lease, leaseExpiresAt });
+}
+export function completeEmbeddingBuild(db, lease, now = Date.now()) {
+    updateOwnedLease(db, lease, `
+    UPDATE embedding_index_state
+    SET status = 'ready', lease_owner = NULL, lease_expires_at = NULL, updated_at = ?
+    WHERE singleton = 1 AND lease_expires_at > ?
+      AND fingerprint = ? AND lease_owner = ? AND generation = ?
+  `, [now, now]);
+}
+export function abandonEmbeddingBuild(db, lease, now = Date.now()) {
+    updateOwnedLease(db, lease, `
+    UPDATE embedding_index_state
+    SET status = CASE WHEN status = 'ready' THEN 'ready' ELSE 'building' END,
+        lease_owner = NULL, lease_expires_at = NULL, updated_at = ?
+    WHERE singleton = 1 AND lease_expires_at > ?
+      AND fingerprint = ? AND lease_owner = ? AND generation = ?
+  `, [now, now]);
+}

package/dist/embedding/local-identity.d.ts

@@ -0,0 +1 @@
+export declare function canonicalLocalEmbeddingIdentityMaterial(model: string, dimension: number): string;

package/dist/embedding/local-identity.js

@@ -0,0 +1,15 @@
+import { formatDocForEmbedding, formatQueryForEmbedding } from "../llm.js";
+import { EmbeddingProviderError } from "./provider.js";
+export function canonicalLocalEmbeddingIdentityMaterial(model, dimension) {
+    if (!Number.isInteger(dimension) || dimension < 1) {
+        throw new EmbeddingProviderError("DIMENSION_MISMATCH", "Embedding identity dimension must be a positive integer.");
+    }
+    return JSON.stringify({
+        provider: "local-llama-cpp",
+        model,
+        dimension,
+        remote: false,
+        query_format: formatQueryForEmbedding("__qmd_query_identity__", model),
+        document_format: formatDocForEmbedding("__qmd_document_identity__", "__qmd_document_identity_title__", model),
+    });
+}

package/dist/embedding/local.d.ts

@@ -0,0 +1,34 @@
+import { type ILLMSession, type LlamaCpp } from "../llm.js";
+import { type EmbeddingOperationOptions, type EmbeddingProvider, type EmbeddingProviderOwner, type EmbeddingVector } from "./provider.js";
+export interface LocalEmbeddingProviderOptions {
+    model?: string;
+    dimension?: number;
+}
+export declare class LocalEmbeddingProvider implements EmbeddingProvider {
+    readonly providerId = "local-llama-cpp";
+    readonly remote = false;
+    readonly model: string;
+    private readonly session;
+    canonicalIdentityMaterialForDimension(dimension: number): string;
+    private readonly closeController;
+    private currentDimension;
+    private closed;
+    constructor(session: ILLMSession, options?: LocalEmbeddingProviderOptions);
+    get dimension(): number | null;
+    canonicalIdentityMaterial(): string;
+    formatQuery(query: string): string;
+    formatDocument(text: string, title?: string): string;
+    embed(text: string, options: EmbeddingOperationOptions): Promise<EmbeddingVector>;
+    embedBatch(texts: string[], options: EmbeddingOperationOptions): Promise<EmbeddingVector[]>;
+    close(): Promise<void>;
+    private validateResult;
+    private runOperation;
+    private waitForOperation;
+}
+export declare class LocalEmbeddingProviderOwner implements EmbeddingProviderOwner {
+    readonly provider: EmbeddingProvider;
+    private readonly llm;
+    private closePromise;
+    constructor(llm: LlamaCpp, options?: LocalEmbeddingProviderOptions);
+    close(): Promise<void>;
+}

package/dist/embedding/local.js

@@ -0,0 +1,290 @@
+import { formatDocForEmbedding, formatQueryForEmbedding, waitForLLMSessionsToDrain, withLLMSessionForLlm, } from "../llm.js";
+import { EmbeddingProviderError, } from "./provider.js";
+import { canonicalLocalEmbeddingIdentityMaterial } from "./local-identity.js";
+const MAX_TIMER_DELAY_MS = 2_147_483_647;
+export class LocalEmbeddingProvider {
+    providerId = "local-llama-cpp";
+    remote = false;
+    model;
+    session;
+    canonicalIdentityMaterialForDimension(dimension) {
+        return canonicalLocalEmbeddingIdentityMaterial(this.model, dimension);
+    }
+    closeController = new AbortController();
+    currentDimension;
+    closed = false;
+    constructor(session, options = {}) {
+        this.session = session;
+        const requestedModel = options.model ?? session.embeddingModel;
+        if (requestedModel !== session.embeddingModel) {
+            throw new EmbeddingProviderError("MODEL_MISMATCH", `Configured embedding model ${requestedModel} does not match session model ${session.embeddingModel}.`);
+        }
+        this.model = session.embeddingModel;
+        if (options.dimension !== undefined && (!Number.isInteger(options.dimension) || options.dimension < 1)) {
+            throw new EmbeddingProviderError("DIMENSION_MISMATCH", "Configured embedding dimension must be a positive integer.");
+        }
+        this.currentDimension = options.dimension ?? null;
+    }
+    get dimension() {
+        return this.currentDimension;
+    }
+    canonicalIdentityMaterial() {
+        if (this.dimension === null) {
+            throw new EmbeddingProviderError("DIMENSION_UNKNOWN", "Embedding provider identity is unavailable until its vector dimension is known.");
+        }
+        return JSON.stringify({
+            provider: this.providerId,
+            model: this.model,
+            dimension: this.dimension,
+            remote: this.remote,
+            query_format: this.formatQuery("__qmd_query_identity__"),
+            document_format: this.formatDocument("__qmd_document_identity__", "__qmd_document_identity_title__"),
+        });
+    }
+    formatQuery(query) {
+        return formatQueryForEmbedding(query, this.model);
+    }
+    formatDocument(text, title) {
+        return formatDocForEmbedding(text, title, this.model);
+    }
+    async embed(text, options) {
+        const result = await this.runOperation("embed", options, () => this.session.embed(text, {
+            model: this.model,
+            isQuery: options.kind === "query",
+        }));
+        const vector = this.validateResult(result, "embed", undefined, this.currentDimension);
+        if (this.currentDimension === null)
+            this.currentDimension = vector.dimension;
+        return vector;
+    }
+    async embedBatch(texts, options) {
+        const results = await this.runOperation("embedBatch", options, () => texts.length === 0
+            ? Promise.resolve([])
+            : this.session.embedBatch(texts, {
+                model: this.model,
+                isQuery: options.kind === "query",
+            }));
+        if (results.length !== texts.length) {
+            throw new EmbeddingProviderError("BATCH_CARDINALITY_MISMATCH", `Embedding batch returned ${results.length} results for ${texts.length} inputs.`, { operation: "embedBatch" });
+        }
+        let batchDimension = this.currentDimension;
+        const vectors = results.map((result, index) => {
+            const vector = this.validateResult(result, "embedBatch", index, batchDimension);
+            batchDimension ??= vector.dimension;
+            return vector;
+        });
+        if (this.currentDimension === null)
+            this.currentDimension = batchDimension;
+        return vectors;
+    }
+    async close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.closeController.abort();
+    }
+    validateResult(result, operation, index, expectedDimension) {
+        if (result === null) {
+            throw new EmbeddingProviderError("MISSING_EMBEDDING", index === undefined
+                ? "Embedding provider returned no vector."
+                : `Embedding provider returned no vector for batch item ${index}.`, { operation, index });
+        }
+        if (result.model !== this.model) {
+            throw new EmbeddingProviderError("MODEL_MISMATCH", `Embedding result model ${result.model} does not match provider model ${this.model}.`, { operation, index });
+        }
+        const vector = result.embedding;
+        if (!Array.isArray(vector) || vector.length === 0) {
+            throw new EmbeddingProviderError("EMPTY_VECTOR", "Embedding provider returned an empty vector.", { operation, index });
+        }
+        if (!vector.every(value => typeof value === "number" && Number.isFinite(value))) {
+            throw new EmbeddingProviderError("NON_FINITE_VECTOR", "Embedding provider returned a vector containing a non-finite value.", { operation, index });
+        }
+        if (expectedDimension !== null && vector.length !== expectedDimension) {
+            throw new EmbeddingProviderError("DIMENSION_MISMATCH", `Embedding vector dimension ${vector.length} does not match provider dimension ${expectedDimension}.`, { operation, index });
+        }
+        return {
+            vector: [...vector],
+            model: result.model,
+            dimension: vector.length,
+        };
+    }
+    async runOperation(operation, options, invoke) {
+        if (this.closed) {
+            throw new EmbeddingProviderError("PROVIDER_CLOSED", "Embedding provider is closed.", { operation });
+        }
+        const signals = [...new Set([options.signal, this.session.signal, this.closeController.signal]
+                .filter((signal) => signal !== undefined))];
+        if (signals.some(signal => signal.aborted)) {
+            throw new EmbeddingProviderError("OPERATION_ABORTED", "Embedding operation was aborted.", { operation });
+        }
+        if (options.deadline !== undefined) {
+            if (!Number.isFinite(options.deadline) || options.deadline <= Date.now()) {
+                throw new EmbeddingProviderError("DEADLINE_EXCEEDED", "Embedding operation deadline was exceeded.", { operation });
+            }
+        }
+        try {
+            return await this.waitForOperation(operation, signals, options.deadline, invoke);
+        }
+        catch (error) {
+            if (error instanceof EmbeddingProviderError)
+                throw error;
+            throw new EmbeddingProviderError("PROVIDER_FAILURE", "Embedding provider operation failed.", { operation });
+        }
+    }
+    waitForOperation(operation, signals, deadline, invoke) {
+        if (signals.length === 0 && deadline === undefined) {
+            return Promise.resolve().then(invoke);
+        }
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            let deadlineTimer;
+            const cleanup = () => {
+                if (deadlineTimer !== undefined)
+                    clearTimeout(deadlineTimer);
+                for (const signal of signals)
+                    signal.removeEventListener("abort", onAbort);
+            };
+            const finish = (callback) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                callback();
+            };
+            const onAbort = () => finish(() => reject(new EmbeddingProviderError("OPERATION_ABORTED", "Embedding operation was aborted.", { operation })));
+            const scheduleDeadline = () => {
+                if (deadline === undefined || settled)
+                    return;
+                const remaining = deadline - Date.now();
+                if (remaining <= 0) {
+                    finish(() => reject(new EmbeddingProviderError("DEADLINE_EXCEEDED", "Embedding operation deadline was exceeded.", { operation })));
+                    return;
+                }
+                deadlineTimer = setTimeout(scheduleDeadline, Math.min(remaining, MAX_TIMER_DELAY_MS));
+                deadlineTimer.unref?.();
+            };
+            for (const signal of signals)
+                signal.addEventListener("abort", onAbort, { once: true });
+            scheduleDeadline();
+            void Promise.resolve().then(() => {
+                if (settled)
+                    return;
+                if (deadline !== undefined && deadline <= Date.now()) {
+                    finish(() => reject(new EmbeddingProviderError("DEADLINE_EXCEEDED", "Embedding operation deadline was exceeded.", { operation })));
+                    return;
+                }
+                try {
+                    void invoke().then(value => finish(() => resolve(value)), error => finish(() => reject(error)));
+                }
+                catch (error) {
+                    finish(() => reject(error));
+                }
+            });
+        });
+    }
+}
+class ScopedLocalEmbeddingProvider {
+    providerId = "local-llama-cpp";
+    remote = false;
+    model;
+    llm;
+    canonicalIdentityMaterialForDimension(dimension) {
+        return canonicalLocalEmbeddingIdentityMaterial(this.model, dimension);
+    }
+    closeController = new AbortController();
+    currentDimension;
+    closed = false;
+    constructor(llm, options = {}) {
+        this.llm = llm;
+        this.model = options.model ?? llm.embedModelName;
+        this.currentDimension = options.dimension ?? null;
+    }
+    get dimension() {
+        return this.currentDimension;
+    }
+    canonicalIdentityMaterial() {
+        if (this.dimension === null) {
+            throw new EmbeddingProviderError("DIMENSION_UNKNOWN", "Embedding provider identity is unavailable until its vector dimension is known.");
+        }
+        return JSON.stringify({
+            provider: this.providerId,
+            model: this.model,
+            dimension: this.dimension,
+            remote: this.remote,
+            query_format: this.formatQuery("__qmd_query_identity__"),
+            document_format: this.formatDocument("__qmd_document_identity__", "__qmd_document_identity_title__"),
+        });
+    }
+    formatQuery(query) {
+        return formatQueryForEmbedding(query, this.model);
+    }
+    formatDocument(text, title) {
+        return formatDocForEmbedding(text, title, this.model);
+    }
+    embed(text, options) {
+        return this.runScoped(options, (provider, scopedOptions) => (provider.embed(text, scopedOptions)));
+    }
+    embedBatch(texts, options) {
+        return this.runScoped(options, (provider, scopedOptions) => (provider.embedBatch(texts, scopedOptions)));
+    }
+    async close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.closeController.abort();
+    }
+    async runScoped(options, invoke) {
+        if (this.closed) {
+            throw new EmbeddingProviderError("PROVIDER_CLOSED", "Embedding provider is closed.");
+        }
+        const signal = options.signal
+            ? AbortSignal.any([options.signal, this.closeController.signal])
+            : this.closeController.signal;
+        const maxDuration = options.deadline === undefined
+            ? undefined
+            : Math.max(1, options.deadline - Date.now());
+        return withLLMSessionForLlm(this.llm, async (session) => {
+            const provider = new LocalEmbeddingProvider(session, {
+                model: this.model,
+                dimension: this.currentDimension ?? undefined,
+            });
+            try {
+                const result = await invoke(provider, { ...options, signal });
+                const vectors = Array.isArray(result) ? result : [result];
+                for (const vector of vectors)
+                    this.captureDimension(vector.dimension);
+                return result;
+            }
+            finally {
+                await provider.close();
+            }
+        }, {
+            maxDuration,
+        });
+    }
+    captureDimension(dimension) {
+        if (this.currentDimension !== null && this.currentDimension !== dimension) {
+            throw new EmbeddingProviderError("DIMENSION_MISMATCH", `Embedding dimension changed from ${this.currentDimension} to ${dimension}.`);
+        }
+        this.currentDimension = dimension;
+    }
+}
+export class LocalEmbeddingProviderOwner {
+    provider;
+    llm;
+    closePromise;
+    constructor(llm, options = {}) {
+        this.llm = llm;
+        this.provider = new ScopedLocalEmbeddingProvider(llm, options);
+    }
+    close() {
+        if (!this.closePromise) {
+            this.closePromise = (async () => {
+                await this.provider.close();
+                await waitForLLMSessionsToDrain(this.llm);
+                await this.llm.dispose();
+            })();
+        }
+        return this.closePromise;
+    }
+}