@loreai/core 0.16.0 → 0.17.0

package/dist/node/db.d.ts

@@ -1,6 +1,43 @@
 import { Database } from "#db/driver";
+/**
+ * Extract the repository name from a normalized git remote URL.
+ *
+ * Examples:
+ *   "github.com/BYK/LoreAI" → "LoreAI"
+ *   "github.com/org/repo"    → "repo"
+ *   "github.com"             → null (no path components)
+ *   null                     → null
+ */
+export declare function repoNameFromRemote(remote: string | null): string | null;
+/** Return the resolved path of the SQLite database file. */
+export declare function dbPath(): string;
 export declare function db(): Database;
+/**
+ * Merge all data from `sourceId` project into `targetId` project.
+ *
+ * Moves knowledge, temporal messages, distillations, LAT sections, and
+ * path aliases from source to target. Registers the source project's path
+ * as an alias of the target. Deletes the source project row.
+ *
+ * Used internally during lazy git-remote backfill when two path-only
+ * projects are discovered to share the same git remote.
+ */
+export declare function mergeProjectInternal(sourceId: string, targetId: string): void;
 export declare function close(): void;
+/**
+ * Look up or create a project by filesystem path, with git-remote awareness.
+ *
+ * Resolution order:
+ *  1. Exact path match in `projects` table (fast path, O(1) index scan)
+ *  2. Path alias match in `project_path_aliases` (worktree/clone re-visits)
+ *  3. Git remote match — runs `git remote -v` (once per unique path, cached),
+ *     finds an existing project with the same normalized remote URL
+ *  4. Create a new project row
+ *
+ * When a git-remote match is found (step 3), the new path is registered as
+ * an alias so subsequent calls skip the subprocess. If the matched project's
+ * git_remote was not yet populated (pre-v14 rows), it is backfilled lazily.
+ */
 export declare function ensureProject(path: string, name?: string): string;
 export declare function projectId(path: string): string | undefined;
 /** Look up a project's display name by its internal ID. */
@@ -19,6 +56,34 @@ export declare function loadForceMinLayer(sessionID: string): number;
  * (consumed) to avoid unbounded growth.
  */
 export declare function saveForceMinLayer(sessionID: string, layer: number): void;
+/** Persisted cost snapshot for a session. */
+export type SessionCostSnapshot = {
+    conversationCost: number;
+    workerCost: number;
+    conversationTurns: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
+    warmupSavings: number;
+    warmupHits: number;
+    ttlSavings: number;
+    ttlHits: number;
+    batchSavings: number;
+};
+/**
+ * Persist a session's cost snapshot. Uses INSERT OR REPLACE so it works
+ * whether or not a row already exists (forceMinLayer may have created one).
+ */
+export declare function saveSessionCosts(sessionID: string, costs: SessionCostSnapshot): void;
+/**
+ * Load persisted cost snapshot for a session. Returns null if not stored
+ * or if all cost columns are zero (pre-migration row from forceMinLayer only).
+ */
+export declare function loadSessionCosts(sessionID: string): SessionCostSnapshot | null;
+/**
+ * Load cost snapshots for all sessions that have non-zero cost data.
+ * Returns a map of sessionID → SessionCostSnapshot.
+ */
+export declare function loadAllSessionCosts(): Map<string, SessionCostSnapshot>;
 /** Get a metadata value by key. Returns null if not found. */
 export declare function getMeta(key: string): string | null;
 /** Set a metadata value (upsert). */

package/dist/node/db.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"db.d.ts","sourceRoot":"","sources":["../../src/db.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAsXtC,wBAAgB,EAAE,IAAI,QAAQ,CAkC7B;AAwGD,wBAAgB,KAAK,SAKpB;AAGD,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAYjE;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAK1D;AAED,2DAA2D;AAC3D,wBAAgB,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAKrD;AAED;;;GAGG;AACH,wBAAgB,UAAU,IAAI,OAAO,CAKpC;AAMD;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAK3D;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAYxE;AAMD,8DAA8D;AAC9D,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAKlD;AAED,qCAAqC;AACrC,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAMxD;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,IAAI,MAAM,CAMtC"}
+{"version":3,"file":"db.d.ts","sourceRoot":"","sources":["../../src/db.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAMtC;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,GAAG,IAAI,CAMvE;AA0bD,4DAA4D;AAC5D,wBAAgB,MAAM,IAAI,MAAM,CAI/B;AAID,wBAAgB,EAAE,IAAI,QAAQ,CA8C7B;AAsHD;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,GACf,IAAI,CAoCN;AAED,wBAAgB,KAAK,SAKpB;AAID;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAiEjE;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAW1D;AAED,2DAA2D;AAC3D,wBAAgB,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAKrD;AAED;;;GAGG;AACH,wBAAgB,UAAU,IAAI,OAAO,CAKpC;AAMD;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAK3D;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAYxE;AAED,6CAA6C;AAC7C,MAAM,MAAM,mBAAmB,GAAG;IAChC,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,eAAe,EAAE,MAAM,CAAC;IACxB,gBAAgB,EAAE,MAAM,CAAC;IACzB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,mBAAmB,GAAG,IAAI,CA2BpF;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,mBAAmB,GAAG,IAAI,CAiC9E;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,IAAI,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAsCtE;AAMD,8DAA8D;AAC9D,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAKlD;AAED,qCAAqC;AACrC,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAMxD;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,IAAI,MAAM,CAMtC"}

package/dist/node/distillation.d.ts

@@ -15,20 +15,58 @@ type TemporalMessage = temporal.TemporalMessage;
  * use as a diagnostic signal, not a hard gate.
  */
 export declare function compressionRatio(distilledTokens: number, sourceTokens: number): number;
+/**
+ * Maximum allowed expansion for distillation output.
+ *
+ * Tiny segments can't meaningfully compress — distillation adds metadata
+ * (timestamps, importance markers, cross-references) that necessarily
+ * exceeds the source. Allow generous expansion for small segments while
+ * still enforcing compression on large ones.
+ *
+ * @returns Maximum allowed distilled tokens for a given source token count.
+ */
+export declare function maxAllowedExpansion(sourceTokens: number): number;
 /**
  * Segment detection: group related messages into distillation-sized chunks.
  *
- * When the message count exceeds `maxSegment`, prefers splitting at the
+ * When the total token count exceeds `maxTokens`, prefers splitting at the
  * largest inter-message time gap (if it's ≥ 3× the median gap) to respect
- * natural conversation boundaries. Falls back to count-based splitting at
- * `maxSegment` when timestamps are uniform.
+ * natural conversation boundaries. Falls back to token-boundary splitting
+ * when timestamps are uniform.
  *
- * Trailing segments with < 3 messages are merged into the previous segment
- * to avoid tiny distillation inputs with too little context.
+ * Trailing segments whose token sum is below {@link MIN_SEGMENT_TOKENS}
+ * are merged into the previous segment to avoid tiny distillation inputs
+ * with too little context.
  *
  * Exported for testing; `run()` is the production caller.
  */
-export declare function detectSegments(messages: TemporalMessage[], maxSegment: number): TemporalMessage[][];
+export declare function detectSegments(messages: TemporalMessage[], maxTokens: number): TemporalMessage[][];
+/**
+ * Compute the max_tokens budget for a worker LLM call.
+ *
+ * @param inputTokens  Estimated source token count
+ * @param ratio        Compression ratio (0.0–1.0) — output ≈ ratio × input
+ * @param floor        Minimum output tokens
+ * @param cap          Maximum output tokens
+ */
+export declare function workerTokenBudget(inputTokens: number, ratio: number, floor: number, cap: number): number;
+/**
+ * Compute the max_tokens budget for gen-0 distillation of raw messages.
+ *
+ * Uses a √N-based formula (8 × √N) instead of a linear ratio so that the
+ * budget grows sub-linearly with input size. This naturally constrains the
+ * LLM to produce output at ~R ≈ 2–4 (the square-root boundary) and avoids
+ * expansion on small segments where a linear 0.25 ratio + 1024 floor gave
+ * the model far too much room.
+ *
+ * The multiplier (8) gives ~4× headroom above the R=2.0 target, accounting
+ * for the detailed observation format (emoji markers, timestamps, entity
+ * tags, exact numbers) required by the distillation prompt.
+ *
+ * @param sourceTokens  Estimated source token count from raw messages
+ * @returns             Token budget clamped to [256, 4096]
+ */
+export declare function distillTokenBudget(sourceTokens: number): number;
 /**
  * Truncate tool outputs within a `TemporalMessage.content` string (produced
  * by `temporal.partsToText`). Plain text and `[reasoning]` chunks pass
@@ -100,6 +138,7 @@ export type Distillation = {
  * rare callers that explicitly want all rows.
  */
 export declare function loadForSession(projectPath: string, sessionID: string, includeArchived?: boolean): Distillation[];
+export declare function gen0Count(projectPath: string, sessionID: string): number;
 export declare function run(input: {
     llm: LLMClient;
     projectPath: string;
@@ -121,6 +160,9 @@ export declare function run(input: {
      *  where the caller is blocking on the result. Background/idle distillation
      *  should leave this false to benefit from batch API 50% cost savings. */
     urgent?: boolean;
+    /** Whether the LLM call will use batch or direct pricing. Recorded on the
+     *  distillation row for accurate historical cost estimates. */
+    callType?: "batch" | "direct";
 }): Promise<{
     rounds: number;
     distilled: number;
@@ -142,6 +184,7 @@ export declare function metaDistill(input: {
         modelID: string;
     };
     urgent?: boolean;
+    callType?: "batch" | "direct";
 }): Promise<DistillationResult | null>;
 /**
  * Backfill `r_compression` and `c_norm` for distillations that were created

package/dist/node/distillation.d.ts.map

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

package/dist/node/embedding-vendor.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Vendored bge-small registration for the standalone Lore binary.
+ *
+ * The Bun-compiled `lore` binary uses `bun build --compile` to bundle
+ * `fastembed` + `onnxruntime-node` + `@anush008/tokenizers-<platform>`
+ * directly into the executable — including the platform-specific
+ * `.node` addons which Bun embeds and dlopens from `$bunfs` at runtime.
+ *
+ * Two pieces don't fit into Bun's automatic bundling and need our help:
+ *
+ *  1. **Side-load shared libraries**. `onnxruntime_binding.node` does a
+ *     runtime `dlopen("libonnxruntime.so.1")` (or the .dylib / .dll
+ *     equivalent) for the actual ONNX Runtime computation library. Bun
+ *     doesn't follow this kind of dependency. The binary's wrapper
+ *     pre-loads these libs via `bun:ffi` *before* fastembed evaluates,
+ *     so when the addon's dlopen fires it finds the cached handle.
+ *
+ *  2. **Model weights + tokenizer**. fastembed downloads from the HF
+ *     Hub on first use; we want zero network on first run. The wrapper
+ *     embeds the bge-small INT8 files as Bun assets, writes them to a
+ *     real disk dir on first run, and sets `globalThis.__LORE_VENDOR_MODEL__`
+ *     to that path. This module exposes that registration to the
+ *     LocalProvider so it can hand the path to fastembed's CUSTOM-mode
+ *     init (`modelAbsoluteDirPath` + `modelName`).
+ *
+ * In npm-mode usage from `@loreai/opencode` / `@loreai/pi` the global
+ * is unset and `vendorModelInfo()` returns `null`, so the LocalProvider
+ * falls through to fastembed's default Qdrant repo + cache.
+ */
+/** What the binary wrapper writes to globalThis after extracting model files. */
+export interface VendorRegistration {
+    /** Absolute path to the dir containing the bge-small files
+     *  (config.json, tokenizer.json, model_quantized.onnx, …). Pass to
+     *  fastembed as `modelAbsoluteDirPath` in CUSTOM init. */
+    modelAbsoluteDirPath: string;
+    /** Filename of the ONNX weights inside that dir. Pass to fastembed
+     *  as `modelName` in CUSTOM init. */
+    modelName: string;
+    /** Target identifier the binary was built for, e.g. "linux-x64".
+     *  Diagnostic only — the runtime doesn't branch on it. */
+    target: string;
+    /** Lore CLI version that produced the binary. Diagnostic only. */
+    version: string;
+}
+/** Test-only: programmatically set/clear the registration to exercise
+ *  both binary-mode and npm-mode code paths without spinning up a real
+ *  compiled binary. */
+export declare function _setVendorRegistration(reg: VendorRegistration | null): void;
+/** Subset of the registration fastembed needs. Stripped of the
+ *  diagnostic fields so the LocalProvider has exactly what it should
+ *  hand to `FlagEmbedding.init`. */
+export interface VendorModelInfo {
+    modelAbsoluteDirPath: string;
+    modelName: string;
+}
+/**
+ * Resolve the bundled-model arguments for fastembed CUSTOM init. Returns
+ * `null` when no vendor is registered (npm-mode), so the caller can fall
+ * through to fastembed's default cacheDir/HF Hub flow.
+ */
+export declare function vendorModelInfo(): VendorModelInfo | null;
+/** True iff this process is running inside a vendored Lore binary. */
+export declare function isVendoredBinary(): boolean;
+/** The full registration, for diagnostics (`lore --print-vendor-info`). */
+export declare function vendorRegistration(): VendorRegistration | null;
+//# sourceMappingURL=embedding-vendor.d.ts.map

package/dist/node/embedding-vendor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embedding-vendor.d.ts","sourceRoot":"","sources":["../../src/embedding-vendor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAMH,iFAAiF;AACjF,MAAM,WAAW,kBAAkB;IACjC;;8DAE0D;IAC1D,oBAAoB,EAAE,MAAM,CAAC;IAC7B;yCACqC;IACrC,SAAS,EAAE,MAAM,CAAC;IAClB;8DAC0D;IAC1D,MAAM,EAAE,MAAM,CAAC;IACf,kEAAkE;IAClE,OAAO,EAAE,MAAM,CAAC;CACjB;AAUD;;uBAEuB;AACvB,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,kBAAkB,GAAG,IAAI,GAAG,IAAI,CAI3E;AAMD;;oCAEoC;AACpC,MAAM,WAAW,eAAe;IAC9B,oBAAoB,EAAE,MAAM,CAAC;IAC7B,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;GAIG;AACH,wBAAgB,eAAe,IAAI,eAAe,GAAG,IAAI,CAOxD;AAED,sEAAsE;AACtE,wBAAgB,gBAAgB,IAAI,OAAO,CAE1C;AAED,2EAA2E;AAC3E,wBAAgB,kBAAkB,IAAI,kBAAkB,GAAG,IAAI,CAE9D"}

package/dist/node/embedding-worker-types.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Shared message types for the embedding worker thread.
+ *
+ * The embedding worker (`embedding-worker.ts`) runs fastembed/ONNX inference
+ * in a separate `node:worker_threads` Worker so the main thread's event loop
+ * stays free during inference. This file defines the message protocol between
+ * the main thread (`LocalProvider` in `embedding.ts`) and the worker.
+ *
+ * Imported by both sides — keep this file free of runtime dependencies.
+ */
+/** Request an embedding batch. */
+export interface EmbedRequest {
+    type: "embed";
+    /** Monotonic request ID for correlating responses. */
+    id: number;
+    /** Texts to embed. */
+    texts: string[];
+    /** "document" for storage, "query" for search. */
+    inputType: "document" | "query";
+    /** "high" = recall queries (jump the queue), "normal" = backfill. */
+    priority: "high" | "normal";
+}
+/** Ask the worker to exit cleanly. */
+export interface ShutdownRequest {
+    type: "shutdown";
+}
+export type WorkerInbound = EmbedRequest | ShutdownRequest;
+/** Embedding result — vectors are Float32Array[], sent via structured clone. */
+export interface EmbedResult {
+    type: "result";
+    /** Matches the request ID. */
+    id: number;
+    /** One Float32Array per input text. Sent via structured clone
+     *  (Bun preserves Float32Array identity across threads). */
+    vectors: Float32Array[];
+}
+/** A single embed request failed (ONNX error, etc.). */
+export interface EmbedError {
+    type: "error";
+    /** Matches the request ID. */
+    id: number;
+    /** Human-readable error message. */
+    error: string;
+}
+/** Model initialization failed inside the worker. All pending and future
+ *  requests should be rejected — the worker is unusable. */
+export interface InitError {
+    type: "init-error";
+    /** Human-readable error message. */
+    error: string;
+}
+export type WorkerOutbound = EmbedResult | EmbedError | InitError;
+/** Passed to the worker via `workerData` at construction time. */
+export interface WorkerInitData {
+    /** fastembed model name, e.g. "BGESmallENV15". */
+    modelName: string;
+    /** Vendored model info for binary mode, or null for npm mode.
+     *  Mirrors the `globalThis.__LORE_VENDOR_MODEL__` registration which
+     *  only exists on the main thread — passed explicitly so the worker
+     *  can hand it to `FlagEmbedding.init()`. */
+    vendorModel: {
+        modelAbsoluteDirPath: string;
+        modelName: string;
+    } | null;
+}
+//# sourceMappingURL=embedding-worker-types.d.ts.map

package/dist/node/embedding-worker-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embedding-worker-types.d.ts","sourceRoot":"","sources":["../../src/embedding-worker-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAMH,kCAAkC;AAClC,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,OAAO,CAAC;IACd,sDAAsD;IACtD,EAAE,EAAE,MAAM,CAAC;IACX,sBAAsB;IACtB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,kDAAkD;IAClD,SAAS,EAAE,UAAU,GAAG,OAAO,CAAC;IAChC,qEAAqE;IACrE,QAAQ,EAAE,MAAM,GAAG,QAAQ,CAAC;CAC7B;AAED,sCAAsC;AACtC,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,UAAU,CAAC;CAClB;AAED,MAAM,MAAM,aAAa,GAAG,YAAY,GAAG,eAAe,CAAC;AAM3D,gFAAgF;AAChF,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,8BAA8B;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX;gEAC4D;IAC5D,OAAO,EAAE,YAAY,EAAE,CAAC;CACzB;AAED,wDAAwD;AACxD,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,OAAO,CAAC;IACd,8BAA8B;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,oCAAoC;IACpC,KAAK,EAAE,MAAM,CAAC;CACf;AAED;4DAC4D;AAC5D,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,YAAY,CAAC;IACnB,oCAAoC;IACpC,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,MAAM,cAAc,GAAG,WAAW,GAAG,UAAU,GAAG,SAAS,CAAC;AAMlE,kEAAkE;AAClE,MAAM,WAAW,cAAc;IAC7B,kDAAkD;IAClD,SAAS,EAAE,MAAM,CAAC;IAClB;;;iDAG6C;IAC7C,WAAW,EAAE;QAAE,oBAAoB,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;CACzE"}

package/dist/node/embedding-worker.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Embedding worker thread — runs fastembed/ONNX inference off the main thread.
+ *
+ * This file is the entry point for a `node:worker_threads` Worker spawned by
+ * `LocalProvider` in `embedding.ts`. It owns the `FlagEmbedding` ONNX model
+ * and processes embed requests sequentially from a priority queue. Moving
+ * inference here keeps the main thread's event loop free — HTTP requests,
+ * SSE streams, and session APIs are no longer blocked during embedding.
+ *
+ * Communication uses `parentPort` message passing with structured clone.
+ * Float32Array vectors are sent back directly (Bun preserves identity).
+ *
+ * @see embedding-worker-types.ts for the message protocol.
+ */
+export {};
+//# sourceMappingURL=embedding-worker.d.ts.map

package/dist/node/embedding-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embedding-worker.d.ts","sourceRoot":"","sources":["../../src/embedding-worker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG"}

package/dist/node/embedding-worker.js

@@ -0,0 +1,100 @@
+// src/embedding-worker.ts
+import { parentPort, workerData } from "node:worker_threads";
+var { modelName, vendorModel } = workerData;
+var model = null;
+var initPromise = null;
+var initFailed = false;
+var initError = null;
+async function ensureModel() {
+  if (model) return model;
+  if (initFailed) throw new Error(initError ?? "fastembed init previously failed");
+  if (!initPromise) {
+    initPromise = (async () => {
+      const fastembed = await import("fastembed");
+      const { EmbeddingModel, FlagEmbedding } = fastembed;
+      let m;
+      if (vendorModel) {
+        m = await FlagEmbedding.init({
+          model: EmbeddingModel.CUSTOM,
+          modelAbsoluteDirPath: vendorModel.modelAbsoluteDirPath,
+          modelName: vendorModel.modelName
+        });
+      } else {
+        const enumValue = EmbeddingModel[modelName];
+        m = await FlagEmbedding.init({
+          model: enumValue ?? modelName
+        });
+      }
+      model = m;
+    })().catch((err) => {
+      initFailed = true;
+      initError = err instanceof Error ? err.message : String(err);
+      initPromise = null;
+      post({ type: "init-error", error: initError });
+      throw err;
+    });
+  }
+  await initPromise;
+  if (!model) throw new Error("model init completed but model is null");
+  return model;
+}
+var queue = [];
+var processing = false;
+function enqueue(msg) {
+  if (msg.priority === "high") {
+    let insertAt = 0;
+    while (insertAt < queue.length && queue[insertAt].priority === "high") {
+      insertAt++;
+    }
+    queue.splice(insertAt, 0, msg);
+  } else {
+    queue.push(msg);
+  }
+  drain();
+}
+async function drain() {
+  if (processing) return;
+  processing = true;
+  while (queue.length > 0) {
+    const req = queue.shift();
+    await processEmbed(req);
+  }
+  processing = false;
+}
+async function processEmbed(req) {
+  try {
+    const m = await ensureModel();
+    let vectors;
+    if (req.inputType === "query" && req.texts.length === 1) {
+      const vec = await m.queryEmbed(req.texts[0]);
+      vectors = [new Float32Array(vec)];
+    } else {
+      vectors = [];
+      for await (const batch of m.passageEmbed(req.texts)) {
+        for (const vec of batch) {
+          vectors.push(new Float32Array(vec));
+        }
+      }
+    }
+    post({ type: "result", id: req.id, vectors });
+  } catch (err) {
+    if (!initFailed) {
+      const msg = err instanceof Error ? err.message : String(err);
+      post({ type: "error", id: req.id, error: msg });
+    }
+  }
+}
+function post(msg) {
+  parentPort.postMessage(msg);
+}
+parentPort.on("message", (msg) => {
+  switch (msg.type) {
+    case "embed":
+      enqueue(msg);
+      break;
+    case "shutdown":
+      process.exit(0);
+      break;
+  }
+});
+//# sourceMappingURL=embedding-worker.js.map

package/dist/node/embedding-worker.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/embedding-worker.ts"],
+  "sourcesContent": ["/**\n * Embedding worker thread \u2014 runs fastembed/ONNX inference off the main thread.\n *\n * This file is the entry point for a `node:worker_threads` Worker spawned by\n * `LocalProvider` in `embedding.ts`. It owns the `FlagEmbedding` ONNX model\n * and processes embed requests sequentially from a priority queue. Moving\n * inference here keeps the main thread's event loop free \u2014 HTTP requests,\n * SSE streams, and session APIs are no longer blocked during embedding.\n *\n * Communication uses `parentPort` message passing with structured clone.\n * Float32Array vectors are sent back directly (Bun preserves identity).\n *\n * @see embedding-worker-types.ts for the message protocol.\n */\n\nimport { parentPort, workerData } from \"node:worker_threads\";\nimport type {\n  WorkerInbound,\n  WorkerOutbound,\n  WorkerInitData,\n  EmbedRequest,\n} from \"./embedding-worker-types\";\n\n// ---------------------------------------------------------------------------\n// workerData\n// ---------------------------------------------------------------------------\n\nconst { modelName, vendorModel } = workerData as WorkerInitData;\n\n// ---------------------------------------------------------------------------\n// Model lifecycle \u2014 lazy init on first embed request\n// ---------------------------------------------------------------------------\n\n/** The fastembed model, typed to the subset of methods we use. */\ntype FastembedModel = {\n  queryEmbed(text: string): Promise<number[]>;\n  passageEmbed(texts: string[], batchSize?: number): AsyncGenerator<number[][]>;\n};\n\nlet model: FastembedModel | null = null;\nlet initPromise: Promise<void> | null = null;\nlet initFailed = false;\nlet initError: string | null = null;\n\n/**\n * Ensure the fastembed model is loaded. Lazy \u2014 first call triggers the\n * dynamic import + FlagEmbedding.init(), subsequent calls return immediately.\n * On failure, marks the worker as permanently broken and posts `init-error`.\n */\nasync function ensureModel(): Promise<FastembedModel> {\n  if (model) return model;\n  if (initFailed) throw new Error(initError ?? \"fastembed init previously failed\");\n\n  if (!initPromise) {\n    initPromise = (async () => {\n      const fastembed = await import(\"fastembed\");\n      const { EmbeddingModel, FlagEmbedding } = fastembed;\n\n      let m: unknown;\n      if (vendorModel) {\n        // Binary mode: use pre-extracted model files.\n        m = await FlagEmbedding.init({\n          model: EmbeddingModel.CUSTOM,\n          modelAbsoluteDirPath: vendorModel.modelAbsoluteDirPath,\n          modelName: vendorModel.modelName,\n        });\n      } else {\n        // npm mode: resolve model name against fastembed's enum.\n        const enumValue = (EmbeddingModel as Record<string, string>)[modelName];\n        m = await FlagEmbedding.init({\n          model: enumValue ?? modelName,\n        } as { model: typeof EmbeddingModel.BGESmallENV15 });\n      }\n      model = m as FastembedModel;\n    })().catch((err) => {\n      initFailed = true;\n      initError = err instanceof Error ? err.message : String(err);\n      initPromise = null;\n      // Notify main thread \u2014 all pending + future requests should fail.\n      post({ type: \"init-error\", error: initError });\n      throw err;\n    });\n  }\n\n  await initPromise;\n  if (!model) throw new Error(\"model init completed but model is null\");\n  return model;\n}\n\n// ---------------------------------------------------------------------------\n// Priority queue \u2014 high-priority (recall) jumps ahead of normal (backfill)\n// ---------------------------------------------------------------------------\n\nconst queue: EmbedRequest[] = [];\nlet processing = false;\n\n/**\n * Enqueue an embed request. High-priority requests are inserted after any\n * existing high-priority items but before all normal-priority items (FIFO\n * within each priority level). Triggers drain if not already running.\n */\nfunction enqueue(msg: EmbedRequest): void {\n  if (msg.priority === \"high\") {\n    // Insert after the last \"high\" item \u2014 keeps FIFO within high priority.\n    let insertAt = 0;\n    while (insertAt < queue.length && queue[insertAt].priority === \"high\") {\n      insertAt++;\n    }\n    queue.splice(insertAt, 0, msg);\n  } else {\n    queue.push(msg);\n  }\n  drain();\n}\n\n/**\n * Process queued requests one at a time. ONNX inference is synchronous\n * inside the NAPI call, so parallelism within the worker buys nothing.\n * The queue gives us a natural point to interleave high-priority requests\n * between normal-priority batches.\n */\nasync function drain(): Promise<void> {\n  if (processing) return;\n  processing = true;\n\n  while (queue.length > 0) {\n    const req = queue.shift()!;\n    await processEmbed(req);\n  }\n\n  processing = false;\n}\n\n// ---------------------------------------------------------------------------\n// Embed processing\n// ---------------------------------------------------------------------------\n\nasync function processEmbed(req: EmbedRequest): Promise<void> {\n  try {\n    const m = await ensureModel();\n\n    let vectors: Float32Array[];\n\n    if (req.inputType === \"query\" && req.texts.length === 1) {\n      // Single query \u2014 use queryEmbed for better quality.\n      const vec = await m.queryEmbed(req.texts[0]);\n      vectors = [new Float32Array(vec)];\n    } else {\n      // Batch document embedding via async generator.\n      vectors = [];\n      for await (const batch of m.passageEmbed(req.texts)) {\n        for (const vec of batch) {\n          vectors.push(new Float32Array(vec));\n        }\n      }\n    }\n\n    post({ type: \"result\", id: req.id, vectors });\n  } catch (err) {\n    // Don't re-post init-error \u2014 it was already sent in ensureModel().\n    if (!initFailed) {\n      const msg = err instanceof Error ? err.message : String(err);\n      post({ type: \"error\", id: req.id, error: msg });\n    }\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Message handling\n// ---------------------------------------------------------------------------\n\nfunction post(msg: WorkerOutbound): void {\n  parentPort!.postMessage(msg);\n}\n\nparentPort!.on(\"message\", (msg: WorkerInbound) => {\n  switch (msg.type) {\n    case \"embed\":\n      enqueue(msg);\n      break;\n    case \"shutdown\":\n      process.exit(0);\n      break;\n  }\n});\n"],
+  "mappings": ";AAeA,SAAS,YAAY,kBAAkB;AAYvC,IAAM,EAAE,WAAW,YAAY,IAAI;AAYnC,IAAI,QAA+B;AACnC,IAAI,cAAoC;AACxC,IAAI,aAAa;AACjB,IAAI,YAA2B;AAO/B,eAAe,cAAuC;AACpD,MAAI,MAAO,QAAO;AAClB,MAAI,WAAY,OAAM,IAAI,MAAM,aAAa,kCAAkC;AAE/E,MAAI,CAAC,aAAa;AAChB,mBAAe,YAAY;AACzB,YAAM,YAAY,MAAM,OAAO,WAAW;AAC1C,YAAM,EAAE,gBAAgB,cAAc,IAAI;AAE1C,UAAI;AACJ,UAAI,aAAa;AAEf,YAAI,MAAM,cAAc,KAAK;AAAA,UAC3B,OAAO,eAAe;AAAA,UACtB,sBAAsB,YAAY;AAAA,UAClC,WAAW,YAAY;AAAA,QACzB,CAAC;AAAA,MACH,OAAO;AAEL,cAAM,YAAa,eAA0C,SAAS;AACtE,YAAI,MAAM,cAAc,KAAK;AAAA,UAC3B,OAAO,aAAa;AAAA,QACtB,CAAmD;AAAA,MACrD;AACA,cAAQ;AAAA,IACV,GAAG,EAAE,MAAM,CAAC,QAAQ;AAClB,mBAAa;AACb,kBAAY,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG;AAC3D,oBAAc;AAEd,WAAK,EAAE,MAAM,cAAc,OAAO,UAAU,CAAC;AAC7C,YAAM;AAAA,IACR,CAAC;AAAA,EACH;AAEA,QAAM;AACN,MAAI,CAAC,MAAO,OAAM,IAAI,MAAM,wCAAwC;AACpE,SAAO;AACT;AAMA,IAAM,QAAwB,CAAC;AAC/B,IAAI,aAAa;AAOjB,SAAS,QAAQ,KAAyB;AACxC,MAAI,IAAI,aAAa,QAAQ;AAE3B,QAAI,WAAW;AACf,WAAO,WAAW,MAAM,UAAU,MAAM,QAAQ,EAAE,aAAa,QAAQ;AACrE;AAAA,IACF;AACA,UAAM,OAAO,UAAU,GAAG,GAAG;AAAA,EAC/B,OAAO;AACL,UAAM,KAAK,GAAG;AAAA,EAChB;AACA,QAAM;AACR;AAQA,eAAe,QAAuB;AACpC,MAAI,WAAY;AAChB,eAAa;AAEb,SAAO,MAAM,SAAS,GAAG;AACvB,UAAM,MAAM,MAAM,MAAM;AACxB,UAAM,aAAa,GAAG;AAAA,EACxB;AAEA,eAAa;AACf;AAMA,eAAe,aAAa,KAAkC;AAC5D,MAAI;AACF,UAAM,IAAI,MAAM,YAAY;AAE5B,QAAI;AAEJ,QAAI,IAAI,cAAc,WAAW,IAAI,MAAM,WAAW,GAAG;AAEvD,YAAM,MAAM,MAAM,EAAE,WAAW,IAAI,MAAM,CAAC,CAAC;AAC3C,gBAAU,CAAC,IAAI,aAAa,GAAG,CAAC;AAAA,IAClC,OAAO;AAEL,gBAAU,CAAC;AACX,uBAAiB,SAAS,EAAE,aAAa,IAAI,KAAK,GAAG;AACnD,mBAAW,OAAO,OAAO;AACvB,kBAAQ,KAAK,IAAI,aAAa,GAAG,CAAC;AAAA,QACpC;AAAA,MACF;AAAA,IACF;AAEA,SAAK,EAAE,MAAM,UAAU,IAAI,IAAI,IAAI,QAAQ,CAAC;AAAA,EAC9C,SAAS,KAAK;AAEZ,QAAI,CAAC,YAAY;AACf,YAAM,MAAM,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG;AAC3D,WAAK,EAAE,MAAM,SAAS,IAAI,IAAI,IAAI,OAAO,IAAI,CAAC;AAAA,IAChD;AAAA,EACF;AACF;AAMA,SAAS,KAAK,KAA2B;AACvC,aAAY,YAAY,GAAG;AAC7B;AAEA,WAAY,GAAG,WAAW,CAAC,QAAuB;AAChD,UAAQ,IAAI,MAAM;AAAA,IAChB,KAAK;AACH,cAAQ,GAAG;AACX;AAAA,IACF,KAAK;AACH,cAAQ,KAAK,CAAC;AACd;AAAA,EACJ;AACF,CAAC;",
+  "names": []
+}

package/dist/node/embedding.d.ts

@@ -11,19 +11,83 @@ export interface EmbeddingProvider {
     embed(texts: string[], inputType: "document" | "query"): Promise<Float32Array[]>;
     readonly maxBatchSize: number;
 }
-/** Reset cached provider — called when config changes. */
-export declare function resetProvider(): void;
+/**
+ * Thrown when `LocalProvider` is requested but `fastembed` cannot be loaded.
+ * `fastembed` is an optionalDependency of `@loreai/core`: if its postinstall
+ * fails (e.g. CUDA 13 hits the upstream `onnxruntime-node` bug — see #185),
+ * the package install still succeeds but local embeddings are disabled.
+ * Callers in `recall.ts` / `ltm.ts` / `distillation.ts` already gate on
+ * `isAvailable()`, which flips to `false` after this error fires once.
+ */
+export declare class LocalProviderUnavailableError extends Error {
+    constructor(cause?: unknown);
+}
+/** For tests: reset the fastembed probe cache. */
+export declare function _resetFastembedProbe(): void;
+/** For tests: simulate fastembed being unresolvable, without mocking the
+ *  dynamic import. After this call, `tryLoadFastembed()` short-circuits to
+ *  `null` and `isAvailable()` returns false for the local provider. */
+export declare function _markFastembedUnavailable(): void;
+/** Reset cached provider — called when config changes.
+ *  Shuts down the worker thread if the current provider is a LocalProvider.
+ *  Returns a promise that resolves once any worker has fully exited.
+ *  Callers that need clean teardown (tests) should await the result. */
+export declare function resetProvider(): Promise<void>;
+/** Shut down the current provider and prevent any new provider from being
+ *  created. After this call, `embed()` throws and `isAvailable()` returns
+ *  false. Test-only: prevents fire-and-forget embeds (queued by other test
+ *  files) from spawning a new worker after cleanup. */
+export declare function _shutdownAndDisable(): Promise<void>;
+/** Save the current cached provider reference (including the live worker)
+ *  and clear the cache so the next `getProvider()` call creates a fresh one.
+ *  Returns an opaque token that must be passed to `_restoreProvider()` to
+ *  put the original provider back — without this, the worker is orphaned and
+ *  a second ONNX load in the same Bun process will crash.
+ *
+ *  Test-only helper: lets suites temporarily swap in a mock/unavailable
+ *  provider without killing the real worker. */
+export declare function _saveAndClearProvider(): unknown;
+/** Restore a provider previously saved by `_saveAndClearProvider()`. Any
+ *  provider created between save and restore is discarded (callers must
+ *  ensure it's not a LocalProvider with a live worker — those suites only
+ *  use `_markFastembedUnavailable()` so no worker is spawned). */
+export declare function _restoreProvider(token: unknown): void;
+/**
+ * Build a remote `EmbeddingProvider` from whichever API key is in env.
+ * Returns `null` when neither `VOYAGE_API_KEY` nor `OPENAI_API_KEY` is set,
+ * which is the signal for callers to fall through to FTS-only behaviour.
+ *
+ * Voyage wins ties because it's the higher-quality option for code search;
+ * users who want OpenAI specifically can pin `search.embeddings.provider`
+ * in `.lore.json` and skip the fallback path entirely.
+ */
+export declare function pickRemoteFallback(): {
+    name: "voyage" | "openai";
+    provider: EmbeddingProvider;
+} | null;
 /** Returns true if embedding is available.
  *  Active when the configured provider's API key is set, unless explicitly
- *  disabled via `search.embeddings.enabled: false` in .lore.json. */
+ *  disabled via `search.embeddings.enabled: false` in .lore.json.
+ *
+ *  For the `local` provider, also returns false once we've discovered the
+ *  optional `fastembed` peer is missing — callers (recall, ltm, distillation)
+ *  use this gate to skip embedding work and fall back to FTS-only search. */
 export declare function isAvailable(): boolean;
 /**
  * Generate embeddings for the given texts using the configured provider.
  *
+ * If the configured provider is `local` and `fastembed` turns out to be
+ * unavailable at runtime (failed install, vendor extraction blocked, etc.),
+ * automatically swap to a remote provider when `VOYAGE_API_KEY` or
+ * `OPENAI_API_KEY` is set in env. The swap is permanent for the rest of
+ * the process — `cachedProvider` is replaced so subsequent calls skip the
+ * local-then-fail path.
+ *
  * @param texts     Array of texts to embed
  * @param inputType "document" for storage, "query" for search
  * @returns         Float32Array per input text
- * @throws          On API errors or missing provider
+ * @throws          On API errors or when no provider (local or remote) is
+ *                  available
  */
 export declare function embed(texts: string[], inputType: "document" | "query"): Promise<Float32Array[]>;
 /**
@@ -64,6 +128,24 @@ export declare function embedKnowledgeEntry(id: string, title: string, content:
  * The distillation remains searchable via FTS even if embedding fails.
  */
 export declare function embedDistillation(id: string, observations: string): void;
+/**
+ * Embed a temporal message and store the result in the DB.
+ * Fire-and-forget — errors are logged, never thrown.
+ * Only called for undistilled messages; once distilled, the embedding
+ * is NULLed (semantic content captured by distillation embedding).
+ */
+export declare function embedTemporalMessage(id: string, content: string): void;
+/**
+ * Search undistilled temporal messages with embeddings by cosine similarity.
+ * Returns top-k entries sorted by similarity descending.
+ *
+ * Only scans undistilled messages (distilled=0) — once a message is
+ * distilled, its semantic content is captured by the distillation
+ * embedding and the temporal embedding is cleared.
+ *
+ * Scoped to a single project. Optionally scoped to a single session.
+ */
+export declare function vectorSearchTemporal(queryEmbedding: Float32Array, projectId: string, limit?: number, sessionId?: string): VectorHit[];
 /**
  * Check if embedding config has changed since the last backfill.
  * If so, clear all existing embeddings (they're incompatible) and
@@ -77,10 +159,11 @@ export declare function checkConfigChange(): boolean;
  *
  * This is the canonical entry point that every host adapter (OpenCode, Pi,
  * future ACP) should call once during init. It:
- *   1. Detects config changes (provider swap) and clears stale embeddings
- *   2. Backfills knowledge entries missing embeddings
- *   3. Backfills non-archived distillations missing embeddings
- *   4. Logs a one-line coverage summary to stderr (always visible, not gated)
+ *   1. Waits a short grace period so first-connect HTTP requests can finish
+ *   2. Detects config changes (provider swap) and clears stale embeddings
+ *   3. Backfills knowledge entries missing embeddings
+ *   4. Backfills non-archived distillations missing embeddings
+ *   5. Logs a one-line coverage summary to stderr (always visible, not gated)
  *
  * Fire-and-forget: callers should `.catch()` — embedding failures must not
  * block plugin initialization.

package/dist/node/embedding.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"embedding.d.ts","sourceRoot":"","sources":["../../src/embedding.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAeH,MAAM,WAAW,iBAAiB;IAChC,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,SAAS,EAAE,UAAU,GAAG,OAAO,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CAAC;IACjF,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B;AAyPD,0DAA0D;AAC1D,wBAAgB,aAAa,IAAI,IAAI,CAEpC;AAMD;;qEAEqE;AACrE,wBAAgB,WAAW,IAAI,OAAO,CAErC;AAMD;;;;;;;GAOG;AACH,wBAAsB,KAAK,CACzB,KAAK,EAAE,MAAM,EAAE,EACf,SAAS,EAAE,UAAU,GAAG,OAAO,GAC9B,OAAO,CAAC,YAAY,EAAE,CAAC,CAIzB;AAMD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,GAAG,MAAM,CAazE;AAMD,8DAA8D;AAC9D,wBAAgB,MAAM,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAEhD;AAED,oEAAoE;AACpE,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,YAAY,CAGhE;AAMD,KAAK,SAAS,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpD;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,cAAc,EAAE,YAAY,EAC5B,KAAK,SAAK,GACT,SAAS,EAAE,CAcb;AAMD;;;;GAIG;AACH,wBAAgB,yBAAyB,CACvC,cAAc,EAAE,YAAY,EAC5B,KAAK,SAAK,GACT,SAAS,EAAE,CAgBb;AAMD;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,GACd,IAAI,CAWN;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,EAAE,EAAE,MAAM,EACV,YAAY,EAAE,MAAM,GACnB,IAAI,CAUN;AAkBD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAoC3C;AAMD;;;;;;;;;;;;GAYG;AACH,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC,CA0CxD;AAMD;;;;;;GAMG;AACH,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,MAAM,CAAC,CAuC1D;AAMD;;;;GAIG;AACH,wBAAsB,8BAA8B,IAAI,OAAO,CAAC,MAAM,CAAC,CAsCtE"}
+{"version":3,"file":"embedding.d.ts","sourceRoot":"","sources":["../../src/embedding.ts"],"names":[],"mappings":"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"}