@yugoo-design/dsh-design-knowledge-ladybug 0.1.0-beta.2 → 0.1.0-beta.8

package/lib/semantic-index-CigpMVTO.js

@@ -0,0 +1,599 @@
+import { n as embeddingDiagnosticSuffix, r as readEmbeddingDiagnostic } from "./embedding-diagnostic-CvIl3TWJ.js";
+import { createHash, randomUUID } from "node:crypto";
+import { copyFile, lstat, mkdir, open, rename } from "node:fs/promises";
+import { constants, createReadStream, existsSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { SEMANTIC_TEXT_VERSION, normalizeVector, semanticDigest, semanticEdges } from "@yugoo-design/dsh-design-core";
+import { lock } from "proper-lockfile";
+import { execFile, fork } from "node:child_process";
+import { homedir } from "node:os";
+import { promisify } from "node:util";
+import { EnvHttpProxyAgent, fetch as fetch$1 } from "undici";
+//#region src/embedding-model-assets.ts
+const run = promisify(execFile);
+const DEFAULT_EMBEDDING_ASSETS = {
+	model: "Xenova/multilingual-e5-small",
+	revision: "761b726dd34fb83930e26aab4e9ac3899aa1fa78",
+	files: [
+		{
+			path: "config.json",
+			bytes: 658,
+			hash: "4104f38273cc595fd9500fd243124e9f6cf383dc",
+			kind: "git-blob-sha1"
+		},
+		{
+			path: "tokenizer_config.json",
+			bytes: 443,
+			hash: "059214673d9d6d2ee319411e2ffec8c024b816d5",
+			kind: "git-blob-sha1"
+		},
+		{
+			path: "tokenizer.json",
+			bytes: 17082730,
+			hash: "0b44a9d7b51c3c62626640cda0e2c2f70fdacdc25bbbd68038369d14ebdf4c39",
+			kind: "sha256"
+		},
+		{
+			path: "onnx/model_quantized.onnx",
+			bytes: 118308185,
+			hash: "f80102d3f2a1229f387d3c81909990d8945513e347b0eab049f7de3c6f98c193",
+			kind: "sha256"
+		}
+	]
+};
+var EmbeddingAssetError = class extends Error {
+	code;
+	constructor(code) {
+		super(`Embedding resource preparation: ${code}`);
+		this.code = code;
+	}
+};
+const hasProcessProxy = (env) => (env.https_proxy ?? env.HTTPS_PROXY) !== void 0 || (env.http_proxy ?? env.HTTP_PROXY) !== void 0;
+const hasProcessBypass = (env) => (env.no_proxy ?? env.NO_PROXY) !== void 0;
+/** Pure projection; explicit process proxy configuration always wins. No env mutation. */
+function modelProxyOptions(platform, env, system = "") {
+	if (hasProcessProxy(env)) return void 0;
+	if (platform !== "darwin") return void 0;
+	const value = (key) => system.match(new RegExp(`^\\s*${key}\\s*:\\s*([^\\r\\n]+)`, "m"))?.[1]?.trim();
+	if (value("HTTPSEnable") !== "1") return void 0;
+	const host = value("HTTPSProxy"), port = Number(value("HTTPSPort"));
+	if (!host || !/^(?:[a-zA-Z0-9.-]+|[a-fA-F0-9:]+)$/.test(host) || !Number.isInteger(port) || port < 1 || port > 65535) throw new EmbeddingAssetError("download");
+	const noProxy = (system.match(/ExceptionsList\s*:\s*<array>\s*\{([^}]+)\}/)?.[1] ?? "").split("\n").map((line) => line.match(/^\s*\d+\s*:\s*(\S+)\s*$/)?.[1]).filter(Boolean).join(",");
+	return {
+		httpsProxy: `http://${host.includes(":") ? `[${host}]` : host}:${port}`,
+		...hasProcessBypass(env) ? {} : { noProxy }
+	};
+}
+async function systemProxyOptions(options = {}) {
+	const platform = options.platform ?? process.platform, env = options.env ?? process.env;
+	if (platform !== "darwin" || hasProcessProxy(env)) return void 0;
+	let system;
+	try {
+		system = options.readSystem ? await options.readSystem() : (await run("/usr/sbin/scutil", ["--proxy"], {
+			timeout: 3e3,
+			maxBuffer: 131072
+		})).stdout;
+	} catch {
+		throw new EmbeddingAssetError("download");
+	}
+	return modelProxyOptions(platform, env, system);
+}
+/** Private per-child environment; never persisted or returned through IPC/status. */
+async function embeddingChildEnvironment(options = {}) {
+	const env = options.env ?? process.env, proxy = await systemProxyOptions(options);
+	if (!proxy) return void 0;
+	return {
+		...env,
+		HTTPS_PROXY: proxy.httpsProxy,
+		...proxy.noProxy !== void 0 ? { NO_PROXY: proxy.noProxy } : {}
+	};
+}
+async function assetNetwork() {
+	const dispatcher = new EnvHttpProxyAgent(await systemProxyOptions());
+	return {
+		request: (async (url, init) => {
+			const response = await fetch$1(url, {
+				...init,
+				dispatcher,
+				redirect: "follow"
+			});
+			return {
+				status: response.status,
+				headers: response.headers,
+				body: response.body
+			};
+		}),
+		close: () => dispatcher.close()
+	};
+}
+async function size(path) {
+	try {
+		const value = await lstat(path);
+		if (!value.isFile() || value.isSymbolicLink()) throw new EmbeddingAssetError("integrity");
+		return value.size;
+	} catch (error) {
+		if (error.code === "ENOENT") return void 0;
+		throw error;
+	}
+}
+async function valid(path, asset) {
+	if (await size(path) !== asset.bytes) return false;
+	const hash = createHash(asset.kind === "git-blob-sha1" ? "sha1" : "sha256");
+	if (asset.kind === "git-blob-sha1") hash.update(`blob ${asset.bytes}\0`);
+	for await (const bytes of createReadStream(path)) hash.update(bytes);
+	return hash.digest("hex") === asset.hash;
+}
+/** Private resource preparation. No model/native session or Design text enters this path.
+* Download has its own bounded lifetime; the existing 180s inference budget is unchanged.
+* A failed pass keeps resumable staging bytes and never publishes a partial canonical file.
+*/
+async function prepareEmbeddingAssetSet(root, files, localOnly, options) {
+	if (files.some((file) => !/^[a-zA-Z0-9_.-]+(?:\/[a-zA-Z0-9_.-]+)*$/.test(file.path) || file.path.split("/").some((p) => p === "..") || !Number.isSafeInteger(file.bytes) || file.bytes < 1 || !["sha256", "git-blob-sha1"].includes(file.kind))) throw new EmbeddingAssetError("integrity");
+	options.signal.throwIfAborted();
+	await mkdir(root, { recursive: true });
+	const compromised = new AbortController();
+	let release;
+	let network;
+	try {
+		try {
+			release = await lock(root, {
+				retries: 0,
+				stale: 6e5,
+				update: 1e4,
+				onCompromised: () => compromised.abort()
+			});
+		} catch {
+			throw new EmbeddingAssetError("busy");
+		}
+		const signal = AbortSignal.any([
+			options.signal,
+			compromised.signal,
+			AbortSignal.timeout(6e5)
+		]);
+		for (const asset of files) {
+			signal.throwIfAborted();
+			const target = join(root, asset.path);
+			if (await valid(target, asset)) continue;
+			if (localOnly) throw new EmbeddingAssetError("missing");
+			await mkdir(dirname(target), { recursive: true });
+			const staged = target + ".yugoo-download.part";
+			let offset = await size(staged);
+			if (offset === void 0) {
+				const old = await size(target);
+				if (old !== void 0 && old > 0 && old < asset.bytes) {
+					await copyFile(target, staged, constants.COPYFILE_EXCL);
+					offset = old;
+				} else offset = 0;
+			}
+			if (offset >= asset.bytes) offset = 0;
+			if (!options.fetch) network ??= await assetNetwork();
+			const response = await (options.fetch ?? network.request)(options.baseUrl + "/" + asset.path, {
+				headers: offset ? { Range: `bytes=${offset}-` } : {},
+				signal
+			});
+			let received = offset;
+			let append = false;
+			if (offset && response.status === 206 && response.headers.get("content-range") === `bytes ${offset}-${asset.bytes - 1}/${asset.bytes}`) append = true;
+			else if (response.status === 200) received = 0;
+			else {
+				if (response.body) for await (const _ of response.body) break;
+				throw new EmbeddingAssetError("download");
+			}
+			if (!response.body) throw new EmbeddingAssetError("download");
+			const output = await open(staged, append ? "a" : "w");
+			try {
+				for await (const bytes of response.body) {
+					signal.throwIfAborted();
+					received += bytes.byteLength;
+					if (received > asset.bytes) throw new EmbeddingAssetError("integrity");
+					await output.writeFile(bytes);
+					options.progress?.(received, asset.bytes);
+				}
+				await output.sync();
+			} finally {
+				await output.close();
+			}
+			if (!await valid(staged, asset)) throw new EmbeddingAssetError("integrity");
+			signal.throwIfAborted();
+			if (await size(target) !== void 0) await copyFile(target, target + ".rejected-" + randomUUID(), constants.COPYFILE_EXCL);
+			await rename(staged, target);
+		}
+	} catch (error) {
+		if (options.signal.aborted) throw options.signal.reason;
+		if (error instanceof EmbeddingAssetError) throw error;
+		throw new EmbeddingAssetError("download");
+	} finally {
+		await network?.close();
+		await release?.();
+	}
+}
+async function prepareDefaultEmbeddingAssets(config, signal, progress) {
+	if (config.model !== DEFAULT_EMBEDDING_ASSETS.model || config.revision !== DEFAULT_EMBEDDING_ASSETS.revision) return;
+	await prepareEmbeddingAssetSet(join(config.cacheDir, config.model, config.revision), DEFAULT_EMBEDDING_ASSETS.files, config.localOnly, {
+		signal,
+		progress,
+		baseUrl: `https://huggingface.co/${config.model}/resolve/${config.revision}`
+	});
+}
+//#endregion
+//#region src/semantic-index.ts
+const localEmbeddingFailures = {
+	runtime: "本地 embedding 运行依赖不可用；请按当前操作系统安装依赖（包括原生模块），不要复用其他平台的 node_modules。",
+	model: "本地 embedding 模型加载失败；请检查固定版本模型缓存，离线模式需要先准备完整模型文件。",
+	inference: "本地 embedding 推理失败；请检查输入限制和本地内存、CPU 运行资源。"
+};
+const modelAssetFailures = {
+	missing: "本地 embedding 模型资源缺失或不完整；离线模式不能下载，请先准备固定版本资源。",
+	download: "本地 embedding 模型资源下载未完成；请检查网络及代理后显式重试，本次未开始模型加载。",
+	integrity: "本地 embedding 模型资源校验失败；完整性通过后才能加载，本次未发布语义索引。",
+	busy: "本地 embedding 模型资源正由另一进程准备；本次未开始模型加载，可在准备完成后重试。"
+};
+/** Disposable, project-local cache. Never stores Knowledge/GRA facts. */
+var MemorySemanticCache = class {
+	limit;
+	byteLimit;
+	values = /* @__PURE__ */ new Map();
+	bytes = 0;
+	constructor(limit = 300, byteLimit = 4e6) {
+		this.limit = limit;
+		this.byteLimit = byteLimit;
+		if (!Number.isSafeInteger(limit) || limit < 1 || !Number.isSafeInteger(byteLimit) || byteLimit < 1) throw new Error("Invalid volatile cache bounds");
+	}
+	async readSemanticCache(key) {
+		return this.values.get(key);
+	}
+	async writeSemanticCache(key, value) {
+		const size = Buffer.byteLength(key) + Buffer.byteLength(value);
+		if (size > this.byteLimit) return;
+		const old = this.values.get(key);
+		if (old !== void 0) {
+			this.bytes -= Buffer.byteLength(key) + Buffer.byteLength(old);
+			this.values.delete(key);
+		}
+		while (this.values.size && (this.values.size >= this.limit || this.bytes + size > this.byteLimit)) {
+			const [id, text] = this.values.entries().next().value;
+			this.values.delete(id);
+			this.bytes -= Buffer.byteLength(id) + Buffer.byteLength(text);
+		}
+		this.values.set(key, value);
+		this.bytes += size;
+	}
+};
+async function stopEmbeddingChild(worker) {
+	if (worker.exitCode !== null || worker.signalCode !== null) return;
+	await new Promise((resolveExit) => {
+		const timer = setTimeout(() => worker.kill("SIGKILL"), 2e3);
+		worker.once("exit", () => {
+			clearTimeout(timer);
+			resolveExit();
+		});
+		worker.kill("SIGTERM");
+	});
+}
+var DesignSemanticIndex = class {
+	idleMs;
+	config;
+	identity;
+	get publicationIdentity() {
+		return semanticDigest(this.identity + ":similarity-v1:" + this.config.threshold);
+	}
+	jobs = /* @__PURE__ */ new Map();
+	tail = Promise.resolve();
+	closed = false;
+	constructor(config = {}, idleMs = 3e5) {
+		this.idleMs = idleMs;
+		if (!Number.isSafeInteger(idleMs) || idleMs < 1) throw new Error("Invalid semantic idle timeout");
+		this.config = {
+			provider: "local",
+			model: "Xenova/multilingual-e5-small",
+			revision: "761b726dd34fb83930e26aab4e9ac3899aa1fa78",
+			cacheDir: resolve(homedir(), ".cache/design-system/embeddings"),
+			localOnly: false,
+			prefix: "query: ",
+			threshold: .8,
+			...config
+		};
+		if (![
+			"local",
+			"remote",
+			"disabled"
+		].includes(this.config.provider)) throw new Error("Unknown embedding provider");
+		if (!this.config.model || !this.config.revision || !isAbsolute(this.config.cacheDir)) throw new Error("Invalid embedding configuration");
+		if (!(this.config.threshold >= 0 && this.config.threshold <= 1)) throw new Error("Invalid semantic threshold");
+		if (this.config.provider === "remote") {
+			if (!this.config.endpoint || !config.model || !config.revision) throw new Error("Remote embedding requires explicit endpoint, model and revision");
+			const url = new URL(this.config.endpoint);
+			if (!["https:", "http:"].includes(url.protocol) || url.username || url.password) throw new Error("Invalid embedding endpoint");
+			if (url.protocol === "http:" && ![
+				"localhost",
+				"127.0.0.1",
+				"[::1]"
+			].includes(url.hostname)) throw new Error("Remote embedding requires HTTPS except loopback");
+		}
+		this.identity = semanticDigest(JSON.stringify({
+			provider: this.config.provider,
+			model: this.config.model,
+			revision: this.config.revision,
+			endpoint: this.config.endpoint,
+			prefix: this.config.prefix,
+			text: SEMANTIC_TEXT_VERSION,
+			pooling: "mean-token-windows-v1",
+			dtype: "q8",
+			engine: "transformers-3.8.1"
+		}));
+	}
+	read(project, graph, cache) {
+		const units = (graph.semanticUnits ?? []).map((unit) => ({
+			...unit,
+			fieldPointers: unit.fieldPointers?.slice()
+		}));
+		const snapshot = {
+			checkpoint: graph.checkpoint,
+			semanticUnits: units
+		};
+		const key = semanticDigest(graph.checkpoint + (graph.generation ?? "") + this.publicationIdentity + (cache ? "persistent" : "memory") + JSON.stringify(units.map((u) => [
+			u.id,
+			u.nodeId,
+			u.file,
+			u.pointer,
+			u.fieldPointers,
+			u.digest
+		])));
+		if (this.closed || this.config.provider === "disabled") return {
+			edges: [],
+			status: {
+				state: "disabled",
+				completed: 0,
+				total: units.length,
+				model: this.config.model
+			}
+		};
+		let job = this.jobs.get(project);
+		if (job?.key !== key) {
+			if (this.jobs.size >= 8 && !job) return {
+				edges: [],
+				status: {
+					state: "error",
+					completed: 0,
+					total: units.length,
+					model: this.config.model,
+					message: "语义索引同时最多处理8个项目。"
+				}
+			};
+			job?.abort.abort();
+			clearTimeout(job?.idle);
+			job = {
+				key,
+				status: {
+					state: "indexing",
+					completed: 0,
+					total: units.length,
+					model: this.config.model,
+					cache: cache ? "persistent" : "memory",
+					message: this.config.provider === "local" ? "本地索引准备中；首次可能下载模型，文本不上传" : "使用已配置远程 embedding 服务处理设计文本"
+				},
+				edges: [],
+				abort: new AbortController(),
+				memory: job?.memory ?? new MemorySemanticCache()
+			};
+			this.jobs.set(project, job);
+			const current = job;
+			this.tail = this.tail.catch(() => {}).then(async () => {
+				if (current.abort.signal.aborted) return;
+				try {
+					await this.build(snapshot, cache, current);
+				} catch (error) {
+					const phase = error?.embeddingFailure;
+					const detail = error instanceof EmbeddingAssetError ? modelAssetFailures[error.code] : phase && Object.hasOwn(localEmbeddingFailures, phase) ? localEmbeddingFailures[phase] : "语义索引失败；请检查本地运行资源或已配置的 embedding 服务。";
+					const diagnostic = embeddingDiagnosticSuffix(error?.embeddingDiagnostic);
+					if (!current.abort.signal.aborted) current.status = {
+						...current.status,
+						state: "error",
+						message: detail + " 保留结构图，不自动上传或重试。" + diagnostic
+					};
+				}
+			});
+			current.settled = this.tail;
+		}
+		clearTimeout(job.idle);
+		if (!job.waiters) {
+			job.idle = setTimeout(() => this.cancelProject(project), this.idleMs);
+			job.idle.unref();
+		}
+		return {
+			edges: job.edges,
+			status: { ...job.status }
+		};
+	}
+	/** Await the existing inference job for background persistence; no polling and
+	* no project write lock held during model execution. Partial edges never escape. */
+	async compute(project, graph, cache, signal) {
+		signal?.throwIfAborted();
+		const status = this.read(project, graph, cache);
+		const job = this.jobs.get(project);
+		if (!job || status.status.state === "disabled" || status.status.state === "error") throw new Error(status.status.message ?? "Semantic indexing unavailable");
+		clearTimeout(job.idle);
+		job.waiters = (job.waiters ?? 0) + 1;
+		let rejectAbort;
+		const cancelled = new Promise((_resolve, reject) => {
+			rejectAbort = reject;
+		});
+		const abort = () => rejectAbort(signal?.reason ?? /* @__PURE__ */ new Error("Semantic consumer cancelled"));
+		signal?.addEventListener("abort", abort, { once: true });
+		try {
+			signal?.throwIfAborted();
+			await Promise.race([job.settled, cancelled]);
+			signal?.throwIfAborted();
+			job.abort.signal.throwIfAborted();
+			if (this.jobs.get(project) !== job || job.status.state !== "ready") throw new Error(job.status.message ?? "Semantic indexing did not complete");
+			return {
+				edges: structuredClone(job.edges),
+				status: { ...job.status }
+			};
+		} finally {
+			signal?.removeEventListener("abort", abort);
+			job.waiters--;
+			if (!job.waiters && signal?.aborted && job.status.state === "indexing") job.abort.abort(signal.reason);
+			if (this.jobs.get(project) === job && !job.waiters) {
+				job.idle = setTimeout(() => this.cancelProject(project), this.idleMs);
+				job.idle.unref();
+			}
+		}
+	}
+	cancelProject(project) {
+		const job = this.jobs.get(project);
+		clearTimeout(job?.idle);
+		job?.abort.abort();
+		this.jobs.delete(project);
+	}
+	async close() {
+		this.closed = true;
+		for (const project of this.jobs.keys()) this.cancelProject(project);
+		await this.tail;
+	}
+	async prepareLocalAssets(job) {
+		await prepareDefaultEmbeddingAssets(this.config, job.abort.signal, (done, total) => {
+			job.status.message = `正在准备固定版本模型资源 ${done}/${total} 字节；设计文本不上传`;
+		});
+	}
+	async build(graph, cache, job) {
+		const units = graph.semanticUnits ?? [], vectors = [], missing = [];
+		const signal = job.abort.signal;
+		for (let i = 0; i < units.length; i++) {
+			signal.throwIfAborted();
+			const key = semanticDigest(this.identity + units[i].digest);
+			let value;
+			if (cache && job.status.cache === "persistent") try {
+				value = await cache.readSemanticCache(key);
+			} catch {
+				job.status.cache = "memory";
+			}
+			value ??= await job.memory.readSemanticCache(key);
+			if (value) try {
+				vectors[i] = normalizeVector(JSON.parse(value));
+				job.status.completed++;
+				continue;
+			} catch {}
+			missing.push(i);
+		}
+		let worker;
+		const kill = () => {
+			worker?.kill("SIGTERM");
+		};
+		signal.addEventListener("abort", kill, { once: true });
+		try {
+			if (missing.length && this.config.provider === "local") {
+				await this.prepareLocalAssets(job);
+				signal.throwIfAborted();
+				const built = new URL("./embedding-worker.js", import.meta.url);
+				const options = {
+					windowsHide: true,
+					execArgv: ["--max-old-space-size=512"],
+					stdio: [
+						"ignore",
+						"ignore",
+						"ignore",
+						"ipc"
+					],
+					env: await embeddingChildEnvironment()
+				};
+				worker = fork(existsSync(built) ? built : new URL("./embedding-worker.mjs", import.meta.url), [], options);
+			}
+			for (let start = 0; start < missing.length; start += 4) {
+				signal.throwIfAborted();
+				const indices = missing.slice(start, start + 4), texts = indices.map((i) => units[i].text);
+				const values = worker ? await this.localBatch(worker, texts, job) : await this.remoteBatch(texts, signal);
+				if (!Array.isArray(values) || values.length !== texts.length) throw new Error("Embedding batch count mismatch");
+				for (let offset = 0; offset < indices.length; offset++) {
+					signal.throwIfAborted();
+					const i = indices[offset], vector = normalizeVector(values[offset]);
+					vectors[i] = vector;
+					const key = semanticDigest(this.identity + units[i].digest), value = JSON.stringify(vector);
+					await job.memory.writeSemanticCache(key, value);
+					if (cache && job.status.cache === "persistent") try {
+						await cache.writeSemanticCache(key, value);
+					} catch {
+						job.status.cache = "memory";
+					}
+					job.status.completed++;
+				}
+			}
+			signal.throwIfAborted();
+			job.edges = semanticEdges(units, vectors, `${this.config.model}@${this.config.revision}/${this.identity.slice(0, 12)}`, graph.checkpoint, this.config.threshold);
+			job.status = {
+				...job.status,
+				state: "ready",
+				message: `${job.edges.length} 条跨文件语义候选；相似度不等于确认关系`
+			};
+		} finally {
+			signal.removeEventListener("abort", kill);
+			if (worker) await stopEmbeddingChild(worker);
+		}
+	}
+	localBatch(worker, texts, job) {
+		return new Promise((resolveBatch, reject) => {
+			const cleanup = () => {
+				clearTimeout(timer);
+				worker.off("message", message);
+				worker.off("error", failure);
+				worker.off("exit", failure);
+				job.abort.signal.removeEventListener("abort", failure);
+			};
+			const failure = () => {
+				cleanup();
+				reject(/* @__PURE__ */ new Error("Embedding worker stopped"));
+			};
+			const message = (data) => {
+				if (data.progress) {
+					job.status.message = data.progress;
+					return;
+				}
+				cleanup();
+				if (data.error || !data.vectors) reject(Object.assign(/* @__PURE__ */ new Error("Embedding worker failed"), {
+					embeddingFailure: data.error,
+					embeddingDiagnostic: readEmbeddingDiagnostic(data.diagnostic)
+				}));
+				else resolveBatch(data.vectors);
+			};
+			const timer = setTimeout(() => {
+				failure();
+				worker.kill("SIGTERM");
+			}, 18e4);
+			worker.on("message", message);
+			worker.once("error", failure);
+			worker.once("exit", failure);
+			job.abort.signal.addEventListener("abort", failure, { once: true });
+			if (job.abort.signal.aborted) {
+				failure();
+				return;
+			}
+			worker.send({
+				texts,
+				config: this.config
+			}, (error) => {
+				if (error) failure();
+			});
+		});
+	}
+	async remoteBatch(texts, signal) {
+		const response = await fetch(this.config.endpoint, {
+			method: "POST",
+			redirect: "error",
+			headers: {
+				"Content-Type": "application/json",
+				...this.config.apiKey ? { Authorization: `Bearer ${this.config.apiKey}` } : {}
+			},
+			body: JSON.stringify({
+				model: this.config.model,
+				input: texts.map((t) => this.config.prefix + t)
+			}),
+			signal: AbortSignal.any([signal, AbortSignal.timeout(6e4)])
+		});
+		if (!response.ok) throw new Error("Remote embedding request failed");
+		const data = await response.json();
+		if (!Array.isArray(data.data) || data.data.length !== texts.length || new Set(data.data.map((d) => d.index)).size !== texts.length || data.data.some((d) => !Number.isInteger(d.index) || d.index < 0 || d.index >= texts.length)) throw new Error("Invalid remote embedding response");
+		return data.data.sort((a, b) => a.index - b.index).map((d) => d.embedding);
+	}
+};
+//#endregion
+export { MemorySemanticCache as n, stopEmbeddingChild as r, DesignSemanticIndex as t };

package/lib/semantic-index.d.ts

@@ -55,6 +55,7 @@ declare class DesignSemanticIndex {
   }>;
   cancelProject(project: string): void;
   close(): Promise<void>;
+  private prepareLocalAssets;
   private build;
   private localBatch;
   private remoteBatch;