scream-code 0.18.7 → 0.18.8

package/dist/{src-CQwXASmd.mjs → src-ClB_Hzp9.mjs}

@@ -4,14 +4,14 @@ import { dirname as __cjsShimDirname } from 'node:path';
 const __filename = __cjsShimFileURLToPath(import.meta.url);
 const __dirname = __cjsShimDirname(__filename);
 import { createHash, randomBytes } from "node:crypto";
-import ro, { mkdir, readFile, readdir, rename, rm, rmdir, stat, unlink, writeFile } from "node:fs/promises";
+import ro, { mkdir, open, readFile, readdir, rename, rm, rmdir, stat, unlink, writeFile } from "node:fs/promises";
 import I from "fs";
 import Qr, { EventEmitter } from "events";
 import js, { dirname, parse } from "path";
 import { Buffer as Buffer$1 } from "buffer";
 import Cs from "node:stream";
-import Kt, { createReadStream, existsSync, mkdirSync, rmSync, statSync } from "node:fs";
-import path, { basename, join, posix, win32 } from "node:path";
+import Kt, { createReadStream, existsSync, mkdirSync, readFileSync, rmSync, statSync } from "node:fs";
+import path, { basename, join, posix, resolve, win32 } from "node:path";
 import { DatabaseSync } from "node:sqlite";
 import { EventEmitter as EventEmitter$1 } from "node:events";
 import { StringDecoder } from "node:string_decoder";
@@ -3531,7 +3531,7 @@ function buildEmbeddingText(memo) {
 */
 const engineCache = /* @__PURE__ */ new Map();
 /**
-* Create an embedding engine backed by fastembed.
+* Create an embedding engine backed by the in-process WASM pipeline.
 * Lazily loads the model on first use so startup is not blocked.
 * Engines are cached by cacheDir so repeated calls with the same cacheDir
 * return the same instance, sharing model state and download progress.
@@ -3539,21 +3539,22 @@ const engineCache = /* @__PURE__ */ new Map();
 *                 Defaults to "local_cache" (CWD-relative) if not provided — prefer
 *                 passing an explicit path so the cache doesn't duplicate across CWDs.
 */
-function createFastEmbedEngine(cacheDir) {
-	const key = cacheDir ?? "";
+function createEmbeddingEngine(cacheDir) {
+	const key = cacheDir === void 0 ? "" : resolve(cacheDir);
 	const cached = engineCache.get(key);
 	if (cached !== void 0) return cached;
-	const engine = createFastEmbedEngineImpl(cacheDir);
+	const engine = createEmbeddingEngineImpl(cacheDir);
 	engineCache.set(key, engine);
 	return engine;
 }
 /** Stable identity of the model used by every engine created here. */
 const EMBEDDING_MODEL_NAME = "bge-small-zh-v1.5";
-function createFastEmbedEngineImpl(cacheDir) {
+function createEmbeddingEngineImpl(cacheDir) {
 	let embedder = null;
 	let initPromise = null;
 	let loadFailed = false;
 	let lastError;
+	let progressListener;
 	return {
 		modelName: EMBEDDING_MODEL_NAME,
 		get available() {
@@ -3562,6 +3563,9 @@ function createFastEmbedEngineImpl(cacheDir) {
 		get lastError() {
 			return lastError;
 		},
+		setProgressListener(listener) {
+			progressListener = listener;
+		},
 		async embedBatch(texts) {
 			if (!this.available) return null;
 			if (texts.length === 0) return [];
@@ -3598,12 +3602,12 @@ function createFastEmbedEngineImpl(cacheDir) {
 				if (loadFailed || initPromise === null) {
 					loadFailed = false;
 					lastError = void 0;
-					initPromise = loadEmbedder(cacheDir);
+					initPromise = loadEmbeddingRuntime(cacheDir, (progress) => progressListener?.(progress));
 				}
 				embedder = await initPromise;
 				if (embedder === null) {
 					initPromise = null;
-					lastError = "fastembed returned an empty model";
+					lastError = "embedding runtime returned an empty session";
 					return false;
 				}
 				loadFailed = false;
@@ -3618,42 +3622,157 @@ function createFastEmbedEngineImpl(cacheDir) {
 		}
 	};
 }
-async function loadEmbedder(cacheDir) {
-	const { FlagEmbedding, EmbeddingModel } = await import("fastembed");
-	if (cacheDir !== void 0) {
-		mkdirSync(cacheDir, { recursive: true });
-		await ensureEmbeddingModelFiles(cacheDir);
-	}
-	const model = EmbeddingModel.BGESmallZH;
-	const initOpts = cacheDir !== void 0 ? {
-		model,
-		cacheDir
-	} : { model };
-	try {
-		return await FlagEmbedding.init(initOpts);
-	} catch (initError) {
-		const msg = initError instanceof Error ? initError.message : "";
-		if (!/Config file not found|Tokenizer file not found|Tokens map file not found/iu.test(msg)) throw initError;
-		await ensureFastembedModelSidecars(model, cacheDir);
-		return FlagEmbedding.init(initOpts);
+/** Maximum tokens per text; matches the model's position-embedding limit. */
+const MAX_SEQ_LEN = 512;
+/** Texts per inference batch: 16 × 512 × 512 floats ≈ 16MB of activations. */
+const EMBED_BATCH_SIZE = 16;
+/** Threads for the WASM backend. One keeps resolution deterministic in packaged
+*  builds; `SCREAM_CODE_EMBEDDING_THREADS=4` is the supported opt-in. */
+const EMBEDDING_THREADS_ENV = "SCREAM_CODE_EMBEDDING_THREADS";
+/**
+* Token-level truncation that keeps the sentence boundary tokens.
+*
+* The tokenizer package does not apply the truncation policy itself and the
+* model package ships no truncation config, so this is the only place it can
+* happen. Keeping the head (which starts with `[CLS]`) and re-appending the
+* trailing special token (`[SEP]`) mirrors what a HuggingFace pipeline would
+* produce; slicing the tail off blindly would feed the encoder a sentence that
+* never closes and drift from the reference vectors on long inputs.
+*/
+function truncateEncoded(ids, types) {
+	if (ids.length <= MAX_SEQ_LEN) return {
+		ids: [...ids],
+		types: [...types]
+	};
+	const headSize = MAX_SEQ_LEN - 1;
+	const head = ids.slice(0, headSize);
+	const headTypes = types.slice(0, headSize);
+	return {
+		ids: [...head, ids.at(-1)],
+		types: [...headTypes, types.at(-1)]
+	};
+}
+/**
+* Builds the embedding runtime in-process on `onnxruntime-web` (WASM) and the
+* pure-JS tokenizer. No native binaries, no install scripts: the whole stack is
+* JavaScript plus one WebAssembly artifact resolved from the package.
+*
+* The numeric pipeline is load-bearing and must stay compatible with the
+* reference embeddings of this model: token ids come from `tokenizer.json`, and
+* the sentence vector is the **CLS token** hidden state (`last_hidden_state[0]`)
+* followed by L2 normalization. Mean pooling produces visibly different vectors
+* (cosine ≈ 0.9 against the reference), so pooling is not a stylistic choice.
+*/
+async function createWasmRuntime(modelDir) {
+	const ort = await import("onnxruntime-web");
+	const { Tokenizer } = await import("@huggingface/tokenizers");
+	const requestedThreads = Number(process.env[EMBEDDING_THREADS_ENV]);
+	ort.env.wasm.numThreads = Number.isFinite(requestedThreads) && requestedThreads > 0 ? requestedThreads : 1;
+	ort.env.logLevel = "error";
+	const tokenizer = new Tokenizer(JSON.parse(readFileSync(join(modelDir, "tokenizer.json"), "utf8")), JSON.parse(readFileSync(join(modelDir, "tokenizer_config.json"), "utf8")));
+	const session = await ort.InferenceSession.create(readFileSync(join(modelDir, "model_optimized.onnx")), { executionProviders: ["wasm"] });
+	if (session === null || session === void 0) return null;
+	return { async *embed(textStrings) {
+		if (textStrings.length === 0) return;
+		const encoded = textStrings.map((text, index) => {
+			const encoding = tokenizer.encode(text, { return_token_type_ids: true });
+			const types = encoding.token_type_ids ?? encoding.ids.map(() => 0);
+			const truncated = truncateEncoded(encoding.ids, types);
+			return {
+				index,
+				ids: truncated.ids,
+				types: truncated.types
+			};
+		});
+		const results = Array.from({ length: textStrings.length });
+		const buckets = encoded.toSorted((a, b) => a.ids.length - b.ids.length);
+		for (let start = 0; start < buckets.length; start += EMBED_BATCH_SIZE) {
+			const group = buckets.slice(start, start + EMBED_BATCH_SIZE);
+			const rows = group.length;
+			const width = Math.max(...group.map((entry) => entry.ids.length));
+			const ids = new BigInt64Array(rows * width);
+			const mask = new BigInt64Array(rows * width);
+			const types = new BigInt64Array(rows * width);
+			group.forEach((entry, row) => {
+				for (let column = 0; column < width; column++) {
+					const offset = row * width + column;
+					ids[offset] = BigInt(column < entry.ids.length ? entry.ids[column] : 0);
+					mask[offset] = column < entry.ids.length ? 1n : 0n;
+					types[offset] = BigInt(column < entry.types.length ? entry.types[column] : 0);
+				}
+			});
+			const output = await session.run({
+				input_ids: new ort.Tensor("int64", ids, [rows, width]),
+				attention_mask: new ort.Tensor("int64", mask, [rows, width]),
+				token_type_ids: new ort.Tensor("int64", types, [rows, width])
+			});
+			const hidden = output["last_hidden_state"] ?? output[Object.keys(output)[0]];
+			const hiddenSize = hidden.dims.at(-1);
+			const data = hidden.data;
+			group.forEach((entry, row) => {
+				const rowStart = row * width * hiddenSize;
+				const vector = Array.from(data.subarray(rowStart, rowStart + hiddenSize));
+				let norm = 0;
+				for (const value of vector) norm += value * value;
+				norm = Math.sqrt(norm) || 1;
+				for (let i = 0; i < vector.length; i += 1) vector[i] = vector[i] / norm;
+				results[entry.index] = vector;
+			});
+		}
+		for (let start = 0; start < results.length; start += EMBED_BATCH_SIZE) yield results.slice(start, start + EMBED_BATCH_SIZE);
+	} };
+}
+async function loadEmbeddingRuntime(cacheDir, emit) {
+	if (cacheDir === void 0) {
+		emit?.({ phase: "load" });
+		return createWasmRuntime(join("local_cache", BGESMALLZH_CACHE_NAME));
 	}
+	mkdirSync(cacheDir, { recursive: true });
+	await ensureEmbeddingModelFiles(cacheDir, {
+		onProgress: (received, total) => {
+			emit?.(total === void 0 ? {
+				phase: "download",
+				received
+			} : {
+				phase: "download",
+				received,
+				total
+			});
+		},
+		onPhase: (phase) => {
+			if (phase === "verify") emit?.({ phase: "verify" });
+		}
+	});
+	emit?.({ phase: "load" });
+	return createWasmRuntime(join(cacheDir, BGESMALLZH_CACHE_NAME));
 }
 /**
-* Cache entry names fastembed uses for the fixed BGESmallZH model: it extracts
-* into `<cacheDir>/<name>/` from the staged archive `<cacheDir>/<name>.tar.gz`.
+* Cache entry name for the fixed BGESmallZH model: the staged archive extracts
+* to `<cacheDir>/<name>/` and the runtime loads from that directory.
 */
 const BGESMALLZH_CACHE_NAME = "fast-bge-small-zh-v1.5";
+/** Files the runtime needs before the model can be considered installed. */
+const EMBEDDING_REQUIRED_FILES = [
+	"model_optimized.onnx",
+	"tokenizer.json",
+	"tokenizer_config.json"
+];
 /** Escape hatch for air-gapped installs and tests: points at an archive file. */
 const EMBEDDING_MODEL_URL_ENV = "SCREAM_CODE_EMBEDDING_MODEL_URL";
-function modelWeightsPath(cacheDir) {
-	return join(cacheDir, BGESMALLZH_CACHE_NAME, "model_optimized.onnx");
+/** Default stall guards: a trickling connection must not spin a spinner forever. */
+const DEFAULT_IDLE_TIMEOUT_MS = 6e4;
+const DEFAULT_TOTAL_TIMEOUT_MS = 15 * 6e4;
+/** Progress callback throttle: frequent enough to move, rare enough to be free. */
+const PROGRESS_THROTTLE_MS = 100;
+function modelDirPath(cacheDir) {
+	return join(cacheDir, BGESMALLZH_CACHE_NAME);
 }
 function sha256File(filePath) {
 	return readFile(filePath).then((data) => createHash("sha256").update(data).digest("hex"));
 }
 /**
 * Stage the embedding model files when they are missing: download the pinned
-* archive (HTTP status verified — unlike fastembed's own downloader), extract,
+* archive (HTTP status verified, unlike a naive downloader), extract,
 * and verify the weights payload against the pinned sha256.
 *
 * A partially extracted tree or a hash mismatch is removed so the caller keeps
@@ -3663,62 +3782,149 @@ function sha256File(filePath) {
 async function ensureEmbeddingModelFiles(cacheDir, options) {
 	if (hasEmbeddingModelCache(cacheDir)) return;
 	mkdirSync(cacheDir, { recursive: true });
-	const modelDir = join(cacheDir, BGESMALLZH_CACHE_NAME);
+	const modelDir = modelDirPath(cacheDir);
 	const stagingPath = join(cacheDir, `${BGESMALLZH_CACHE_NAME}.tar.gz.part`);
 	const url = options?.sourceUrl ?? process.env[EMBEDDING_MODEL_URL_ENV] ?? "https://github.com/LIUTod/scream-code/releases/download/embedding-models-v1/fast-bge-small-zh-v1.5.tar.gz";
+	const idleTimeoutMs = options?.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS;
+	const totalTimeoutMs = options?.totalTimeoutMs ?? DEFAULT_TOTAL_TIMEOUT_MS;
+	const controller = new AbortController();
+	const onExternalAbort = () => {
+		controller.abort();
+	};
+	if (options?.signal !== void 0) if (options.signal.aborted) controller.abort();
+	else options.signal.addEventListener("abort", onExternalAbort, { once: true });
+	let idleTimer;
+	const armIdleTimer = () => {
+		if (idleTimer !== void 0) clearTimeout(idleTimer);
+		idleTimer = setTimeout(() => {
+			controller.abort();
+		}, idleTimeoutMs);
+	};
+	const totalTimer = setTimeout(() => {
+		controller.abort();
+	}, totalTimeoutMs);
+	let received = 0;
+	let announcedTotal;
+	let downloadCompleted = false;
+	const announceProgress = () => {
+		options?.onProgress?.(received, announcedTotal);
+	};
 	try {
 		let response;
 		try {
-			response = await fetch(url);
+			armIdleTimer();
+			response = await fetch(url, { signal: controller.signal });
 		} catch (error) {
 			const message = error instanceof Error ? error.message : String(error);
 			throw new Error(`fetch failed for ${url}: ${message}`, { cause: error });
 		}
 		if (!response.ok) throw new Error(`model source returned HTTP ${response.status} for ${url}`);
-		await writeFile(stagingPath, Buffer.from(await response.arrayBuffer()));
+		const contentLength = Number(response.headers.get("content-length"));
+		announcedTotal = Number.isFinite(contentLength) && contentLength > 0 ? contentLength : void 0;
+		announceProgress();
+		const body = response.body;
+		if (body === null) throw new Error(`model source returned an empty body for ${url}`);
+		const reader = body.getReader();
+		const abortRejection = new Promise((_, reject) => {
+			if (controller.signal.aborted) {
+				reject(/* @__PURE__ */ new Error("aborted"));
+				return;
+			}
+			controller.signal.addEventListener("abort", () => {
+				reject(/* @__PURE__ */ new Error("aborted"));
+			}, { once: true });
+		});
+		const abortAwareRead = () => Promise.race([reader.read(), abortRejection]);
+		let handle;
+		try {
+			handle = await open(stagingPath, "w");
+		} catch (error) {
+			await reader.cancel().catch(() => void 0);
+			throw error;
+		}
+		let lastProgressAt = 0;
+		try {
+			await (async () => {
+				for (;;) {
+					let chunk;
+					try {
+						chunk = await abortAwareRead();
+					} catch (error) {
+						const message = error instanceof Error ? error.message : String(error);
+						throw new Error(`${message} (received ${received} of ${announcedTotal ?? "?"} bytes): ${url}`, { cause: error });
+					}
+					if (chunk.done) break;
+					const bytes = chunk.value;
+					armIdleTimer();
+					await handle.write(bytes);
+					received += bytes.byteLength;
+					const now = Date.now();
+					if (now - lastProgressAt >= PROGRESS_THROTTLE_MS) {
+						lastProgressAt = now;
+						announceProgress();
+					}
+				}
+				announceProgress();
+				downloadCompleted = true;
+			})();
+		} finally {
+			if (idleTimer !== void 0) clearTimeout(idleTimer);
+			await handle.close();
+			await reader.cancel().catch(() => void 0);
+		}
+		options?.onPhase?.("verify");
 		await So({
 			file: stagingPath,
 			cwd: cacheDir
 		});
-		const weightsPath = modelWeightsPath(cacheDir);
-		if (!existsSync(weightsPath) || statSync(weightsPath).size === 0) throw new Error(`model package did not contain weights after extraction: ${url}`);
-		const sha256 = await sha256File(weightsPath);
+		for (const fileName of EMBEDDING_REQUIRED_FILES) {
+			const target = join(modelDir, fileName);
+			if (!existsSync(target) || statSync(target).size === 0) throw new Error(`model package is missing ${fileName} after extraction: ${url}`);
+		}
+		const sha256 = await sha256File(join(modelDir, "model_optimized.onnx"));
 		const expected = options?.expectedOnnxSha256 ?? "1294ea4b6331115a353d81f96b85e8c8d7fdcc284453d5b2fab5b016230aad38";
 		if (sha256 !== expected) throw new Error(`model weights sha256 mismatch (${sha256.slice(0, 12)}… != ${expected.slice(0, 12)}…): ${url}`);
 	} catch (error) {
-		rmSync(modelDir, {
-			recursive: true,
-			force: true
-		});
-		throw error instanceof Error ? error : new Error(String(error));
+		try {
+			rmSync(modelDir, {
+				recursive: true,
+				force: true
+			});
+		} catch {}
+		if (!downloadCompleted && controller.signal.aborted && !(options?.signal?.aborted ?? false)) throw new Error(`model download timed out (received ${received} of ${announcedTotal ?? "?"} bytes): ${url}`, { cause: error });
+		throw error instanceof Error ? error : new Error(String(error), { cause: error });
 	} finally {
+		clearTimeout(totalTimer);
+		if (idleTimer !== void 0) clearTimeout(idleTimer);
+		if (options?.signal !== void 0) options.signal.removeEventListener("abort", onExternalAbort);
 		rmSync(stagingPath, { force: true });
 	}
 }
-const PLATFORM_FAILURE = /@anush008\/tokenizers|Failed to load native binding|Unsupported (?:OS|platform|architecture)|ERR_DLOPEN_FAILED|invalid ELF header|Exec format error|is not a valid Win32 application|GLIBC_\d+[^"\n]*not found|Error loading shared library|cannot open shared object file/iu;
-const ARCHIVE_FAILURE = /\bTAR_[A-Z_]+|incorrect header check|unexpected end of file|invalid tar|zlib/iu;
-const NETWORK_FAILURE = /\b(?:ENOTFOUND|EAI_AGAIN|ETIMEDOUT|ECONNRESET|ECONNREFUSED|EHOSTUNREACH|socket hang up|fetch failed)\b|network error|HTTP \d{3}/iu;
+const INSTALL_FAILURE = /Cannot find (?:package|module) '(?:onnxruntime-web|@huggingface\/tokenizers)'|ERR_MODULE_NOT_FOUND|Failed to resolve module specifier/iu;
+const ARCHIVE_FAILURE = /\bTAR_[A-Z_]+|incorrect header check|unexpected end of file|invalid tar|zlib|after extraction|sha256 mismatch/iu;
+const NETWORK_FAILURE = /\b(?:ENOTFOUND|EAI_AGAIN|ETIMEDOUT|ECONNRESET|ECONNREFUSED|EHOSTUNREACH|socket hang up|fetch failed)\b|network error|HTTP \d{3}|timed out|empty body/iu;
 /**
-* Classify a load failure so callers can say something true about it: the four
-* causes need four different answers (unsupported platform, corrupt cache,
-* network, unknown), and they used to be reported as one network problem.
+* Classify a load failure so callers can say something true about it: an
+* incomplete install, a corrupt cache, a network problem and anything else need
+* four different answers, and they used to be reported as one network problem.
 */
 function classifyEmbeddingFailure(message) {
 	if (message === void 0) return "other";
-	if (PLATFORM_FAILURE.test(message)) return "platform";
+	if (INSTALL_FAILURE.test(message)) return "install";
 	if (ARCHIVE_FAILURE.test(message)) return "archive";
 	if (NETWORK_FAILURE.test(message)) return "network";
 	return "other";
 }
 /**
-* Loads only the module entry point — no model download — so callers can tell
-* "this machine cannot run the local model at all" apart from "the download
-* failed". fastembed imports its native tokenizer binding at module scope, which
-* is exactly the step a platform without a published binary cannot pass.
+* Loads both runtime packages — no model download — so callers can tell "this
+* installation cannot run the local model at all" apart from "the download
+* failed". The runtime is JavaScript plus WebAssembly, so a failure here is an
+* incomplete installation rather than an unsupported platform.
 */
 async function probeLocalEmbeddingSupport() {
 	try {
-		await import("fastembed");
+		await import("onnxruntime-web");
+		await import("@huggingface/tokenizers");
 		return { supported: true };
 	} catch (error) {
 		return {
@@ -3729,15 +3935,11 @@ async function probeLocalEmbeddingSupport() {
 }
 /**
 * Remove every trace of a previous BGESmallZH download: the extracted model
-* directory *and* the staged archive it came from.
+* directory and the legacy staged archive name.
 *
-* The archive has to go with it. fastembed skips the download whenever
-* `<cacheDir>/<name>.tar.gz` exists, and it only deletes that file after a
-* *successful* extract — its download error paths (response error, file stream
-* error) reject and leave whatever was written behind. So an archive sitting
-* next to a failed attempt is usually a partial leftover, and keeping it makes
-* every retry extract the same junk locally: no network traffic, a few
-* milliseconds, the same failure forever.
+* The legacy `<name>.tar.gz` file is still swept because older versions staged
+* the archive under that name; leaving it behind would waste 55MB per doomed
+* attempt. Our own downloader stages `.tar.gz.part` and always removes it.
 *
 * Never throws: a file locked by another process (on Windows a mapped ONNX file
 * stays locked) must not replace the download error the caller is reporting.
@@ -3755,48 +3957,19 @@ function clearEmbeddingModelCache(cacheDir) {
 	}
 }
 /**
-* True when the extracted model weights are already on disk. Loading then
-* never downloads (fastembed skips the fetch whenever the model dir exists),
-* so callers can safely trigger a local load without risking a surprise
-* mid-query download.
+* True when every file the runtime needs is already on disk. Loading then never
+* downloads, so callers can safely trigger a local load without risking a
+* surprise mid-query download. All required files are checked (not just the
+* weights): a partially restored cache must count as missing so the setup flow
+* repairs it instead of failing at load time.
 */
 function hasEmbeddingModelCache(cacheDir) {
-	const modelDir = join(cacheDir, BGESMALLZH_CACHE_NAME);
-	return existsSync(modelDir) && existsSync(join(modelDir, "model_optimized.onnx"));
-}
-/**
-* Small config/tokenizer files that fastembed expects alongside model.onnx.
-* If these are missing (e.g. GCS download partially failed), fastembed throws.
-* We download them from HuggingFace so the model can load — this covers the
-* case where the GCS tarball was incomplete but the HF repo is reachable.
-*/
-const FASTEMBED_SIDECARS = [
-	"config.json",
-	"tokenizer.json",
-	"tokenizer_config.json",
-	"special_tokens_map.json"
-];
-const FASTEMBED_HF_REPOS = { "fast-bge-small-zh-v1.5": "BAAI/bge-small-zh-v1.5" };
-async function ensureFastembedModelSidecars(model, cacheDir) {
-	const repo = FASTEMBED_HF_REPOS[model];
-	if (repo === void 0) return;
-	const modelDir = join(cacheDir ?? "local_cache", model);
-	mkdirSync(modelDir, { recursive: true });
-	for (const fileName of FASTEMBED_SIDECARS) {
+	const modelDir = modelDirPath(cacheDir);
+	if (!existsSync(modelDir)) return false;
+	return EMBEDDING_REQUIRED_FILES.every((fileName) => {
 		const target = join(modelDir, fileName);
-		try {
-			const { access } = await import("node:fs/promises");
-			await access(target);
-			continue;
-		} catch {}
-		const hfUrl = `https://huggingface.co/${repo}/resolve/main/${fileName}`;
-		try {
-			const response = await fetch(hfUrl);
-			if (!response.ok) continue;
-			const { writeFile } = await import("node:fs/promises");
-			await writeFile(target, Buffer.from(await response.arrayBuffer()));
-		} catch {}
-	}
+		return existsSync(target) && statSync(target).size > 0;
+	});
 }
 //#endregion
 //#region ../../packages/memory/src/store.ts
@@ -5977,7 +6150,7 @@ function entryFor(homeDir) {
 				await store.init();
 				const cacheDir = join$1(homeDir, "cache", "fastembed");
 				mkdirSync(cacheDir, { recursive: true });
-				store.setEmbeddingEngine(createFastEmbedEngine(cacheDir));
+				store.setEmbeddingEngine(createEmbeddingEngine(cacheDir));
 			} catch (error) {
 				entries.delete(homeDir);
 				throw error;
@@ -5994,7 +6167,7 @@ function entryFor(homeDir) {
 *
 * The map key is the raw homeDir string so the engine cache key
 * join(homeDir, 'cache', 'fastembed') stays byte-identical with every other
-* createFastEmbedEngine call site: same string → same engine instance.
+* createEmbeddingEngine call site: same string → same engine instance.
 */
 function sharedKnowledgeStore(homeDir) {
 	return entryFor(homeDir).store;
@@ -6008,7 +6181,7 @@ function sharedKnowledgeStoreReady(homeDir) {
 const HEADING_RE = /^(#{1,6})\s+(.+?)\s*$/;
 const CODE_FENCE_RE = /^(\s*)(`{3,}|~{3,})/;
 /**
-* Soft cap on chunk token count. BGE-small-zh-v1.5 (the fastembed model used
+* Soft cap on chunk token count. BGE-small-zh-v1.5 (the embedding model used
 * here) has a 512-token sequence limit; chunks longer than that get truncated
 * at the embedding layer, hurting retrieval quality. We split at ~480 to leave
 * headroom for the heading line that gets prepended at embed time.
@@ -7254,4 +7427,4 @@ async function chunkVectorFallback(store, queryVec, topK) {
 	return results;
 }
 //#endregion
-export { sharedMemoStore as A, buildProjectTagCloud as B, applyConsolidation as C, parseMemoryMemos as D, buildExitExtractionPrompt as E, probeLocalEmbeddingSupport as F, join$1 as G, basename$1 as H, createMemoryMemo as I, relative$1 as J, normalize as K, toSummary as L, clearEmbeddingModelCache as M, createFastEmbedEngine as N, stripMemoryTags as O, hasEmbeddingModelCache as P, generateTags as R, DreamTracker as S, EXIT_EXTRACTION_SYSTEM_PROMPT as T, dirname$2 as U, rankMemos as V, isAbsolute$1 as W, resolve$1 as Y, splitLargeSection as _, isSupportedFile as a, sharedKnowledgeStoreReady as b, buildExtractionUserPrompt as c, extractQueryEntities as d, parseExtractionResponse as f, estimateTokens as g, chunkText as h, ingestFile as i, classifyEmbeddingFailure as j, MemoryMemoStore as k, extractEventFromChunk as l, chunkMarkdown as m, multiSearchWithTrace as n, ENTITY_TYPES as o, rerankEventsWithLlm as p, parse$1 as q, ingestDirectory as r, EXTRACTION_SYSTEM_PROMPT as s, multiSearch as t, extractJsonFromText as u, stripMarkdown as v, buildConsolidationPlan as w, KnowledgeStore as x, sharedKnowledgeStore as y, normalizeTags as z };
+export { sharedMemoStore as A, buildProjectTagCloud as B, applyConsolidation as C, parseMemoryMemos as D, buildExitExtractionPrompt as E, probeLocalEmbeddingSupport as F, join$1 as G, basename$1 as H, createMemoryMemo as I, relative$1 as J, normalize as K, toSummary as L, clearEmbeddingModelCache as M, createEmbeddingEngine as N, stripMemoryTags as O, hasEmbeddingModelCache as P, generateTags as R, DreamTracker as S, EXIT_EXTRACTION_SYSTEM_PROMPT as T, dirname$2 as U, rankMemos as V, isAbsolute$1 as W, resolve$1 as Y, splitLargeSection as _, isSupportedFile as a, sharedKnowledgeStoreReady as b, buildExtractionUserPrompt as c, extractQueryEntities as d, parseExtractionResponse as f, estimateTokens as g, chunkText as h, ingestFile as i, classifyEmbeddingFailure as j, MemoryMemoStore as k, extractEventFromChunk as l, chunkMarkdown as m, multiSearchWithTrace as n, ENTITY_TYPES as o, rerankEventsWithLlm as p, parse$1 as q, ingestDirectory as r, EXTRACTION_SYSTEM_PROMPT as s, multiSearch as t, extractJsonFromText as u, stripMarkdown as v, buildConsolidationPlan as w, KnowledgeStore as x, sharedKnowledgeStore as y, normalizeTags as z };

package/dist/{src-ChTWl9Cn.mjs → src-DA34cXSv.mjs}

@@ -3,5 +3,5 @@ import { fileURLToPath as __cjsShimFileURLToPath } from 'node:url';
 import { dirname as __cjsShimDirname } from 'node:path';
 const __filename = __cjsShimFileURLToPath(import.meta.url);
 const __dirname = __cjsShimDirname(__filename);
-import { n as multiSearchWithTrace } from "./src-CQwXASmd.mjs";
+import { n as multiSearchWithTrace } from "./src-ClB_Hzp9.mjs";
 export { multiSearchWithTrace };

package/dist/{text-input-dialog-D7dm6kak.mjs → text-input-dialog-CFRUSCi6.mjs}

@@ -3,5 +3,5 @@ import { fileURLToPath as __cjsShimFileURLToPath } from 'node:url';
 import { dirname as __cjsShimDirname } from 'node:path';
 const __filename = __cjsShimFileURLToPath(import.meta.url);
 const __dirname = __cjsShimDirname(__filename);
-import { t as TextInputDialogComponent } from "./text-input-dialog-gDr3i7xz.mjs";
+import { t as TextInputDialogComponent } from "./text-input-dialog-DHDsHCqR.mjs";
 export { TextInputDialogComponent };