@openspecui/server 3.7.1 → 3.9.0

package/dist/index.mjs

@@ -1,6 +1,6 @@
-import { CliExecutor, CodeEditorThemeSchema, ConfigManager, CustomSoundHashSchema, DASHBOARD_METRIC_KEYS, DashboardConfigSchema, DocumentTranslationConfigSchema, GitConfigSchema, GlobalSettingsManager, MarkdownParser, NotificationPublishInputSchema, NotificationSettingsSchema, OPENSPECUI_HOOKS_VERSION, OpenSpecAdapter, OpenSpecUIGlobalSettingsSchema, OpenSpecWatcher, OpsxConfigSchema, OpsxKernel, PtyClientMessageSchema, ReactiveContext, TerminalConfigSchema, TerminalControlParser, TerminalRendererEngineSchema, TranslationCacheReadInputSchema, TranslationCacheSettingsSchema, TranslationCacheWriteInputSchema, buildBackendHealthPayload, getAllTools, getAvailableTools, getConfiguredTools, getDefaultCliCommandString, getDetectedProjectTools, getToolInitStates, getWatcherRuntimeStatus, initWatcherPool, isWatcherPoolInitialized, parseOpsxEntityMetadata, parseOpsxSchemaDetail, resolveTerminalShellDefaults, sniffGlobalCli, subscribeWatcherRuntimeStatus, terminalNotificationEventToPublishInput } from "@openspecui/core";
+import { BatchTranslateInputSchema, CliExecutor, CodeEditorThemeSchema, ConfigManager, CustomSoundHashSchema, DASHBOARD_METRIC_KEYS, DashboardConfigSchema, DocumentTranslationConfigSchema, GitConfigSchema, GlobalSettingsManager, LocalModelAssetStateSchema, MarkdownParser, NotificationPublishInputSchema, NotificationSettingsSchema, OPENSPECUI_HOOKS_VERSION, OpenSpecAdapter, OpenSpecUIGlobalSettingsSchema, OpenSpecWatcher, OpsxConfigSchema, OpsxKernel, PtyClientMessageSchema, ReactiveContext, ServiceTranslationEngineIdSchema, TRANSLATION_ENGINE_MANIFESTS, TerminalConfigSchema, TerminalControlParser, TerminalRendererEngineSchema, TranslationCacheReadInputSchema, TranslationCacheSettingsSchema, TranslationCacheWriteInputSchema, TranslationEngineIdSchema, TranslationLocalSettingsSchema, TranslationOpenAISettingsSchema, buildBackendHealthPayload, buildLocalDownloadPlanFromRepositoryFiles, clearCache, getAllTools, getAvailableTools, getConfiguredTools, getDefaultCliCommandString, getDetectedProjectTools, getToolInitStates, getWatcherRuntimeStatus, initWatcherPool, isWatcherPoolInitialized, parseOpsxEntityMetadata, parseOpsxSchemaDetail, resolveTerminalShellDefaults, selectLocalDownloadGroup, sniffGlobalCli, subscribeWatcherRuntimeStatus, terminalNotificationEventToPublishInput } from "@openspecui/core";
 import { basename, dirname, join, matchesGlob, relative, resolve, sep } from "node:path";
-import { access, mkdir, readFile, realpath, rm, stat, writeFile } from "node:fs/promises";
+import { access, copyFile, lstat, mkdir, open, readFile, readlink, realpath, rename, rm, stat, symlink, unlink, writeFile } from "node:fs/promises";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { createServer as createServer$1 } from "node:net";
 import { serve } from "@hono/node-server";
@@ -8,7 +8,7 @@ import { fetchRequestHandler } from "@trpc/server/adapters/fetch";
 import { applyWSSHandler } from "@trpc/server/adapters/ws";
 import { Hono } from "hono";
 import { cors } from "hono/cors";
-import { readFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { WebSocketServer } from "ws";
 import { CustomSoundHashSchema as CustomSoundHashSchema$1, CustomSoundIdSchema, CustomSoundMetadataFileSchema, customHashFromSoundId, soundIdFromCustomHash } from "@openspecui/core/sounds";
 import { createHash } from "node:crypto";
@@ -16,13 +16,15 @@ import { homedir, platform } from "node:os";
 import { EventEmitter } from "node:events";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
+import { downloadFile, fileDownloadInfo, listFiles } from "@huggingface/hub";
+import { observable } from "@trpc/server/observable";
+import { z } from "zod";
+import { Agent, EnvHttpProxyAgent, setGlobalDispatcher } from "undici";
 import { NotificationGroupKeySchema, NotificationPublishInputSchema as NotificationPublishInputSchema$1, getNotificationGroupKey } from "@openspecui/core/notifications";
 import * as pty from "@lydell/node-pty";
 import { EventEmitter as EventEmitter$1 } from "events";
 import { SearchQuerySchema } from "@openspecui/search";
 import { initTRPC } from "@trpc/server";
-import { observable } from "@trpc/server/observable";
-import { z } from "zod";
 import { NodeWorkerSearchProvider } from "@openspecui/search/node";
 
 //#region src/document-service.ts
@@ -355,7 +357,7 @@ function normalizeHooksModule(moduleValue) {
 		onRunWorkflow: isOnRunWorkflowHook(record.onRunWorkflow) ? record.onRunWorkflow : isOnRunWorkflowHook(defaultRecord.onRunWorkflow) ? defaultRecord.onRunWorkflow : isOnRunWorkflowHook(moduleExportsRecord.onRunWorkflow) ? moduleExportsRecord.onRunWorkflow : void 0
 	};
 }
-async function pathExists$1(path) {
+async function pathExists$2(path) {
 	try {
 		await access(path);
 		return true;
@@ -384,7 +386,7 @@ var ProjectHookRuntime = class {
 		await Promise.allSettled(callbacks.map((cleanup) => cleanup()));
 	}
 	async loadFresh() {
-		if (!await pathExists$1(this.hooksPath)) return {};
+		if (!await pathExists$2(this.hooksPath)) return {};
 		const { tsImport } = await import("tsx/esm/api");
 		return normalizeHooksModule(await tsImport(`${pathToFileURL(this.hooksPath).href}?t=${Date.now()}`, { parentURL: pathToFileURL(this.hooksPath).href }));
 	}
@@ -1448,6 +1450,1783 @@ async function buildEntityReadOptions(ctx, stage, id) {
 	}
 }
 
+//#endregion
+//#region src/huggingface-endpoint.ts
+const DEFAULT_HUGGING_FACE_ENDPOINT = "https://huggingface.co";
+function normalizeHuggingFaceEndpoint(endpoint) {
+	const trimmed = endpoint?.trim();
+	if (!trimmed) return DEFAULT_HUGGING_FACE_ENDPOINT;
+	return trimmed.replace(/\/+$/, "");
+}
+function buildHuggingFaceApiBaseUrl(endpoint) {
+	return `${normalizeHuggingFaceEndpoint(endpoint)}/api`;
+}
+function buildTransformersRemoteHost(endpoint) {
+	return `${normalizeHuggingFaceEndpoint(endpoint)}/`;
+}
+
+//#endregion
+//#region src/local-model-asset-store.ts
+const LocalModelAssetIndexSchema = LocalModelAssetStateSchema.array();
+var LocalModelAssetStore = class {
+	constructor(options) {
+		this.options = options;
+	}
+	getIndexPath() {
+		return this.options.indexPath;
+	}
+	async readAll() {
+		try {
+			const content = await readFile(this.options.indexPath, "utf8");
+			const parsed = JSON.parse(content);
+			const result = LocalModelAssetIndexSchema.safeParse(parsed);
+			return result.success ? result.data : [];
+		} catch {
+			return [];
+		}
+	}
+	async readMap() {
+		return new Map((await this.readAll()).map((state) => [state.modelId, state]));
+	}
+	async writeAll(states) {
+		const normalized = LocalModelAssetIndexSchema.parse([...states].sort((left, right) => left.modelId.localeCompare(right.modelId)));
+		const serialized = JSON.stringify(normalized, null, 2);
+		await mkdir(dirname(this.options.indexPath), { recursive: true });
+		const tempPath = `${this.options.indexPath}.${process.pid}.${Date.now()}.tmp`;
+		await writeFile(tempPath, `${serialized}\n`, "utf8");
+		await rename(tempPath, this.options.indexPath);
+		clearCache();
+	}
+	async upsert(state) {
+		const states = await this.readMap();
+		states.set(state.modelId, LocalModelAssetStateSchema.parse(state));
+		await this.writeAll([...states.values()]);
+	}
+	async remove(modelId) {
+		const states = await this.readMap();
+		if (!states.delete(modelId)) return;
+		await this.writeAll([...states.values()]);
+	}
+};
+
+//#endregion
+//#region src/translation-cache-path.ts
+function getDefaultTranslationCacheDatabasePath() {
+	return join(getOpenSpecUICacheDir(), "translation-cache.sqlite");
+}
+function getOpenSpecUICacheDir() {
+	const currentPlatform = platform();
+	if (currentPlatform === "darwin") return join(homedir(), "Library", "Caches", "openspecui");
+	if (currentPlatform === "win32") return join(process.env.LOCALAPPDATA || join(homedir(), "AppData", "Local"), "OpenSpecUI", "Cache");
+	return join(process.env.XDG_CACHE_HOME || join(homedir(), ".cache"), "openspecui");
+}
+
+//#endregion
+//#region src/local-model-cache-path.ts
+function getDefaultLocalModelCacheRoot() {
+	return join(getOpenSpecUICacheDir(), "translation-engines", "local");
+}
+function getDefaultLocalModelCacheDir() {
+	return join(getDefaultLocalModelCacheRoot(), "hf-cache");
+}
+function getDefaultLocalModelIndexPath() {
+	return join(getDefaultLocalModelCacheRoot(), "models.json");
+}
+function getDefaultLocalModelFetchCachePath() {
+	return join(getDefaultLocalModelCacheRoot(), "fetch-cache.json");
+}
+
+//#endregion
+//#region src/local-model-fetch-cache-store.ts
+const RawJsonRecordSchema = z.record(z.string(), z.unknown());
+const HttpHeaderRecordSchema = z.record(z.string(), z.string());
+const LocalModelFetchCacheQueryContextSchema = z.object({
+	query: z.string().optional(),
+	sourceLanguage: z.string().optional(),
+	targetLanguage: z.string().optional()
+});
+const LocalModelProviderFetchRecordSchema = z.object({
+	id: z.string().min(1),
+	source: z.literal("huggingface"),
+	fetchedAt: z.number().int().nonnegative(),
+	request: z.object({
+		method: z.literal("GET"),
+		url: z.string().min(1),
+		queryContext: LocalModelFetchCacheQueryContextSchema.optional()
+	}),
+	response: z.object({
+		status: z.number().int().nonnegative(),
+		ok: z.boolean(),
+		headers: HttpHeaderRecordSchema,
+		bodyText: z.string()
+	})
+});
+const LocalModelFetchCacheRecordSchema = z.object({
+	modelId: z.string().min(1),
+	source: z.literal("huggingface"),
+	listItemRaw: RawJsonRecordSchema.optional(),
+	detailRaw: RawJsonRecordSchema.optional(),
+	queryContext: LocalModelFetchCacheQueryContextSchema.optional(),
+	listFetchedAt: z.number().int().nonnegative().optional(),
+	detailFetchedAt: z.number().int().nonnegative().optional(),
+	updatedAt: z.number().int().nonnegative()
+});
+const LocalModelFetchCacheFileSchema = z.object({
+	version: z.literal(1).default(1),
+	fetches: z.array(LocalModelProviderFetchRecordSchema).default([]),
+	records: z.array(LocalModelFetchCacheRecordSchema).default([])
+});
+var LocalModelFetchCacheStore = class {
+	now;
+	constructor(options) {
+		this.options = options;
+		this.now = options.now ?? Date.now;
+	}
+	async readAll() {
+		return (await this.readFile()).records;
+	}
+	async readFetches() {
+		return (await this.readFile()).fetches;
+	}
+	async readFile() {
+		try {
+			const content = await readFile(this.options.cachePath, "utf8");
+			const parsed = JSON.parse(content);
+			const result = LocalModelFetchCacheFileSchema.safeParse(parsed);
+			return result.success ? result.data : LocalModelFetchCacheFileSchema.parse({});
+		} catch {
+			return LocalModelFetchCacheFileSchema.parse({});
+		}
+	}
+	async read(modelId) {
+		return (await this.readMap()).get(modelId) ?? null;
+	}
+	async readMap() {
+		return new Map((await this.readAll()).map((record) => [record.modelId, record]));
+	}
+	async writeAll(records) {
+		const current = await this.readFile();
+		await this.writeFile({
+			fetches: current.fetches,
+			records
+		});
+	}
+	async writeFile(input) {
+		const normalized = LocalModelFetchCacheFileSchema.parse({
+			version: 1,
+			fetches: [...input.fetches].sort((left, right) => left.id.localeCompare(right.id)),
+			records: [...input.records].sort((left, right) => left.modelId.localeCompare(right.modelId))
+		});
+		await mkdir(dirname(this.options.cachePath), { recursive: true });
+		await writeFile(this.options.cachePath, `${JSON.stringify(normalized, null, 2)}\n`, "utf8");
+		clearCache();
+	}
+	async upsertProviderFetch(input) {
+		const current = await this.readFile();
+		const id = buildProviderFetchId(input.url);
+		const fetches = new Map(current.fetches.map((record) => [record.id, record]));
+		fetches.set(id, LocalModelProviderFetchRecordSchema.parse({
+			id,
+			source: "huggingface",
+			fetchedAt: this.now(),
+			request: {
+				method: "GET",
+				url: input.url,
+				queryContext: input.queryContext
+			},
+			response: {
+				status: input.status,
+				ok: input.ok,
+				headers: input.headers,
+				bodyText: input.bodyText
+			}
+		}));
+		await this.writeFile({
+			fetches: [...fetches.values()],
+			records: current.records
+		});
+	}
+	async upsertListItem(input) {
+		const records = await this.readMap();
+		const current = records.get(input.modelId);
+		records.set(input.modelId, LocalModelFetchCacheRecordSchema.parse({
+			...current,
+			modelId: input.modelId,
+			source: "huggingface",
+			listItemRaw: input.raw,
+			queryContext: input.queryContext ?? current?.queryContext,
+			listFetchedAt: this.now(),
+			updatedAt: this.now()
+		}));
+		await this.writeAll([...records.values()]);
+	}
+	async upsertDetail(input) {
+		const records = await this.readMap();
+		const current = records.get(input.modelId);
+		records.set(input.modelId, LocalModelFetchCacheRecordSchema.parse({
+			...current,
+			modelId: input.modelId,
+			source: "huggingface",
+			detailRaw: input.raw,
+			queryContext: input.queryContext ?? current?.queryContext,
+			detailFetchedAt: this.now(),
+			updatedAt: this.now()
+		}));
+		await this.writeAll([...records.values()]);
+	}
+};
+function buildProviderFetchId(url) {
+	return `huggingface:GET:${url}`;
+}
+
+//#endregion
+//#region src/local-model-local-cache.ts
+function getTransformersLocalModelPath(cacheDir, modelId) {
+	return join(cacheDir, "models", modelId);
+}
+function getTransformersFileCacheModelPath(cacheDir, modelId) {
+	return join(cacheDir, modelId);
+}
+async function readLocalModelFileStatus(input) {
+	const files = await Promise.all(input.files.map(async (file) => ({
+		file,
+		cached: await pathExists$1(join(getTransformersLocalModelPath(input.cacheDir, input.modelId), file)) || await pathExists$1(join(getTransformersFileCacheModelPath(input.cacheDir, input.modelId), file))
+	})));
+	return {
+		allCached: files.length > 0 && files.every((file) => file.cached),
+		files
+	};
+}
+async function pathExists$1(path) {
+	return stat(path).then(() => true, () => false);
+}
+
+//#endregion
+//#region src/local-model-runtime.ts
+async function configureTransformersRuntime(transformers, cacheDir) {
+	await mkdir(cacheDir, { recursive: true });
+	transformers.env.cacheDir = cacheDir;
+	transformers.env.allowLocalModels = false;
+	transformers.env.localModelPath = join(cacheDir, "models");
+}
+async function resolveLocalModelRuntimePlan(input) {
+	await configureTransformersRuntime(input.transformers, input.cacheDir);
+	const hubUrl = normalizeHuggingFaceEndpoint(input.hfEndpoint);
+	const repositoryFiles = await readHuggingFaceRepositoryFiles({
+		selectedGroupId: input.selectedGroupId,
+		modelId: input.modelId,
+		hubUrl,
+		fetchCacheStore: input.fetchCacheStore
+	});
+	return buildLocalDownloadPlanFromRepositoryFiles({
+		modelId: input.modelId,
+		selectedGroupId: input.selectedGroupId,
+		files: repositoryFiles
+	});
+}
+async function resolveLocalModelRuntimePlanFromProject(input) {
+	const transformers = await (input.loadTransformersModule ?? loadLocalTransformersModule)(input.projectDir, input.globalSettingsManager);
+	const settings = await input.globalSettingsManager.readSettings();
+	return resolveLocalModelRuntimePlan({
+		modelId: input.modelId,
+		transformers,
+		cacheDir: input.cacheDir ?? getDefaultLocalModelCacheDir(),
+		selectedGroupId: input.selectedGroupId,
+		hfEndpoint: settings.translationEngines.local?.hfEndpoint,
+		fetchCacheStore: input.fetchCacheStore
+	});
+}
+async function readHuggingFaceRepositoryFiles(input) {
+	let lastError;
+	for (let attempt = 0; attempt < 3; attempt += 1) {
+		try {
+			const files = [];
+			for await (const entry of listFiles({
+				repo: {
+					type: "model",
+					name: input.modelId
+				},
+				recursive: true,
+				expand: true,
+				hubUrl: input.hubUrl,
+				fetch: input.fetchCacheStore ? createProviderFetchCache(input.fetchCacheStore) : void 0
+			})) {
+				if (entry.type !== "file") continue;
+				files.push({
+					path: entry.path,
+					sizeBytes: entry.lfs?.size ?? entry.size
+				});
+			}
+			if (files.length > 0) return files;
+			lastError = /* @__PURE__ */ new Error(`No repository files were returned for ${input.modelId}.`);
+		} catch (error) {
+			lastError = error;
+		}
+		if (attempt < 2) await delay$2(300 * (attempt + 1));
+	}
+	const cachedFiles = await readCachedHuggingFaceRepositoryFiles(input);
+	if (cachedFiles.length > 0) return cachedFiles;
+	throw lastError instanceof Error ? lastError : /* @__PURE__ */ new Error(`Unable to read repository files for ${input.modelId}.`);
+}
+async function readCachedHuggingFaceRepositoryFiles(input) {
+	if (!input.fetchCacheStore) return [];
+	const record = await input.fetchCacheStore.read(input.modelId);
+	if (!record?.detailRaw) return [];
+	return extractRepositoryFilesFromCachedDetail(record.detailRaw);
+}
+function extractRepositoryFilesFromCachedDetail(raw) {
+	const siblings = Array.isArray(raw.siblings) ? raw.siblings : [];
+	const files = [];
+	for (const sibling of siblings) {
+		if (!sibling || typeof sibling !== "object") continue;
+		const record = sibling;
+		const path = typeof record.rfilename === "string" ? record.rfilename : null;
+		if (!path) continue;
+		files.push({
+			path,
+			sizeBytes: typeof record.size === "number" && Number.isFinite(record.size) ? record.size : void 0
+		});
+	}
+	return files;
+}
+function createProviderFetchCache(fetchCacheStore) {
+	return async (input, init) => {
+		const response = await fetch(input, init);
+		const url = normalizeRequestUrl(input);
+		if (!url.includes("/api/models/") || !url.includes("/tree/")) return response;
+		await fetchCacheStore.upsertProviderFetch({
+			url,
+			status: response.status,
+			ok: response.ok,
+			headers: headersToRecord$1(response.headers),
+			bodyText: await response.clone().text()
+		});
+		return response;
+	};
+}
+function normalizeRequestUrl(input) {
+	if (typeof input === "string") return input;
+	if (input instanceof URL) return input.href;
+	return input.url;
+}
+function headersToRecord$1(headers) {
+	return Object.fromEntries(headers.entries());
+}
+function delay$2(ms) {
+	return new Promise((resolve$1) => setTimeout(resolve$1, ms));
+}
+async function loadLocalTransformersModule(_projectDir, _globalSettingsManager) {
+	return await import("@huggingface/transformers");
+}
+
+//#endregion
+//#region src/network-dispatcher.ts
+const DEFAULT_CONNECT_TIMEOUT_MS = 3e4;
+let sharedDispatcher = null;
+function createProxyAwareDispatcher() {
+	if (hasProxyEnvironment()) return new EnvHttpProxyAgent({
+		httpProxy: process.env.http_proxy ?? process.env.HTTP_PROXY,
+		httpsProxy: process.env.https_proxy ?? process.env.HTTPS_PROXY,
+		noProxy: process.env.no_proxy ?? process.env.NO_PROXY,
+		connectTimeout: DEFAULT_CONNECT_TIMEOUT_MS
+	});
+	return new Agent({ connectTimeout: DEFAULT_CONNECT_TIMEOUT_MS });
+}
+function ensureProxyAwareFetchDispatcher() {
+	if (sharedDispatcher) return sharedDispatcher;
+	sharedDispatcher = createProxyAwareDispatcher();
+	setGlobalDispatcher(sharedDispatcher);
+	return sharedDispatcher;
+}
+function hasProxyEnvironment() {
+	return Boolean(process.env.http_proxy || process.env.HTTP_PROXY || process.env.https_proxy || process.env.HTTPS_PROXY || process.env.all_proxy || process.env.ALL_PROXY);
+}
+
+//#endregion
+//#region src/network-retry.ts
+const RETRYABLE_STATUS_CODES = new Set([
+	408,
+	409,
+	425,
+	429,
+	500,
+	502,
+	503,
+	504,
+	520,
+	521,
+	522,
+	523,
+	524
+]);
+const RETRYABLE_ERROR_CODES = new Set([
+	"ECONNABORTED",
+	"ECONNREFUSED",
+	"ECONNRESET",
+	"EAI_AGAIN",
+	"ENETDOWN",
+	"ENETRESET",
+	"ENETUNREACH",
+	"ENOTFOUND",
+	"ETIMEDOUT",
+	"UND_ERR_BODY_TIMEOUT",
+	"UND_ERR_CONNECT_TIMEOUT",
+	"UND_ERR_HEADERS_TIMEOUT",
+	"UND_ERR_SOCKET"
+]);
+const RETRYABLE_MESSAGE_FRAGMENTS = [
+	"fetch failed",
+	"timeout",
+	"timed out",
+	"socket hang up",
+	"econnreset",
+	"econnrefused",
+	"eai_again",
+	"enotfound",
+	"terminated",
+	"too many requests",
+	"rate limit",
+	"bad gateway",
+	"service unavailable",
+	"gateway timeout",
+	"temporarily unavailable",
+	"connection reset",
+	"connection refused"
+];
+function isRetryableNetworkStatusCode(statusCode) {
+	return RETRYABLE_STATUS_CODES.has(statusCode);
+}
+function isRetryableNetworkError(error, options = {}) {
+	return isRetryableNetworkErrorInternal(error, options, /* @__PURE__ */ new Set());
+}
+function isRetryableNetworkErrorInternal(error, options, seen) {
+	if (error === void 0 || error === null) return options.treatUnknownAsRetryable ?? false;
+	if (typeof error === "string") return isRetryableNetworkMessage(error);
+	if (typeof error !== "object") return options.treatUnknownAsRetryable ?? false;
+	if (seen.has(error)) return false;
+	seen.add(error);
+	const record = error;
+	if (record.name === "AbortError") return false;
+	const statusCode = readNumericField(record, ["statusCode", "status"]);
+	if (statusCode !== void 0 && isRetryableNetworkStatusCode(statusCode)) return true;
+	const code = typeof record.code === "string" ? record.code.toUpperCase() : void 0;
+	if (code && RETRYABLE_ERROR_CODES.has(code)) return true;
+	if (typeof record.message === "string" && isRetryableNetworkMessage(record.message)) return true;
+	if ("cause" in record) return isRetryableNetworkErrorInternal(record.cause, options, seen);
+	return options.treatUnknownAsRetryable ?? false;
+}
+function readNumericField(record, keys) {
+	for (const key of keys) {
+		const value = record[key];
+		if (typeof value === "number" && Number.isFinite(value)) return value;
+	}
+}
+function isRetryableNetworkMessage(message) {
+	const lower = message.toLowerCase();
+	return RETRYABLE_MESSAGE_FRAGMENTS.some((fragment) => lower.includes(fragment)) || hasRetryableStatusInMessage(lower);
+}
+function hasRetryableStatusInMessage(message) {
+	const statusMatch = message.match(/status\s+(\d{3})/);
+	if (!statusMatch) return false;
+	return isRetryableNetworkStatusCode(Number(statusMatch[1]));
+}
+
+//#endregion
+//#region src/translation-model-catalog.ts
+const DEFAULT_SEARCH_LIMIT = 6;
+const MAX_SEARCH_FETCH_LIMIT = 12;
+const DEFAULT_SMALL_VERIFY_MODEL_ID = "Xenova/opus-mt-no-de";
+const HUGGING_FACE_FETCH_RETRY_COUNT = 2;
+const HUGGING_FACE_FETCH_RETRY_DELAY_MS = 750;
+const HUGGING_FACE_FETCH_DISPATCHER = createProxyAwareDispatcher();
+async function searchLocalModels(input, options = {}) {
+	const list = await fetchHuggingFaceModelList(input, options);
+	return {
+		items: rankCandidates(await Promise.all(list.items.map(async (item) => {
+			const detail = await getHuggingFaceModelDetail(item.id, input, options).catch(() => null);
+			return detail ? toTranslationModelCandidate(detail, input) : toTranslationModelCandidate(item, input);
+		})), input).slice(0, normalizeSearchLimit(input.limit)),
+		nextCursor: list.nextCursor
+	};
+}
+async function searchLocalModelsProgressively(input, options = {}) {
+	const list = await fetchHuggingFaceModelList(input, options);
+	const candidateShells = rankCandidates(list.items.map((item) => toTranslationModelCandidate(item, input)), input).slice(0, normalizeSearchLimit(input.limit));
+	const events = [{
+		requestId: input.requestId,
+		phase: "candidates",
+		items: candidateShells,
+		nextCursor: list.nextCursor
+	}];
+	const enriched = await Promise.all(candidateShells.map(async (candidate) => {
+		const detail = await getHuggingFaceModelDetail(candidate.id, input, options).catch(() => null);
+		return detail ? toTranslationModelCandidate(detail, input) : candidate;
+	}));
+	events.push({
+		requestId: input.requestId,
+		phase: "enriched",
+		items: rankCandidates(enriched, input).slice(0, normalizeSearchLimit(input.limit)),
+		nextCursor: list.nextCursor
+	});
+	events.push({
+		requestId: input.requestId,
+		phase: "complete",
+		items: rankCandidates(enriched, input).slice(0, normalizeSearchLimit(input.limit)),
+		nextCursor: list.nextCursor
+	});
+	return events;
+}
+async function fetchHuggingFaceModelList(input, options) {
+	const limit = normalizeSearchLimit(input.limit);
+	const fetchLimit = Math.min(Math.max(limit * 2, limit), MAX_SEARCH_FETCH_LIMIT);
+	const params = new URLSearchParams({
+		pipeline_tag: "translation",
+		sort: "trendingScore",
+		direction: "-1",
+		limit: String(fetchLimit)
+	});
+	if (input.query?.trim()) params.set("search", input.query.trim());
+	if (input.cursor?.trim()) params.set("cursor", input.cursor.trim());
+	const url = `${buildHuggingFaceApiBaseUrl(options.hfEndpoint)}/models?${params.toString()}`;
+	const response = await fetchHuggingFace(url);
+	const responseBody = await response.text();
+	const fetchCacheStore = getFetchCacheStore(options);
+	await fetchCacheStore.upsertProviderFetch({
+		url,
+		status: response.status,
+		ok: response.ok,
+		headers: headersToRecord(response.headers),
+		bodyText: responseBody,
+		queryContext: buildQueryContext(input)
+	});
+	if (!response.ok) throw new Error(`Hugging Face model search failed with status ${response.status}.`);
+	const listJson = parseJson(responseBody);
+	const rawItems = Array.isArray(listJson) ? listJson.filter(isRecord) : [];
+	const items = rawItems.map(normalizeHfModelListItem).filter((item) => item !== null);
+	for (const raw of rawItems) {
+		const item = normalizeHfModelListItem(raw);
+		if (!item) continue;
+		await fetchCacheStore.upsertListItem({
+			modelId: item.id,
+			raw,
+			queryContext: buildQueryContext(input)
+		});
+	}
+	return {
+		items,
+		nextCursor: readNextCursor(response.headers.get("link"))
+	};
+}
+async function getHuggingFaceModelDetail(modelId, input, options) {
+	const [namespace, repo] = modelId.split("/", 2);
+	const modelPath = namespace && repo ? `${encodeURIComponent(namespace)}/${encodeURIComponent(repo)}` : encodeURIComponent(modelId);
+	const url = `${buildHuggingFaceApiBaseUrl(options.hfEndpoint)}/models/${modelPath}?blobs=true`;
+	const response = await fetchHuggingFace(url);
+	const responseBody = await response.text();
+	await getFetchCacheStore(options).upsertProviderFetch({
+		url,
+		status: response.status,
+		ok: response.ok,
+		headers: headersToRecord(response.headers),
+		bodyText: responseBody,
+		queryContext: input ? buildQueryContext(input) : void 0
+	});
+	if (!response.ok) throw new Error(`Hugging Face model detail failed with status ${response.status}.`);
+	const detailJson = parseJson(responseBody);
+	const raw = isRecord(detailJson) ? detailJson : {};
+	await getFetchCacheStore(options).upsertDetail({
+		modelId,
+		raw,
+		queryContext: input ? buildQueryContext(input) : void 0
+	});
+	return normalizeHfModelDetail(detailJson, modelId);
+}
+function parseJson(text) {
+	try {
+		return JSON.parse(text);
+	} catch {
+		return null;
+	}
+}
+function headersToRecord(headers) {
+	return Object.fromEntries(headers.entries());
+}
+async function fetchHuggingFace(input) {
+	let lastError;
+	for (let attempt = 0; attempt <= HUGGING_FACE_FETCH_RETRY_COUNT; attempt += 1) {
+		try {
+			const response = await fetchWithDispatcher(input);
+			if (response.ok || !isRetryableNetworkStatusCode(response.status)) return response;
+			lastError = /* @__PURE__ */ new Error(`Hugging Face request failed with status ${response.status}.`);
+			if (attempt === HUGGING_FACE_FETCH_RETRY_COUNT) return response;
+			await response.body?.cancel().catch(() => void 0);
+		} catch (error) {
+			lastError = error;
+			if (!isRetryableFetchError(error) || attempt === HUGGING_FACE_FETCH_RETRY_COUNT) throw error;
+		}
+		await delay$1(HUGGING_FACE_FETCH_RETRY_DELAY_MS * (attempt + 1));
+	}
+	throw lastError instanceof Error ? lastError : /* @__PURE__ */ new Error("Hugging Face request failed.");
+}
+async function fetchWithDispatcher(input) {
+	return fetch(input, { dispatcher: HUGGING_FACE_FETCH_DISPATCHER });
+}
+function isRetryableFetchError(error) {
+	return isRetryableNetworkError(error);
+}
+function delay$1(ms) {
+	return new Promise((resolve$1) => {
+		setTimeout(resolve$1, ms);
+	});
+}
+function normalizeHfModelListItem(value) {
+	if (!value || typeof value !== "object") return null;
+	const record = value;
+	if (typeof record.id !== "string" || record.id.length === 0) return null;
+	return {
+		id: record.id,
+		pipeline_tag: typeof record.pipeline_tag === "string" ? record.pipeline_tag : void 0,
+		tags: Array.isArray(record.tags) ? record.tags.filter(isString) : [],
+		downloads: normalizeNonNegativeNumber(record.downloads),
+		likes: normalizeNonNegativeNumber(record.likes),
+		trendingScore: normalizeOptionalNumber(record.trendingScore),
+		lastModified: typeof record.lastModified === "string" ? record.lastModified : void 0
+	};
+}
+function normalizeHfModelDetail(value, fallbackId) {
+	const base = normalizeHfModelListItem(value) ?? {
+		id: fallbackId,
+		tags: [],
+		downloads: 0,
+		likes: 0
+	};
+	const record = value && typeof value === "object" ? value : {};
+	const configRecord = record.config && typeof record.config === "object" ? record.config : void 0;
+	return {
+		...base,
+		config: configRecord ? {
+			is_encoder_decoder: typeof configRecord.is_encoder_decoder === "boolean" ? configRecord.is_encoder_decoder : void 0,
+			model_type: typeof configRecord.model_type === "string" ? configRecord.model_type : void 0
+		} : void 0,
+		siblings: Array.isArray(record.siblings) ? record.siblings.map((entry) => normalizeSibling(entry)).filter((entry) => entry !== null) : []
+	};
+}
+function normalizeSibling(value) {
+	if (!value || typeof value !== "object") return null;
+	const record = value;
+	if (typeof record.rfilename !== "string" || record.rfilename.length === 0) return null;
+	return {
+		rfilename: record.rfilename,
+		size: normalizeOptionalNumber(record.size)
+	};
+}
+function toTranslationModelCandidate(detail, input) {
+	const plan = isHfModelDetail(detail) ? resolveLocalModelPlan(detail) : null;
+	const languageMatch = buildLanguageMatch(detail, input.sourceLanguage, input.targetLanguage);
+	const compatibility = {
+		transformersJs: detail.tags.includes("transformers.js"),
+		onnx: detail.tags.includes("onnx"),
+		localRuntimeVerified: detail.tags.includes("transformers.js") && detail.tags.includes("onnx")
+	};
+	const estimatedTotalBytes = plan?.estimatedTotalBytes;
+	return {
+		id: detail.id,
+		label: detail.id,
+		summary: buildCandidateSummary(detail, compatibility.localRuntimeVerified, estimatedTotalBytes),
+		downloads: detail.downloads,
+		likes: detail.likes,
+		trendingScore: detail.trendingScore,
+		lastModified: detail.lastModified,
+		pipelineTag: detail.pipeline_tag,
+		tags: detail.tags,
+		compatibility,
+		size: {
+			estimatedTotalBytes,
+			primaryBytes: estimatedTotalBytes
+		},
+		downloadGroups: plan?.groups,
+		languageMatch
+	};
+}
+function resolveLocalModelPlan(detail) {
+	return buildLocalDownloadPlanFromRepositoryFiles({
+		modelId: detail.id,
+		isEncoderDecoder: detail.config?.is_encoder_decoder,
+		files: detail.siblings.map((entry) => ({
+			path: entry.rfilename,
+			sizeBytes: entry.size
+		}))
+	});
+}
+function buildCandidateSummary(detail, verified, estimatedTotalBytes) {
+	const parts = [verified ? "Verified Transformers.js + ONNX model." : "Translation model from Hugging Face."];
+	if (estimatedTotalBytes !== void 0) parts.push(`Estimated download ${formatBytes$1(estimatedTotalBytes)}.`);
+	if (detail.tags.includes("translation")) parts.push("Tagged for translation.");
+	return parts.join(" ");
+}
+function buildLanguageMatch(detail, sourceLanguage, targetLanguage) {
+	const sourceTokens = buildLanguageTokens(sourceLanguage);
+	const targetTokens = buildLanguageTokens(targetLanguage);
+	const searchable = [detail.id, ...detail.tags].join(" ").toLowerCase();
+	const sourceMatched = sourceTokens.some((token) => searchable.includes(token));
+	const targetMatched = targetTokens.some((token) => searchable.includes(token));
+	let directionalScore = 0;
+	if (sourceTokens.length > 0 && targetTokens.length > 0) {
+		for (const sourceToken of sourceTokens) for (const targetToken of targetTokens) if (searchable.includes(`${sourceToken}-${targetToken}`) || searchable.includes(`${sourceToken}_${targetToken}`) || searchable.includes(`-${sourceToken}-${targetToken}`)) directionalScore = Math.max(directionalScore, 2);
+	}
+	if (targetMatched) directionalScore += 1;
+	if (sourceMatched) directionalScore += .5;
+	return {
+		sourceMatched,
+		targetMatched,
+		directionalScore
+	};
+}
+function buildLanguageTokens(language) {
+	if (!language) return [];
+	const normalized = language.trim().toLowerCase();
+	if (!normalized) return [];
+	const primary = normalized.split(/[-_]/, 1)[0] ?? normalized;
+	return [...new Set([normalized, primary].filter(Boolean))];
+}
+function rankCandidate(candidate) {
+	const smallVerifyBoost = candidate.id === DEFAULT_SMALL_VERIFY_MODEL_ID ? 18 : 0;
+	const compatibilityBoost = candidate.compatibility.localRuntimeVerified ? 140 : -80;
+	const trend = (candidate.trendingScore ?? 0) * 100;
+	const directionalBoost = candidate.languageMatch.directionalScore * 45;
+	const downloadsBoost = Math.log10(candidate.downloads + 1) * 12;
+	const likesBoost = candidate.likes * .15;
+	const sizePenalty = candidate.size.estimatedTotalBytes === void 0 ? 0 : Math.log10(candidate.size.estimatedTotalBytes / (1024 * 1024) + 1) * 12;
+	return smallVerifyBoost + compatibilityBoost + trend + directionalBoost + downloadsBoost + likesBoost - sizePenalty;
+}
+function rankCandidates(candidates, input) {
+	const verifiedCandidates = candidates.filter((candidate) => candidate.compatibility.localRuntimeVerified);
+	return [...input.query?.trim() ? candidates : verifiedCandidates].sort((left, right) => rankCandidate(right) - rankCandidate(left));
+}
+function normalizeSearchLimit(limit) {
+	return Math.min(Math.max(limit ?? DEFAULT_SEARCH_LIMIT, 1), 20);
+}
+function buildQueryContext(input) {
+	return {
+		...input.query?.trim() ? { query: input.query.trim() } : {},
+		...input.sourceLanguage?.trim() ? { sourceLanguage: input.sourceLanguage.trim() } : {},
+		...input.targetLanguage?.trim() ? { targetLanguage: input.targetLanguage.trim() } : {}
+	};
+}
+function getFetchCacheStore(options) {
+	return options.fetchCacheStore ?? new LocalModelFetchCacheStore({ cachePath: getDefaultLocalModelFetchCachePath() });
+}
+function readNextCursor(linkHeader) {
+	if (!linkHeader) return void 0;
+	const match = /[?&]cursor=([^&>]+).*rel="next"/.exec(linkHeader);
+	if (!match) return void 0;
+	try {
+		return decodeURIComponent(match[1]);
+	} catch {
+		return match[1];
+	}
+}
+function formatBytes$1(value) {
+	if (!Number.isFinite(value) || value <= 0) return "0 B";
+	const units = [
+		"B",
+		"KB",
+		"MB",
+		"GB"
+	];
+	let size = value;
+	let unitIndex = 0;
+	while (size >= 1024 && unitIndex < units.length - 1) {
+		size /= 1024;
+		unitIndex += 1;
+	}
+	const digits = size >= 100 || unitIndex === 0 ? 0 : 1;
+	return `${size.toFixed(digits)} ${units[unitIndex]}`;
+}
+function normalizeNonNegativeNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
+}
+function normalizeOptionalNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+function isHfModelDetail(value) {
+	return "siblings" in value;
+}
+function isString(value) {
+	return typeof value === "string";
+}
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+//#endregion
+//#region src/local-model-asset-service.ts
+const DEFAULT_NETWORK_RETRY_LIMIT = Number.POSITIVE_INFINITY;
+const DEFAULT_NETWORK_RETRY_DELAY_MS = 500;
+const DEFAULT_NETWORK_RETRY_DELAY_MAX_MS = 5e3;
+var LocalModelAssetService = class {
+	now;
+	store;
+	cacheDir;
+	fetchCacheStore;
+	networkRetryPolicy;
+	listeners = /* @__PURE__ */ new Set();
+	sessions = /* @__PURE__ */ new Map();
+	sessionTasks = /* @__PURE__ */ new Map();
+	logs = /* @__PURE__ */ new Map();
+	transformersModulePromise = null;
+	constructor(options) {
+		this.options = options;
+		ensureProxyAwareFetchDispatcher();
+		this.now = options.now ?? Date.now;
+		this.cacheDir = options.cacheDir ?? getDefaultLocalModelCacheDir();
+		this.networkRetryPolicy = {
+			limit: options.networkRetryPolicy?.limit ?? DEFAULT_NETWORK_RETRY_LIMIT,
+			delayMs: options.networkRetryPolicy?.delayMs ?? DEFAULT_NETWORK_RETRY_DELAY_MS,
+			maxDelayMs: options.networkRetryPolicy?.maxDelayMs ?? DEFAULT_NETWORK_RETRY_DELAY_MAX_MS
+		};
+		this.store = new LocalModelAssetStore({ indexPath: options.indexPath ?? getDefaultLocalModelIndexPath() });
+		this.fetchCacheStore = new LocalModelFetchCacheStore({
+			cachePath: options.fetchCachePath ?? getDefaultLocalModelFetchCachePath(),
+			now: this.now
+		});
+	}
+	subscribeLogs() {
+		return observable((emit) => {
+			for (const log of this.logs.values()) emit.next(log);
+			const listener = (log) => emit.next(log);
+			this.listeners.add(listener);
+			return () => {
+				this.listeners.delete(listener);
+			};
+		});
+	}
+	async listLocalCatalog() {
+		const localMap = await this.store.readMap();
+		const items = await Promise.all([...localMap.values()].map(async (state) => {
+			const asset = await this.refreshCachedState(state);
+			return toCatalogItem({
+				id: state.modelId,
+				label: state.modelId,
+				summary: state.plan?.estimatedTotalBytes !== void 0 ? `Previously selected local model. Estimated download ${formatBytes(state.plan.estimatedTotalBytes)}.` : "Previously selected local model.",
+				downloads: 0,
+				likes: 0,
+				tags: ["local"],
+				compatibility: {
+					transformersJs: true,
+					onnx: true,
+					localRuntimeVerified: true
+				},
+				size: {
+					estimatedTotalBytes: state.plan?.estimatedTotalBytes,
+					primaryBytes: state.plan?.estimatedTotalBytes
+				},
+				downloadGroups: state.plan?.groups,
+				languageMatch: {
+					sourceMatched: false,
+					targetMatched: false,
+					directionalScore: 0
+				}
+			}, asset);
+		}));
+		items.sort(compareCatalogItems);
+		return { items };
+	}
+	async searchRemoteCatalog(input) {
+		const [remote, localMap, selectedModel] = await Promise.all([
+			this.searchRemote(input),
+			this.store.readMap(),
+			this.readSelectedModel()
+		]);
+		const items = await this.decorateCatalogItems(remote.items, localMap, selectedModel);
+		items.sort(compareCatalogItems);
+		return {
+			items,
+			nextCursor: remote.nextCursor
+		};
+	}
+	subscribeRemoteCatalog(input) {
+		return observable((emit) => {
+			let active = true;
+			(async () => {
+				try {
+					const events = await searchLocalModelsProgressively(input, {
+						fetchCacheStore: this.fetchCacheStore,
+						hfEndpoint: await this.readHuggingFaceEndpoint()
+					});
+					for (const event of events) {
+						if (!active) return;
+						const localMap = await this.store.readMap();
+						const selectedModel = await this.readSelectedModel();
+						const items = event.items ? await this.decorateCatalogItems(event.items, localMap, selectedModel, { includeLocalOnly: false }) : void 0;
+						emit.next({
+							requestId: event.requestId,
+							phase: event.phase,
+							items,
+							nextCursor: event.nextCursor,
+							message: event.message
+						});
+					}
+				} catch (error) {
+					if (!active) return;
+					emit.next({
+						requestId: input.requestId,
+						phase: "error",
+						message: error instanceof Error ? error.message : "Unable to search remote local models."
+					});
+				}
+			})();
+			return () => {
+				active = false;
+			};
+		});
+	}
+	async listCatalog(input) {
+		return this.searchRemoteCatalog(input);
+	}
+	async readSelectedModelState(modelId, selectedGroupId) {
+		const state = (await this.store.readMap()).get(modelId);
+		if (state) return this.refreshCachedState(state, selectedGroupId);
+		const session = this.sessions.get(modelId);
+		if (session) {
+			const selected = modelId === await this.readSelectedModel();
+			const plan = await this.readPlanForState(modelId, selectedGroupId ?? session.selectedGroupId);
+			const selectedGroup = selectLocalDownloadGroup(plan, selectedGroupId ?? session.selectedGroupId);
+			const files = (selectedGroup?.files ?? plan?.files ?? []).map((file) => ({
+				path: file.path,
+				sizeBytes: file.sizeBytes,
+				downloadedBytes: 0
+			}));
+			return LocalModelAssetStateSchema.parse({
+				modelId,
+				plan: plan ?? void 0,
+				status: "downloading",
+				selected,
+				resumable: true,
+				totalBytes: selectedGroup?.estimatedTotalBytes ?? plan?.estimatedTotalBytes,
+				progress: 0,
+				files,
+				updatedAt: this.now()
+			});
+		}
+		return LocalModelAssetStateSchema.parse({
+			modelId,
+			status: "not-downloaded",
+			selected: modelId === await this.readSelectedModel(),
+			updatedAt: this.now()
+		});
+	}
+	async startDownload(modelId, selectedGroupId) {
+		return this.runDownload(modelId, "downloading", "Downloading local model", selectedGroupId);
+	}
+	async resumeDownload(modelId, selectedGroupId) {
+		return this.runDownload(modelId, "downloading", "Resuming local model download", selectedGroupId);
+	}
+	async pauseDownload(modelId) {
+		const session = this.sessions.get(modelId);
+		if (session) {
+			session.abortController.abort();
+			this.sessions.delete(modelId);
+		}
+		const current = await this.readSelectedModelState(modelId);
+		const nextState = LocalModelAssetStateSchema.parse({
+			...current,
+			status: "paused",
+			resumable: true,
+			updatedAt: this.now()
+		});
+		await this.store.upsert(nextState);
+		this.emitLog({
+			engineId: "local",
+			modelId,
+			selectedGroupId: current.plan?.selectedGroupId,
+			status: "paused",
+			message: "Local model download paused.",
+			progress: nextState.progress,
+			bytesDownloaded: nextState.bytesDownloaded,
+			totalBytes: nextState.totalBytes,
+			resumable: true,
+			files: nextState.files,
+			updatedAt: this.now()
+		});
+		return { success: true };
+	}
+	async deleteModel(modelId) {
+		this.sessions.get(modelId)?.abortController.abort();
+		this.sessions.delete(modelId);
+		const current = await this.readSelectedModelState(modelId);
+		await this.store.upsert(LocalModelAssetStateSchema.parse({
+			...current,
+			status: "deleting",
+			updatedAt: this.now()
+		}));
+		this.emitLog({
+			engineId: "local",
+			modelId,
+			selectedGroupId: current.plan?.selectedGroupId,
+			status: "deleting",
+			message: "Deleting local model files.",
+			files: current.files,
+			updatedAt: this.now()
+		});
+		await mkdir(this.cacheDir, { recursive: true });
+		await rm(getTransformersLocalModelPath(this.cacheDir, modelId), {
+			recursive: true,
+			force: true
+		});
+		await rm(getTransformersFileCacheModelPath(this.cacheDir, modelId), {
+			recursive: true,
+			force: true
+		});
+		await rm(getHubCacheRepoPath(this.cacheDir, modelId), {
+			recursive: true,
+			force: true
+		});
+		await this.store.remove(modelId);
+		this.emitLog({
+			engineId: "local",
+			modelId,
+			selectedGroupId: current.plan?.selectedGroupId,
+			status: "not-downloaded",
+			message: "Local model files were removed.",
+			progress: 0,
+			bytesDownloaded: 0,
+			totalBytes: 0,
+			files: [],
+			updatedAt: this.now()
+		});
+		return { success: true };
+	}
+	async markSelectedModel(modelId) {
+		const nextStates = (await this.store.readAll()).map((state) => LocalModelAssetStateSchema.parse({
+			...state,
+			selected: state.modelId === modelId
+		}));
+		if (!nextStates.some((state) => state.modelId === modelId)) nextStates.push(LocalModelAssetStateSchema.parse({
+			modelId,
+			status: "not-downloaded",
+			selected: true,
+			updatedAt: this.now()
+		}));
+		await this.store.writeAll(nextStates);
+	}
+	async waitForModelTask(modelId) {
+		await this.sessionTasks.get(modelId);
+	}
+	async close() {
+		const sessions = [...this.sessions.values()];
+		for (const session of sessions) session.abortController.abort();
+		await Promise.allSettled(this.sessionTasks.values());
+	}
+	async searchRemote(input) {
+		return searchLocalModels({
+			query: input.query,
+			sourceLanguage: input.sourceLanguage,
+			targetLanguage: input.targetLanguage,
+			limit: input.limit,
+			cursor: input.cursor
+		}, {
+			fetchCacheStore: this.fetchCacheStore,
+			hfEndpoint: await this.readHuggingFaceEndpoint()
+		});
+	}
+	async decorateCatalogItems(candidates, localMap, selectedModel, options = {}) {
+		const seen = /* @__PURE__ */ new Set();
+		const remoteItems = await Promise.all(candidates.map(async (candidate) => {
+			seen.add(candidate.id);
+			const localState = localMap.get(candidate.id);
+			return toCatalogItem(candidate, localState ? await this.refreshCachedState(localState) : LocalModelAssetStateSchema.parse({
+				modelId: candidate.id,
+				status: "not-downloaded",
+				selected: candidate.id === selectedModel,
+				updatedAt: this.now()
+			}));
+		}));
+		const localOnlyItems = options.includeLocalOnly === false ? [] : await Promise.all([...localMap.values()].filter((state) => !seen.has(state.modelId)).map(async (state) => {
+			const asset = await this.refreshCachedState(state);
+			return toCatalogItem({
+				id: state.modelId,
+				label: state.modelId,
+				summary: state.plan?.estimatedTotalBytes !== void 0 ? `Previously selected local model. Estimated download ${formatBytes(state.plan.estimatedTotalBytes)}.` : "Previously selected local model.",
+				downloads: 0,
+				likes: 0,
+				tags: ["local"],
+				compatibility: {
+					transformersJs: true,
+					onnx: true,
+					localRuntimeVerified: true
+				},
+				size: {
+					estimatedTotalBytes: state.plan?.estimatedTotalBytes,
+					primaryBytes: state.plan?.estimatedTotalBytes
+				},
+				downloadGroups: state.plan?.groups,
+				languageMatch: {
+					sourceMatched: false,
+					targetMatched: false,
+					directionalScore: 0
+				}
+			}, asset);
+		}));
+		return [...remoteItems, ...localOnlyItems];
+	}
+	async refreshCachedState(state, selectedGroupId) {
+		const requestedGroupId = selectedGroupId;
+		const session = this.sessions.get(state.modelId);
+		const selected = state.selected || state.modelId === await this.readSelectedModel();
+		if (state.status === "deleting") return LocalModelAssetStateSchema.parse({
+			...state,
+			selected,
+			updatedAt: this.now()
+		});
+		if (state.status === "downloaded" && state.plan && (requestedGroupId === void 0 || requestedGroupId === state.plan.selectedGroupId)) {
+			const files$1 = (selectLocalDownloadGroup(state.plan, requestedGroupId ?? state.plan.selectedGroupId)?.files ?? state.plan.files).map((file) => ({
+				path: file.path,
+				sizeBytes: file.sizeBytes,
+				downloadedBytes: file.sizeBytes
+			}));
+			return LocalModelAssetStateSchema.parse({
+				...state,
+				selected,
+				status: "downloaded",
+				progress: 1,
+				bytesDownloaded: state.totalBytes ?? state.plan.estimatedTotalBytes,
+				totalBytes: state.totalBytes ?? state.plan.estimatedTotalBytes,
+				resumable: false,
+				error: void 0,
+				files: files$1,
+				updatedAt: this.now(),
+				installedAt: state.installedAt ?? this.now()
+			});
+		}
+		const transformers = await this.getTransformersModule();
+		transformers.env.remoteHost = buildTransformersRemoteHost(await this.readHuggingFaceEndpoint());
+		const [plan, persistedSelectedGroupId] = await Promise.all([this.readPlan(state.modelId, transformers, requestedGroupId ?? state.plan?.selectedGroupId), this.readSelectedGroupId()]);
+		if (!plan && state.status !== "downloaded") return LocalModelAssetStateSchema.parse({
+			...state,
+			selected,
+			plan: void 0
+		});
+		const effectivePlan = plan ?? {
+			modelId: state.modelId,
+			estimatedTotalBytes: state.totalBytes,
+			files: state.files.map((file) => ({
+				path: file.path,
+				sizeBytes: file.sizeBytes,
+				required: true
+			})),
+			selectedGroupId: state.plan?.selectedGroupId,
+			groups: state.plan?.groups
+		};
+		const selectedGroup = selectLocalDownloadGroup(effectivePlan, requestedGroupId ?? state.plan?.selectedGroupId ?? persistedSelectedGroupId);
+		if (requestedGroupId && requestedGroupId !== effectivePlan.selectedGroupId && !selectedGroup) return LocalModelAssetStateSchema.parse({
+			...state,
+			selected,
+			status: "not-downloaded",
+			progress: 0,
+			bytesDownloaded: 0,
+			totalBytes: void 0,
+			resumable: false,
+			files: [],
+			updatedAt: this.now()
+		});
+		const planFiles = selectedGroup?.files ?? effectivePlan.files;
+		const cacheStatus = await readLocalModelFileStatus({
+			cacheDir: this.cacheDir,
+			modelId: state.modelId,
+			files: planFiles.map((file) => file.path)
+		});
+		const sameRequestedGroup = requestedGroupId === void 0 || requestedGroupId === state.plan?.selectedGroupId;
+		const cachedFileSet = new Set(cacheStatus.files.filter((file) => file.cached).map((file) => file.file));
+		const runtimeAllCached = cacheStatus.allCached;
+		const files = planFiles.map((file) => {
+			const cached = cachedFileSet.has(file.path);
+			const existingDownloadedBytes = state.files.find((entry) => entry.path === file.path)?.downloadedBytes ?? 0;
+			const downloadedBytes = file.sizeBytes === void 0 ? cached ? existingDownloadedBytes : existingDownloadedBytes : cached ? file.sizeBytes : Math.min(existingDownloadedBytes, file.sizeBytes);
+			return {
+				path: file.path,
+				sizeBytes: file.sizeBytes,
+				downloadedBytes
+			};
+		});
+		const detectedBytesDownloaded = sumDownloadedBytes(files);
+		const detectedProgress = effectivePlan.estimatedTotalBytes !== void 0 && effectivePlan.estimatedTotalBytes > 0 ? detectedBytesDownloaded / effectivePlan.estimatedTotalBytes : runtimeAllCached ? 1 : void 0;
+		const progress = cacheStatus.allCached ? 1 : session ? state.progress : detectedProgress;
+		const hasPartialCache = !runtimeAllCached && detectedBytesDownloaded > 0;
+		return LocalModelAssetStateSchema.parse({
+			...state,
+			selected,
+			plan: effectivePlan,
+			status: runtimeAllCached ? "downloaded" : session ? state.status : sameRequestedGroup && state.status === "paused" ? "paused" : sameRequestedGroup && state.status === "error" ? "error" : hasPartialCache ? "paused" : "not-downloaded",
+			progress: progress === void 0 ? void 0 : Math.max(0, Math.min(1, progress)),
+			totalBytes: effectivePlan.estimatedTotalBytes ?? state.totalBytes,
+			bytesDownloaded: session ? state.bytesDownloaded : detectedBytesDownloaded,
+			error: runtimeAllCached ? void 0 : state.error,
+			resumable: runtimeAllCached ? false : sameRequestedGroup && state.status === "paused" || sameRequestedGroup && state.status === "error" || hasPartialCache || progress !== void 0 && progress > 0 && progress < 1,
+			files,
+			updatedAt: this.now(),
+			installedAt: runtimeAllCached ? state.installedAt ?? this.now() : state.installedAt
+		});
+	}
+	async runDownload(modelId, targetStatus, messagePrefix, selectedGroupId) {
+		const existing = this.sessions.get(modelId);
+		if (existing) return { sessionId: existing.sessionId };
+		const sessionId = `local-model-${sanitizeId(modelId)}-${this.now()}`;
+		const abortController = new AbortController();
+		this.sessions.set(modelId, {
+			modelId,
+			sessionId,
+			abortController,
+			selectedGroupId
+		});
+		const current = await this.readSelectedModelState(modelId);
+		const transformers = await this.getTransformersModule();
+		const plan = await this.readPlan(modelId, transformers, selectedGroupId ?? current.plan?.selectedGroupId);
+		if (!plan || plan.files.length === 0 || plan.estimatedTotalBytes === void 0) {
+			this.sessions.delete(modelId);
+			throw new Error("No concrete local model download plan is available.");
+		}
+		const totalBytes = plan.estimatedTotalBytes;
+		const resumedFiles = buildDownloadStateFiles({
+			planFiles: plan.files,
+			currentFiles: current.files
+		});
+		const resumedBytesDownloaded = sumDownloadedBytes(resumedFiles);
+		const nextState = LocalModelAssetStateSchema.parse({
+			...current,
+			modelId,
+			plan,
+			status: targetStatus,
+			selected: true,
+			bytesDownloaded: resumedBytesDownloaded,
+			progress: totalBytes > 0 ? resumedBytesDownloaded / totalBytes : current.progress,
+			totalBytes,
+			resumable: true,
+			files: resumedFiles,
+			updatedAt: this.now()
+		});
+		await this.store.upsert(nextState);
+		this.emitLog({
+			engineId: "local",
+			modelId,
+			selectedGroupId: nextState.plan?.selectedGroupId,
+			status: targetStatus,
+			message: `${messagePrefix} ${modelId}.`,
+			progress: nextState.progress,
+			bytesDownloaded: nextState.bytesDownloaded,
+			totalBytes,
+			sessionId,
+			resumable: true,
+			files: nextState.files,
+			updatedAt: this.now()
+		});
+		const task = this.performDownload(modelId, sessionId, abortController.signal, nextState).catch((error) => this.finishDownload(modelId, sessionId, false, error instanceof Error ? error.message : String(error))).finally(() => {
+			if (this.sessionTasks.get(modelId) === task) this.sessionTasks.delete(modelId);
+		});
+		this.sessionTasks.set(modelId, task);
+		return { sessionId };
+	}
+	async performDownload(modelId, sessionId, signal, state) {
+		const transformers = await this.getTransformersModule();
+		await configureTransformersRuntime(transformers, this.cacheDir);
+		transformers.env.remoteHost = buildTransformersRemoteHost(await this.readHuggingFaceEndpoint());
+		const selectedGroup = selectLocalDownloadGroup(state.plan ?? null, state.plan?.selectedGroupId);
+		const files = selectedGroup?.files ?? state.plan?.files ?? [];
+		const totalBytes = selectedGroup?.estimatedTotalBytes ?? state.plan?.estimatedTotalBytes;
+		const hfEndpoint = normalizeHuggingFaceEndpoint(await this.readHuggingFaceEndpoint());
+		const downloadedFiles = buildDownloadStateFiles({
+			planFiles: files,
+			currentFiles: state.files
+		});
+		let bytesDownloaded = sumDownloadedBytes(downloadedFiles);
+		if (files.length === 0) throw new Error("No concrete local model download files were selected.");
+		for (const [fileIndex, file] of files.entries()) {
+			throwIfAborted(signal);
+			const previousFileBytes = downloadedFiles[fileIndex]?.downloadedBytes ?? 0;
+			if (file.sizeBytes !== void 0 && previousFileBytes >= file.sizeBytes) continue;
+			downloadedFiles[fileIndex] = {
+				path: file.path,
+				sizeBytes: file.sizeBytes,
+				downloadedBytes: previousFileBytes
+			};
+			await this.emitDownloadProgress({
+				modelId,
+				sessionId,
+				state,
+				message: `Downloading ${file.path}.`,
+				totalBytes,
+				bytesDownloaded,
+				files: downloadedFiles
+			});
+			const cachedPath = await downloadHuggingFaceFileToCacheDirWithProgress({
+				repo: {
+					type: "model",
+					name: modelId
+				},
+				path: file.path,
+				cacheDir: this.cacheDir,
+				hubUrl: hfEndpoint,
+				expectedSizeBytes: file.sizeBytes,
+				retryPolicy: this.networkRetryPolicy,
+				fetch: createAbortableFetch(signal),
+				signal,
+				onProgress: async (fileBytesDownloaded) => {
+					throwIfAborted(signal);
+					const boundedFileBytes = file.sizeBytes ? Math.min(file.sizeBytes, fileBytesDownloaded) : fileBytesDownloaded;
+					downloadedFiles[fileIndex] = {
+						path: file.path,
+						sizeBytes: file.sizeBytes,
+						downloadedBytes: boundedFileBytes
+					};
+					await this.emitDownloadProgress({
+						modelId,
+						sessionId,
+						state,
+						message: `Downloading ${file.path}.`,
+						totalBytes,
+						bytesDownloaded: bytesDownloaded - previousFileBytes + boundedFileBytes,
+						files: downloadedFiles
+					});
+				},
+				onRetry: async ({ retryDelayMs, phase }) => {
+					const retryTarget = phase === "metadata" ? `metadata for ${file.path}` : `${file.path}`;
+					await this.emitDownloadProgress({
+						modelId,
+						sessionId,
+						state,
+						message: `Connection interrupted while downloading ${retryTarget}. Retrying automatically in ${formatDuration(retryDelayMs)}.`,
+						totalBytes,
+						bytesDownloaded: bytesDownloaded - previousFileBytes + (downloadedFiles[fileIndex]?.downloadedBytes ?? 0),
+						files: downloadedFiles
+					});
+				}
+			});
+			await mirrorHubCacheFileForTransformers({
+				cacheDir: this.cacheDir,
+				modelId,
+				filePath: file.path,
+				cachedPath
+			});
+			throwIfAborted(signal);
+			const nextDownloadedBytes = file.sizeBytes ?? 0;
+			bytesDownloaded = bytesDownloaded - previousFileBytes + nextDownloadedBytes;
+			downloadedFiles[fileIndex] = {
+				path: file.path,
+				sizeBytes: file.sizeBytes,
+				downloadedBytes: file.sizeBytes
+			};
+			await this.emitDownloadProgress({
+				modelId,
+				sessionId,
+				state,
+				message: `Downloaded ${file.path}.`,
+				totalBytes,
+				bytesDownloaded,
+				files: downloadedFiles
+			});
+		}
+		await this.finishDownload(modelId, sessionId, true, `Local model ${modelId} is ready.`);
+	}
+	async emitDownloadProgress(input) {
+		if (!this.isActiveSession(input.modelId, input.sessionId)) return;
+		const progress = input.totalBytes && input.totalBytes > 0 ? Math.max(0, Math.min(1, input.bytesDownloaded / input.totalBytes)) : void 0;
+		const nextState = LocalModelAssetStateSchema.parse({
+			...input.state,
+			status: "downloading",
+			progress,
+			bytesDownloaded: input.bytesDownloaded,
+			totalBytes: input.totalBytes,
+			files: input.files,
+			updatedAt: this.now(),
+			resumable: true
+		});
+		await this.store.upsert(nextState);
+		this.emitLog({
+			engineId: "local",
+			modelId: input.modelId,
+			selectedGroupId: input.state.plan?.selectedGroupId,
+			status: "downloading",
+			message: input.message,
+			progress,
+			bytesDownloaded: input.bytesDownloaded,
+			totalBytes: input.totalBytes,
+			files: input.files,
+			sessionId: input.sessionId,
+			resumable: true,
+			updatedAt: this.now()
+		});
+	}
+	async finishDownload(modelId, sessionId, success, message) {
+		if (!this.isActiveSession(modelId, sessionId)) return;
+		const current = await this.readSelectedModelState(modelId);
+		const nextState = LocalModelAssetStateSchema.parse({
+			...current,
+			status: success ? "downloaded" : "error",
+			progress: success ? 1 : current.progress,
+			bytesDownloaded: success ? current.totalBytes ?? current.bytesDownloaded : current.bytesDownloaded,
+			totalBytes: current.totalBytes,
+			installedAt: success ? this.now() : current.installedAt,
+			updatedAt: this.now(),
+			error: success ? void 0 : message,
+			resumable: !success
+		});
+		await this.store.upsert(nextState);
+		this.sessions.delete(modelId);
+		this.emitLog({
+			engineId: "local",
+			modelId,
+			selectedGroupId: nextState.plan?.selectedGroupId,
+			status: nextState.status,
+			message,
+			progress: nextState.progress,
+			bytesDownloaded: nextState.bytesDownloaded,
+			totalBytes: nextState.totalBytes,
+			sessionId,
+			resumable: nextState.resumable,
+			files: nextState.files,
+			updatedAt: this.now()
+		});
+	}
+	async readPlan(modelId, transformers, selectedGroupId) {
+		return resolveLocalModelRuntimePlan({
+			modelId,
+			transformers,
+			cacheDir: this.cacheDir,
+			selectedGroupId: selectedGroupId ?? await this.readSelectedGroupId(),
+			hfEndpoint: await this.readHuggingFaceEndpoint(),
+			fetchCacheStore: this.fetchCacheStore
+		}).catch(() => null);
+	}
+	async readPlanForState(modelId, selectedGroupId) {
+		const transformers = await this.getTransformersModule();
+		transformers.env.remoteHost = buildTransformersRemoteHost(await this.readHuggingFaceEndpoint());
+		return this.readPlan(modelId, transformers, selectedGroupId);
+	}
+	async readSelectedModel() {
+		return (await this.options.globalSettingsManager.readSettings()).translationEngines.local.model;
+	}
+	async readSelectedGroupId() {
+		return (await this.options.globalSettingsManager.readSettings()).translationEngines.local.selectedGroupId;
+	}
+	async readHuggingFaceEndpoint() {
+		return (await this.options.globalSettingsManager.readSettings()).translationEngines.local.hfEndpoint;
+	}
+	isActiveSession(modelId, sessionId) {
+		return this.sessions.get(modelId)?.sessionId === sessionId;
+	}
+	emitLog(log) {
+		this.logs.set(log.modelId, log);
+		for (const listener of this.listeners) listener(log);
+	}
+	async getTransformersModule() {
+		if (!this.transformersModulePromise) this.transformersModulePromise = this.loadTransformersModule();
+		return this.transformersModulePromise;
+	}
+	async loadTransformersModule() {
+		return import("@huggingface/transformers");
+	}
+};
+function buildDownloadStateFiles(input) {
+	const currentFileByPath = new Map(input.currentFiles.map((file) => [file.path, file]));
+	return input.planFiles.map((file) => {
+		const downloadedBytes = currentFileByPath.get(file.path)?.downloadedBytes;
+		return {
+			path: file.path,
+			sizeBytes: file.sizeBytes,
+			downloadedBytes: downloadedBytes === void 0 ? 0 : file.sizeBytes === void 0 ? downloadedBytes : Math.min(downloadedBytes, file.sizeBytes)
+		};
+	});
+}
+function sumDownloadedBytes(files) {
+	return files.reduce((total, file) => {
+		const downloadedBytes = file.downloadedBytes ?? 0;
+		if (file.sizeBytes === void 0) return total + downloadedBytes;
+		return total + Math.min(downloadedBytes, file.sizeBytes);
+	}, 0);
+}
+function createAbortableFetch(signal) {
+	return (input, init) => fetch(input, {
+		...init,
+		signal: mergeAbortSignals(init?.signal, signal)
+	});
+}
+function mergeAbortSignals(left, right) {
+	if (!left) return right;
+	if (left === right) return right;
+	const controller = new AbortController();
+	const abort = () => controller.abort();
+	left.addEventListener("abort", abort, { once: true });
+	right.addEventListener("abort", abort, { once: true });
+	if (left.aborted || right.aborted) controller.abort();
+	return controller.signal;
+}
+function throwIfAborted(signal) {
+	if (signal.aborted) throw new Error("Local model download aborted.");
+}
+async function downloadHuggingFaceFileToCacheDirWithProgress(input) {
+	const revision = "main";
+	let lastError;
+	const info = await readHuggingFaceFileDownloadInfoWithRetry({
+		repo: input.repo,
+		path: input.path,
+		revision,
+		hubUrl: input.hubUrl,
+		retryPolicy: input.retryPolicy,
+		fetch: input.fetch,
+		signal: input.signal,
+		onRetry: input.onRetry
+	});
+	if (!info) throw new Error(`Cannot get path info for ${input.path}.`);
+	const totalBytes = input.expectedSizeBytes ?? info.size;
+	if (totalBytes === void 0) throw new Error(`Cannot get path info for ${input.path}.`);
+	const cachePaths = getHubCacheFilePaths({
+		cacheDir: input.cacheDir,
+		modelId: input.repo.name,
+		filePath: input.path,
+		revision,
+		etag: info.etag
+	});
+	const existingPointerSize = await readPathSize(cachePaths.pointerPath);
+	if (existingPointerSize !== null && existingPointerSize >= totalBytes) {
+		await input.onProgress(totalBytes);
+		return cachePaths.pointerPath;
+	}
+	for (let attempt = 0; attempt <= input.retryPolicy.limit; attempt += 1) try {
+		throwIfAborted(input.signal);
+		let resumeBytes = await readPathSize(cachePaths.incompletePath);
+		if (resumeBytes !== null && resumeBytes > totalBytes) {
+			await rm(cachePaths.incompletePath, { force: true });
+			resumeBytes = 0;
+		}
+		if (resumeBytes !== null && resumeBytes > 0) await input.onProgress(Math.min(resumeBytes, totalBytes));
+		if (!await streamDownloadToIncompleteFile({
+			url: info.url,
+			incompletePath: cachePaths.incompletePath,
+			startBytes: resumeBytes ?? 0,
+			totalBytes,
+			accessToken: void 0,
+			fetch: input.fetch,
+			signal: input.signal,
+			onProgress: input.onProgress
+		})) {
+			const blob = await downloadFile({
+				repo: input.repo,
+				path: input.path,
+				revision,
+				hubUrl: input.hubUrl,
+				fetch: input.fetch,
+				downloadInfo: info,
+				xet: false
+			});
+			if (!blob) throw new Error(`Invalid response for file ${input.path}.`);
+			await appendBlobToIncompleteFile({
+				blob: resumeBytes && resumeBytes > 0 ? blob.slice(resumeBytes, totalBytes) : blob,
+				incompletePath: cachePaths.incompletePath,
+				startBytes: resumeBytes ?? 0,
+				totalBytes,
+				onProgress: input.onProgress
+			});
+		}
+		await finalizeHubCacheFile(cachePaths);
+		await input.onProgress(totalBytes);
+		return cachePaths.pointerPath;
+	} catch (error) {
+		lastError = error;
+		if (!isRetryableDownloadError(error) || attempt === input.retryPolicy.limit) throw error;
+		const retryDelayMs = Math.min(input.retryPolicy.maxDelayMs, input.retryPolicy.delayMs * (attempt + 1));
+		await input.onRetry?.({
+			retryDelayMs,
+			phase: "download"
+		});
+		await delay(retryDelayMs, input.signal);
+	}
+	throw lastError instanceof Error ? lastError : /* @__PURE__ */ new Error(`Cannot download ${input.path}.`);
+}
+async function readHuggingFaceFileDownloadInfoWithRetry(input) {
+	let lastError;
+	for (let attempt = 0; attempt <= input.retryPolicy.limit; attempt += 1) try {
+		throwIfAborted(input.signal);
+		return await fileDownloadInfo({
+			repo: input.repo,
+			path: input.path,
+			revision: input.revision,
+			hubUrl: input.hubUrl,
+			fetch: input.fetch
+		});
+	} catch (error) {
+		lastError = error;
+		if (!isRetryableDownloadError(error) || attempt === input.retryPolicy.limit) throw error;
+		const retryDelayMs = Math.min(input.retryPolicy.maxDelayMs, input.retryPolicy.delayMs * (attempt + 1));
+		await input.onRetry?.({
+			retryDelayMs,
+			phase: "metadata"
+		});
+		await delay(retryDelayMs, input.signal);
+	}
+	throw lastError instanceof Error ? lastError : /* @__PURE__ */ new Error(`Cannot get path info for ${input.path}.`);
+}
+async function appendBlobToIncompleteFile(input) {
+	await mkdir(dirname(input.incompletePath), { recursive: true });
+	const fileHandle = await open(input.incompletePath, "a");
+	const reader = input.blob.stream().getReader();
+	let downloadedBytes = input.startBytes;
+	try {
+		while (true) {
+			const result = await reader.read();
+			if (result.done) break;
+			await fileHandle.write(result.value);
+			downloadedBytes += result.value.byteLength;
+			await input.onProgress(Math.min(downloadedBytes, input.totalBytes));
+		}
+	} finally {
+		await reader.cancel().catch(() => void 0);
+		await fileHandle.close();
+	}
+}
+async function streamDownloadToIncompleteFile(input) {
+	const headers = new Headers();
+	if (input.accessToken) headers.set("Authorization", `Bearer ${input.accessToken}`);
+	if (input.startBytes > 0) headers.set("Range", `bytes=${input.startBytes}-`);
+	const response = await input.fetch(input.url, {
+		method: "GET",
+		headers,
+		signal: input.signal
+	});
+	if (!response.ok && response.status !== 206) throw new Error(`Invalid response for file download: status ${response.status}.`);
+	if (!response.body) return false;
+	await mkdir(dirname(input.incompletePath), { recursive: true });
+	const fileHandle = await open(input.incompletePath, input.startBytes > 0 ? "a" : "w");
+	const reader = response.body.getReader();
+	let downloadedBytes = input.startBytes;
+	try {
+		while (true) {
+			const result = await reader.read();
+			if (result.done) break;
+			await fileHandle.write(result.value);
+			downloadedBytes += result.value.byteLength;
+			await input.onProgress(Math.min(downloadedBytes, input.totalBytes));
+		}
+	} finally {
+		await reader.cancel().catch(() => void 0);
+		await fileHandle.close();
+	}
+	return true;
+}
+async function finalizeHubCacheFile(input) {
+	await mkdir(dirname(input.blobPath), { recursive: true });
+	await mkdir(dirname(input.pointerPath), { recursive: true });
+	await rm(input.blobPath, { force: true });
+	await rename(input.incompletePath, input.blobPath);
+	await unlink(input.pointerPath).catch(() => void 0);
+	await symlink(input.blobPath, input.pointerPath);
+}
+function getHubCacheFilePaths(input) {
+	const repoPath = getHubCacheRepoPath(input.cacheDir, input.modelId);
+	const snapshotId = sanitizeEtag(input.etag) || sanitizeId(input.revision);
+	const blobPath = join(repoPath, "blobs", sanitizeEtag(input.etag));
+	return {
+		blobPath,
+		incompletePath: `${blobPath}.incomplete`,
+		pointerPath: join(repoPath, "snapshots", snapshotId, input.filePath)
+	};
+}
+async function readPathSize(path) {
+	try {
+		return (await stat(path)).size;
+	} catch {
+		return null;
+	}
+}
+function isRetryableDownloadError(error) {
+	return isRetryableNetworkError(error, { treatUnknownAsRetryable: true });
+}
+function delay(ms, signal) {
+	return new Promise((resolve$1, reject) => {
+		const timer = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve$1();
+		}, ms);
+		const onAbort = () => {
+			clearTimeout(timer);
+			signal?.removeEventListener("abort", onAbort);
+			reject(/* @__PURE__ */ new Error("Local model download aborted."));
+		};
+		if (signal) {
+			if (signal.aborted) {
+				clearTimeout(timer);
+				reject(/* @__PURE__ */ new Error("Local model download aborted."));
+				return;
+			}
+			signal.addEventListener("abort", onAbort, { once: true });
+		}
+	});
+}
+function formatDuration(ms) {
+	if (ms < 1e3) return `${ms} ms`;
+	const seconds = ms / 1e3;
+	return seconds >= 10 ? `${Math.round(seconds)} s` : `${seconds.toFixed(1)} s`;
+}
+async function mirrorHubCacheFileForTransformers(input) {
+	const sourcePath = await resolveRealCacheFile(input.cachedPath);
+	await copyFileIfMissing(sourcePath, join(getTransformersLocalModelPath(input.cacheDir, input.modelId), input.filePath));
+	await copyFileIfMissing(sourcePath, join(getTransformersFileCacheModelPath(input.cacheDir, input.modelId), input.filePath));
+}
+async function copyFileIfMissing(sourcePath, targetPath) {
+	if (existsSync(targetPath)) return;
+	await mkdir(dirname(targetPath), { recursive: true });
+	await copyFile(sourcePath, targetPath);
+}
+async function readSymlinkTarget(path) {
+	return readlink(path);
+}
+async function resolveRealCacheFile(path) {
+	if (!(await lstat(path)).isSymbolicLink()) return path;
+	return resolve(dirname(path), await readSymlinkTarget(path));
+}
+function getHubCacheRepoPath(cacheDir, modelId) {
+	return join(cacheDir, `models--${modelId.split("/").join("--")}`);
+}
+function toCatalogItem(candidate, asset) {
+	const hasSelectableGroup = candidate.downloadGroups?.some((group) => group.selectable) ?? false;
+	return {
+		...candidate,
+		asset,
+		selectable: hasSelectableGroup || (candidate.size.estimatedTotalBytes ?? 0) > 0,
+		local: asset.status === "downloaded" || asset.status === "paused" || asset.status === "downloading" || (asset.progress ?? 0) > 0
+	};
+}
+function compareCatalogItems(left, right) {
+	if (left.local !== right.local) return left.local ? -1 : 1;
+	if (left.asset.selected !== right.asset.selected) return left.asset.selected ? -1 : 1;
+	const rightProgress = right.asset.progress ?? 0;
+	const leftProgress = left.asset.progress ?? 0;
+	if (left.local && right.local && leftProgress !== rightProgress) return rightProgress - leftProgress;
+	return right.downloads - left.downloads;
+}
+function sanitizeId(value) {
+	return value.replace(/[^a-zA-Z0-9_-]+/g, "-");
+}
+function sanitizeEtag(value) {
+	return sanitizeId(value.replace(/^W\//, "").replace(/^"+|"+$/g, ""));
+}
+function formatBytes(value) {
+	if (!Number.isFinite(value) || value <= 0) return "0 B";
+	const units = [
+		"B",
+		"KB",
+		"MB",
+		"GB"
+	];
+	let size = value;
+	let unitIndex = 0;
+	while (size >= 1024 && unitIndex < units.length - 1) {
+		size /= 1024;
+		unitIndex += 1;
+	}
+	const digits = size >= 100 || unitIndex === 0 ? 0 : 1;
+	return `${size.toFixed(digits)} ${units[unitIndex]}`;
+}
+
 //#endregion
 //#region src/notification-service.ts
 var NotificationService = class {
@@ -3085,7 +4864,13 @@ const globalSettingsRouter = router({
 	get: publicProcedure.query(({ ctx }) => {
 		return ctx.globalSettingsManager.readSettings();
 	}),
-	update: publicProcedure.input(OpenSpecUIGlobalSettingsSchema.partial().extend({ translationCache: TranslationCacheSettingsSchema.partial().optional() })).mutation(async ({ ctx, input }) => {
+	update: publicProcedure.input(OpenSpecUIGlobalSettingsSchema.partial().extend({
+		translationCache: TranslationCacheSettingsSchema.partial().optional(),
+		translationEngines: z.object({
+			openai: TranslationOpenAISettingsSchema.partial().optional(),
+			local: TranslationLocalSettingsSchema.partial().optional()
+		}).optional()
+	})).mutation(async ({ ctx, input }) => {
 		await ctx.globalSettingsManager.writeSettings(input);
 		return { success: true };
 	}),
@@ -3110,6 +4895,96 @@ const translationCacheRouter = router({
 		return ctx.translationCacheService.clear();
 	})
 });
+const translationEnginesRouter = router({
+	list: publicProcedure.query(({ ctx }) => {
+		return ctx.translationEngineService.listEngines();
+	}),
+	searchModels: publicProcedure.input(z.object({
+		engineId: ServiceTranslationEngineIdSchema,
+		query: z.string().optional(),
+		sourceLanguage: z.string().optional(),
+		targetLanguage: z.string().optional(),
+		limit: z.number().int().positive().max(20).optional(),
+		cursor: z.string().optional()
+	})).query(({ ctx, input }) => {
+		return ctx.translationEngineService.searchModels(input);
+	}),
+	getModelDownloadPlan: publicProcedure.input(z.object({
+		engineId: ServiceTranslationEngineIdSchema,
+		model: z.string().min(1),
+		selectedGroupId: z.string().min(1).optional()
+	})).query(({ ctx, input }) => {
+		return ctx.translationEngineService.getModelDownloadPlan(input);
+	}),
+	select: publicProcedure.input(z.object({ engineId: TranslationEngineIdSchema })).mutation(({ ctx, input }) => {
+		return ctx.translationEngineService.selectEngine(input.engineId);
+	}),
+	batchTranslate: publicProcedure.input(BatchTranslateInputSchema).subscription(({ ctx, input }) => {
+		return ctx.translationEngineService.batchTranslate(input);
+	})
+});
+const localModelsRouter = router({
+	listLocal: publicProcedure.query(({ ctx }) => {
+		return ctx.localModelAssetService.listLocalCatalog();
+	}),
+	searchRemote: publicProcedure.input(z.object({
+		requestId: z.string().min(1).optional(),
+		query: z.string().optional(),
+		sourceLanguage: z.string().optional(),
+		targetLanguage: z.string().optional(),
+		limit: z.number().int().positive().max(20).optional(),
+		cursor: z.string().optional()
+	})).query(({ ctx, input }) => {
+		return ctx.localModelAssetService.searchRemoteCatalog({
+			engineId: "local",
+			...input
+		});
+	}),
+	searchRemoteStream: publicProcedure.input(z.object({
+		requestId: z.string().min(1),
+		query: z.string().optional(),
+		sourceLanguage: z.string().optional(),
+		targetLanguage: z.string().optional(),
+		limit: z.number().int().positive().max(20).optional(),
+		cursor: z.string().optional()
+	})).subscription(({ ctx, input }) => {
+		return ctx.localModelAssetService.subscribeRemoteCatalog({
+			engineId: "local",
+			...input
+		});
+	}),
+	state: publicProcedure.input(z.object({
+		modelId: z.string().min(1),
+		selectedGroupId: z.string().min(1).optional()
+	})).query(({ ctx, input }) => {
+		return ctx.localModelAssetService.readSelectedModelState(input.modelId, input.selectedGroupId);
+	}),
+	subscribeLogs: publicProcedure.subscription(({ ctx }) => {
+		return ctx.localModelAssetService.subscribeLogs();
+	}),
+	markSelected: publicProcedure.input(z.object({ modelId: z.string().min(1) })).mutation(async ({ ctx, input }) => {
+		await ctx.localModelAssetService.markSelectedModel(input.modelId);
+		return { success: true };
+	}),
+	download: publicProcedure.input(z.object({
+		modelId: z.string().min(1),
+		selectedGroupId: z.string().min(1).optional()
+	})).mutation(async ({ ctx, input }) => {
+		return ctx.localModelAssetService.startDownload(input.modelId, input.selectedGroupId);
+	}),
+	pause: publicProcedure.input(z.object({ modelId: z.string().min(1) })).mutation(({ ctx, input }) => {
+		return ctx.localModelAssetService.pauseDownload(input.modelId);
+	}),
+	resume: publicProcedure.input(z.object({
+		modelId: z.string().min(1),
+		selectedGroupId: z.string().min(1).optional()
+	})).mutation(async ({ ctx, input }) => {
+		return ctx.localModelAssetService.resumeDownload(input.modelId, input.selectedGroupId);
+	}),
+	delete: publicProcedure.input(z.object({ modelId: z.string().min(1) })).mutation(({ ctx, input }) => {
+		return ctx.localModelAssetService.deleteModel(input.modelId);
+	})
+});
 const OPSX_CORE_PROFILE_WORKFLOWS = [
 	"propose",
 	"explore",
@@ -3552,7 +5427,13 @@ const configRouter = router({
 		dashboard: DashboardConfigSchema.partial().optional(),
 		git: GitConfigSchema.partial().optional(),
 		notifications: NotificationSettingsSchema.partial().optional(),
-		translation: DocumentTranslationConfigSchema.partial().optional()
+		translation: DocumentTranslationConfigSchema.partial().extend({ engines: z.object({
+			local: z.object({
+				model: z.string().min(1).optional(),
+				selectedGroupId: z.string().min(1).optional()
+			}).optional(),
+			openai: z.object({ model: z.string().min(1).optional() }).optional()
+		}).optional() }).optional()
 	})).mutation(async ({ ctx, input }) => {
 		const hasCliCommand = input.cli !== void 0 && Object.prototype.hasOwnProperty.call(input.cli, "command");
 		const hasCliArgs = input.cli !== void 0 && Object.prototype.hasOwnProperty.call(input.cli, "args");
@@ -4207,6 +6088,8 @@ const appRouter = router({
 	config: configRouter,
 	globalSettings: globalSettingsRouter,
 	translationCache: translationCacheRouter,
+	translationEngines: translationEnginesRouter,
+	localModels: localModelsRouter,
 	notifications: notificationsRouter,
 	sounds: soundsRouter,
 	cli: cliRouter,
@@ -4371,6 +6254,10 @@ var SqliteTranslationCacheAdapter = class {
         placeholder_topology_hash TEXT NOT NULL,
         attribute_topology_hash TEXT NOT NULL,
         display_policy_version INTEGER NOT NULL,
+        engine_id TEXT NOT NULL DEFAULT 'browser',
+        engine_version TEXT,
+        model TEXT,
+        translator_contract_version INTEGER NOT NULL DEFAULT 1,
         created_at INTEGER NOT NULL,
         last_accessed_at INTEGER NOT NULL
       );
@@ -4378,13 +6265,18 @@ var SqliteTranslationCacheAdapter = class {
         ON translation_cache_entries(last_accessed_at ASC);
     `);
 		ensureTargetNodesJsonColumn(database);
+		ensureColumn(database, "engine_id", "TEXT NOT NULL DEFAULT 'browser'");
+		ensureColumn(database, "engine_version", "TEXT");
+		ensureColumn(database, "model", "TEXT");
+		ensureColumn(database, "translator_contract_version", "INTEGER NOT NULL DEFAULT 1");
 		this.database = database;
 	}
 	async read(keyHash, now) {
 		const database = await this.requireDatabase();
 		const row = database.prepare(`SELECT key_hash, cache_key, source_text, translated_text, target_nodes_json, source_language,
           target_language, placeholder_topology_hash, attribute_topology_hash,
-          display_policy_version, created_at, last_accessed_at
+          display_policy_version, engine_id, engine_version, model, translator_contract_version,
+          created_at, last_accessed_at
         FROM translation_cache_entries
         WHERE key_hash = ?`).get(keyHash);
 		if (!isSqliteTranslationCacheRow(row)) return null;
@@ -4400,16 +6292,23 @@ var SqliteTranslationCacheAdapter = class {
 			placeholderTopologyHash: row.placeholder_topology_hash,
 			attributeTopologyHash: row.attribute_topology_hash,
 			displayPolicyVersion: row.display_policy_version,
+			engineId: row.engine_id,
+			...row.engine_version ? { engineVersion: row.engine_version } : {},
+			...row.model ? { model: row.model } : {},
+			translatorContractVersion: row.translator_contract_version,
 			createdAt: row.created_at,
 			lastAccessedAt: now
 		};
 	}
 	async write(input, now) {
-		(await this.requireDatabase()).prepare(`INSERT INTO translation_cache_entries (
+		const database = await this.requireDatabase();
+		const entry = TranslationCacheWriteInputSchema.parse(input);
+		database.prepare(`INSERT INTO translation_cache_entries (
           key_hash, cache_key, source_text, translated_text, target_nodes_json, source_language,
           target_language, placeholder_topology_hash, attribute_topology_hash,
-          display_policy_version, created_at, last_accessed_at
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+          display_policy_version, engine_id, engine_version, model, translator_contract_version,
+          created_at, last_accessed_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
         ON CONFLICT(key_hash) DO UPDATE SET
           cache_key = excluded.cache_key,
           source_text = excluded.source_text,
@@ -4420,7 +6319,11 @@ var SqliteTranslationCacheAdapter = class {
           placeholder_topology_hash = excluded.placeholder_topology_hash,
           attribute_topology_hash = excluded.attribute_topology_hash,
           display_policy_version = excluded.display_policy_version,
-          last_accessed_at = excluded.last_accessed_at`).run(input.keyHash, input.key, input.sourceText, input.translatedText, input.targetNodesJson ?? null, input.sourceLanguage, input.targetLanguage, input.placeholderTopologyHash, input.attributeTopologyHash, input.displayPolicyVersion, now, now);
+          engine_id = excluded.engine_id,
+          engine_version = excluded.engine_version,
+          model = excluded.model,
+          translator_contract_version = excluded.translator_contract_version,
+          last_accessed_at = excluded.last_accessed_at`).run(entry.keyHash, entry.key, entry.sourceText, entry.translatedText, entry.targetNodesJson ?? null, entry.sourceLanguage, entry.targetLanguage, entry.placeholderTopologyHash, entry.attributeTopologyHash, entry.displayPolicyVersion, entry.engineId, entry.engineVersion ?? null, entry.model ?? null, entry.translatorContractVersion, now, now);
 	}
 	async count() {
 		return readSqliteCount((await this.requireDatabase()).prepare("SELECT COUNT(*) AS count FROM translation_cache_entries").get());
@@ -4480,15 +6383,18 @@ function isBunRuntime() {
 	return typeof process.versions.bun === "string";
 }
 function ensureTargetNodesJsonColumn(database) {
+	ensureColumn(database, "target_nodes_json", "TEXT");
+}
+function ensureColumn(database, columnName, definition) {
 	if (!database.prepare("PRAGMA table_info(translation_cache_entries)").all().some((row) => {
 		if (!row || typeof row !== "object") return false;
-		return row.name === "target_nodes_json";
-	})) database.exec("ALTER TABLE translation_cache_entries ADD COLUMN target_nodes_json TEXT");
+		return row.name === columnName;
+	})) database.exec(`ALTER TABLE translation_cache_entries ADD COLUMN ${columnName} ${definition}`);
 }
 function isSqliteTranslationCacheRow(value) {
 	if (!value || typeof value !== "object") return false;
 	const row = value;
-	return typeof row.key_hash === "string" && typeof row.cache_key === "string" && typeof row.source_text === "string" && typeof row.translated_text === "string" && (typeof row.target_nodes_json === "string" || row.target_nodes_json === null) && typeof row.source_language === "string" && typeof row.target_language === "string" && typeof row.placeholder_topology_hash === "string" && typeof row.attribute_topology_hash === "string" && typeof row.display_policy_version === "number" && typeof row.created_at === "number" && typeof row.last_accessed_at === "number";
+	return typeof row.key_hash === "string" && typeof row.cache_key === "string" && typeof row.source_text === "string" && typeof row.translated_text === "string" && (typeof row.target_nodes_json === "string" || row.target_nodes_json === null) && typeof row.source_language === "string" && typeof row.target_language === "string" && typeof row.placeholder_topology_hash === "string" && typeof row.attribute_topology_hash === "string" && typeof row.display_policy_version === "number" && (row.engine_id === "browser" || row.engine_id === "local" || row.engine_id === "openai") && (typeof row.engine_version === "string" || row.engine_version === null) && (typeof row.model === "string" || row.model === null) && typeof row.translator_contract_version === "number" && typeof row.created_at === "number" && typeof row.last_accessed_at === "number";
 }
 function readSqliteCount(value) {
 	if (!value || typeof value !== "object") return 0;
@@ -4496,18 +6402,6 @@ function readSqliteCount(value) {
 	return typeof count === "number" ? count : 0;
 }
 
-//#endregion
-//#region src/translation-cache-path.ts
-function getDefaultTranslationCacheDatabasePath() {
-	return join(getOpenSpecUICacheDir(), "translation-cache.sqlite");
-}
-function getOpenSpecUICacheDir() {
-	const currentPlatform = platform();
-	if (currentPlatform === "darwin") return join(homedir(), "Library", "Caches", "openspecui");
-	if (currentPlatform === "win32") return join(process.env.LOCALAPPDATA || join(homedir(), "AppData", "Local"), "OpenSpecUI", "Cache");
-	return join(process.env.XDG_CACHE_HOME || join(homedir(), ".cache"), "openspecui");
-}
-
 //#endregion
 //#region src/translation-cache-service.ts
 var TranslationCacheService = class {
@@ -4568,6 +6462,225 @@ var TranslationCacheService = class {
 	}
 };
 
+//#endregion
+//#region src/translation-engine-service.ts
+var TranslationEngineService = class {
+	projectDir;
+	configManager;
+	globalSettingsManager;
+	now;
+	localCacheDir;
+	localAssetStore;
+	localFetchCacheStore;
+	constructor(options) {
+		ensureProxyAwareFetchDispatcher();
+		this.projectDir = options.projectDir;
+		this.configManager = options.configManager;
+		this.globalSettingsManager = options.globalSettingsManager;
+		this.now = options.now ?? Date.now;
+		this.localCacheDir = options.localCacheDir ?? getDefaultLocalModelCacheDir();
+		this.localAssetStore = new LocalModelAssetStore({ indexPath: options.localAssetIndexPath ?? getDefaultLocalModelIndexPath() });
+		this.localFetchCacheStore = new LocalModelFetchCacheStore({
+			cachePath: options.localFetchCachePath ?? getDefaultLocalModelFetchCachePath(),
+			now: this.now
+		});
+	}
+	async listEngines() {
+		const [config, globalSettings] = await Promise.all([this.configManager.readConfig(), this.globalSettingsManager.readSettings()]);
+		return TRANSLATION_ENGINE_MANIFESTS.map((manifest) => ({
+			...manifest,
+			selected: config.translation.engineId === manifest.id,
+			status: "available",
+			model: manifest.id === "local" ? config.translation.engines.local.model ?? globalSettings.translationEngines.local.model : manifest.id === "openai" ? config.translation.engines.openai.model ?? globalSettings.translationEngines.openai.model : void 0
+		}));
+	}
+	async searchModels(input) {
+		if (input.engineId !== "local") return { items: [] };
+		return searchLocalModels(input, { hfEndpoint: (await this.globalSettingsManager.readSettings()).translationEngines.local.hfEndpoint });
+	}
+	async getModelDownloadPlan(input) {
+		if (input.engineId !== "local") return null;
+		const state = (await this.localAssetStore.readMap()).get(input.model);
+		const plan = await resolveLocalModelRuntimePlanFromProject({
+			projectDir: this.projectDir,
+			globalSettingsManager: this.globalSettingsManager,
+			modelId: input.model,
+			selectedGroupId: input.selectedGroupId,
+			cacheDir: this.localCacheDir,
+			fetchCacheStore: this.localFetchCacheStore,
+			loadTransformersModule: this.loadLocalTransformersModuleForPlan.bind(this)
+		}).catch(() => null);
+		const fallbackPlan = selectPersistedLocalPlan(state, input.selectedGroupId);
+		const effectivePlan = plan ?? fallbackPlan;
+		if (!effectivePlan) return null;
+		return enrichDownloadPlanWithAssetSnapshot(effectivePlan, state, input.selectedGroupId);
+	}
+	async selectEngine(engineId) {
+		await this.configManager.writeConfig({ translation: { engineId } });
+		return { success: true };
+	}
+	batchTranslate(input) {
+		return observable((emit) => {
+			if (input.engineId === "browser") {
+				emit.error(/* @__PURE__ */ new Error("Browser translator runs in the browser runtime."));
+				return () => {};
+			}
+			const controller = new AbortController();
+			(async () => {
+				try {
+					if (input.engineId === "browser") throw new Error("Browser translator runs in the browser runtime.");
+					const dtype = await this.readLocalDtype(input.engineId, input.model, input.selectedGroupId);
+					if (input.engineId === "local" && input.model) await this.assertLocalModelReady(input.model, input.selectedGroupId);
+					const translator = await (await this.loadFactory(input.engineId, input.model)).create({
+						sourceLanguage: input.sourceLanguage,
+						targetLanguage: input.targetLanguage,
+						model: input.model,
+						dtype,
+						runtimeConfig: input.engineId === "local" && input.model ? await this.readLocalRuntimeConfig(input.model) : void 0,
+						signal: controller.signal
+					});
+					try {
+						for await (const event of translator.batchTranslate(input.inputs, {
+							instructions: input.instructions,
+							context: input.context,
+							signal: controller.signal
+						})) emit.next(event);
+						emit.complete();
+					} finally {
+						translator.destroy?.();
+					}
+				} catch (error) {
+					if (!controller.signal.aborted) emit.error(error instanceof Error ? error : new Error(String(error)));
+				}
+			})();
+			return () => {
+				controller.abort();
+			};
+		});
+	}
+	async readLocalDtype(engineId, model, selectedGroupId) {
+		if (engineId !== "local" || !model) return void 0;
+		const effectiveSelectedGroupId = selectedGroupId ?? (await this.globalSettingsManager.readSettings()).translationEngines.local.selectedGroupId;
+		if (!effectiveSelectedGroupId) return void 0;
+		return (await this.getModelDownloadPlan({
+			engineId: "local",
+			model,
+			selectedGroupId: effectiveSelectedGroupId
+		}))?.groups?.find((group) => group.id === effectiveSelectedGroupId)?.dtype;
+	}
+	async assertLocalModelReady(model, selectedGroupId) {
+		const plan = await this.getModelDownloadPlan({
+			engineId: "local",
+			model,
+			selectedGroupId
+		});
+		const files = (plan?.groups?.find((group) => group.id === (selectedGroupId ?? plan.selectedGroupId)) ?? plan?.groups?.find((group) => group.selected))?.files ?? plan?.files ?? [];
+		if (!plan || files.length === 0) throw new Error("No local runtime file plan is available for the selected model.");
+		const cacheStatus = await readLocalModelFileStatus({
+			cacheDir: this.localCacheDir,
+			modelId: model,
+			files: files.map((file) => file.path)
+		});
+		if (cacheStatus.allCached) {
+			const current = (await this.localAssetStore.readMap()).get(model);
+			if (current) await this.localAssetStore.upsert({
+				...current,
+				status: "downloaded",
+				progress: 1,
+				bytesDownloaded: plan.estimatedTotalBytes ?? current.bytesDownloaded,
+				totalBytes: plan.estimatedTotalBytes ?? current.totalBytes,
+				resumable: false,
+				error: void 0,
+				plan,
+				files: files.map((file) => ({
+					path: file.path,
+					sizeBytes: file.sizeBytes,
+					downloadedBytes: file.sizeBytes
+				})),
+				installedAt: current.installedAt ?? this.now(),
+				updatedAt: this.now()
+			});
+			return;
+		}
+		const allMissingFiles = cacheStatus.files.filter((file) => !file.cached).map((file) => file.file);
+		const missingFiles = allMissingFiles.slice(0, 3);
+		const suffix = allMissingFiles.length > missingFiles.length ? ` and ${allMissingFiles.length - missingFiles.length} more` : "";
+		throw new Error(`Selected local model files are not installed locally: ${missingFiles.join(", ")}${suffix}.`);
+	}
+	async readLocalRuntimeConfig(model) {
+		try {
+			return JSON.parse(await readFile(join(this.localCacheDir, "models", model, "config.json"), "utf8"));
+		} catch {
+			return;
+		}
+	}
+	async loadFactory(engineId, model) {
+		const globalSettings = await this.globalSettingsManager.readSettings();
+		if (engineId === "local") return (await import("@openspecui/local-translator")).createLocalTranslatorFactory({
+			defaultModel: model ?? globalSettings.translationEngines.local.model,
+			cacheDir: this.localCacheDir,
+			localOnly: true
+		});
+		return (await import("@openspecui/openai-completion-translator")).createOpenAICompletionTranslatorFactory({
+			baseUrl: globalSettings.translationEngines.openai.baseUrl,
+			token: globalSettings.translationEngines.openai.token,
+			model: model ?? globalSettings.translationEngines.openai.model
+		});
+	}
+	async loadLocalTransformersModuleForPlan(_projectDir, _globalSettingsManager) {
+		return await import("@huggingface/transformers");
+	}
+};
+function enrichDownloadPlanWithAssetSnapshot(plan, state, selectedGroupId) {
+	if (!state?.plan) return plan;
+	const assetGroup = state.plan.groups?.find((group) => group.id === (selectedGroupId ?? plan.selectedGroupId));
+	const mergedGroups = plan.groups?.map((group) => {
+		const matchingAssetGroup = state.plan?.groups?.find((asset) => asset.id === group.id);
+		if (!matchingAssetGroup) return group;
+		return {
+			...group,
+			estimatedTotalBytes: group.estimatedTotalBytes ?? matchingAssetGroup.estimatedTotalBytes,
+			files: group.files.map((file) => {
+				const matchingAssetFile = matchingAssetGroup.files.find((asset) => asset.path === file.path);
+				return matchingAssetFile?.sizeBytes !== void 0 && file.sizeBytes === void 0 ? {
+					...file,
+					sizeBytes: matchingAssetFile.sizeBytes
+				} : file;
+			})
+		};
+	});
+	return {
+		...plan,
+		estimatedTotalBytes: plan.estimatedTotalBytes ?? assetGroup?.estimatedTotalBytes ?? state.plan.estimatedTotalBytes,
+		groups: mergedGroups
+	};
+}
+function selectPersistedLocalPlan(state, selectedGroupId) {
+	const plan = state?.plan;
+	if (!plan) return null;
+	if (!selectedGroupId || !plan.groups?.length) return {
+		...plan,
+		files: [...plan.files],
+		groups: plan.groups?.map((group) => ({
+			...group,
+			files: [...group.files]
+		}))
+	};
+	const selectedGroup = plan.groups.find((group) => group.id === selectedGroupId);
+	if (!selectedGroup) return null;
+	return {
+		modelId: plan.modelId,
+		estimatedTotalBytes: selectedGroup.estimatedTotalBytes,
+		files: [...selectedGroup.files],
+		selectedGroupId: selectedGroup.id,
+		groups: plan.groups.map((group) => ({
+			...group,
+			selected: group.id === selectedGroup.id,
+			files: [...group.files]
+		}))
+	};
+}
+
 //#endregion
 //#region src/workflow-invocation-service.ts
 const COMMAND_CAPABLE_ACTIONS = new Set([
@@ -4822,7 +6935,7 @@ function deferBackgroundTask(task) {
 function createServer(config) {
 	const adapter = new OpenSpecAdapter(config.projectDir);
 	const configManager = new ConfigManager(config.projectDir);
-	const globalSettingsManager = new GlobalSettingsManager();
+	const globalSettingsManager = new GlobalSettingsManager(config.runtimePaths?.globalSettingsPath);
 	const cliExecutor = new CliExecutor(configManager, config.projectDir);
 	const kernel = config.kernel;
 	const hookRuntime = createHookRuntime(config.projectDir);
@@ -4834,16 +6947,17 @@ function createServer(config) {
 	});
 	const notificationService = new NotificationService();
 	const customSoundService = new CustomSoundService();
+	const translationCacheDatabasePath = config.runtimePaths?.translationCacheDatabasePath ?? getDefaultTranslationCacheDatabasePath();
 	let translationCacheAdapterPromise = null;
 	const getTranslationCacheAdapter = () => {
-		translationCacheAdapterPromise ??= createRuntimeSqliteTranslationCacheAdapter(getDefaultTranslationCacheDatabasePath());
+		translationCacheAdapterPromise ??= createRuntimeSqliteTranslationCacheAdapter(translationCacheDatabasePath);
 		return translationCacheAdapterPromise;
 	};
 	const translationCacheService = new TranslationCacheService({
 		configManager,
 		globalSettingsManager,
 		adapter: {
-			databasePath: getDefaultTranslationCacheDatabasePath(),
+			databasePath: translationCacheDatabasePath,
 			init: async () => (await getTranslationCacheAdapter()).init(),
 			read: async (keyHash, now) => (await getTranslationCacheAdapter()).read(keyHash, now),
 			write: async (input, now) => (await getTranslationCacheAdapter()).write(input, now),
@@ -4859,6 +6973,25 @@ function createServer(config) {
 			console.warn("Translation cache write failed:", error);
 		}
 	});
+	const nmtModelCacheDir = config.runtimePaths?.localModelCacheDir ?? getDefaultLocalModelCacheDir();
+	const nmtModelIndexPath = config.runtimePaths?.localModelAssetIndexPath ?? getDefaultLocalModelIndexPath();
+	const nmtModelFetchCachePath = config.runtimePaths?.localModelFetchCachePath ?? getDefaultLocalModelFetchCachePath();
+	const translationEngineService = new TranslationEngineService({
+		projectDir: config.projectDir,
+		configManager,
+		globalSettingsManager,
+		localCacheDir: nmtModelCacheDir,
+		localAssetIndexPath: nmtModelIndexPath,
+		localFetchCachePath: nmtModelFetchCachePath
+	});
+	const localModelAssetService = new LocalModelAssetService({
+		projectDir: config.projectDir,
+		configManager,
+		globalSettingsManager,
+		cacheDir: nmtModelCacheDir,
+		indexPath: nmtModelIndexPath,
+		fetchCachePath: nmtModelFetchCachePath
+	});
 	const watcher = config.enableWatcher !== false ? new OpenSpecWatcher(config.projectDir) : void 0;
 	const entityReadOptionsContext = {
 		adapter,
@@ -4940,6 +7073,8 @@ function createServer(config) {
 				customSoundService,
 				globalSettingsManager,
 				translationCacheService,
+				translationEngineService,
+				localModelAssetService,
 				gitWorktreeHandoff: config.gitWorktreeHandoff,
 				watcher,
 				projectDir: config.projectDir
@@ -4960,6 +7095,8 @@ function createServer(config) {
 		customSoundService,
 		globalSettingsManager,
 		translationCacheService,
+		translationEngineService,
+		localModelAssetService,
 		gitWorktreeHandoff: config.gitWorktreeHandoff,
 		watcher,
 		projectDir: config.projectDir
@@ -4979,6 +7116,7 @@ function createServer(config) {
 		customSoundService,
 		globalSettingsManager,
 		translationCacheService,
+		translationEngineService,
 		hookRuntime,
 		watcher,
 		createContext,
@@ -5077,6 +7215,7 @@ async function startServer(config, setupApp) {
 		close: async () => {
 			kernel.dispose();
 			await server.hookRuntime.dispose();
+			await server.createContext().localModelAssetService.close();
 			server.translationCacheService.close();
 			wsServer.close();
 			httpServer.close();
@@ -5085,4 +7224,4 @@ async function startServer(config, setupApp) {
 }
 
 //#endregion
-export { DocumentService, OPENSPECUI_HOOKS_RELATIVE_PATH, ProjectHookRuntime, WorkflowInvocationService, createHookRuntime, createServer, createWebSocketServer, findAvailablePort, isPortAvailable, startServer };
+export { DocumentService, LocalModelAssetService, OPENSPECUI_HOOKS_RELATIVE_PATH, ProjectHookRuntime, TranslationEngineService, WorkflowInvocationService, createHookRuntime, createServer, createWebSocketServer, findAvailablePort, isPortAvailable, startServer };