@openspecui/server 3.10.0 → 3.11.1

package/dist/index.mjs

@@ -1,5 +1,5 @@
-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 { BatchTranslateInputSchema, CliExecutor, CodeEditorThemeSchema, ConfigManager, CustomSoundHashSchema, DASHBOARD_METRIC_KEYS, DashboardConfigSchema, DocumentTranslationConfigSchema, GitConfigSchema, GlobalSettingsManager, LocalModelAssetStateSchema, LocalModelLifecycleFileStateSchema, LocalModelLifecycleGroupStateSchema, LocalModelProfileManifestSchema, 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, checkLocalDirectionalModelLanguagePair, clearCache, getAllTools, getAvailableTools, getConfiguredTools, getDefaultCliCommandString, getDetectedProjectTools, getOpsxEntityRootRelativePath, getToolInitStates, getWatcherRuntimeStatus, inferFileMime, inferFilePreviewKind, initWatcherPool, isWatcherPoolInitialized, normalizeOpsxEntityPath, parseOpsxEntityMetadata, parseOpsxSchemaDetail, resolveTerminalShellDefaults, selectLocalDownloadGroup, sniffGlobalCli, subscribeWatcherRuntimeStatus, terminalNotificationEventToPublishInput } from "@openspecui/core";
+import { basename, dirname, extname, join, matchesGlob, relative, resolve, sep } from "node:path";
 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";
@@ -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 { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, statSync } 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,7 +16,7 @@ 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 { downloadFile, fileDownloadInfo, listFiles, modelInfo } from "@huggingface/hub";
 import { observable } from "@trpc/server/observable";
 import { z } from "zod";
 import { Agent, EnvHttpProxyAgent, setGlobalDispatcher } from "undici";
@@ -357,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$2(path) {
+async function pathExists$1(path) {
 	try {
 		await access(path);
 		return true;
@@ -386,8 +386,8 @@ var ProjectHookRuntime = class {
 		await Promise.allSettled(callbacks.map((cleanup) => cleanup()));
 	}
 	async loadFresh() {
-		if (!await pathExists$2(this.hooksPath)) return {};
-		const { tsImport } = await import("tsx/esm/api");
+		if (!await pathExists$1(this.hooksPath)) return {};
+		const { tsImport } = await import("./api-C9I67iTa.mjs");
 		return normalizeHooksModule(await tsImport(`${pathToFileURL(this.hooksPath).href}?t=${Date.now()}`, { parentURL: pathToFileURL(this.hooksPath).href }));
 	}
 };
@@ -799,7 +799,7 @@ function parseRelatedChanges(paths) {
 			continue;
 		}
 	}
-	return [...related].sort((a, b) => a.localeCompare(b));
+	return [...related].sort((a$1, b) => a$1.localeCompare(b));
 }
 async function resolveDefaultBranch(projectDir, runGit) {
 	const remoteHead = await runGit(projectDir, [
@@ -1067,9 +1067,9 @@ async function buildDashboardGitSnapshot(options) {
 		maxCommitEntries,
 		readPathTimestampMs
 	})));
-	worktrees.sort((a, b) => {
-		if (a.isCurrent !== b.isCurrent) return a.isCurrent ? -1 : 1;
-		return a.branchName.localeCompare(b.branchName);
+	worktrees.sort((a$1, b) => {
+		if (a$1.isCurrent !== b.isCurrent) return a$1.isCurrent ? -1 : 1;
+		return a$1.branchName.localeCompare(b.branchName);
 	});
 	return {
 		defaultBranch,
@@ -1092,7 +1092,7 @@ function createEmptyTrendSeries() {
 	return Object.fromEntries(DASHBOARD_METRIC_KEYS.map((metric) => [metric, []]));
 }
 function normalizeEvents(events, pointLimit) {
-	return events.filter((event) => Number.isFinite(event.ts) && event.ts > 0 && Number.isFinite(event.value)).sort((a, b) => a.ts - b.ts).slice(-pointLimit);
+	return events.filter((event) => Number.isFinite(event.ts) && event.ts > 0 && Number.isFinite(event.value)).sort((a$1, b) => a$1.ts - b.ts).slice(-pointLimit);
 }
 function buildTimeWindow(options) {
 	const { probeEvents, targetBars, rightEdgeTs } = options;
@@ -1450,6 +1450,160 @@ async function buildEntityReadOptions(ctx, stage, id) {
 	}
 }
 
+//#endregion
+//#region src/entity-file-paths.ts
+function ensureInsideRoot(rootPath, candidatePath) {
+	if (candidatePath === rootPath) return;
+	if (!candidatePath.startsWith(rootPath + "/")) throw new Error("Resolved path escaped entity root.");
+}
+function getEntityRootPath(projectDir, stage, changeId) {
+	return resolve(projectDir, getOpsxEntityRootRelativePath(stage, changeId));
+}
+function resolveEntityEntryPath(input) {
+	const relativePath$1 = normalizeOpsxEntityPath(input.path);
+	if (!relativePath$1) throw new Error("path is required");
+	const entityRoot = getEntityRootPath(input.projectDir, input.stage, input.changeId);
+	const absolutePath = resolve(entityRoot, relativePath$1);
+	ensureInsideRoot(entityRoot, absolutePath);
+	return {
+		entityRoot,
+		relativePath: relativePath$1,
+		absolutePath
+	};
+}
+
+//#endregion
+//#region src/file-preview-service.ts
+const PREVIEW_ENTRY_FILE_BY_KIND = {
+	image: "image-preview.html",
+	audio: "audio-preview.html",
+	video: "video-preview.html",
+	pdf: "pdf-preview.html"
+};
+const SESSION_PREVIEW_KINDS = new Set([
+	"html",
+	"image",
+	"audio",
+	"video",
+	"pdf"
+]);
+function isSessionPreviewKind(previewKind) {
+	return SESSION_PREVIEW_KINDS.has(previewKind);
+}
+function toHash(input) {
+	return createHash("sha256").update(input).digest("hex");
+}
+function stripLeadingSlash(path) {
+	return path.replace(/^\/+/, "");
+}
+function inferPreviewAssetContentType(path) {
+	switch (extname(path).toLowerCase()) {
+		case ".html": return "text/html";
+		case ".js":
+		case ".mjs": return "application/javascript";
+		case ".css": return "text/css";
+		case ".json": return "application/json";
+		case ".svg": return "image/svg+xml";
+		case ".png": return "image/png";
+		case ".jpg":
+		case ".jpeg": return "image/jpeg";
+		case ".woff": return "font/woff";
+		case ".woff2": return "font/woff2";
+		default: return inferFileMime(path) ?? "application/octet-stream";
+	}
+}
+function isRewritablePreviewAsset(path) {
+	const extension = extname(path).toLowerCase();
+	return extension === ".html" || extension === ".js" || extension === ".mjs" || extension === ".css";
+}
+function rewritePreviewAssetPaths(content, hash) {
+	const sessionAssetPrefix = `/api/file-preview/${hash}/assets/`;
+	return content.replaceAll("/assets/", sessionAssetPrefix);
+}
+var FilePreviewService = class {
+	sessions = /* @__PURE__ */ new Map();
+	constructor(projectDir, previewAssetsDir) {
+		this.projectDir = projectDir;
+		this.previewAssetsDir = previewAssetsDir;
+	}
+	prepareEntityFilePreview(input) {
+		const resolved = resolveEntityEntryPath({
+			projectDir: this.projectDir,
+			stage: input.stage,
+			changeId: input.changeId,
+			path: input.path
+		});
+		if (!statSync(resolved.absolutePath, { throwIfNoEntry: false })?.isFile()) throw new Error("Preview target file not found.");
+		const mime = inferFileMime(resolved.relativePath);
+		if (!mime) throw new Error("Preview target mime is unknown.");
+		const previewKind = inferFilePreviewKind(resolved.relativePath, mime);
+		if (!isSessionPreviewKind(previewKind)) throw new Error("Preview route is not supported for this file type.");
+		const directoryPath = resolve(resolved.absolutePath, "..");
+		const hash = toHash(`${directoryPath}:${mime}`);
+		const entryFileName = previewKind === "html" ? null : PREVIEW_ENTRY_FILE_BY_KIND[previewKind];
+		const fileName = basename(resolved.absolutePath);
+		this.sessions.set(hash, {
+			hash,
+			directoryPath,
+			mime,
+			previewKind,
+			entryFileName
+		});
+		const htmlPathname = `/api/file-preview/${hash}/${fileName}`;
+		const resourcePathname = previewKind === "html" ? null : `/api/file-preview/${hash}/resource/${fileName}`;
+		const entryPathname = previewKind === "html" ? htmlPathname : `/api/file-preview/${hash}/${entryFileName}`;
+		return {
+			hash,
+			mime,
+			previewKind,
+			relativePath: resolved.relativePath,
+			resourcePathname,
+			entryPathname,
+			urlPath: previewKind === "html" ? htmlPathname : `${entryPathname}?file=${encodeURIComponent(fileName)}`
+		};
+	}
+	readPreviewRequest(hash, requestPath) {
+		const session = this.sessions.get(hash);
+		if (!session) return null;
+		const normalized = stripLeadingSlash(requestPath);
+		if (session.previewKind === "html") {
+			const absolutePath$1 = resolve(session.directoryPath, normalized);
+			if (!absolutePath$1.startsWith(session.directoryPath + "/")) return null;
+			if (!existsSync(absolutePath$1) || !statSync(absolutePath$1).isFile()) return null;
+			return {
+				content: readFileSync(absolutePath$1),
+				contentType: inferFileMime(absolutePath$1) ?? "application/octet-stream"
+			};
+		}
+		if (normalized.startsWith("resource/")) {
+			const resourcePath = normalized.slice(9);
+			const absolutePath$1 = resolve(session.directoryPath, resourcePath);
+			if (!absolutePath$1.startsWith(session.directoryPath + "/")) return null;
+			if (!existsSync(absolutePath$1) || !statSync(absolutePath$1).isFile()) return null;
+			return {
+				content: readFileSync(absolutePath$1),
+				contentType: inferFileMime(absolutePath$1) ?? "application/octet-stream"
+			};
+		}
+		const assetName = normalized || session.entryFileName;
+		if (!assetName) return null;
+		const absolutePath = resolve(this.previewAssetsDir, assetName);
+		if (!absolutePath.startsWith(resolve(this.previewAssetsDir) + "/")) return null;
+		if (!existsSync(absolutePath) || !statSync(absolutePath).isFile()) return null;
+		if (isRewritablePreviewAsset(assetName)) {
+			const rewritten = rewritePreviewAssetPaths(readFileSync(absolutePath, "utf8"), hash);
+			return {
+				content: Buffer.from(rewritten, "utf8"),
+				contentType: inferPreviewAssetContentType(absolutePath)
+			};
+		}
+		return {
+			content: readFileSync(absolutePath),
+			contentType: inferPreviewAssetContentType(absolutePath)
+		};
+	}
+};
+
 //#endregion
 //#region src/huggingface-endpoint.ts
 const DEFAULT_HUGGING_FACE_ENDPOINT = "https://huggingface.co";
@@ -1461,9 +1615,6 @@ function normalizeHuggingFaceEndpoint(endpoint) {
 function buildHuggingFaceApiBaseUrl(endpoint) {
 	return `${normalizeHuggingFaceEndpoint(endpoint)}/api`;
 }
-function buildTransformersRemoteHost(endpoint) {
-	return `${normalizeHuggingFaceEndpoint(endpoint)}/`;
-}
 
 //#endregion
 //#region src/local-model-asset-store.ts
@@ -1532,9 +1683,21 @@ function getDefaultLocalModelCacheDir() {
 function getDefaultLocalModelIndexPath() {
 	return join(getDefaultLocalModelCacheRoot(), "models.json");
 }
+function getDefaultLocalModelProfileManifestPath() {
+	return join(getDefaultLocalModelCacheRoot(), "profile-manifests.json");
+}
 function getDefaultLocalModelFetchCachePath() {
 	return join(getDefaultLocalModelCacheRoot(), "fetch-cache.json");
 }
+function getLocalModelProfileRoot(cacheDir, modelId) {
+	return join(cacheDir, "profiles", sanitizeLocalModelPathSegment(modelId));
+}
+function getLocalModelProfileGroupRoot(cacheDir, modelId, groupId) {
+	return join(getLocalModelProfileRoot(cacheDir, modelId), sanitizeLocalModelPathSegment(groupId));
+}
+function sanitizeLocalModelPathSegment(value) {
+	return value.replace(/[^a-zA-Z0-9._-]+/g, "-");
+}
 
 //#endregion
 //#region src/local-model-fetch-cache-store.ts
@@ -1687,60 +1850,80 @@ function getTransformersLocalModelPath(cacheDir, 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-profile-manifest-store.ts
+const LocalModelProfileManifestIndexSchema = z.object({
+	version: z.literal(1).default(1),
+	manifests: z.array(LocalModelProfileManifestSchema).default([])
+});
+var LocalModelProfileManifestStore = class {
+	constructor(options) {
+		this.options = options;
+	}
+	getManifestPath() {
+		return this.options.manifestPath;
+	}
+	async readAll() {
+		return (await this.readFile()).manifests;
+	}
+	async readMap() {
+		return new Map((await this.readAll()).map((manifest) => [manifest.modelId, manifest]));
+	}
+	async read(modelId) {
+		return (await this.readMap()).get(modelId) ?? null;
+	}
+	async writeAll(manifests) {
+		const normalized = LocalModelProfileManifestIndexSchema.parse({
+			version: 1,
+			manifests: [...manifests].sort((left, right) => left.modelId.localeCompare(right.modelId))
+		});
+		const serialized = JSON.stringify(normalized, null, 2);
+		await mkdir(dirname(this.options.manifestPath), { recursive: true });
+		const tempPath = `${this.options.manifestPath}.${process.pid}.${Date.now()}.tmp`;
+		await writeFile(tempPath, `${serialized}\n`, "utf8");
+		await rename(tempPath, this.options.manifestPath);
+		clearCache();
+	}
+	async upsert(manifest) {
+		const manifests = await this.readMap();
+		manifests.set(manifest.modelId, LocalModelProfileManifestSchema.parse(manifest));
+		await this.writeAll([...manifests.values()]);
+	}
+	async remove(modelId) {
+		const manifests = await this.readMap();
+		if (!manifests.delete(modelId)) return;
+		await this.writeAll([...manifests.values()]);
+	}
+	async readFile() {
+		try {
+			const content = await readFile(this.options.manifestPath, "utf8");
+			const parsed = JSON.parse(content);
+			const result = LocalModelProfileManifestIndexSchema.safeParse(parsed);
+			return result.success ? result.data : LocalModelProfileManifestIndexSchema.parse({});
+		} catch {
+			return LocalModelProfileManifestIndexSchema.parse({});
+		}
+	}
+};
 
 //#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({
+async function readLocalModelRepositorySnapshot(input) {
+	return readHuggingFaceRepositorySnapshot({
 		modelId: input.modelId,
-		selectedGroupId: input.selectedGroupId,
-		files: repositoryFiles
+		hubUrl: normalizeHuggingFaceEndpoint(input.hfEndpoint),
+		fetchCacheStore: input.fetchCacheStore,
+		revision: input.revision
 	});
 }
-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) {
+async function readHuggingFaceRepositorySnapshot(input) {
+	const detail = await readHuggingFaceModelSnapshotInfo(input).catch(() => null);
 	let lastError;
 	for (let attempt = 0; attempt < 3; attempt += 1) {
 		try {
 			const files = [];
+			let commitHash = detail?.commitHash;
 			for await (const entry of listFiles({
 				repo: {
 					type: "model",
@@ -1748,16 +1931,30 @@ async function readHuggingFaceRepositoryFiles(input) {
 				},
 				recursive: true,
 				expand: true,
+				revision: input.revision,
 				hubUrl: input.hubUrl,
 				fetch: input.fetchCacheStore ? createProviderFetchCache(input.fetchCacheStore) : void 0
 			})) {
 				if (entry.type !== "file") continue;
+				commitHash ??= entry.lastCommit?.id;
+				const etag = entry.lfs?.oid ?? entry.xetHash ?? entry.oid;
 				files.push({
 					path: entry.path,
-					sizeBytes: entry.lfs?.size ?? entry.size
+					sizeBytes: entry.lfs?.size ?? entry.size,
+					etag,
+					revision: entry.lastCommit?.id,
+					sourceUrl: `${input.hubUrl}/${input.modelId}/resolve/${entry.lastCommit?.id ?? input.revision ?? "main"}/${entry.path}`,
+					raw: entry
 				});
 			}
-			if (files.length > 0) return files;
+			if (files.length > 0 && commitHash) return {
+				modelId: input.modelId,
+				revision: input.revision ?? "main",
+				commitHash,
+				shortCommitHash: commitHash.slice(0, 6),
+				files,
+				raw: detail?.raw
+			};
 			lastError = /* @__PURE__ */ new Error(`No repository files were returned for ${input.modelId}.`);
 		} catch (error) {
 			lastError = error;
@@ -1765,17 +1962,40 @@ async function readHuggingFaceRepositoryFiles(input) {
 		if (attempt < 2) await delay$2(300 * (attempt + 1));
 	}
 	const cachedFiles = await readCachedHuggingFaceRepositoryFiles(input);
-	if (cachedFiles.length > 0) return cachedFiles;
+	if (cachedFiles.files.length > 0 && cachedFiles.commitHash) return {
+		modelId: input.modelId,
+		revision: input.revision ?? "main",
+		commitHash: cachedFiles.commitHash,
+		shortCommitHash: cachedFiles.commitHash.slice(0, 6),
+		files: cachedFiles.files,
+		raw: cachedFiles.raw
+	};
 	throw lastError instanceof Error ? lastError : /* @__PURE__ */ new Error(`Unable to read repository files for ${input.modelId}.`);
 }
+async function readHuggingFaceModelSnapshotInfo(input) {
+	const detail = await modelInfo({
+		name: input.modelId,
+		hubUrl: input.hubUrl,
+		revision: input.revision,
+		additionalFields: ["sha"]
+	});
+	const raw = detail;
+	const commitHash = typeof detail.sha === "string" ? detail.sha : void 0;
+	if (!commitHash) throw new Error(`Unable to resolve a commit hash for ${input.modelId}.`);
+	return {
+		commitHash,
+		raw
+	};
+}
 async function readCachedHuggingFaceRepositoryFiles(input) {
-	if (!input.fetchCacheStore) return [];
+	if (!input.fetchCacheStore) return { files: [] };
 	const record = await input.fetchCacheStore.read(input.modelId);
-	if (!record?.detailRaw) return [];
+	if (!record?.detailRaw) return { files: [] };
 	return extractRepositoryFilesFromCachedDetail(record.detailRaw);
 }
 function extractRepositoryFilesFromCachedDetail(raw) {
 	const siblings = Array.isArray(raw.siblings) ? raw.siblings : [];
+	const commitHash = typeof raw.sha === "string" ? raw.sha : void 0;
 	const files = [];
 	for (const sibling of siblings) {
 		if (!sibling || typeof sibling !== "object") continue;
@@ -1784,10 +2004,16 @@ function extractRepositoryFilesFromCachedDetail(raw) {
 		if (!path) continue;
 		files.push({
 			path,
-			sizeBytes: typeof record.size === "number" && Number.isFinite(record.size) ? record.size : void 0
+			sizeBytes: typeof record.size === "number" && Number.isFinite(record.size) ? record.size : void 0,
+			revision: commitHash,
+			raw: record
 		});
 	}
-	return files;
+	return {
+		files,
+		commitHash,
+		raw
+	};
 }
 function createProviderFetchCache(fetchCacheStore) {
 	return async (input, init) => {
@@ -1815,9 +2041,6 @@ function headersToRecord$1(headers) {
 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
@@ -2267,6 +2490,7 @@ const DEFAULT_NETWORK_RETRY_DELAY_MAX_MS = 5e3;
 var LocalModelAssetService = class {
 	now;
 	store;
+	profileManifestStore;
 	cacheDir;
 	fetchCacheStore;
 	networkRetryPolicy;
@@ -2286,6 +2510,7 @@ var LocalModelAssetService = class {
 			maxDelayMs: options.networkRetryPolicy?.maxDelayMs ?? DEFAULT_NETWORK_RETRY_DELAY_MAX_MS
 		};
 		this.store = new LocalModelAssetStore({ indexPath: options.indexPath ?? getDefaultLocalModelIndexPath() });
+		this.profileManifestStore = new LocalModelProfileManifestStore({ manifestPath: options.profileManifestPath ?? getDefaultLocalModelProfileManifestPath() });
 		this.fetchCacheStore = new LocalModelFetchCacheStore({
 			cachePath: options.fetchCachePath ?? getDefaultLocalModelFetchCachePath(),
 			now: this.now
@@ -2387,106 +2612,129 @@ var LocalModelAssetService = class {
 	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({
+		const selected = modelId === await this.readSelectedModel();
+		const baseState = LocalModelAssetStateSchema.parse({
 			modelId,
 			status: "not-downloaded",
-			selected: modelId === await this.readSelectedModel(),
+			selected,
+			selectedGroupId,
 			updatedAt: this.now()
 		});
+		return this.refreshCachedState(baseState, selectedGroupId);
 	}
-	async startDownload(modelId, selectedGroupId) {
-		return this.runDownload(modelId, "downloading", "Downloading local model", selectedGroupId);
+	async startDownload(modelId, groupId) {
+		return this.runDownload(modelId, "downloading", "Downloading local model", groupId);
 	}
-	async resumeDownload(modelId, selectedGroupId) {
-		return this.runDownload(modelId, "downloading", "Resuming local model download", selectedGroupId);
+	async resumeDownload(modelId, groupId) {
+		return this.runDownload(modelId, "downloading", "Resuming local model download", groupId);
 	}
-	async pauseDownload(modelId) {
-		const session = this.sessions.get(modelId);
+	async pauseDownload(modelId, groupId) {
+		const requestedGroupId = groupId ?? await this.readSelectedGroupId();
+		if (!requestedGroupId) return { success: true };
+		const current = await this.readSelectedModelState(modelId, requestedGroupId);
+		const effectiveGroupId = current.plan?.selectedGroupId ?? current.selectedGroupId ?? requestedGroupId;
+		const sessionKey = buildSessionKey(modelId, effectiveGroupId);
+		const session = this.sessions.get(sessionKey);
 		if (session) {
 			session.abortController.abort();
-			this.sessions.delete(modelId);
+			this.sessions.delete(sessionKey);
 		}
-		const current = await this.readSelectedModelState(modelId);
+		const nextGroupsState = {
+			...current.groupsState,
+			[effectiveGroupId]: LocalModelLifecycleGroupStateSchema.parse({
+				...current.groupsState[effectiveGroupId],
+				groupId: effectiveGroupId,
+				status: "paused",
+				resumable: true,
+				updatedAt: this.now()
+			})
+		};
 		const nextState = LocalModelAssetStateSchema.parse({
 			...current,
-			status: "paused",
-			resumable: true,
+			groupsState: nextGroupsState,
 			updatedAt: this.now()
 		});
-		await this.store.upsert(nextState);
+		const projected = await this.refreshCachedState(nextState, effectiveGroupId, { revalidateDisk: true });
+		await this.store.upsert(projected);
 		this.emitLog({
 			engineId: "local",
 			modelId,
-			selectedGroupId: current.plan?.selectedGroupId,
+			selectedGroupId: effectiveGroupId,
+			groupId: effectiveGroupId,
 			status: "paused",
 			message: "Local model download paused.",
-			progress: nextState.progress,
-			bytesDownloaded: nextState.bytesDownloaded,
-			totalBytes: nextState.totalBytes,
+			progress: projected.progress,
+			bytesDownloaded: projected.bytesDownloaded,
+			totalBytes: projected.totalBytes,
 			resumable: true,
-			files: nextState.files,
+			files: projected.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);
+	async deleteModel(modelId, groupId) {
+		const requestedGroupId = groupId ?? await this.readSelectedGroupId();
+		if (!requestedGroupId) {
+			await this.store.remove(modelId);
+			await this.profileManifestStore.remove(modelId);
+			return { success: true };
+		}
+		const current = await this.readSelectedModelState(modelId, requestedGroupId);
+		const effectiveGroupId = current.plan?.selectedGroupId ?? current.selectedGroupId ?? requestedGroupId;
+		const sessionKey = buildSessionKey(modelId, effectiveGroupId);
+		this.sessions.get(sessionKey)?.abortController.abort();
+		this.sessions.delete(sessionKey);
 		await this.store.upsert(LocalModelAssetStateSchema.parse({
 			...current,
-			status: "deleting",
+			groupsState: {
+				...current.groupsState,
+				[effectiveGroupId]: LocalModelLifecycleGroupStateSchema.parse({
+					...current.groupsState[effectiveGroupId],
+					groupId: effectiveGroupId,
+					status: "deleting",
+					updatedAt: this.now()
+				})
+			},
 			updatedAt: this.now()
 		}));
 		this.emitLog({
 			engineId: "local",
 			modelId,
-			selectedGroupId: current.plan?.selectedGroupId,
+			selectedGroupId: effectiveGroupId,
+			groupId: effectiveGroupId,
 			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), {
+		await rm(getLocalModelProfileGroupRoot(this.cacheDir, modelId, effectiveGroupId), {
 			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);
+		const persistedManifest = await this.profileManifestStore.read(modelId);
+		const nextGroupsState = { ...current.groupsState };
+		delete nextGroupsState[effectiveGroupId];
+		const isPersistedManifestGroup = Boolean(persistedManifest?.groups[effectiveGroupId]);
+		const nextManifest = isPersistedManifestGroup ? persistedManifest : current.profileManifest ? removeManifestGroup(current.profileManifest, effectiveGroupId) : void 0;
+		const nextPlan = isPersistedManifestGroup ? void 0 : current.plan ? removePlanGroup(current.plan, effectiveGroupId) : void 0;
+		const nextSelectedGroupId = current.selectedGroupId === effectiveGroupId ? void 0 : current.selectedGroupId;
+		const nextState = await this.refreshCachedState(LocalModelAssetStateSchema.parse({
+			...current,
+			selectedGroupId: nextSelectedGroupId,
+			profileManifest: nextManifest,
+			groupsState: nextGroupsState,
+			plan: nextPlan,
+			updatedAt: this.now()
+		}), nextSelectedGroupId, { revalidateDisk: true });
+		if (nextState.profileManifest) await this.profileManifestStore.upsert(nextState.profileManifest);
+		else await this.profileManifestStore.remove(modelId);
+		if (nextState.profileManifest || nextState.plan?.groups?.length) await this.store.upsert(nextState);
+		else await this.store.remove(modelId);
 		this.emitLog({
 			engineId: "local",
 			modelId,
-			selectedGroupId: current.plan?.selectedGroupId,
+			selectedGroupId: effectiveGroupId,
+			groupId: effectiveGroupId,
 			status: "not-downloaded",
 			message: "Local model files were removed.",
 			progress: 0,
@@ -2497,6 +2745,49 @@ var LocalModelAssetService = class {
 		});
 		return { success: true };
 	}
+	async refreshProfiles(modelId) {
+		const targetModelId = modelId ?? await this.readSelectedModel();
+		const loadingState = LocalModelAssetStateSchema.parse({
+			...await this.readSelectedModelState(targetModelId),
+			profileLoad: {
+				status: "loading",
+				message: "Loading local model profiles.",
+				updatedAt: this.now()
+			},
+			updatedAt: this.now()
+		});
+		await this.store.upsert(loadingState);
+		try {
+			const manifest = await this.createProfileManifest(targetModelId);
+			await this.profileManifestStore.upsert(manifest);
+			const current = await this.readSelectedModelState(targetModelId);
+			const nextState = await this.refreshCachedState(LocalModelAssetStateSchema.parse({
+				...current,
+				profileManifest: manifest,
+				profileLoad: {
+					status: "ready",
+					message: "Local model profiles are ready.",
+					updatedAt: this.now()
+				},
+				updatedAt: this.now()
+			}), void 0, { revalidateDisk: true });
+			await this.store.upsert(nextState);
+			return nextState;
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unable to load local model profiles.";
+			const failedState = LocalModelAssetStateSchema.parse({
+				...await this.readSelectedModelState(targetModelId),
+				profileLoad: {
+					status: "error",
+					error: message,
+					updatedAt: this.now()
+				},
+				updatedAt: this.now()
+			});
+			await this.store.upsert(failedState);
+			throw error;
+		}
+	}
 	async markSelectedModel(modelId) {
 		const nextStates = (await this.store.readAll()).map((state) => LocalModelAssetStateSchema.parse({
 			...state,
@@ -2511,7 +2802,7 @@ var LocalModelAssetService = class {
 		await this.store.writeAll(nextStates);
 	}
 	async waitForModelTask(modelId) {
-		await this.sessionTasks.get(modelId);
+		await Promise.all([...this.sessionTasks.entries()].filter(([sessionKey]) => sessionKey.startsWith(`${modelId}:`)).map(([, task]) => task));
 	}
 	async close() {
 		const sessions = [...this.sessions.values()];
@@ -2570,176 +2861,298 @@ var LocalModelAssetService = class {
 		}));
 		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
+	async refreshCachedState(state, selectedGroupId, options = {}) {
+		const [selectedModel, persistedSelectedGroupId] = await Promise.all([this.readSelectedModel(), this.readSelectedGroupId()]);
+		const selected = state.selected || state.modelId === selectedModel;
+		const selectedGroupIdFromSettings = selectedGroupId ?? persistedSelectedGroupId;
+		const manifest = filterConcreteProfileManifest(state.profileManifest ?? await this.profileManifestStore.read(state.modelId) ?? void 0);
+		const migrated = migrateLegacyStateToGroups(state, manifest, this.now());
+		const manifestWithHistoricalGroups = mergeHistoricalGroupsIntoManifest({
+			cacheDir: this.cacheDir,
+			modelId: state.modelId,
+			manifest,
+			groupsState: migrated.groupsState,
+			fallbackPlan: migrated.plan
 		});
-		const effectivePlan = plan ?? {
+		const selectedGroupIdForProjection = resolveManifestGroupId(manifestWithHistoricalGroups, selectedGroupIdFromSettings ?? migrated.selectedGroupId ?? migrated.plan?.selectedGroupId) ?? selectFirstManifestGroupId(manifestWithHistoricalGroups);
+		const reconciledGroupsState = options.revalidateDisk ? await this.reconcileGroupsFromDisk({
 			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()
+			manifest: manifestWithHistoricalGroups,
+			groupsState: migrated.groupsState
+		}) : this.reconcileGroupsFromSnapshot({
+			modelId: state.modelId,
+			manifest: manifestWithHistoricalGroups,
+			groupsState: migrated.groupsState
 		});
-		const planFiles = selectedGroup?.files ?? effectivePlan.files;
-		const cacheStatus = await readLocalModelFileStatus({
-			cacheDir: this.cacheDir,
+		const plan = buildPlanFromManifest({
 			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);
+			manifest: manifestWithHistoricalGroups,
+			groupsState: reconciledGroupsState,
+			selectedGroupId: selectedGroupIdForProjection
+		});
+		const selectedPlanGroup = selectLocalDownloadGroup(plan, selectedGroupIdForProjection);
+		const selectedGroupState = selectedPlanGroup && reconciledGroupsState[selectedPlanGroup.id] ? reconciledGroupsState[selectedPlanGroup.id] : void 0;
+		const files = selectedPlanGroup?.files.map((file) => {
+			const stateFile = selectedGroupState?.files.find((entry) => entry.path === file.path);
 			return {
 				path: file.path,
 				sizeBytes: file.sizeBytes,
-				downloadedBytes
+				downloadedBytes: stateFile?.downloadedBytes ?? 0
 			};
-		});
-		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;
+		}) ?? [];
+		const status = selectedGroupState?.status ?? "not-downloaded";
 		return LocalModelAssetStateSchema.parse({
-			...state,
+			...migrated,
 			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,
+			selectedGroupId: selectedGroupIdForProjection,
+			profileManifest: manifestWithHistoricalGroups,
+			groupsState: reconciledGroupsState,
+			plan: plan ?? void 0,
+			status,
+			progress: selectedGroupState?.progress,
+			totalBytes: selectedGroupState?.totalBytes ?? selectedPlanGroup?.estimatedTotalBytes,
+			bytesDownloaded: selectedGroupState?.bytesDownloaded,
+			error: selectedGroupState?.error,
+			resumable: selectedGroupState?.resumable ?? false,
 			files,
 			updatedAt: this.now(),
-			installedAt: runtimeAllCached ? state.installedAt ?? this.now() : state.installedAt
+			installedAt: selectedGroupState?.installedAt ?? state.installedAt
 		});
 	}
-	async runDownload(modelId, targetStatus, messagePrefix, selectedGroupId) {
-		const existing = this.sessions.get(modelId);
+	reconcileGroupsFromSnapshot(input) {
+		if (!input.manifest) return input.groupsState;
+		const nextGroupsState = { ...input.groupsState };
+		for (const groupId of input.manifest.groupOrder) {
+			const manifestGroup = input.manifest.groups[groupId];
+			if (!manifestGroup) continue;
+			const current = nextGroupsState[groupId];
+			const files = reconcileGroupFilesFromSnapshot({
+				manifestGroup,
+				currentFiles: current?.files ?? [],
+				currentStatus: current?.status ?? "not-downloaded"
+			});
+			const bytesDownloaded = sumDownloadedBytes(files);
+			const totalBytes = manifestGroup.estimatedTotalBytes;
+			const status = current?.status ?? "not-downloaded";
+			nextGroupsState[groupId] = LocalModelLifecycleGroupStateSchema.parse({
+				...current,
+				groupId,
+				baseGroupId: manifestGroup.baseGroupId,
+				status,
+				rootDir: manifestGroup.rootDir,
+				bytesDownloaded,
+				totalBytes,
+				progress: totalBytes && totalBytes > 0 ? Math.max(0, Math.min(1, bytesDownloaded / totalBytes)) : current?.progress,
+				resumable: current?.resumable ?? (status === "paused" || status === "error" || status === "downloading"),
+				error: current?.error,
+				installedAt: current?.installedAt,
+				updatedAt: current?.updatedAt ?? this.now(),
+				files
+			});
+		}
+		return nextGroupsState;
+	}
+	async reconcileGroupsFromDisk(input) {
+		if (!input.manifest) return input.groupsState;
+		const nextGroupsState = { ...input.groupsState };
+		for (const groupId of input.manifest.groupOrder) {
+			const manifestGroup = input.manifest.groups[groupId];
+			if (!manifestGroup) continue;
+			const current = nextGroupsState[groupId];
+			if (isActiveDownloadStatus(current?.status ?? "not-downloaded")) {
+				nextGroupsState[groupId] = LocalModelLifecycleGroupStateSchema.parse({
+					...current,
+					groupId,
+					baseGroupId: manifestGroup.baseGroupId,
+					rootDir: manifestGroup.rootDir,
+					totalBytes: manifestGroup.estimatedTotalBytes,
+					files: reconcileGroupFiles({
+						manifestGroup,
+						currentFiles: current?.files ?? []
+					})
+				});
+				continue;
+			}
+			const files = await reconcileGroupFilesFromDisk({
+				rootDir: manifestGroup.rootDir,
+				manifestGroup,
+				currentFiles: current?.files ?? []
+			});
+			const bytesDownloaded = sumDownloadedBytes(files);
+			const totalBytes = manifestGroup.estimatedTotalBytes;
+			const allComplete = files.length > 0 && files.every((file) => file.sizeBytes !== void 0 && (file.downloadedBytes ?? 0) >= file.sizeBytes && file.status === "downloaded");
+			const hasPartial = files.some((file) => (file.downloadedBytes ?? 0) > 0);
+			const status = allComplete ? "downloaded" : current?.status === "error" ? "error" : current?.status === "paused" ? "paused" : hasPartial ? "paused" : "not-downloaded";
+			nextGroupsState[groupId] = LocalModelLifecycleGroupStateSchema.parse({
+				...current,
+				groupId,
+				baseGroupId: manifestGroup.baseGroupId,
+				status,
+				rootDir: manifestGroup.rootDir,
+				bytesDownloaded,
+				totalBytes,
+				progress: totalBytes && totalBytes > 0 ? Math.max(0, Math.min(1, bytesDownloaded / totalBytes)) : void 0,
+				resumable: status === "paused" || status === "error",
+				error: status === "error" ? current?.error : void 0,
+				installedAt: status === "downloaded" ? current?.installedAt ?? this.now() : current?.installedAt,
+				updatedAt: this.now(),
+				files
+			});
+		}
+		return nextGroupsState;
+	}
+	async runDownload(modelId, targetStatus, messagePrefix, groupId) {
+		const effectiveGroupId = groupId ?? await this.readSelectedGroupId();
+		if (!effectiveGroupId) throw new Error("No local model profile is selected.");
+		const manifest = await this.ensureProfileManifest(modelId);
+		const resolvedGroupId = resolveManifestGroupId(manifest, effectiveGroupId);
+		if (!resolvedGroupId) throw new Error("No concrete local model download plan is available.");
+		const sessionKey = buildSessionKey(modelId, resolvedGroupId);
+		const existing = this.sessions.get(sessionKey);
 		if (existing) return { sessionId: existing.sessionId };
-		const sessionId = `local-model-${sanitizeId(modelId)}-${this.now()}`;
+		const sessionId = `local-model-${sanitizeId(modelId)}-${sanitizeId(resolvedGroupId)}-${this.now()}`;
 		const abortController = new AbortController();
-		this.sessions.set(modelId, {
+		this.sessions.set(sessionKey, {
 			modelId,
 			sessionId,
 			abortController,
-			selectedGroupId
+			groupId: resolvedGroupId
 		});
-		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);
+		const current = await this.readSelectedModelState(modelId, resolvedGroupId);
+		const manifestGroup = manifest.groups[resolvedGroupId];
+		if (!manifestGroup || manifestGroup.files.length === 0 || manifestGroup.estimatedTotalBytes === void 0) {
+			this.sessions.delete(sessionKey);
 			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 totalBytes = manifestGroup.estimatedTotalBytes;
+		const currentGroup = current.groupsState[resolvedGroupId];
+		const resumedFiles = await reconcileGroupFilesFromDisk({
+			rootDir: manifestGroup.rootDir,
+			manifestGroup,
+			currentFiles: currentGroup?.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,
+			profileManifest: manifest,
+			groupsState: {
+				...current.groupsState,
+				[resolvedGroupId]: LocalModelLifecycleGroupStateSchema.parse({
+					...currentGroup,
+					groupId: resolvedGroupId,
+					baseGroupId: manifestGroup.baseGroupId,
+					status: targetStatus,
+					rootDir: manifestGroup.rootDir,
+					bytesDownloaded: resumedBytesDownloaded,
+					progress: totalBytes > 0 ? resumedBytesDownloaded / totalBytes : currentGroup?.progress,
+					totalBytes,
+					resumable: true,
+					files: resumedFiles,
+					updatedAt: this.now()
+				})
+			},
 			updatedAt: this.now()
 		});
-		await this.store.upsert(nextState);
+		const projected = await this.refreshCachedState(nextState, resolvedGroupId, { revalidateDisk: true });
+		await this.store.upsert(projected);
 		this.emitLog({
 			engineId: "local",
 			modelId,
-			selectedGroupId: nextState.plan?.selectedGroupId,
+			selectedGroupId: resolvedGroupId,
+			groupId: resolvedGroupId,
 			status: targetStatus,
 			message: `${messagePrefix} ${modelId}.`,
-			progress: nextState.progress,
-			bytesDownloaded: nextState.bytesDownloaded,
+			progress: projected.progress,
+			bytesDownloaded: projected.bytesDownloaded,
 			totalBytes,
 			sessionId,
 			resumable: true,
-			files: nextState.files,
+			files: projected.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);
+		const task = this.performDownload(modelId, resolvedGroupId, sessionId, abortController.signal).catch((error) => this.finishDownload(modelId, resolvedGroupId, sessionId, false, error instanceof Error ? error.message : String(error))).finally(() => {
+			if (this.sessionTasks.get(sessionKey) === task) this.sessionTasks.delete(sessionKey);
 		});
-		this.sessionTasks.set(modelId, task);
+		this.sessionTasks.set(sessionKey, 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;
+	async ensureProfileManifest(modelId) {
+		const existing = await this.profileManifestStore.read(modelId);
+		if (existing) return existing;
+		const manifest = await this.createProfileManifest(modelId);
+		await this.profileManifestStore.upsert(manifest);
+		return manifest;
+	}
+	async createProfileManifest(modelId) {
+		const hfEndpoint = await this.readHuggingFaceEndpoint();
+		const snapshot = await readLocalModelRepositorySnapshot({
+			modelId,
+			hfEndpoint,
+			fetchCacheStore: this.fetchCacheStore
+		});
+		const basePlan = buildLocalDownloadPlanFromRepositoryFiles({
+			modelId,
+			files: snapshot.files.map((file) => ({
+				...file,
+				revision: snapshot.commitHash
+			}))
+		});
+		if (!basePlan?.groups?.length) throw new Error(`No recognizable local model profiles were found for ${modelId}.`);
+		const groupsEntries = basePlan.groups.flatMap((group) => {
+			if (!group.selectable || group.estimatedTotalBytes === void 0) return [];
+			const groupId = buildVersionedGroupId(group.id, snapshot.shortCommitHash);
+			const rootDir = getLocalModelProfileGroupRoot(this.cacheDir, modelId, groupId);
+			return [[groupId, {
+				id: groupId,
+				baseGroupId: group.id,
+				label: group.label,
+				displayLabel: group.label,
+				description: group.description,
+				profile: group.profile,
+				dtype: group.dtype,
+				commitHash: snapshot.commitHash,
+				shortCommitHash: snapshot.shortCommitHash,
+				rootDir,
+				estimatedTotalBytes: group.estimatedTotalBytes,
+				selectable: group.selectable,
+				files: group.files.map((file) => ({
+					...file,
+					revision: snapshot.commitHash,
+					sourceUrl: file.sourceUrl ?? `${normalizeHuggingFaceEndpoint(hfEndpoint)}/${modelId}/resolve/${snapshot.commitHash}/${file.path}`
+				}))
+			}]];
+		});
+		if (groupsEntries.length === 0) throw new Error(`No selectable local model profiles were found for ${modelId}.`);
+		return LocalModelProfileManifestSchema.parse({
+			modelId,
+			source: "huggingface",
+			endpoint: normalizeHuggingFaceEndpoint(hfEndpoint),
+			revision: snapshot.revision,
+			commitHash: snapshot.commitHash,
+			shortCommitHash: snapshot.shortCommitHash,
+			fetchedAt: this.now(),
+			updatedAt: this.now(),
+			raw: snapshot.raw,
+			groups: Object.fromEntries(groupsEntries),
+			groupOrder: groupsEntries.map(([groupId]) => groupId)
+		});
+	}
+	async performDownload(modelId, groupId, sessionId, signal) {
+		const manifestGroup = (await this.ensureProfileManifest(modelId)).groups[groupId];
+		if (!manifestGroup) throw new Error(`Unknown local model profile: ${groupId}.`);
+		const files = manifestGroup.files;
+		const totalBytes = manifestGroup.estimatedTotalBytes;
 		const hfEndpoint = normalizeHuggingFaceEndpoint(await this.readHuggingFaceEndpoint());
-		const downloadedFiles = buildDownloadStateFiles({
-			planFiles: files,
-			currentFiles: state.files
+		const currentGroup = (await this.readSelectedModelState(modelId, groupId)).groupsState[groupId];
+		const downloadedFiles = await reconcileGroupFilesFromDisk({
+			rootDir: manifestGroup.rootDir,
+			manifestGroup,
+			currentFiles: currentGroup?.files ?? []
 		});
 		let bytesDownloaded = sumDownloadedBytes(downloadedFiles);
-		if (files.length === 0) throw new Error("No concrete local model download files were selected.");
+		if (files.length === 0 || totalBytes === void 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;
@@ -2747,12 +3160,14 @@ var LocalModelAssetService = class {
 			downloadedFiles[fileIndex] = {
 				path: file.path,
 				sizeBytes: file.sizeBytes,
-				downloadedBytes: previousFileBytes
+				downloadedBytes: previousFileBytes,
+				required: file.required,
+				status: previousFileBytes > 0 ? "paused" : "not-downloaded"
 			};
 			await this.emitDownloadProgress({
 				modelId,
+				groupId,
 				sessionId,
-				state,
 				message: `Downloading ${file.path}.`,
 				totalBytes,
 				bytesDownloaded,
@@ -2765,7 +3180,10 @@ var LocalModelAssetService = class {
 				},
 				path: file.path,
 				cacheDir: this.cacheDir,
+				targetPath: join(manifestGroup.rootDir, file.path),
 				hubUrl: hfEndpoint,
+				revision: manifestGroup.commitHash,
+				etag: file.etag,
 				expectedSizeBytes: file.sizeBytes,
 				retryPolicy: this.networkRetryPolicy,
 				fetch: createAbortableFetch(signal),
@@ -2776,12 +3194,14 @@ var LocalModelAssetService = class {
 					downloadedFiles[fileIndex] = {
 						path: file.path,
 						sizeBytes: file.sizeBytes,
-						downloadedBytes: boundedFileBytes
+						downloadedBytes: boundedFileBytes,
+						required: file.required,
+						status: boundedFileBytes >= (file.sizeBytes ?? Number.POSITIVE_INFINITY) ? "downloaded" : "downloading"
 					};
 					await this.emitDownloadProgress({
 						modelId,
+						groupId,
 						sessionId,
-						state,
 						message: `Downloading ${file.path}.`,
 						totalBytes,
 						bytesDownloaded: bytesDownloaded - previousFileBytes + boundedFileBytes,
@@ -2792,8 +3212,8 @@ var LocalModelAssetService = class {
 					const retryTarget = phase === "metadata" ? `metadata for ${file.path}` : `${file.path}`;
 					await this.emitDownloadProgress({
 						modelId,
+						groupId,
 						sessionId,
-						state,
 						message: `Connection interrupted while downloading ${retryTarget}. Retrying automatically in ${formatDuration(retryDelayMs)}.`,
 						totalBytes,
 						bytesDownloaded: bytesDownloaded - previousFileBytes + (downloadedFiles[fileIndex]?.downloadedBytes ?? 0),
@@ -2804,6 +3224,7 @@ var LocalModelAssetService = class {
 			await mirrorHubCacheFileForTransformers({
 				cacheDir: this.cacheDir,
 				modelId,
+				profileRoot: manifestGroup.rootDir,
 				filePath: file.path,
 				cachedPath
 			});
@@ -2813,95 +3234,123 @@ var LocalModelAssetService = class {
 			downloadedFiles[fileIndex] = {
 				path: file.path,
 				sizeBytes: file.sizeBytes,
-				downloadedBytes: file.sizeBytes
+				downloadedBytes: file.sizeBytes,
+				required: file.required,
+				status: "downloaded"
 			};
 			await this.emitDownloadProgress({
 				modelId,
+				groupId,
 				sessionId,
-				state,
 				message: `Downloaded ${file.path}.`,
 				totalBytes,
 				bytesDownloaded,
 				files: downloadedFiles
 			});
 		}
-		await this.finishDownload(modelId, sessionId, true, `Local model ${modelId} is ready.`);
+		await this.finishDownload(modelId, groupId, sessionId, true, `Local model ${modelId} is ready.`);
 	}
 	async emitDownloadProgress(input) {
-		if (!this.isActiveSession(input.modelId, input.sessionId)) return;
+		if (!this.isActiveSession(input.modelId, input.groupId, input.sessionId)) return;
 		const progress = input.totalBytes && input.totalBytes > 0 ? Math.max(0, Math.min(1, input.bytesDownloaded / input.totalBytes)) : void 0;
+		const current = await this.readSelectedModelState(input.modelId, input.groupId);
+		const currentGroup = current.groupsState[input.groupId];
 		const nextState = LocalModelAssetStateSchema.parse({
-			...input.state,
-			status: "downloading",
-			progress,
-			bytesDownloaded: input.bytesDownloaded,
-			totalBytes: input.totalBytes,
-			files: input.files,
-			updatedAt: this.now(),
-			resumable: true
+			...current,
+			groupsState: {
+				...current.groupsState,
+				[input.groupId]: LocalModelLifecycleGroupStateSchema.parse({
+					...currentGroup,
+					groupId: input.groupId,
+					status: "downloading",
+					bytesDownloaded: input.bytesDownloaded,
+					totalBytes: input.totalBytes,
+					progress,
+					resumable: true,
+					files: input.files,
+					updatedAt: this.now()
+				})
+			},
+			updatedAt: this.now()
 		});
-		await this.store.upsert(nextState);
+		const projected = await this.refreshCachedState(nextState, input.groupId, { revalidateDisk: true });
+		await this.store.upsert(projected);
 		this.emitLog({
 			engineId: "local",
 			modelId: input.modelId,
-			selectedGroupId: input.state.plan?.selectedGroupId,
+			selectedGroupId: input.groupId,
+			groupId: input.groupId,
 			status: "downloading",
 			message: input.message,
 			progress,
 			bytesDownloaded: input.bytesDownloaded,
 			totalBytes: input.totalBytes,
-			files: input.files,
+			files: input.files.map((file) => ({
+				path: file.path,
+				sizeBytes: file.sizeBytes,
+				downloadedBytes: file.downloadedBytes
+			})),
 			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);
+	async finishDownload(modelId, groupId, sessionId, success, message) {
+		if (!this.isActiveSession(modelId, groupId, sessionId)) return;
+		const sessionKey = buildSessionKey(modelId, groupId);
+		const current = await this.readSelectedModelState(modelId, groupId);
+		const currentGroup = current.groupsState[groupId];
+		const totalBytes = currentGroup?.totalBytes ?? current.totalBytes;
+		const files = success ? current.files.map((file) => LocalModelLifecycleFileStateSchema.parse({
+			...file,
+			required: true,
+			downloadedBytes: file.sizeBytes,
+			status: "downloaded",
+			updatedAt: this.now()
+		})) : (currentGroup?.files ?? []).map((file) => LocalModelLifecycleFileStateSchema.parse({
+			...file,
+			status: file.status === "downloaded" ? "downloaded" : "paused",
+			updatedAt: this.now()
+		}));
 		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
+			groupsState: {
+				...current.groupsState,
+				[groupId]: LocalModelLifecycleGroupStateSchema.parse({
+					...currentGroup,
+					groupId,
+					status: success ? "downloaded" : "error",
+					progress: success ? 1 : current.progress,
+					bytesDownloaded: success ? totalBytes : current.bytesDownloaded,
+					totalBytes,
+					installedAt: success ? this.now() : currentGroup?.installedAt,
+					updatedAt: this.now(),
+					error: success ? void 0 : message,
+					resumable: !success,
+					files
+				})
+			},
+			updatedAt: this.now()
 		});
-		await this.store.upsert(nextState);
-		this.sessions.delete(modelId);
+		const projected = await this.refreshCachedState(nextState, groupId, { revalidateDisk: true });
+		await this.store.upsert(projected);
+		this.sessions.delete(sessionKey);
 		this.emitLog({
 			engineId: "local",
 			modelId,
-			selectedGroupId: nextState.plan?.selectedGroupId,
-			status: nextState.status,
+			selectedGroupId: groupId,
+			groupId,
+			status: projected.status,
 			message,
-			progress: nextState.progress,
-			bytesDownloaded: nextState.bytesDownloaded,
-			totalBytes: nextState.totalBytes,
+			progress: projected.progress,
+			bytesDownloaded: projected.bytesDownloaded,
+			totalBytes: projected.totalBytes,
 			sessionId,
-			resumable: nextState.resumable,
-			files: nextState.files,
+			resumable: projected.resumable,
+			files: projected.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;
 	}
@@ -2911,8 +3360,8 @@ var LocalModelAssetService = class {
 	async readHuggingFaceEndpoint() {
 		return (await this.options.globalSettingsManager.readSettings()).translationEngines.local.hfEndpoint;
 	}
-	isActiveSession(modelId, sessionId) {
-		return this.sessions.get(modelId)?.sessionId === sessionId;
+	isActiveSession(modelId, groupId, sessionId) {
+		return this.sessions.get(buildSessionKey(modelId, groupId))?.sessionId === sessionId;
 	}
 	emitLog(log) {
 		this.logs.set(log.modelId, log);
@@ -2926,17 +3375,279 @@ var LocalModelAssetService = class {
 		return import("@huggingface/transformers");
 	}
 };
-function buildDownloadStateFiles(input) {
+function buildSessionKey(modelId, groupId) {
+	return `${modelId}::${groupId}`;
+}
+function buildVersionedGroupId(baseGroupId, shortCommitHash) {
+	return `${sanitizeId(baseGroupId)}-${sanitizeId(shortCommitHash)}`;
+}
+function selectFirstManifestGroupId(manifest) {
+	return manifest?.groupOrder.find((groupId) => manifest.groups[groupId]?.selectable);
+}
+function resolveManifestGroupId(manifest, requestedGroupId) {
+	if (!manifest || !requestedGroupId) return requestedGroupId;
+	if (manifest.groups[requestedGroupId]?.selectable) return requestedGroupId;
+	return manifest.groupOrder.find((groupId) => {
+		const group = manifest.groups[groupId];
+		return group?.selectable && group.baseGroupId === requestedGroupId;
+	});
+}
+function removeManifestGroup(manifest, groupId) {
+	const groups = { ...manifest.groups };
+	delete groups[groupId];
+	const groupOrder = manifest.groupOrder.filter((id) => id !== groupId);
+	if (groupOrder.length === 0) return void 0;
+	return LocalModelProfileManifestSchema.parse({
+		...manifest,
+		groups,
+		groupOrder
+	});
+}
+function removePlanGroup(plan, groupId) {
+	const groups = plan.groups?.filter((group) => group.id !== groupId);
+	if (!groups?.length) return void 0;
+	const selectedGroup = groups.find((group) => group.selected) ?? groups[0];
+	return {
+		...plan,
+		selectedGroupId: selectedGroup?.id,
+		estimatedTotalBytes: selectedGroup?.estimatedTotalBytes,
+		files: selectedGroup?.files ?? [],
+		groups: groups.map((group) => ({
+			...group,
+			selected: group.id === selectedGroup?.id
+		}))
+	};
+}
+function migrateLegacyStateToGroups(state, manifest, now) {
+	const selectedGroupId = state.selectedGroupId ?? state.plan?.selectedGroupId;
+	const groupsState = { ...state.groupsState };
+	for (const group of manifest ? [] : state.plan?.groups ?? []) {
+		if (groupsState[group.id] || !group.status || group.status === "not-downloaded") continue;
+		const groupStatus = group.status;
+		const manifestGroup = manifest?.groups[group.id];
+		const groupFiles = group.id === selectedGroupId && state.files.length > 0 ? state.files.map((file) => ({
+			...file,
+			required: true,
+			status: file.sizeBytes !== void 0 && (file.downloadedBytes ?? 0) >= file.sizeBytes ? "downloaded" : normalizeLiveStatusForStoredState(groupStatus)
+		})) : group.files.map((file) => ({
+			...file,
+			downloadedBytes: groupStatus === "downloaded" ? file.sizeBytes : 0,
+			status: normalizeLiveStatusForStoredState(groupStatus)
+		}));
+		const bytesDownloaded = sumDownloadedBytes(groupFiles);
+		const totalBytes = group.estimatedTotalBytes;
+		groupsState[group.id] = LocalModelLifecycleGroupStateSchema.parse({
+			groupId: group.id,
+			baseGroupId: group.baseGroupId ?? manifestGroup?.baseGroupId ?? group.id,
+			status: normalizeLiveStatusForStoredState(groupStatus),
+			rootDir: group.rootDir ?? manifestGroup?.rootDir,
+			bytesDownloaded,
+			totalBytes,
+			progress: totalBytes && totalBytes > 0 ? Math.max(0, Math.min(1, bytesDownloaded / totalBytes)) : group.progress,
+			resumable: group.resumable ?? (groupStatus === "paused" || groupStatus === "downloading" || groupStatus === "queued" || groupStatus === "error"),
+			error: group.error,
+			installedAt: groupStatus === "downloaded" ? state.installedAt ?? now : void 0,
+			updatedAt: state.updatedAt ?? now,
+			files: groupFiles
+		});
+	}
+	if (selectedGroupId && !groupsState[selectedGroupId] && state.files.length > 0 && state.status !== "not-downloaded") {
+		const manifestGroup = manifest?.groups[selectedGroupId];
+		groupsState[selectedGroupId] = LocalModelLifecycleGroupStateSchema.parse({
+			groupId: selectedGroupId,
+			baseGroupId: manifestGroup?.baseGroupId ?? selectedGroupId,
+			status: normalizeLiveStatusForStoredState(state.status),
+			rootDir: manifestGroup?.rootDir,
+			bytesDownloaded: state.bytesDownloaded,
+			totalBytes: state.totalBytes,
+			progress: state.progress,
+			resumable: state.resumable,
+			error: state.error,
+			installedAt: state.installedAt,
+			updatedAt: state.updatedAt ?? now,
+			files: state.files.map((file) => LocalModelLifecycleFileStateSchema.parse({
+				...file,
+				required: true,
+				status: file.sizeBytes !== void 0 && (file.downloadedBytes ?? 0) >= file.sizeBytes ? "downloaded" : state.status === "downloaded" ? "downloaded" : normalizeLiveStatusForStoredState(state.status)
+			}))
+		});
+	}
+	return LocalModelAssetStateSchema.parse({
+		...state,
+		selectedGroupId,
+		groupsState
+	});
+}
+function mergeHistoricalGroupsIntoManifest(input) {
+	const existing = input.manifest;
+	const groups = existing ? { ...existing.groups } : {};
+	const groupOrder = existing ? [...existing.groupOrder] : [];
+	const fallbackGroups = input.fallbackPlan?.groups ?? [];
+	for (const fallbackGroup of fallbackGroups) {
+		if (groups[fallbackGroup.id]) continue;
+		if (!isConcreteCommitHash(fallbackGroup.commitHash) || !isConcreteCommitHash(fallbackGroup.shortCommitHash)) continue;
+		const state = input.groupsState[fallbackGroup.id];
+		const commitHash = fallbackGroup.commitHash;
+		const shortCommitHash = fallbackGroup.shortCommitHash;
+		groups[fallbackGroup.id] = {
+			id: fallbackGroup.id,
+			baseGroupId: fallbackGroup.baseGroupId ?? fallbackGroup.id,
+			label: fallbackGroup.label,
+			displayLabel: `${fallbackGroup.label} · ${shortCommitHash}`,
+			description: fallbackGroup.description,
+			profile: fallbackGroup.profile,
+			dtype: fallbackGroup.dtype,
+			commitHash,
+			shortCommitHash,
+			rootDir: fallbackGroup.rootDir ?? state?.rootDir ?? getLocalModelProfileGroupRoot(input.cacheDir, input.modelId, fallbackGroup.id),
+			estimatedTotalBytes: fallbackGroup.estimatedTotalBytes,
+			selectable: fallbackGroup.selectable,
+			files: fallbackGroup.files.map((file) => ({
+				...file,
+				revision: file.revision ?? commitHash
+			}))
+		};
+		groupOrder.push(fallbackGroup.id);
+	}
+	if (!existing && groupOrder.length === 0) return void 0;
+	return LocalModelProfileManifestSchema.parse({
+		modelId: input.modelId,
+		source: "huggingface",
+		endpoint: existing?.endpoint ?? "",
+		revision: existing?.revision ?? "legacy",
+		commitHash: existing?.commitHash ?? "legacy",
+		shortCommitHash: existing?.shortCommitHash ?? "legacy",
+		fetchedAt: existing?.fetchedAt ?? 0,
+		updatedAt: existing?.updatedAt ?? 0,
+		raw: existing?.raw,
+		groups,
+		groupOrder
+	});
+}
+function filterConcreteProfileManifest(manifest) {
+	if (!manifest || !isConcreteCommitHash(manifest.commitHash)) return void 0;
+	const groups = Object.fromEntries(manifest.groupOrder.flatMap((groupId) => {
+		const group = manifest.groups[groupId];
+		if (!group || !isConcreteCommitHash(group.commitHash)) return [];
+		return [[groupId, group]];
+	}));
+	const groupOrder = manifest.groupOrder.filter((groupId) => groups[groupId]);
+	if (groupOrder.length === 0) return void 0;
+	return LocalModelProfileManifestSchema.parse({
+		...manifest,
+		groups,
+		groupOrder
+	});
+}
+function isConcreteCommitHash(value) {
+	return Boolean(value && value !== "legacy");
+}
+function formatManifestGroupChipLabel(manifest, group) {
+	if (group.commitHash === manifest.commitHash) return group.label;
+	return `${group.label} · ${group.shortCommitHash}`;
+}
+function buildPlanFromManifest(input) {
+	const manifest = input.manifest;
+	if (!manifest) return null;
+	const selectedGroupId = input.selectedGroupId && manifest.groups[input.selectedGroupId]?.selectable ? input.selectedGroupId : selectFirstManifestGroupId(manifest);
+	const groups = manifest.groupOrder.flatMap((groupId) => {
+		const manifestGroup = manifest.groups[groupId];
+		if (!manifestGroup) return [];
+		const groupState = input.groupsState[groupId];
+		return [{
+			id: manifestGroup.id,
+			label: formatManifestGroupChipLabel(manifest, manifestGroup),
+			description: manifestGroup.description,
+			profile: manifestGroup.profile,
+			dtype: manifestGroup.dtype,
+			estimatedTotalBytes: manifestGroup.estimatedTotalBytes,
+			baseGroupId: manifestGroup.baseGroupId,
+			commitHash: manifestGroup.commitHash,
+			shortCommitHash: manifestGroup.shortCommitHash,
+			rootDir: manifestGroup.rootDir,
+			status: groupState?.status ?? "not-downloaded",
+			progress: groupState?.progress,
+			bytesDownloaded: groupState?.bytesDownloaded,
+			totalBytes: groupState?.totalBytes ?? manifestGroup.estimatedTotalBytes,
+			resumable: groupState?.resumable,
+			error: groupState?.error,
+			selectable: manifestGroup.selectable,
+			selected: manifestGroup.id === selectedGroupId,
+			files: manifestGroup.files.map((file) => ({
+				...file,
+				required: file.required
+			}))
+		}];
+	});
+	const selectedGroup = groups.find((group) => group.id === selectedGroupId) ?? groups[0];
+	if (!selectedGroup) return null;
+	return {
+		modelId: input.modelId,
+		estimatedTotalBytes: selectedGroup.estimatedTotalBytes,
+		files: selectedGroup.files,
+		selectedGroupId: selectedGroup.id,
+		groups
+	};
+}
+function reconcileGroupFiles(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 {
+	return input.manifestGroup.files.map((file) => {
+		const current = currentFileByPath.get(file.path);
+		const downloadedBytes = current?.downloadedBytes === void 0 ? 0 : file.sizeBytes === void 0 ? current.downloadedBytes : Math.min(current.downloadedBytes, file.sizeBytes);
+		const status = file.sizeBytes !== void 0 && downloadedBytes >= file.sizeBytes ? "downloaded" : current?.status ?? "not-downloaded";
+		return LocalModelLifecycleFileStateSchema.parse({
 			path: file.path,
 			sizeBytes: file.sizeBytes,
-			downloadedBytes: downloadedBytes === void 0 ? 0 : file.sizeBytes === void 0 ? downloadedBytes : Math.min(downloadedBytes, file.sizeBytes)
-		};
+			downloadedBytes,
+			required: file.required,
+			status,
+			updatedAt: current?.updatedAt,
+			error: current?.error
+		});
+	});
+}
+function reconcileGroupFilesFromSnapshot(input) {
+	const currentFileByPath = new Map(input.currentFiles.map((file) => [file.path, file]));
+	return input.manifestGroup.files.map((file) => {
+		const current = currentFileByPath.get(file.path);
+		const downloadedBytes = current?.downloadedBytes === void 0 ? input.currentStatus === "downloaded" ? file.sizeBytes : 0 : file.sizeBytes === void 0 ? current.downloadedBytes : Math.min(current.downloadedBytes, file.sizeBytes);
+		const status = current?.status ?? (file.sizeBytes !== void 0 && downloadedBytes !== void 0 && downloadedBytes >= file.sizeBytes ? "downloaded" : input.currentStatus === "downloaded" ? "downloaded" : input.currentStatus === "paused" || input.currentStatus === "downloading" || input.currentStatus === "error" ? input.currentStatus : "not-downloaded");
+		return LocalModelLifecycleFileStateSchema.parse({
+			path: file.path,
+			sizeBytes: file.sizeBytes,
+			downloadedBytes,
+			required: file.required,
+			status,
+			updatedAt: current?.updatedAt,
+			error: current?.error
+		});
 	});
 }
+async function reconcileGroupFilesFromDisk(input) {
+	const currentFileByPath = new Map(input.currentFiles.map((file) => [file.path, file]));
+	return Promise.all(input.manifestGroup.files.map(async (file) => {
+		const current = currentFileByPath.get(file.path);
+		const diskBytes = await readPathSize(join(input.rootDir, file.path));
+		const downloadedBytes = diskBytes === null ? current?.downloadedBytes ?? 0 : file.sizeBytes === void 0 ? diskBytes : Math.min(diskBytes, file.sizeBytes);
+		const status = file.sizeBytes !== void 0 && downloadedBytes >= file.sizeBytes ? "downloaded" : downloadedBytes > 0 ? "paused" : "not-downloaded";
+		return LocalModelLifecycleFileStateSchema.parse({
+			path: file.path,
+			sizeBytes: file.sizeBytes,
+			downloadedBytes,
+			required: file.required,
+			status,
+			updatedAt: current?.updatedAt,
+			error: current?.error
+		});
+	}));
+}
+function isActiveDownloadStatus(status) {
+	return status === "queued" || status === "downloading" || status === "deleting";
+}
+function normalizeLiveStatusForStoredState(status) {
+	if (status === "queued" || status === "downloading") return "paused";
+	return status;
+}
 function sumDownloadedBytes(files) {
 	return files.reduce((total, file) => {
 		const downloadedBytes = file.downloadedBytes ?? 0;
@@ -2964,12 +3675,11 @@ 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,
+		revision: input.revision,
 		hubUrl: input.hubUrl,
 		retryPolicy: input.retryPolicy,
 		fetch: input.fetch,
@@ -2983,25 +3693,25 @@ async function downloadHuggingFaceFileToCacheDirWithProgress(input) {
 		cacheDir: input.cacheDir,
 		modelId: input.repo.name,
 		filePath: input.path,
-		revision,
-		etag: info.etag
+		revision: input.revision,
+		etag: input.etag ?? info.etag
 	});
-	const existingPointerSize = await readPathSize(cachePaths.pointerPath);
-	if (existingPointerSize !== null && existingPointerSize >= totalBytes) {
+	const existingTargetSize = await readPathSize(input.targetPath);
+	if (existingTargetSize !== null && existingTargetSize >= totalBytes) {
 		await input.onProgress(totalBytes);
-		return cachePaths.pointerPath;
+		return input.targetPath;
 	}
 	for (let attempt = 0; attempt <= input.retryPolicy.limit; attempt += 1) try {
 		throwIfAborted(input.signal);
-		let resumeBytes = await readPathSize(cachePaths.incompletePath);
+		let resumeBytes = await readPathSize(`${input.targetPath}.incomplete`);
 		if (resumeBytes !== null && resumeBytes > totalBytes) {
-			await rm(cachePaths.incompletePath, { force: true });
+			await rm(`${input.targetPath}.incomplete`, { 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,
+			incompletePath: `${input.targetPath}.incomplete`,
 			startBytes: resumeBytes ?? 0,
 			totalBytes,
 			accessToken: void 0,
@@ -3012,7 +3722,7 @@ async function downloadHuggingFaceFileToCacheDirWithProgress(input) {
 			const blob = await downloadFile({
 				repo: input.repo,
 				path: input.path,
-				revision,
+				revision: input.revision,
 				hubUrl: input.hubUrl,
 				fetch: input.fetch,
 				downloadInfo: info,
@@ -3021,15 +3731,24 @@ async function downloadHuggingFaceFileToCacheDirWithProgress(input) {
 			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,
+				incompletePath: `${input.targetPath}.incomplete`,
 				startBytes: resumeBytes ?? 0,
 				totalBytes,
 				onProgress: input.onProgress
 			});
 		}
-		await finalizeHubCacheFile(cachePaths);
+		const incompleteSize = await readPathSize(`${input.targetPath}.incomplete`);
+		if (incompleteSize === null || incompleteSize < totalBytes) throw new Error(`Incomplete response for file ${input.path}: downloaded ${incompleteSize ?? 0} of ${totalBytes} bytes.`);
+		await finalizeDownloadedFile({
+			incompletePath: `${input.targetPath}.incomplete`,
+			targetPath: input.targetPath
+		});
+		await mirrorDownloadedFileToHubCache({
+			targetPath: input.targetPath,
+			cachePaths
+		});
 		await input.onProgress(totalBytes);
-		return cachePaths.pointerPath;
+		return input.targetPath;
 	} catch (error) {
 		lastError = error;
 		if (!isRetryableDownloadError(error) || attempt === input.retryPolicy.limit) throw error;
@@ -3112,13 +3831,18 @@ async function streamDownloadToIncompleteFile(input) {
 	}
 	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);
+async function finalizeDownloadedFile(input) {
+	await mkdir(dirname(input.targetPath), { recursive: true });
+	await rm(input.targetPath, { force: true });
+	await rename(input.incompletePath, input.targetPath);
+}
+async function mirrorDownloadedFileToHubCache(input) {
+	await mkdir(dirname(input.cachePaths.blobPath), { recursive: true });
+	await mkdir(dirname(input.cachePaths.pointerPath), { recursive: true });
+	await rm(input.cachePaths.blobPath, { force: true });
+	await copyFile(input.targetPath, input.cachePaths.blobPath);
+	await unlink(input.cachePaths.pointerPath).catch(() => void 0);
+	await symlink(input.cachePaths.blobPath, input.cachePaths.pointerPath);
 }
 function getHubCacheFilePaths(input) {
 	const repoPath = getHubCacheRepoPath(input.cacheDir, input.modelId);
@@ -3168,6 +3892,7 @@ function formatDuration(ms) {
 }
 async function mirrorHubCacheFileForTransformers(input) {
 	const sourcePath = await resolveRealCacheFile(input.cachedPath);
+	await copyFileIfMissing(sourcePath, join(input.profileRoot, input.filePath));
 	await copyFileIfMissing(sourcePath, join(getTransformersLocalModelPath(input.cacheDir, input.modelId), input.filePath));
 	await copyFileIfMissing(sourcePath, join(getTransformersFileCacheModelPath(input.cacheDir, input.modelId), input.filePath));
 }
@@ -3187,9 +3912,11 @@ function getHubCacheRepoPath(cacheDir, modelId) {
 	return join(cacheDir, `models--${modelId.split("/").join("--")}`);
 }
 function toCatalogItem(candidate, asset) {
-	const hasSelectableGroup = candidate.downloadGroups?.some((group) => group.selectable) ?? false;
+	const downloadGroups = asset.plan?.groups ?? candidate.downloadGroups;
+	const hasSelectableGroup = downloadGroups?.some((group) => group.selectable) ?? false;
 	return {
 		...candidate,
+		downloadGroups,
 		asset,
 		selectable: hasSelectableGroup || (candidate.size.estimatedTotalBytes ?? 0) > 0,
 		local: asset.status === "downloaded" || asset.status === "paused" || asset.status === "downloading" || (asset.progress ?? 0) > 0
@@ -4868,7 +5595,7 @@ const globalSettingsRouter = router({
 		translationCache: TranslationCacheSettingsSchema.partial().optional(),
 		translationEngines: z.object({
 			openai: TranslationOpenAISettingsSchema.partial().optional(),
-			local: TranslationLocalSettingsSchema.partial().optional()
+			local: TranslationLocalSettingsSchema.partial().extend({ selectedGroupId: z.string().min(1).nullable().optional() }).optional()
 		}).optional()
 	})).mutation(async ({ ctx, input }) => {
 		await ctx.globalSettingsManager.writeSettings(input);
@@ -4959,6 +5686,18 @@ const localModelsRouter = router({
 	})).query(({ ctx, input }) => {
 		return ctx.localModelAssetService.readSelectedModelState(input.modelId, input.selectedGroupId);
 	}),
+	panelState: publicProcedure.input(z.object({
+		modelId: z.string().min(1),
+		selectedGroupId: z.string().min(1).optional()
+	})).query(async ({ ctx, input }) => {
+		const asset = await ctx.localModelAssetService.readSelectedModelState(input.modelId, input.selectedGroupId);
+		return {
+			modelId: input.modelId,
+			selectedGroupId: input.selectedGroupId ?? asset.plan?.selectedGroupId,
+			asset,
+			downloadPlan: asset.plan ?? null
+		};
+	}),
 	subscribeLogs: publicProcedure.subscription(({ ctx }) => {
 		return ctx.localModelAssetService.subscribeLogs();
 	}),
@@ -4968,21 +5707,40 @@ const localModelsRouter = router({
 	}),
 	download: publicProcedure.input(z.object({
 		modelId: z.string().min(1),
+		groupId: z.string().min(1).optional(),
 		selectedGroupId: z.string().min(1).optional()
 	})).mutation(async ({ ctx, input }) => {
-		return ctx.localModelAssetService.startDownload(input.modelId, input.selectedGroupId);
+		return ctx.localModelAssetService.startDownload(input.modelId, input.groupId ?? input.selectedGroupId);
 	}),
-	pause: publicProcedure.input(z.object({ modelId: z.string().min(1) })).mutation(({ ctx, input }) => {
-		return ctx.localModelAssetService.pauseDownload(input.modelId);
+	pause: publicProcedure.input(z.object({
+		modelId: z.string().min(1),
+		groupId: z.string().min(1).optional(),
+		selectedGroupId: z.string().min(1).optional()
+	})).mutation(({ ctx, input }) => {
+		return ctx.localModelAssetService.pauseDownload(input.modelId, input.groupId ?? input.selectedGroupId);
 	}),
 	resume: publicProcedure.input(z.object({
 		modelId: z.string().min(1),
+		groupId: z.string().min(1).optional(),
 		selectedGroupId: z.string().min(1).optional()
 	})).mutation(async ({ ctx, input }) => {
-		return ctx.localModelAssetService.resumeDownload(input.modelId, input.selectedGroupId);
+		return ctx.localModelAssetService.resumeDownload(input.modelId, input.groupId ?? input.selectedGroupId);
 	}),
-	delete: publicProcedure.input(z.object({ modelId: z.string().min(1) })).mutation(({ ctx, input }) => {
-		return ctx.localModelAssetService.deleteModel(input.modelId);
+	delete: publicProcedure.input(z.object({
+		modelId: z.string().min(1),
+		groupId: z.string().min(1).optional(),
+		selectedGroupId: z.string().min(1).optional()
+	})).mutation(({ ctx, input }) => {
+		return ctx.localModelAssetService.deleteModel(input.modelId, input.groupId ?? input.selectedGroupId);
+	}),
+	refreshProfiles: publicProcedure.input(z.object({ modelId: z.string().min(1).optional() })).mutation(async ({ ctx, input }) => {
+		const asset = await ctx.localModelAssetService.refreshProfiles(input.modelId);
+		return {
+			modelId: asset.modelId,
+			selectedGroupId: asset.selectedGroupId ?? asset.plan?.selectedGroupId,
+			asset,
+			downloadPlan: asset.plan ?? null
+		};
 	})
 });
 const OPSX_CORE_PROFILE_WORKFLOWS = [
@@ -5290,6 +6048,31 @@ const changeRouter = router({
 	}),
 	subscribeFiles: publicProcedure.input(z.object({ id: z.string() })).subscription(({ ctx, input }) => {
 		return createReactiveSubscriptionWithInput((id) => ctx.adapter.readChangeFiles(id))(input.id);
+	}),
+	writeFile: publicProcedure.input(z.object({
+		id: z.string(),
+		path: z.string(),
+		content: z.string()
+	})).mutation(async ({ ctx, input }) => {
+		const info = resolveEntityEntryPath({
+			projectDir: ctx.projectDir,
+			stage: "change",
+			changeId: input.id,
+			path: input.path
+		});
+		await mkdir(dirname(info.absolutePath), { recursive: true });
+		await writeFile(info.absolutePath, input.content, "utf-8");
+		return { success: true };
+	}),
+	prepareFilePreview: publicProcedure.input(z.object({
+		id: z.string(),
+		path: z.string()
+	})).query(({ ctx, input }) => {
+		return ctx.filePreviewService.prepareEntityFilePreview({
+			stage: "change",
+			changeId: input.id,
+			path: input.path
+		});
 	})
 });
 /**
@@ -5322,9 +6105,32 @@ const archiveRouter = router({
 		return createReactiveSubscriptionWithInput(async (id) => ctx.documentService.readEntityDetail("archive", id, "view", "processed", await buildEntityReadOptions(ctx, "archive", id)))(input.id);
 	}),
 	subscribeFiles: publicProcedure.input(z.object({ id: z.string() })).subscription(({ ctx, input }) => {
-		return createReactiveSubscriptionWithInput(async (id) => {
-			return (await ctx.documentService.readEntityDetail("archive", id, "view", "processed", await buildEntityReadOptions(ctx, "archive", id)))?.files ?? [];
-		})(input.id);
+		return createReactiveSubscriptionWithInput((id) => ctx.documentService.readArchivedChangeFiles(id, "view", "source"))(input.id);
+	}),
+	writeFile: publicProcedure.input(z.object({
+		id: z.string(),
+		path: z.string(),
+		content: z.string()
+	})).mutation(async ({ ctx, input }) => {
+		const info = resolveEntityEntryPath({
+			projectDir: ctx.projectDir,
+			stage: "archive",
+			changeId: input.id,
+			path: input.path
+		});
+		await mkdir(dirname(info.absolutePath), { recursive: true });
+		await writeFile(info.absolutePath, input.content, "utf-8");
+		return { success: true };
+	}),
+	prepareFilePreview: publicProcedure.input(z.object({
+		id: z.string(),
+		path: z.string()
+	})).query(({ ctx, input }) => {
+		return ctx.filePreviewService.prepareEntityFilePreview({
+			stage: "archive",
+			changeId: input.id,
+			path: input.path
+		});
 	})
 });
 z.object({
@@ -5430,7 +6236,7 @@ const configRouter = router({
 		translation: DocumentTranslationConfigSchema.partial().extend({ engines: z.object({
 			local: z.object({
 				model: z.string().min(1).optional(),
-				selectedGroupId: z.string().min(1).optional()
+				selectedGroupId: z.string().min(1).nullable().optional()
 			}).optional(),
 			openai: z.object({ model: z.string().min(1).optional() }).optional()
 		}).optional() }).optional()
@@ -6465,22 +7271,19 @@ 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({
+		new LocalModelFetchCacheStore({
 			cachePath: options.localFetchCachePath ?? getDefaultLocalModelFetchCachePath(),
 			now: this.now
 		});
@@ -6500,20 +7303,7 @@ var TranslationEngineService = class {
 	}
 	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);
+		return selectPersistedLocalPlan((await this.localAssetStore.readMap()).get(input.model), input.selectedGroupId);
 	}
 	async selectEngine(engineId) {
 		await this.configManager.writeConfig({ translation: { engineId } });
@@ -6529,14 +7319,26 @@ var TranslationEngineService = class {
 			(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({
+					const settingsSnapshot = await this.globalSettingsManager.readSettings();
+					const effectiveModel = resolveBatchTranslateModel(input, settingsSnapshot);
+					if (input.engineId === "local") {
+						const directionCheck = checkLocalDirectionalModelLanguagePair({
+							model: effectiveModel,
+							sourceLanguage: input.sourceLanguage,
+							targetLanguage: input.targetLanguage
+						});
+						if (!directionCheck.supported) throw new Error(directionCheck.message ?? "Selected local model does not support the requested translation direction.");
+					}
+					const effectiveSelectedGroupId = input.engineId === "local" ? input.selectedGroupId ?? settingsSnapshot.translationEngines.local.selectedGroupId : void 0;
+					const dtype = await this.readLocalDtype(input.engineId, effectiveModel, effectiveSelectedGroupId);
+					if (input.engineId === "local" && effectiveModel) await this.assertLocalModelReady(effectiveModel, effectiveSelectedGroupId);
+					const runtimeConfig = input.engineId === "local" && effectiveModel ? await this.readLocalRuntimeConfig(effectiveModel, effectiveSelectedGroupId) : void 0;
+					const translator = await (await this.loadFactory(input.engineId, effectiveModel, settingsSnapshot)).create({
 						sourceLanguage: input.sourceLanguage,
 						targetLanguage: input.targetLanguage,
-						model: input.model,
+						model: effectiveModel,
 						dtype,
-						runtimeConfig: input.engineId === "local" && input.model ? await this.readLocalRuntimeConfig(input.model) : void 0,
+						runtimeConfig,
 						signal: controller.signal
 					});
 					try {
@@ -6562,11 +7364,11 @@ var TranslationEngineService = class {
 		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({
+		return selectLocalPlanGroup(await this.getModelDownloadPlan({
 			engineId: "local",
 			model,
 			selectedGroupId: effectiveSelectedGroupId
-		}))?.groups?.find((group) => group.id === effectiveSelectedGroupId)?.dtype;
+		}), effectiveSelectedGroupId)?.dtype;
 	}
 	async assertLocalModelReady(model, selectedGroupId) {
 		const plan = await this.getModelDownloadPlan({
@@ -6574,89 +7376,57 @@ var TranslationEngineService = class {
 			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 selectedGroup = selectLocalPlanGroup(plan, selectedGroupId);
+		if (!plan || !selectedGroup || selectedGroup.files.length === 0) throw new Error("No local runtime file plan is available for the selected model.");
+		const files = selectedGroup.files;
+		const selectedGroupState = await this.readSelectedLocalGroupState(model, selectedGroup.id);
+		if (selectedGroupState?.status === "downloaded" && selectedGroup.rootDir) {
+			if ((await readMissingLocalGroupFiles(selectedGroup.rootDir, files)).length === 0) return;
 		}
-		const allMissingFiles = cacheStatus.files.filter((file) => !file.cached).map((file) => file.file);
+		if (selectedGroupState?.status === "downloaded") return;
+		const allMissingFiles = selectedGroup.rootDir ? await readMissingLocalGroupFiles(selectedGroup.rootDir, files) : files.map((file) => file.path);
 		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) {
+	async readLocalRuntimeConfig(model, selectedGroupId) {
+		const selectedGroup = selectLocalPlanGroup(await this.getModelDownloadPlan({
+			engineId: "local",
+			model,
+			selectedGroupId
+		}), selectedGroupId);
+		const configPath = selectedGroup?.rootDir ? join(selectedGroup.rootDir, "config.json") : join(this.localCacheDir, "models", model, "config.json");
 		try {
-			return JSON.parse(await readFile(join(this.localCacheDir, "models", model, "config.json"), "utf8"));
+			return JSON.parse(await readFile(configPath, "utf8"));
 		} catch {
 			return;
 		}
 	}
-	async loadFactory(engineId, model) {
-		const globalSettings = await this.globalSettingsManager.readSettings();
-		if (engineId === "local") return (await import("./src-DBFY1eQK.mjs")).createLocalTranslatorFactory({
+	async readSelectedLocalGroupState(model, selectedGroupId) {
+		return (await this.localAssetStore.readMap()).get(model)?.groupsState[selectedGroupId];
+	}
+	async loadFactory(engineId, model, settingsSnapshot) {
+		const globalSettings = settingsSnapshot ?? await this.globalSettingsManager.readSettings();
+		if (engineId === "local") return (await import("./src-DPZ2-0Yn.mjs")).createLocalTranslatorFactory({
 			defaultModel: model ?? globalSettings.translationEngines.local.model,
 			cacheDir: this.localCacheDir,
 			localOnly: true
 		});
-		return (await import("./src-DuQ_-3Kn.mjs")).createOpenAICompletionTranslatorFactory({
+		return (await import("./src-CoUhFB25.mjs")).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 resolveBatchTranslateModel(input, settings) {
+	if (input.model) return input.model;
+	if (input.engineId === "local") return settings.translationEngines.local.model;
+	if (input.engineId === "openai") return settings.translationEngines.openai.model;
 }
 function selectPersistedLocalPlan(state, selectedGroupId) {
-	const plan = state?.plan;
+	if (!state) return null;
+	const plan = LocalModelAssetStateSchema.parse(state).plan;
 	if (!plan) return null;
 	if (!selectedGroupId || !plan.groups?.length) return {
 		...plan,
@@ -6666,7 +7436,7 @@ function selectPersistedLocalPlan(state, selectedGroupId) {
 			files: [...group.files]
 		}))
 	};
-	const selectedGroup = plan.groups.find((group) => group.id === selectedGroupId);
+	const selectedGroup = selectLocalPlanGroup(plan, selectedGroupId);
 	if (!selectedGroup) return null;
 	return {
 		modelId: plan.modelId,
@@ -6680,6 +7450,22 @@ function selectPersistedLocalPlan(state, selectedGroupId) {
 		}))
 	};
 }
+function selectLocalPlanGroup(plan, selectedGroupId) {
+	if (!plan?.groups?.length) return void 0;
+	const requestedGroupId = selectedGroupId ?? plan.selectedGroupId;
+	return plan.groups.find((group) => group.id === requestedGroupId) ?? plan.groups.find((group) => group.baseGroupId === requestedGroupId) ?? plan.groups.find((group) => group.selected) ?? plan.groups[0];
+}
+async function readMissingLocalGroupFiles(rootDir, files) {
+	return (await Promise.all(files.map(async (file) => {
+		try {
+			const entry = await stat(join(rootDir, file.path));
+			if (file.sizeBytes !== void 0 && entry.size < file.sizeBytes) return file.path;
+			return null;
+		} catch {
+			return file.path;
+		}
+	}))).filter((file) => file !== null);
+}
 
 //#endregion
 //#region src/workflow-invocation-service.ts
@@ -6940,6 +7726,7 @@ function createServer(config) {
 	const kernel = config.kernel;
 	const hookRuntime = createHookRuntime(config.projectDir);
 	const documentService = new DocumentService(config.projectDir, adapter, hookRuntime);
+	const filePreviewService = new FilePreviewService(config.projectDir, config.previewAssetsDir ?? join(__dirname, "..", "..", "web", "dist"));
 	const workflowInvocationService = new WorkflowInvocationService({
 		projectDir: config.projectDir,
 		hookRuntime,
@@ -6975,6 +7762,7 @@ function createServer(config) {
 	});
 	const nmtModelCacheDir = config.runtimePaths?.localModelCacheDir ?? getDefaultLocalModelCacheDir();
 	const nmtModelIndexPath = config.runtimePaths?.localModelAssetIndexPath ?? getDefaultLocalModelIndexPath();
+	const nmtModelProfileManifestPath = config.runtimePaths?.localModelProfileManifestPath ?? getDefaultLocalModelProfileManifestPath();
 	const nmtModelFetchCachePath = config.runtimePaths?.localModelFetchCachePath ?? getDefaultLocalModelFetchCachePath();
 	const translationEngineService = new TranslationEngineService({
 		projectDir: config.projectDir,
@@ -6990,6 +7778,7 @@ function createServer(config) {
 		globalSettingsManager,
 		cacheDir: nmtModelCacheDir,
 		indexPath: nmtModelIndexPath,
+		profileManifestPath: nmtModelProfileManifestPath,
 		fetchCachePath: nmtModelFetchCachePath
 	});
 	const watcher = config.enableWatcher !== false ? new OpenSpecWatcher(config.projectDir) : void 0;
@@ -7054,6 +7843,21 @@ function createServer(config) {
 			"Cache-Control": "private, max-age=31536000, immutable"
 		} });
 	});
+	app.get("/api/file-preview/:hash/*", async (c) => {
+		const hash = c.req.param("hash");
+		const prefix = `/api/file-preview/${hash}/`;
+		const requestPath = c.req.path.startsWith(prefix) ? c.req.path.slice(prefix.length) : "";
+		const asset = filePreviewService.readPreviewRequest(hash, requestPath);
+		if (!asset) return c.notFound();
+		const stream = new ReadableStream({ start(controller) {
+			controller.enqueue(new Uint8Array(asset.content));
+			controller.close();
+		} });
+		return new Response(stream, {
+			status: 200,
+			headers: { "Content-Type": asset.contentType }
+		});
+	});
 	app.use("/trpc/*", async (c) => {
 		return await fetchRequestHandler({
 			endpoint: "/trpc",
@@ -7073,6 +7877,7 @@ function createServer(config) {
 				customSoundService,
 				globalSettingsManager,
 				translationCacheService,
+				filePreviewService,
 				translationEngineService,
 				localModelAssetService,
 				gitWorktreeHandoff: config.gitWorktreeHandoff,
@@ -7095,6 +7900,7 @@ function createServer(config) {
 		customSoundService,
 		globalSettingsManager,
 		translationCacheService,
+		filePreviewService,
 		translationEngineService,
 		localModelAssetService,
 		gitWorktreeHandoff: config.gitWorktreeHandoff,
@@ -7116,7 +7922,9 @@ function createServer(config) {
 		customSoundService,
 		globalSettingsManager,
 		translationCacheService,
+		filePreviewService,
 		translationEngineService,
+		localModelAssetService,
 		hookRuntime,
 		watcher,
 		createContext,