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

package/lib/dsh-plugin.d.ts

@@ -0,0 +1,2 @@
+import { a as name, i as inject, n as LADYBUG_WASM_PROVIDER_ID, r as apply, t as Config } from "./dsh-plugin-BPwDtoBY.js";
+export { Config, LADYBUG_WASM_PROVIDER_ID, apply, inject, name };

package/lib/dsh-plugin.js

@@ -0,0 +1,3 @@
+import { i as name, n as apply, r as inject, t as LADYBUG_WASM_PROVIDER_ID } from "./dsh-plugin-C0TG9tJI.js";
+import "./semantic-index.js";
+export { LADYBUG_WASM_PROVIDER_ID, apply, inject, name };

package/lib/embedding-worker.js

@@ -0,0 +1,80 @@
+//#region src/embedding-text.mjs
+/** Exact tokenizer windows. Preserve every character; never silently truncate evidence. */
+function embeddingWindows(text, prefix, tokenizer, limit = 512, maxParts = 32) {
+	const pending = [text], result = [];
+	while (pending.length) {
+		const content = pending.pop(), input = prefix + content, tokens = tokenizer.encode(input).length;
+		if (tokens <= limit) {
+			result.push({
+				input,
+				content,
+				tokens
+			});
+			continue;
+		}
+		const chars = Array.from(content);
+		if (chars.length < 2 || result.length + pending.length + 2 > maxParts) throw new Error("Embedding text exceeds bounded tokenizer windows");
+		const middle = Math.floor(chars.length / 2);
+		pending.push(chars.slice(middle).join(""), chars.slice(0, middle).join(""));
+	}
+	return result;
+}
+function combineEmbeddingWindows(vectors, windows) {
+	if (!vectors.length || vectors.length !== windows.length) throw new Error("Embedding window count mismatch");
+	const sum = Array(vectors[0].length).fill(0);
+	for (let i = 0; i < vectors.length; i++) for (let j = 0; j < sum.length; j++) sum[j] += vectors[i][j] * windows[i].tokens;
+	const norm = Math.hypot(...sum);
+	if (!Number.isFinite(norm) || norm < 1e-12) throw new Error("Invalid combined embedding");
+	return sum.map((x) => x / norm);
+}
+//#endregion
+//#region src/embedding-worker.mjs
+let extractor;
+process.on("disconnect", () => process.exit(0));
+process.on("message", async ({ texts, config }) => {
+	let phase = "runtime";
+	try {
+		const { pipeline, env } = await import("@huggingface/transformers");
+		if (process.env.HTTPS_PROXY || process.env.HTTP_PROXY || process.env.https_proxy || process.env.http_proxy) {
+			const { EnvHttpProxyAgent, setGlobalDispatcher } = await import("undici");
+			setGlobalDispatcher(new EnvHttpProxyAgent());
+		}
+		env.backends.onnx.wasm.numThreads = 1;
+		phase = "model";
+		env.cacheDir = config.cacheDir;
+		env.allowRemoteModels = !config.localOnly;
+		extractor ??= await pipeline("feature-extraction", config.model, {
+			revision: config.revision,
+			dtype: "q8",
+			device: "cpu",
+			session_options: {
+				intraOpNumThreads: 2,
+				interOpNumThreads: 1
+			},
+			progress_callback: (info) => {
+				if (info.status === "download") process.send?.({ progress: config.localOnly ? "正在加载本地模型文件；离线模式，设计文本不上传" : "正在准备模型文件（首次可能下载）；设计文本不上传" });
+			}
+		});
+		phase = "inference";
+		const groups = texts.map((text) => embeddingWindows(text, config.prefix, extractor.tokenizer));
+		const windows = groups.flat(), vectors = [];
+		for (let start = 0; start < windows.length; start += 4) {
+			const result = await extractor(windows.slice(start, start + 4).map((w) => w.input), {
+				pooling: "mean",
+				normalize: true,
+				truncation: false
+			});
+			vectors.push(...result.tolist());
+		}
+		let offset = 0;
+		process.send?.({ vectors: groups.map((group) => {
+			const result = combineEmbeddingWindows(vectors.slice(offset, offset + group.length), group);
+			offset += group.length;
+			return result;
+		}) });
+	} catch {
+		process.send?.({ error: phase });
+	}
+});
+//#endregion
+export {};

package/lib/index.d.ts

@@ -0,0 +1,63 @@
+import { a as name, c as resolveLadybugKnowledgeConfig, i as inject, n as LADYBUG_WASM_PROVIDER_ID, o as LadybugKnowledgeConfig, r as apply, s as LadybugKnowledgeConfigInput, t as Config } from "./dsh-plugin-BPwDtoBY.js";
+import { DesignSemanticIndex } from "./semantic-index.js";
+import { DesignKnowledgeArchive, DesignKnowledgeDecision, DesignKnowledgeDelta, DesignKnowledgeImpactRequest, DesignKnowledgeImportReport, DesignKnowledgeMutationResult, DesignKnowledgeProposal, DesignKnowledgeProposalBatch, DesignKnowledgeProposalBatchResult, DesignKnowledgeQuery, DesignKnowledgeQueryResult, DesignKnowledgeRevision, DesignKnowledgeService, DesignKnowledgeTraceRequest, DesignKnowledgeTraceResult, DesignProjectId } from "@yugoo-design/dsh-design-core";
+//#region src/provider.d.ts
+/** Current on-disk schema accepted by the provider. */
+declare const LADYBUG_KNOWLEDGE_SCHEMA_VERSION = 2;
+/** The per-project cross-process owner could not be acquired. */
+declare class LadybugProjectLockError extends Error {
+  readonly databasePath: string;
+  constructor(databasePath: string, options?: ErrorOptions);
+}
+/** The bounded serialized-writer acquisition budget was exhausted. */
+declare class LadybugWriterBusyError extends Error {
+  readonly attempts: number;
+  constructor(attempts: number);
+}
+/** Existing durable bytes do not identify the requested project and schema. */
+declare class LadybugSchemaMismatchError extends Error {
+  readonly databasePath: string;
+  constructor(databasePath: string, detail: string, options?: ErrorOptions);
+}
+interface LadybugRecoveryState {
+  state: 'rebuilding' | 'ready' | 'error';
+  message: string;
+  generation?: string;
+}
+interface LadybugRecoveryOptions {
+  retryFailed?: boolean;
+  /** Rebuild only from current Design Files. Return a last-moment source fence. */
+  rebuild(provider: LadybugDesignKnowledgeProvider): Promise<() => Promise<void>>;
+  onState?(state: LadybugRecoveryState): void;
+}
+/** Only known durable-format failures permit discarding a derived index. */
+declare function isRecoverableLadybugError(error: unknown): boolean;
+/** Implemented subset in the first production slice. */
+type LadybugDesignKnowledgeService = DesignKnowledgeService;
+/** Stop the package-global Ladybug worker after every project provider closes. */
+declare function shutdownLadybugKnowledgeRuntime(): Promise<void>;
+/** Private embedded provider for revisioned Design Knowledge projection. */
+declare class LadybugDesignKnowledgeProvider implements LadybugDesignKnowledgeService {
+  #private;
+  recovery?: LadybugRecoveryState;
+  private constructor();
+  /** Open one exclusively owned project database and initialize its strict schema. */
+  static open(projectId: DesignProjectId, input: LadybugKnowledgeConfigInput, recovery?: LadybugRecoveryOptions): Promise<LadybugDesignKnowledgeProvider>;
+  /** Close the database, release project ownership, and stop the shared worker when unused. */
+  close(): Promise<void>;
+  revision(projectId: Parameters<DesignKnowledgeService['revision']>[0]): Promise<DesignKnowledgeRevision>;
+  applyDelta(delta: DesignKnowledgeDelta): Promise<DesignKnowledgeMutationResult>;
+  /** Disposable vector cache in the same project DB, outside fact revisions/journal. */
+  readSemanticCache(key: string): Promise<string | undefined>;
+  writeSemanticCache(key: string, value: string): Promise<void>;
+  query(request: DesignKnowledgeQuery): Promise<DesignKnowledgeQueryResult>;
+  trace(request: DesignKnowledgeTraceRequest): Promise<DesignKnowledgeTraceResult>;
+  impact(request: DesignKnowledgeImpactRequest): Promise<DesignKnowledgeQueryResult>;
+  propose(proposal: DesignKnowledgeProposal, pin: Parameters<DesignKnowledgeService['propose']>[1]): Promise<DesignKnowledgeMutationResult>;
+  proposeBatch(batch: DesignKnowledgeProposalBatch): Promise<DesignKnowledgeProposalBatchResult>;
+  applyDecision(decision: DesignKnowledgeDecision, pin: Parameters<DesignKnowledgeService['applyDecision']>[1]): Promise<DesignKnowledgeMutationResult>;
+  exportProject(projectId: DesignProjectId, requested?: DesignKnowledgeRevision): Promise<DesignKnowledgeArchive>;
+  importProject(archive: DesignKnowledgeArchive): Promise<DesignKnowledgeImportReport>;
+}
+//#endregion
+export { DesignSemanticIndex, type Config as DshLadybugKnowledgeConfig, LADYBUG_KNOWLEDGE_SCHEMA_VERSION, LADYBUG_WASM_PROVIDER_ID, LadybugDesignKnowledgeProvider, type LadybugDesignKnowledgeService, type LadybugKnowledgeConfig, type LadybugKnowledgeConfigInput, LadybugProjectLockError, type LadybugRecoveryOptions, type LadybugRecoveryState, LadybugSchemaMismatchError, LadybugWriterBusyError, apply as applyDshLadybugKnowledge, inject as dshLadybugKnowledgeInject, name as dshLadybugKnowledgeName, isRecoverableLadybugError, resolveLadybugKnowledgeConfig, shutdownLadybugKnowledgeRuntime };

package/lib/index.js

@@ -0,0 +1,3 @@
+import { a as LADYBUG_KNOWLEDGE_SCHEMA_VERSION, c as LadybugSchemaMismatchError, d as shutdownLadybugKnowledgeRuntime, f as resolveLadybugKnowledgeConfig, i as name, l as LadybugWriterBusyError, n as apply, o as LadybugDesignKnowledgeProvider, r as inject, s as LadybugProjectLockError, t as LADYBUG_WASM_PROVIDER_ID, u as isRecoverableLadybugError } from "./dsh-plugin-C0TG9tJI.js";
+import { DesignSemanticIndex } from "./semantic-index.js";
+export { DesignSemanticIndex, LADYBUG_KNOWLEDGE_SCHEMA_VERSION, LADYBUG_WASM_PROVIDER_ID, LadybugDesignKnowledgeProvider, LadybugProjectLockError, LadybugSchemaMismatchError, LadybugWriterBusyError, apply as applyDshLadybugKnowledge, inject as dshLadybugKnowledgeInject, name as dshLadybugKnowledgeName, isRecoverableLadybugError, resolveLadybugKnowledgeConfig, shutdownLadybugKnowledgeRuntime };

package/lib/semantic-index.d.ts

@@ -0,0 +1,63 @@
+import { DesignFieldGraphEdge, DesignGraph, SemanticStatus } from "@yugoo-design/dsh-design-core";
+import { ChildProcess } from "node:child_process";
+//#region src/semantic-index.d.ts
+interface EmbeddingConfig {
+  provider?: 'local' | 'remote' | 'disabled';
+  model?: string;
+  revision?: string;
+  cacheDir?: string;
+  localOnly?: boolean;
+  endpoint?: string;
+  apiKey?: string;
+  prefix?: string;
+  threshold?: number;
+}
+interface SemanticCache {
+  readSemanticCache(key: string): Promise<string | undefined>;
+  writeSemanticCache(key: string, value: string): Promise<void>;
+}
+/** Disposable, project-local cache. Never stores Knowledge/GRA facts. */
+declare class MemorySemanticCache implements SemanticCache {
+  private readonly limit;
+  private readonly byteLimit;
+  private values;
+  private bytes;
+  constructor(limit?: number, byteLimit?: number);
+  readSemanticCache(key: string): Promise<string | undefined>;
+  writeSemanticCache(key: string, value: string): Promise<void>;
+}
+declare function stopEmbeddingChild(worker: ChildProcess): Promise<void>;
+declare class DesignSemanticIndex {
+  private readonly idleMs;
+  readonly config: Required<Omit<EmbeddingConfig, 'endpoint' | 'apiKey'>> & Pick<EmbeddingConfig, 'endpoint' | 'apiKey'>;
+  readonly identity: string;
+  get publicationIdentity(): string;
+  private jobs;
+  private tail;
+  private closed;
+  constructor(config?: EmbeddingConfig, idleMs?: number);
+  read(project: string, graph: DesignGraph, cache?: SemanticCache): {
+    edges: DesignFieldGraphEdge[];
+    status: SemanticStatus;
+  };
+  /** Await the existing inference job for background persistence; no polling and
+   * no project write lock held during model execution. Partial edges never escape. */
+  compute(project: string, graph: DesignGraph, cache?: SemanticCache, signal?: AbortSignal): Promise<{
+    edges: DesignFieldGraphEdge[];
+    status: {
+      state: "indexing" | "ready" | "error" | "disabled";
+      completed: number;
+      total: number;
+      model: string;
+      message?: string;
+      cache?: "persistent" | "memory";
+    };
+  }>;
+  cancelProject(project: string): void;
+  close(): Promise<void>;
+  private build;
+  private localBatch;
+  private remoteBatch;
+}
+//#endregion
+export { DesignSemanticIndex, EmbeddingConfig, MemorySemanticCache, SemanticCache, stopEmbeddingChild };

package/lib/semantic-index.js

@@ -0,0 +1,367 @@
+import { existsSync } from "node:fs";
+import { isAbsolute, resolve } from "node:path";
+import { SEMANTIC_TEXT_VERSION, normalizeVector, semanticDigest, semanticEdges } from "@yugoo-design/dsh-design-core";
+import { fork } from "node:child_process";
+import { homedir } from "node:os";
+//#region src/semantic-index.ts
+const localEmbeddingFailures = {
+	runtime: "本地 embedding 运行依赖不可用；请按当前操作系统安装依赖（包括原生模块），不要复用其他平台的 node_modules。",
+	model: "本地 embedding 模型加载失败；请检查固定版本模型缓存，离线模式需要先准备完整模型文件。",
+	inference: "本地 embedding 推理失败；请检查输入限制和本地内存、CPU 运行资源。"
+};
+/** 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 = phase && Object.hasOwn(localEmbeddingFailures, phase) ? localEmbeddingFailures[phase] : "语义索引失败；请检查本地运行资源或已配置的 embedding 服务。";
+					if (!current.abort.signal.aborted) current.status = {
+						...current.status,
+						state: "error",
+						message: detail + " 保留结构图，不自动上传或重试。"
+					};
+				}
+			});
+			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 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") {
+				const built = new URL("./embedding-worker.js", import.meta.url);
+				worker = fork(existsSync(built) ? built : new URL("./embedding-worker.mjs", import.meta.url), [], {
+					windowsHide: true,
+					execArgv: ["--max-old-space-size=512"],
+					stdio: [
+						"ignore",
+						"ignore",
+						"ignore",
+						"ipc"
+					]
+				});
+			}
+			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 }));
+				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 { DesignSemanticIndex, MemorySemanticCache, stopEmbeddingChild };