@bud.sh/app 0.1.0 → 0.3.0

package/dist/node-host/assets/files-CTzcWGjb.js

@@ -0,0 +1,3771 @@
+import { i as __toESM } from "./rolldown-runtime-DktXgydw.js";
+import { $ as FileSearchPanel, $n as resolveLanguage, A as parseEditorPreferences, An as reviewConflictIdentity, At as defaultReviewView, Bn as markWorkerErrorReported, Bt as fileHref, D as ReviewActionDialog, E as FileConflictPanel, F as FileWorkspace, Fn as areDiffTargetsEqual, Ft as reviewComparison, Gn as areThemesEqual, Gt as fileRoutes, Hn as renderFileWithHighlighter, Ht as readFileLocation, I as defaultFileDestination, In as WorkerPoolTaskCanceledError, It as reviewContextKey, Jn as validateResolvedThemeName, Kn as getSharedHighlighter, L as fileActionIntent, Ln as WorkerPoolTerminatedError, Lt as reviewHref, M as FileMutationDialog, Mn as renderDiffWithHighlighter, Mt as parseReviewSession, N as FileReviewPanel, Nn as areDiffRenderOptionsEqual, Nt as readReviewLocation, O as FileEditorPanel, On as createCodeAnchor, P as codeThemes, Pn as areFilesEqual, Pt as rememberReviewPosition, Qn as getResolvedOrResolveLanguage, R as mutationFileView, Rn as WorkerPoolWorkerError, Rt as closeFileTab, St as isCodeConversation, Tt as readConversationLocation, Un as areFileRenderOptionsEqual, Ut as reconcileFileView, Vn as isFilePlainText, Vt as parseFileView, Wn as hasResolvedThemes, Wt as rememberFile, Xn as themeResolver, Yn as attachResolvedThemes, Zn as getThemes, _r as parseFileSearchResult, ar as parseFileSaveRequest, br as parseFileIndex, bt as conversationHref, cn as toast, cr as parseMutationPlan, dn as Text, dr as parseReviewDiff, er as areLanguagesAttached, f as storeDocument, fr as parseReviewHistory, gr as parseFileSearchQuery, hr as parseReviewSource, ir as parseReviewActionResult, j as FileRecoveryDialog, jn as isDiffPlainText, k as defaultEditorPreferences, kn as parseFileUpdate, kt as defaultReviewPosition, l as projectStore, ln as readPreference, lr as parseMutationResult, m as storedFiles, mr as parseReviewSnapshot, nr as parseReviewActionPlan, or as parseFileSaveResult, p as storedDocument, pr as parseReviewRepository, qn as prepareThemeResolution, rr as parseReviewActionRecoveries, s as applyFileUpdate, sr as maxFileSaveBytes, t as commentsUnavailable, tr as ResolvedLanguages, tt as ConversationSidebar, u as saveFiles, un as writePreference, ur as parseRecoveries, v as projectLive, vr as parseFileChange, vt as codeCommentCounts, wt as locateCodeConversations, xr as parseFilePath, y as routes, yr as parseFileDocument, z as remainingMutationIntent, zn as isHandledWorkerPoolError, zt as defaultFileView } from "./comment-data-nUlI0szN.js";
+import { B as DEFAULT_THEMES, C as getFiletypeFromFileName, S as getCustomExtensionsVersion, x as getCustomExtensionsMap } from "./cloneFileDiffMetadata-C1BcNpxN.js";
+import { n as createProjectComments, t as defineScreen } from "./screen-DQoTOWYR.js";
+import { t as require_lru } from "./lru-C0_oUet4.js";
+import { t as ProjectThreadLinks } from "./project-thread-links-LpUAGcDr.js";
+import { ref } from "remix/component";
+import { jsx, jsxs } from "remix/component/jsx-runtime";
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.3.1_react@19.3.1__react@19.3.1/node_modules/@pierre/diffs/dist/highlighter/languages/getResolvedLanguages.js
+function getResolvedLanguages(languages) {
+	const resolvedLanguages = [];
+	for (const language of languages) {
+		const resolvedLanguage = ResolvedLanguages.get(language);
+		if (resolvedLanguage == null) throw new Error(`getResolvedLanguages: ${language} is not resolved. Please resolve languages before calling getResolvedLanguages`);
+		resolvedLanguages.push(resolvedLanguage);
+	}
+	return resolvedLanguages;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.3.1_react@19.3.1__react@19.3.1/node_modules/@pierre/diffs/dist/highlighter/languages/hasResolvedLanguages.js
+function hasResolvedLanguages(languages) {
+	for (const language of Array.isArray(languages) ? languages : [languages]) if (!ResolvedLanguages.has(language)) return false;
+	return true;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.3.1_react@19.3.1__react@19.3.1/node_modules/@pierre/diffs/dist/highlighter/languages/resolveLanguages.js
+async function resolveLanguages(languages) {
+	const resolvedLanguages = [];
+	const languagesToResolve = [];
+	for (const language of languages) {
+		if (language === "text" || language === "ansi") continue;
+		const maybeResolvedLanguage = getResolvedOrResolveLanguage(language) ?? resolveLanguage(language);
+		if ("then" in maybeResolvedLanguage) languagesToResolve.push(maybeResolvedLanguage);
+		else resolvedLanguages.push(maybeResolvedLanguage);
+	}
+	if (languagesToResolve.length > 0) await Promise.all(languagesToResolve).then((_resolvedLanguages) => {
+		for (const resolvedLanguage of _resolvedLanguages) {
+			if (resolvedLanguage == null) throw new Error("resolvedLanguages: unable to resolve language");
+			resolvedLanguages.push(resolvedLanguage);
+		}
+	});
+	return resolvedLanguages;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.3.1_react@19.3.1__react@19.3.1/node_modules/@pierre/diffs/dist/highlighter/themes/getResolvedThemes.js
+function getResolvedThemes(themeNames) {
+	return themeResolver.getResolvedThemes(themeNames);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.3.1_react@19.3.1__react@19.3.1/node_modules/@pierre/diffs/dist/highlighter/themes/resolveThemes.js
+async function resolveThemes(themes) {
+	for (const themeName of themes) prepareThemeResolution(themeName);
+	const resolvedThemes = await themeResolver.resolveThemes(themes);
+	for (let i = 0; i < themes.length; i++) validateResolvedThemeName(themes[i], resolvedThemes[i]);
+	return resolvedThemes;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.3.1_react@19.3.1__react@19.3.1/node_modules/@pierre/diffs/dist/worker/WorkerPoolManager.js
+var import_lru = /* @__PURE__ */ __toESM(require_lru(), 1);
+var IGNORE_RESPONSE = Symbol("IGNORE_RESPONSE");
+var DEFAULT_WORKER_INITIALIZATION_TIMEOUT = 1e4;
+var WorkerPoolManager = class {
+	options;
+	highlighter;
+	preferredHighlighter;
+	renderOptions;
+	renderOptionsRequestVersion = 0;
+	renderOptionsVersion = 0;
+	initialized = false;
+	workers = [];
+	queuedTasks = [];
+	queuedTaskByInstance = /* @__PURE__ */ new Map();
+	taskByHighlightKey = /* @__PURE__ */ new Map();
+	activeTaskById = /* @__PURE__ */ new Map();
+	activeRequestByInstance = /* @__PURE__ */ new Map();
+	nextRequestId = 0;
+	themeSubscribers = /* @__PURE__ */ new Set();
+	workersFailed = false;
+	statSubscribers = /* @__PURE__ */ new Set();
+	fileCache;
+	diffCache;
+	_queuedBroadcast;
+	lifecycleGeneration = 0;
+	constructor(options, { langs, theme = DEFAULT_THEMES, useTokenTransformer = false, lineDiffType = "word-alt", maxLineDiffLength = 1e3, tokenizeMaxLineLength = 1e3, preferredHighlighter = "shiki-js" }) {
+		this.options = options;
+		this.preferredHighlighter = preferredHighlighter;
+		this.renderOptions = {
+			theme,
+			useTokenTransformer,
+			lineDiffType,
+			maxLineDiffLength,
+			tokenizeMaxLineLength
+		};
+		this.fileCache = new import_lru.default.LRUMap(options.totalASTLRUCacheSize ?? 100);
+		this.diffCache = new import_lru.default.LRUMap(options.totalASTLRUCacheSize ?? 100);
+		this.queueInitialization(langs);
+	}
+	isWorkingPool() {
+		return !this.workersFailed;
+	}
+	getFileResultCache(file) {
+		return file.cacheKey != null ? this.fileCache.get(file.cacheKey) : void 0;
+	}
+	getDiffResultCache(diff) {
+		return diff.cacheKey != null ? this.diffCache.get(diff.cacheKey) : void 0;
+	}
+	inspectCaches() {
+		const { fileCache, diffCache } = this;
+		return {
+			fileCache,
+			diffCache
+		};
+	}
+	evictFileFromCache(cacheKey) {
+		try {
+			return this.fileCache.delete(cacheKey) !== void 0;
+		} finally {
+			this.queueBroadcastStateChanges();
+		}
+	}
+	evictDiffFromCache(cacheKey) {
+		try {
+			return this.diffCache.delete(cacheKey) !== void 0;
+		} finally {
+			this.queueBroadcastStateChanges();
+		}
+	}
+	async setRenderOptions({ theme = this.renderOptions.theme ?? DEFAULT_THEMES, useTokenTransformer = this.renderOptions.useTokenTransformer ?? false, lineDiffType = this.renderOptions.lineDiffType ?? "word-alt", maxLineDiffLength = this.renderOptions.maxLineDiffLength ?? 1e3, tokenizeMaxLineLength = this.renderOptions.tokenizeMaxLineLength ?? 1e3 }) {
+		const { lifecycleGeneration } = this;
+		const renderOptionsRequestVersion = ++this.renderOptionsRequestVersion;
+		const isCurrentRequest = () => this.isCurrentLifecycle(lifecycleGeneration) && this.renderOptionsRequestVersion === renderOptionsRequestVersion;
+		try {
+			const newRenderOptions = {
+				theme,
+				useTokenTransformer,
+				lineDiffType,
+				maxLineDiffLength,
+				tokenizeMaxLineLength
+			};
+			if (!this.isInitialized()) await this.initialize();
+			if (!isCurrentRequest() || areDiffRenderOptionsEqual(newRenderOptions, this.renderOptions)) return;
+			const themeNames = getThemes(theme);
+			let resolvedThemes = [];
+			if (!areThemesEqual(newRenderOptions.theme, this.renderOptions.theme)) {
+				if (hasResolvedThemes(themeNames)) resolvedThemes = getResolvedThemes(themeNames);
+				else resolvedThemes = await resolveThemes(themeNames);
+			}
+			if (!isCurrentRequest()) return;
+			if (this.highlighter != null) attachResolvedThemes(resolvedThemes, this.highlighter);
+			else {
+				const highlighter = await getSharedHighlighter({
+					themes: themeNames,
+					langs: ["text"],
+					preferredHighlighter: this.preferredHighlighter
+				});
+				if (!isCurrentRequest()) return;
+				this.highlighter = highlighter;
+			}
+			const workerSetup = this.setRenderOptionsOnWorkers(newRenderOptions, resolvedThemes);
+			this.renderOptions = newRenderOptions;
+			this.renderOptionsVersion++;
+			this.diffCache.clear();
+			this.fileCache.clear();
+			this.invalidateRenderTasks();
+			for (const instance of this.themeSubscribers) instance.onThemeChange();
+			await workerSetup;
+		} catch (error) {
+			if (error instanceof WorkerPoolTerminatedError || !isCurrentRequest()) return;
+			throw error;
+		}
+	}
+	getPreferredHighlighter() {
+		return this.preferredHighlighter;
+	}
+	getFileRenderOptions() {
+		const { tokenizeMaxLineLength, theme, useTokenTransformer } = this.renderOptions;
+		return {
+			theme,
+			useTokenTransformer,
+			tokenizeMaxLineLength
+		};
+	}
+	getDiffRenderOptions() {
+		return { ...this.renderOptions };
+	}
+	async setRenderOptionsOnWorkers(renderOptions, resolvedThemes) {
+		if (this.workersFailed) return;
+		if (!this.isInitialized()) await this.initialize();
+		const taskPromises = [];
+		for (const managedWorker of this.workers) {
+			if (!managedWorker.initialized) {
+				console.log({ managedWorker });
+				throw new Error("setRenderOptionsOnWorkers: Somehow we have an uninitialized worker");
+			}
+			taskPromises.push(new Promise((resolve, reject) => {
+				const id = this.generateRequestId();
+				const task = {
+					type: "set-render-options",
+					id,
+					request: {
+						type: "set-render-options",
+						id,
+						renderOptions,
+						resolvedThemes
+					},
+					resolve,
+					reject,
+					requestStart: Date.now()
+				};
+				this.activeTaskById.set(id, task);
+				managedWorker.pendingSetupRequestId = id;
+				managedWorker.worker.postMessage(task.request);
+			}));
+		}
+		await Promise.all(taskPromises);
+	}
+	subscribeToThemeChanges(instance) {
+		this.themeSubscribers.add(instance);
+		this.queueBroadcastStateChanges();
+		return () => {
+			this.unsubscribeToThemeChanges(instance);
+			this.queueBroadcastStateChanges();
+		};
+	}
+	unsubscribeToThemeChanges(instance) {
+		this.themeSubscribers.delete(instance);
+		this.queueBroadcastStateChanges();
+	}
+	subscribeToStatChanges(callback) {
+		this.statSubscribers.add(callback);
+		callback(this.getStats());
+		return () => {
+			this.statSubscribers.delete(callback);
+		};
+	}
+	queueBroadcastStateChanges() {
+		if (this._queuedBroadcast != null) return;
+		this._queuedBroadcast = requestAnimationFrame(this._broadcastStateChanges);
+	}
+	_broadcastStateChanges = () => {
+		if (this._queuedBroadcast != null) {
+			cancelAnimationFrame(this._queuedBroadcast);
+			this._queuedBroadcast = void 0;
+		}
+		const stats = this.getStats();
+		for (const callback of this.statSubscribers) callback(stats);
+	};
+	cleanUpTasks(instance) {
+		this.detachInstanceFromQueuedTasks(instance);
+		const requestId = this.activeRequestByInstance.get(instance);
+		if (requestId != null) {
+			const task = this.activeTaskById.get(requestId);
+			if (isRenderTask(task)) {
+				this.detachInstanceFromRenderTask(task, instance);
+				if (!task.primeCache && task.instances.size === 0) this.removeActiveTask(task);
+			} else this.activeTaskById.delete(requestId);
+		}
+		this.activeRequestByInstance.delete(instance);
+		this.queueBroadcastStateChanges();
+	}
+	isInitialized() {
+		return this.initialized === true;
+	}
+	async initialize(languages = []) {
+		if (this.initialized === true) return;
+		else if (this.initialized === false) {
+			const { lifecycleGeneration } = this;
+			const initialization = new Promise((resolve, reject) => {
+				(async () => {
+					try {
+						const themes = getThemes(this.renderOptions.theme);
+						let resolvedThemes = [];
+						if (hasResolvedThemes(themes)) resolvedThemes = getResolvedThemes(themes);
+						else resolvedThemes = await resolveThemes(themes);
+						if (!this.isCurrentLifecycle(lifecycleGeneration)) {
+							resolve();
+							return;
+						}
+						let resolvedLanguages = [];
+						if (hasResolvedLanguages(languages)) resolvedLanguages = getResolvedLanguages(languages);
+						else resolvedLanguages = await resolveLanguages(languages);
+						if (!this.isCurrentLifecycle(lifecycleGeneration)) {
+							resolve();
+							return;
+						}
+						const [highlighter] = await Promise.all([getSharedHighlighter({
+							themes,
+							langs: ["text", ...languages],
+							preferredHighlighter: this.preferredHighlighter
+						}), this.initializeWorkers(resolvedThemes, resolvedLanguages)]);
+						if (!this.isCurrentLifecycle(lifecycleGeneration)) {
+							this.terminateWorkers();
+							resolve();
+							return;
+						}
+						this.highlighter = highlighter;
+						this.initialized = true;
+						this.diffCache.clear();
+						this.fileCache.clear();
+						this.drainQueue();
+						this.queueBroadcastStateChanges();
+						resolve();
+					} catch (e) {
+						if (e instanceof WorkerPoolTerminatedError || !this.isCurrentLifecycle(lifecycleGeneration)) {
+							resolve();
+							return;
+						}
+						this.initialized = false;
+						this.workersFailed = true;
+						this.cancelActiveWorkerTasks();
+						this.terminateWorkers();
+						this.activeTaskById.clear();
+						for (const task of this.queuedTasks) this.rejectRenderTaskCallbacks(task, normalizeWorkerError(e));
+						this.queueBroadcastStateChanges();
+						reject(e);
+					}
+				})();
+			});
+			this.initialized = initialization;
+			this.queueBroadcastStateChanges();
+			return initialization;
+		} else return this.initialized;
+	}
+	async initializeWorkers(resolvedThemes, resolvedLanguages) {
+		this.workersFailed = false;
+		const initPromises = [];
+		const customExtensionVersion = getCustomExtensionsVersion();
+		const customExtensionMap = customExtensionVersion > 0 ? getCustomExtensionsMap() : void 0;
+		if (this.workers.length > 0) this.terminateWorkers();
+		for (let i = 0; i < (this.options.poolSize ?? 8); i++) {
+			const worker = this.options.workerFactory();
+			const managedWorker = {
+				worker,
+				requestId: void 0,
+				pendingSetupRequestId: void 0,
+				initialized: false,
+				langs: /* @__PURE__ */ new Set(["text", ...resolvedLanguages.map(({ name }) => name)]),
+				customExtensionsVersion: 0
+			};
+			worker.addEventListener("message", (event) => {
+				this.handleWorkerMessage(managedWorker, event.data);
+			});
+			worker.addEventListener("error", (error) => this.handleWorkerError(managedWorker, error));
+			this.workers.push(managedWorker);
+			initPromises.push(new Promise((resolve, reject) => {
+				const id = this.generateRequestId();
+				const task = {
+					type: "initialize",
+					id,
+					request: {
+						type: "initialize",
+						id,
+						renderOptions: this.renderOptions,
+						preferredHighlighter: this.preferredHighlighter,
+						resolvedThemes,
+						resolvedLanguages,
+						customExtensionsVersion: customExtensionMap != null ? customExtensionVersion : void 0,
+						customExtensionMap
+					},
+					resolve() {
+						managedWorker.initialized = true;
+						resolve();
+					},
+					reject,
+					requestStart: Date.now()
+				};
+				managedWorker.pendingSetupRequestId = id;
+				this.activeTaskById.set(id, task);
+				this.executeTask(managedWorker, task);
+			}));
+		}
+		const timeoutMs = this.options.workerInitializationTimeout ?? DEFAULT_WORKER_INITIALIZATION_TIMEOUT;
+		let timeoutId;
+		try {
+			await Promise.race([Promise.all(initPromises), new Promise((_, reject) => {
+				timeoutId = setTimeout(() => {
+					reject(/* @__PURE__ */ new Error(`WorkerPoolManager: worker initialization timed out after ${timeoutMs}ms`));
+				}, timeoutMs);
+			})]);
+		} finally {
+			if (timeoutId != null) clearTimeout(timeoutId);
+		}
+	}
+	/**
+	* Pass worker errors to onWorkerError, or log them if no callback is set.
+	*
+	* A startup error rejects initialization so components can highlight on the
+	* main thread. Other requests wait for their own responses: worker.ts catches
+	* request errors, so this event may be unrelated to the current request.
+	* A worker that stops responding remains busy and receives no further work.
+	*/
+	handleWorkerError(managedWorker, event) {
+		const { onWorkerError } = this.options;
+		if (onWorkerError != null) try {
+			onWorkerError(event, managedWorker.worker);
+		} catch (hookError) {
+			console.error("WorkerPoolManager: onWorkerError threw:", hookError);
+		}
+		else console.error("Worker error:", event, managedWorker);
+		const { pendingSetupRequestId } = managedWorker;
+		if (pendingSetupRequestId == null) return;
+		const task = this.activeTaskById.get(pendingSetupRequestId);
+		if (task?.type !== "initialize") return;
+		const error = errorFromWorkerErrorEvent(event);
+		if (onWorkerError != null) markWorkerErrorReported(error);
+		task.reject(error);
+		this.cleanWorkerAndTask(managedWorker, task);
+	}
+	drainQueue = () => {
+		this._queuedDrain = void 0;
+		if (this.initialized !== true || this.queuedTasks.length === 0) return;
+		for (let i = 0; i < this.queuedTasks.length;) {
+			const task = this.queuedTasks[i];
+			if (this.hasActiveRequest(task)) {
+				i++;
+				continue;
+			}
+			const langs = getLangsFromTask(task);
+			const availableWorker = this.getAvailableWorker(langs);
+			if (availableWorker == null) break;
+			this.queuedTasks.splice(i, 1);
+			this.assignWorkerToTask(task, availableWorker);
+			this.resolveLanguagesAndExecuteTask(availableWorker, task, langs);
+		}
+		this.queueBroadcastStateChanges();
+	};
+	highlightFileAST(instance, file) {
+		const cachedResult = this.getFileResultCache(file);
+		if (isFilePlainText(file) || cachedResult != null && areFileRenderOptionsEqual(cachedResult.options, this.getFileRenderOptions())) return;
+		if (!this.hasMatchingFileInstanceTask(instance, file)) this.submitTask(instance, {
+			type: "file",
+			file
+		});
+	}
+	primeFileHighlightCache(file) {
+		if (!this.isWorkingPool()) return Promise.reject(/* @__PURE__ */ new Error("WorkerPoolManager.primeFileHighlightCache: worker pool is not working"));
+		const task = this.getOrCreateFileHighlightCacheTask(file);
+		return task != null ? this.createRenderTaskCallbacks(task) : Promise.resolve();
+	}
+	getOrCreateFileHighlightCacheTask(file) {
+		if (file.cacheKey == null) {
+			console.warn(`WorkerPoolManager.primeFileHighlightCache: priming highlight cache requires file.cacheKey; skipping "${file.name}".`);
+			return;
+		}
+		const cachedResult = this.getFileResultCache(file);
+		const highlightKey = this.getFileHighlightKey(file);
+		if (highlightKey == null || isFilePlainText(file) || cachedResult != null && areFileRenderOptionsEqual(cachedResult.options, this.getFileRenderOptions())) return;
+		const existingTask = this.getTaskByHighlightKey(highlightKey);
+		if (existingTask != null) {
+			existingTask.primeCache = true;
+			return existingTask.type === "file" ? existingTask : void 0;
+		} else {
+			const task = this.submitCacheTask({
+				type: "file",
+				file
+			}, highlightKey);
+			return task.type === "file" ? task : void 0;
+		}
+	}
+	getPlainFileAST(file, startingLine, totalLines, lines) {
+		if (this.highlighter == null) {
+			this.queueInitialization();
+			return;
+		}
+		return renderFileWithHighlighter(file, this.highlighter, this.renderOptions, {
+			forcePlainText: true,
+			startingLine,
+			totalLines,
+			lines
+		});
+	}
+	highlightDiffAST(instance, diff) {
+		const cachedResult = this.getDiffResultCache(diff);
+		if (isDiffPlainText(diff) || cachedResult != null && areDiffRenderOptionsEqual(cachedResult.options, this.getDiffRenderOptions())) return;
+		if (!this.hasMatchingDiffInstanceTask(instance, diff)) this.submitTask(instance, {
+			type: "diff",
+			diff
+		});
+	}
+	primeDiffHighlightCache(diff) {
+		if (!this.isWorkingPool()) return Promise.reject(/* @__PURE__ */ new Error("WorkerPoolManager.primeDiffHighlightCache: worker pool is not working"));
+		const task = this.getOrCreateDiffHighlightCacheTask(diff);
+		return task != null ? this.createRenderTaskCallbacks(task) : Promise.resolve();
+	}
+	getOrCreateDiffHighlightCacheTask(diff) {
+		if (diff.cacheKey == null) {
+			console.warn(`WorkerPoolManager.primeDiffHighlightCache: priming highlight cache requires diff.cacheKey; skipping "${diff.prevName ?? diff.name}" -> "${diff.name}".`);
+			return;
+		}
+		const cachedResult = this.getDiffResultCache(diff);
+		const highlightKey = this.getDiffHighlightKey(diff);
+		if (highlightKey == null || isDiffPlainText(diff) || cachedResult != null && areDiffRenderOptionsEqual(cachedResult.options, this.getDiffRenderOptions())) return;
+		const existingTask = this.getTaskByHighlightKey(highlightKey);
+		if (existingTask != null) {
+			existingTask.primeCache = true;
+			return existingTask.type === "diff" ? existingTask : void 0;
+		} else {
+			const task = this.submitCacheTask({
+				type: "diff",
+				diff
+			}, highlightKey);
+			return task.type === "diff" ? task : void 0;
+		}
+	}
+	getPlainDiffAST(diff, startingLine, totalLines, expandedHunks, collapsedContextThreshold) {
+		return this.highlighter != null ? renderDiffWithHighlighter(diff, this.highlighter, this.renderOptions, {
+			forcePlainText: true,
+			startingLine,
+			totalLines,
+			expandedHunks,
+			collapsedContextThreshold
+		}) : void 0;
+	}
+	terminate() {
+		this.lifecycleGeneration++;
+		this.cancelActiveWorkerTasks();
+		this.terminateWorkers();
+		const error = new WorkerPoolTerminatedError();
+		for (const task of this.queuedTasks) this.rejectRenderTaskCallbacks(task, error);
+		this.fileCache.clear();
+		this.diffCache.clear();
+		this.activeRequestByInstance.clear();
+		this.queuedTasks.length = 0;
+		this.queuedTaskByInstance.clear();
+		this.taskByHighlightKey.clear();
+		this.activeTaskById.clear();
+		this.highlighter = void 0;
+		this.initialized = false;
+		this.workersFailed = false;
+		this.queueBroadcastStateChanges();
+	}
+	isCurrentLifecycle(lifecycleGeneration) {
+		return this.lifecycleGeneration === lifecycleGeneration;
+	}
+	queueInitialization(languages) {
+		this.initialize(languages).catch((error) => {
+			if (isHandledWorkerPoolError(error)) return;
+			console.error(error);
+		});
+	}
+	cancelActiveWorkerTasks() {
+		const error = new WorkerPoolTerminatedError();
+		for (const task of this.activeTaskById.values()) if ("reject" in task) task.reject(error);
+		else if (isRenderTask(task)) this.rejectRenderTaskCallbacks(task, error);
+	}
+	terminateWorkers() {
+		for (const managedWorker of this.workers) managedWorker.worker.terminate();
+		this.workers.length = 0;
+	}
+	getStats() {
+		return {
+			managerState: (() => {
+				if (this.initialized === false) return "waiting";
+				if (this.initialized !== true) return "initializing";
+				return "initialized";
+			})(),
+			totalWorkers: this.workers.length,
+			workersFailed: this.workersFailed,
+			busyWorkers: this.workers.filter((w) => w.requestId != null || w.pendingSetupRequestId != null).length,
+			queuedTasks: this.queuedTasks.length,
+			activeTasks: this.activeTaskById.size,
+			themeSubscribers: this.themeSubscribers.size,
+			fileCacheSize: this.fileCache.size,
+			diffCacheSize: this.diffCache.size
+		};
+	}
+	submitTask(instance, request) {
+		if (this.initialized === false) this.queueInitialization();
+		const highlightKey = this.getHighlightKeyForRequest(request);
+		const existingTask = highlightKey != null ? this.getTaskByHighlightKey(highlightKey) : void 0;
+		if (existingTask != null) {
+			this.detachInstanceFromQueuedTasks(instance, existingTask);
+			this.addInstanceToTask(existingTask, instance);
+			this.queueBroadcastStateChanges();
+			return;
+		}
+		this.detachInstanceFromQueuedTasks(instance);
+		const id = this.generateRequestId();
+		const requestStart = Date.now();
+		const { renderOptionsVersion } = this;
+		const task = (() => {
+			switch (request.type) {
+				case "file": return {
+					type: "file",
+					id,
+					request: {
+						...request,
+						id
+					},
+					instances: /* @__PURE__ */ new Set([instance]),
+					primeCache: false,
+					highlightKey,
+					callbacks: /* @__PURE__ */ new Set(),
+					renderOptionsVersion,
+					requestStart
+				};
+				case "diff": return {
+					type: "diff",
+					id,
+					request: {
+						...request,
+						id
+					},
+					instances: /* @__PURE__ */ new Set([instance]),
+					primeCache: false,
+					highlightKey,
+					callbacks: /* @__PURE__ */ new Set(),
+					renderOptionsVersion,
+					requestStart
+				};
+			}
+		})();
+		this.enqueueRenderTask(task, instance);
+	}
+	submitCacheTask(request, highlightKey) {
+		if (this.initialized === false) this.queueInitialization();
+		const id = this.generateRequestId();
+		const requestStart = Date.now();
+		const { renderOptionsVersion } = this;
+		const task = (() => {
+			switch (request.type) {
+				case "file": return {
+					type: "file",
+					id,
+					request: {
+						...request,
+						id
+					},
+					instances: /* @__PURE__ */ new Set(),
+					primeCache: true,
+					highlightKey,
+					callbacks: /* @__PURE__ */ new Set(),
+					renderOptionsVersion,
+					requestStart
+				};
+				case "diff": return {
+					type: "diff",
+					id,
+					request: {
+						...request,
+						id
+					},
+					instances: /* @__PURE__ */ new Set(),
+					primeCache: true,
+					highlightKey,
+					callbacks: /* @__PURE__ */ new Set(),
+					renderOptionsVersion,
+					requestStart
+				};
+			}
+		})();
+		this.enqueueRenderTask(task);
+		return task;
+	}
+	enqueueRenderTask(task, instance) {
+		this.queuedTasks.push(task);
+		if (instance != null) this.queuedTaskByInstance.set(instance, task);
+		if (task.highlightKey != null) this.taskByHighlightKey.set(task.highlightKey, task);
+		this.queueDrain();
+	}
+	async resolveLanguagesAndExecuteTask(availableWorker, task, langs) {
+		try {
+			const mainThreadLangs = langs.filter((lang) => !areLanguagesAttached(lang));
+			if (mainThreadLangs.length > 0) getSharedHighlighter({
+				themes: getThemes(this.renderOptions.theme),
+				langs: ["text", ...mainThreadLangs],
+				preferredHighlighter: this.preferredHighlighter
+			}).catch((error) => {
+				console.error(error);
+			});
+			const workerMissingLangs = langs.filter((lang) => !availableWorker.langs.has(lang));
+			if (workerMissingLangs.length > 0) {
+				if (hasResolvedLanguages(workerMissingLangs)) task.request.resolvedLanguages = getResolvedLanguages(workerMissingLangs);
+				else task.request.resolvedLanguages = await resolveLanguages(workerMissingLangs);
+			}
+			if (!this.activeTaskById.has(task.id)) {
+				if (availableWorker.requestId === task.id) {
+					this.cleanWorkerAndTask(availableWorker, task);
+					this.queueBroadcastStateChanges();
+					if (this.queuedTasks.length > 0) this.queueDrain();
+				}
+				return;
+			}
+			this.executeTask(availableWorker, task);
+		} catch (error) {
+			this.rejectRenderTaskCallbacks(task, normalizeWorkerError(error));
+			this.cleanWorkerAndTask(availableWorker, task);
+			this.queueBroadcastStateChanges();
+			if (this.queuedTasks.length > 0) this.queueDrain();
+		}
+	}
+	handleWorkerMessage(managedWorker, response) {
+		const task = this.activeTaskById.get(response.id);
+		try {
+			if (task == null) throw IGNORE_RESPONSE;
+			else if (response.type === "error") {
+				const error = new Error(response.error);
+				if (response.stack) error.stack = response.stack;
+				if ("reject" in task) task.reject(error);
+				else if (isRenderTask(task)) {
+					this.notifyHighlightError(task, error);
+					this.rejectRenderTaskCallbacks(task, error);
+				} else throw new Error("handleWorkerMessage: unknown task type");
+				throw error;
+			} else {
+				if (isRenderTask(task)) for (const { name } of task.request.resolvedLanguages ?? []) managedWorker.langs.add(name);
+				switch (response.requestType) {
+					case "initialize":
+						if (task.type !== "initialize") throw new Error("handleWorkerMessage: task/response dont match");
+						this.syncCustomExtensionVersion(managedWorker, task.request);
+						task.resolve();
+						break;
+					case "set-render-options":
+						if (task.type !== "set-render-options") throw new Error("handleWorkerMessage: task/response dont match");
+						task.resolve();
+						break;
+					case "file": {
+						if (task.type !== "file") throw new Error("handleWorkerMessage: task/response dont match");
+						const { result, options } = response;
+						if (!this.isCurrentRenderTask(task) || !areFileRenderOptionsEqual(options, this.getFileRenderOptions())) throw IGNORE_RESPONSE;
+						const { request } = task;
+						this.syncCustomExtensionVersion(managedWorker, request);
+						if (task.cacheKeyAtDispatch != null) this.fileCache.set(task.cacheKeyAtDispatch, {
+							result,
+							options
+						});
+						this.resolveRenderTaskCallbacks(task);
+						this.notifyFileInstances(task, result, options);
+						break;
+					}
+					case "diff": {
+						if (task.type !== "diff") throw new Error("handleWorkerMessage: task/response dont match");
+						const { result, options } = response;
+						if (!this.isCurrentRenderTask(task) || !areDiffRenderOptionsEqual(options, this.getDiffRenderOptions())) throw IGNORE_RESPONSE;
+						const { request } = task;
+						this.syncCustomExtensionVersion(managedWorker, request);
+						if (task.cacheKeyAtDispatch != null) this.diffCache.set(task.cacheKeyAtDispatch, {
+							result,
+							options
+						});
+						this.resolveRenderTaskCallbacks(task);
+						this.notifyDiffInstances(task, result, options);
+						break;
+					}
+				}
+			}
+		} catch (error) {
+			if (error !== IGNORE_RESPONSE) console.error(error, task, response);
+		}
+		this.cleanWorkerAndTask(managedWorker, task, response.id);
+		this.queueBroadcastStateChanges();
+		if (this.queuedTasks.length > 0) this.queueDrain();
+	}
+	_queuedDrain;
+	queueDrain() {
+		if (this._queuedDrain != null) return;
+		this._queuedDrain = Promise.resolve().then(this.drainQueue);
+		this.queueBroadcastStateChanges();
+	}
+	assignWorkerToTask(task, managedWorker) {
+		managedWorker.requestId = task.id;
+		if (isRenderTask(task)) {
+			this.clearQueuedInstanceRequests(task);
+			this.trackInstanceRequests(task);
+		}
+		this.activeTaskById.set(task.id, task);
+	}
+	cleanWorkerAndTask(managedWorker, task, requestId = task?.id) {
+		if (managedWorker.requestId === requestId) managedWorker.requestId = void 0;
+		if (managedWorker.pendingSetupRequestId === requestId) managedWorker.pendingSetupRequestId = void 0;
+		if (task != null) {
+			if (isRenderTask(task)) {
+				this.rejectRenderTaskCallbacks(task, new WorkerPoolTaskCanceledError());
+				this.clearInstanceRequests(task);
+				this.clearHighlightKey(task);
+			}
+			this.activeTaskById.delete(task.id);
+		}
+	}
+	executeTask(managedWorker, task) {
+		if (shouldSyncCustomExtensions(task.request)) this.maybeAttachCustomExtensions(managedWorker, task.request);
+		if (!this.activeTaskById.has(task.id)) this.assignWorkerToTask(task, managedWorker);
+		try {
+			if (task.type === "file") task.cacheKeyAtDispatch = task.request.file.cacheKey;
+			else if (task.type === "diff") task.cacheKeyAtDispatch = task.request.diff.cacheKey;
+			managedWorker.worker.postMessage(task.request);
+		} catch (error) {
+			console.error("Failed to post message to worker:", error);
+			if (isRenderTask(task)) {
+				this.notifyHighlightError(task, error);
+				this.rejectRenderTaskCallbacks(task, normalizeWorkerError(error));
+			} else if ("reject" in task) task.reject(error);
+			this.cleanWorkerAndTask(managedWorker, task);
+			if (this.queuedTasks.length > 0) this.queueDrain();
+		}
+		this.queueBroadcastStateChanges();
+	}
+	maybeAttachCustomExtensions(managedWorker, request) {
+		if (request.customExtensionsVersion != null) return;
+		const version = getCustomExtensionsVersion();
+		if (managedWorker.customExtensionsVersion >= version) return;
+		request.customExtensionsVersion = version;
+		request.customExtensionMap = getCustomExtensionsMap();
+	}
+	syncCustomExtensionVersion(managedWorker, request) {
+		if (request.customExtensionsVersion == null) return;
+		managedWorker.customExtensionsVersion = request.customExtensionsVersion;
+	}
+	getAvailableWorker(langs) {
+		let worker;
+		for (const managedWorker of this.workers) {
+			if (managedWorker.requestId != null || managedWorker.pendingSetupRequestId != null || !managedWorker.initialized) continue;
+			worker = managedWorker;
+			if (langs.length === 0) break;
+			let hasEveryLang = true;
+			for (const lang of langs) if (!managedWorker.langs.has(lang)) {
+				hasEveryLang = false;
+				break;
+			}
+			if (hasEveryLang) break;
+		}
+		return worker;
+	}
+	getFileHighlightKey(file) {
+		if (file.cacheKey == null) return;
+		return `file:${file.cacheKey}:${this.renderOptionsVersion}`;
+	}
+	getDiffHighlightKey(diff) {
+		if (diff.cacheKey == null) return;
+		return `diff:${diff.cacheKey}:${this.renderOptionsVersion}`;
+	}
+	getHighlightKeyForRequest(request) {
+		switch (request.type) {
+			case "file": return this.getFileHighlightKey(request.file);
+			case "diff": return this.getDiffHighlightKey(request.diff);
+		}
+	}
+	hasActiveRequest(task) {
+		for (const instance of getInstances(task)) if (this.activeRequestByInstance.has(instance)) return true;
+		return false;
+	}
+	addInstanceToTask(task, instance) {
+		if (task.type === "file") task.instances.add(instance);
+		else task.instances.add(instance);
+		if (this.activeTaskById.has(task.id)) this.activeRequestByInstance.set(instance, task.id);
+		else this.queuedTaskByInstance.set(instance, task);
+	}
+	detachInstanceFromQueuedTasks(instance, exceptTask) {
+		const task = this.queuedTaskByInstance.get(instance);
+		if (task == null || task === exceptTask) return;
+		this.queuedTaskByInstance.delete(instance);
+		this.detachInstanceFromRenderTask(task, instance);
+		if (!task.primeCache && task.instances.size === 0) this.removeQueuedTask(task);
+	}
+	detachInstanceFromRenderTask(task, instance) {
+		if (task.type === "file") task.instances.delete(instance);
+		else task.instances.delete(instance);
+	}
+	removeQueuedTask(task) {
+		const index = this.queuedTasks.indexOf(task);
+		if (index !== -1) this.queuedTasks.splice(index, 1);
+		this.rejectRenderTaskCallbacks(task, new WorkerPoolTaskCanceledError());
+		this.clearQueuedInstanceRequests(task);
+		this.clearHighlightKey(task);
+	}
+	removeActiveTask(task) {
+		this.rejectRenderTaskCallbacks(task, new WorkerPoolTaskCanceledError());
+		this.clearInstanceRequests(task);
+		this.clearHighlightKey(task);
+		this.activeTaskById.delete(task.id);
+	}
+	createRenderTaskCallbacks(task) {
+		return new Promise((resolve, reject) => {
+			task.callbacks.add({
+				resolve,
+				reject
+			});
+		});
+	}
+	resolveRenderTaskCallbacks(task) {
+		for (const callbacks of task.callbacks) callbacks.resolve();
+		task.callbacks.clear();
+	}
+	rejectRenderTaskCallbacks(task, error) {
+		for (const callbacks of task.callbacks) callbacks.reject(error);
+		task.callbacks.clear();
+	}
+	invalidateRenderTasks() {
+		for (let index = this.queuedTasks.length - 1; index >= 0; index--) {
+			const task = this.queuedTasks[index];
+			if (task.renderOptionsVersion !== this.renderOptionsVersion) this.removeQueuedTask(task);
+		}
+		for (const task of Array.from(this.activeTaskById.values())) if (isRenderTask(task) && task.renderOptionsVersion !== this.renderOptionsVersion) this.removeActiveTask(task);
+	}
+	clearQueuedInstanceRequests(task) {
+		for (const instance of getInstances(task)) if (this.queuedTaskByInstance.get(instance) === task) this.queuedTaskByInstance.delete(instance);
+	}
+	clearHighlightKey(task) {
+		if (task.highlightKey != null && this.taskByHighlightKey.get(task.highlightKey) === task) this.taskByHighlightKey.delete(task.highlightKey);
+	}
+	trackInstanceRequests(task) {
+		for (const instance of getInstances(task)) this.activeRequestByInstance.set(instance, task.id);
+	}
+	clearInstanceRequests(task) {
+		for (const instance of getInstances(task)) if (this.activeRequestByInstance.get(instance) === task.id) this.activeRequestByInstance.delete(instance);
+	}
+	notifyFileInstances(task, result, options) {
+		for (const instance of task.instances) if (this.activeRequestByInstance.get(instance) === task.id) instance.onHighlightSuccess(task.request.file, result, options);
+	}
+	notifyDiffInstances(task, result, options) {
+		for (const instance of task.instances) if (this.activeRequestByInstance.get(instance) === task.id) instance.onHighlightSuccess(task.request.diff, result, options);
+	}
+	notifyHighlightError(task, error) {
+		for (const instance of getInstances(task)) if (this.activeRequestByInstance.get(instance) === task.id) instance.onHighlightError(error);
+	}
+	hasMatchingFileInstanceTask(instance, file) {
+		for (const task of this.iterateRenderTasks()) if (task.type === "file" && this.isCurrentRenderTask(task) && task.instances.has(instance) && areFilesEqual(file, task.request.file)) return true;
+		return false;
+	}
+	hasMatchingDiffInstanceTask(instance, diff) {
+		for (const task of this.iterateRenderTasks()) if (task.type === "diff" && this.isCurrentRenderTask(task) && task.instances.has(instance) && areDiffTargetsEqual(task.request.diff, diff)) return true;
+		return false;
+	}
+	getTaskByHighlightKey(highlightKey) {
+		const task = this.taskByHighlightKey.get(highlightKey);
+		return task != null && this.isCurrentRenderTask(task) ? task : void 0;
+	}
+	isCurrentRenderTask(task) {
+		return task.renderOptionsVersion === this.renderOptionsVersion;
+	}
+	*iterateRenderTasks() {
+		for (const task of this.queuedTasks) yield task;
+		for (const task of this.activeTaskById.values()) if (isRenderTask(task)) yield task;
+	}
+	generateRequestId() {
+		return `req_${++this.nextRequestId}`;
+	}
+};
+function shouldSyncCustomExtensions(request) {
+	return request.type === "initialize" || request.type === "file" || request.type === "diff";
+}
+function getLangsFromTask(task) {
+	const langs = /* @__PURE__ */ new Set();
+	if (task.type === "initialize" || task.type === "set-render-options") return [];
+	switch (task.type) {
+		case "file":
+			langs.add(task.request.file.lang ?? getFiletypeFromFileName(task.request.file.name));
+			break;
+		case "diff":
+			langs.add(task.request.diff.lang ?? getFiletypeFromFileName(task.request.diff.name));
+			langs.add(task.request.diff.lang ?? getFiletypeFromFileName(task.request.diff.prevName ?? "-"));
+	}
+	langs.delete("text");
+	return Array.from(langs);
+}
+function isRenderTask(task) {
+	return task?.type === "file" || task?.type === "diff";
+}
+function getInstances(task) {
+	return task.instances;
+}
+function normalizeWorkerError(error) {
+	if (error instanceof Error) return error;
+	if (error != null && typeof error === "object") {
+		if ("error" in error && error.error instanceof Error) return error.error;
+		if ("message" in error && typeof error.message === "string") return new Error(error.message);
+	}
+	return new Error(String(error));
+}
+function errorFromWorkerErrorEvent(event) {
+	const cause = "error" in event ? event.error : void 0;
+	const message = "message" in event && typeof event.message === "string" && event.message !== "" ? event.message : cause instanceof Error ? cause.message : "the worker script failed to load (the error event carries no message)";
+	return new WorkerPoolWorkerError(`WorkerPoolManager: worker failed: ${message}`, cause instanceof Error ? { cause } : void 0);
+}
+//#endregion
+//#region ../ui/src/lib/files/code-workers.ts
+/**
+* Create one pool per workspace in a browser lifecycle, then lend it to its viewers.
+* @param options - Pool configuration and the owning workspace's lifetime signal.
+* @returns The borrowed manager, observable initialization, and idempotent disposal.
+*/
+async function createCodeWorkerPool(options = {}) {
+	let { signal, renderOptions, ...poolOptions } = options;
+	signal?.throwIfAborted();
+	let workerFactory = options.workerFactory ?? (await import("./worker-factory-C80HGMWf.js")).createCodeWorker;
+	signal?.throwIfAborted();
+	let pool = new WorkerPoolManager({
+		poolSize: 2,
+		...poolOptions,
+		workerFactory
+	}, renderOptions ?? {});
+	let disposed = false;
+	function dispose() {
+		if (disposed) return;
+		disposed = true;
+		signal?.removeEventListener("abort", dispose);
+		pool.terminate();
+	}
+	signal?.addEventListener("abort", dispose, { once: true });
+	return {
+		pool,
+		ready: pool.initialize().then(() => {
+			if (disposed) pool.terminate();
+		}),
+		dispose
+	};
+}
+//#endregion
+//#region app/client/files-request.ts
+var endpoints = new Set([
+	routes.filesApi,
+	routes.fileSearchApi,
+	routes.fileReviewApi,
+	routes.fileMutationsApi,
+	routes.fileSavesApi,
+	routes.fileReviewActionsApi
+].flatMap((group) => Object.values(group).map((route) => route.href())));
+/** A Files request that failed, with the service's error code and the HTTP status. */
+var FilesRequestError = class extends Error {
+	code;
+	status;
+	constructor(message, code = "request", status = 0) {
+		super(message);
+		this.name = "FilesRequestError";
+		this.code = code;
+		this.status = status;
+	}
+};
+/**
+* Reads one bounded, same-origin Files endpoint with the project capability.
+* @param url - Relative endpoint from the application's route contract.
+* @param token - Current project's capability; never sent to previewed pages or redirects.
+* @param signal - Owner's request lifetime.
+* @param parse - Domain DTO validator.
+* @param fetcher - Injectable transport for browser-free boundary tests.
+* @param action - JSON payload, accepted only by the explicit mutation POST endpoints.
+* @returns A validated value or explicit request error, never an invented empty success.
+*/
+async function requestFiles(url, token, signal, parse, fetcher = fetch, action) {
+	let parsed = new URL(url, "http://bud.invalid");
+	let mutation = parsed.pathname === "/api/files/mutations/prepare" || parsed.pathname === "/api/files/mutations/apply" || parsed.pathname === "/api/files/review-actions/prepare" || parsed.pathname === "/api/files/review-actions/apply" || parsed.pathname === "/api/files/save";
+	if (!url.startsWith("/api/files") || url.startsWith("//") || parsed.origin !== "http://bud.invalid" || parsed.hash || !endpoints.has(parsed.pathname) || (parsed.pathname === "/api/files/refresh" || parsed.pathname === "/api/files/save" || parsed.pathname.startsWith("/api/files/review-actions/") || parsed.pathname.startsWith("/api/files/mutations/")) && parsed.search || mutation !== Boolean(action)) throw new FilesRequestError("Invalid file endpoint.", "input");
+	signal.throwIfAborted();
+	let response = await fetcher(url, {
+		method: mutation || parsed.pathname === "/api/files/refresh" ? "POST" : "GET",
+		headers: {
+			"X-Bud-Token": token,
+			...mutation ? { "Content-Type": "application/json" } : {}
+		},
+		...action ? { body: JSON.stringify(action.body) } : {},
+		credentials: "same-origin",
+		redirect: "error",
+		cache: "no-store",
+		signal
+	});
+	let reader = response.body?.getReader();
+	if (!reader) throw new FilesRequestError("The file service returned an empty response.", "response", response.status);
+	let chunks = [];
+	let size = 0;
+	let cancel = () => {
+		reader.cancel(signal.reason).catch(() => {});
+	};
+	signal.addEventListener("abort", cancel, { once: true });
+	try {
+		while (true) {
+			signal.throwIfAborted();
+			let part = await reader.read();
+			signal.throwIfAborted();
+			if (part.done) break;
+			size += part.value.byteLength;
+			if (size > 16777216) throw new FilesRequestError("This file response exceeds the display limit. Narrow the file view and try again.", "limit", response.status);
+			chunks.push(part.value);
+		}
+	} catch (error) {
+		await reader.cancel().catch(() => {});
+		throw error;
+	} finally {
+		signal.removeEventListener("abort", cancel);
+		reader.releaseLock();
+	}
+	let bytes = new Uint8Array(size);
+	let offset = 0;
+	for (let chunk of chunks) {
+		bytes.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	let value;
+	try {
+		value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+	} catch {
+		throw new FilesRequestError("The file service returned invalid data. Refresh and try again.", "response", response.status);
+	}
+	if (!response.ok) throw new FilesRequestError(value && typeof value === "object" && "error" in value && typeof value.error === "string" ? value.error.slice(0, 1e3) : "Could not load files. Try again.", value && typeof value === "object" && "code" in value && typeof value.code === "string" ? value.code.slice(0, 100) : "request", response.status);
+	try {
+		return parse(value);
+	} catch {
+		throw new FilesRequestError("The file service returned unexpected data. Refresh and try again.", "response", response.status);
+	}
+}
+//#endregion
+//#region app/client/file-mutation-controller.ts
+/**
+* Collects the guards of the open views and runs them, in order, around every file action.
+* @returns The guard set: register a guard for its lifetime, then run them before and after.
+*/
+function createFileMutationGuards() {
+	let guards = /* @__PURE__ */ new Set();
+	return {
+		register(guard, signal) {
+			if (signal.aborted) return;
+			guards.add(guard);
+			signal.addEventListener("abort", () => guards.delete(guard), { once: true });
+		},
+		async beforeApply(intent, plan, signal) {
+			for (let guard of guards) {
+				signal.throwIfAborted();
+				let reason = await guard.beforeApply(intent, plan, signal);
+				signal.throwIfAborted();
+				if (reason) throw new Error(reason);
+			}
+		},
+		async afterApply(intent, result) {
+			for (let guard of guards) await guard.afterApply(intent, result);
+		}
+	};
+}
+function message$4(cause) {
+	return cause instanceof Error ? cause.message : "The file action could not be completed.";
+}
+function assertPlan(intent, plan) {
+	if (intent.kind !== plan.kind) throw new Error("The service returned a different file action.");
+	if (intent.kind === "restore") return;
+	let expected = "entries" in intent ? intent.entries.map((item) => [item.path, item.destination]) : intent.kind === "delete" ? intent.paths.map((source) => [source, null]) : [[null, intent.path]];
+	let actual = plan.items.map((item) => [item.source, item.destination]);
+	if (JSON.stringify(expected) !== JSON.stringify(actual)) throw new Error("The service returned different file paths. Refresh before continuing.");
+}
+function assertResult(plan, result) {
+	if (result.id !== plan.id || result.items.length !== plan.items.length || result.items.some((item, index) => item.source !== plan.items[index].source || item.destination !== plan.items[index].destination)) throw new Error("The file result does not match its confirmed plan. Refresh and check Recovery before retrying.");
+}
+/**
+* Coordinates validated plans without hiding partial results or retrying writes.
+* @param options - Scoped transport, draft guards and authoritative refresh callbacks.
+* @returns The dialog state and deliberate action/recovery commands.
+*/
+function createFileMutationController(options) {
+	let state = null;
+	let recoveryOpen = false;
+	let recoveries = null;
+	let recoveryLoading = false;
+	let recoveryError = "";
+	let request;
+	let recoveryRequest;
+	let intent = null;
+	let sequence = 0;
+	function changed() {
+		if (!options.signal.aborted) options.onChange();
+	}
+	function busy() {
+		return state?.phase === "preparing" || state?.phase === "applying";
+	}
+	function close() {
+		if (state?.phase === "applying") return;
+		request?.abort();
+		sequence++;
+		state = null;
+		intent = null;
+		changed();
+	}
+	async function prepare(current, applyImmediately) {
+		if (!state || state.phase === "applying") return;
+		request?.abort();
+		let controller = new AbortController();
+		request = controller;
+		let signal = AbortSignal.any([options.signal, controller.signal]);
+		let turn = ++sequence;
+		intent = current;
+		state = {
+			...state,
+			phase: "preparing",
+			plan: null,
+			result: null,
+			error: ""
+		};
+		changed();
+		try {
+			let plan = await options.transport.prepare(current, signal);
+			signal.throwIfAborted();
+			assertPlan(current, plan);
+			if (turn !== sequence || !state) return;
+			state = {
+				...state,
+				plan,
+				phase: "confirming"
+			};
+			changed();
+			if (applyImmediately) await apply();
+		} catch (cause) {
+			if (!signal.aborted && turn === sequence && state) {
+				state = {
+					...state,
+					phase: "editing",
+					error: message$4(cause)
+				};
+				changed();
+			}
+		}
+	}
+	async function apply() {
+		if (!state?.plan || !intent || busy()) return;
+		let current = intent;
+		let plan = state.plan;
+		if (Date.parse(plan.expiresAt) <= Date.now()) {
+			state = {
+				...state,
+				phase: "editing",
+				plan: null,
+				error: "This confirmation expired. Review the current files again."
+			};
+			changed();
+			return;
+		}
+		request?.abort();
+		let controller = new AbortController();
+		request = controller;
+		let signal = AbortSignal.any([options.signal, controller.signal]);
+		let turn = ++sequence;
+		let sent = false;
+		state = {
+			...state,
+			phase: "applying",
+			error: ""
+		};
+		changed();
+		try {
+			await options.guards.beforeApply(current, plan, signal);
+			signal.throwIfAborted();
+			sent = true;
+			let result = await options.transport.apply(plan, signal);
+			signal.throwIfAborted();
+			assertResult(plan, result);
+			if (turn !== sequence || !state) return;
+			state = {
+				...state,
+				phase: "result",
+				result
+			};
+			let draftError = "";
+			try {
+				await options.guards.afterApply(current, result);
+			} catch (cause) {
+				draftError = `Files changed, but retained draft metadata could not be updated. ${message$4(cause)}`;
+			}
+			await options.onApplied(current, result);
+			if (turn !== sequence || !state) return;
+			state = {
+				...state,
+				error: draftError
+			};
+			if (result.status === "applied" && !draftError && !["delete", "restore"].includes(current.kind)) {
+				state = null;
+				intent = null;
+			}
+			changed();
+		} catch (cause) {
+			if (signal.aborted || turn !== sequence || !state) return;
+			state = {
+				...state,
+				phase: "editing",
+				plan: null,
+				error: message$4(cause)
+			};
+			if (sent) {
+				await options.onUncertain().catch(() => {});
+				if (state && turn === sequence) state = {
+					...state,
+					error: `${message$4(cause)} Refresh and check Recovery before retrying.`
+				};
+			}
+			changed();
+		}
+	}
+	function open(next, runImmediately = false) {
+		if (busy()) return;
+		request?.abort();
+		recoveryRequest?.abort();
+		sequence++;
+		recoveryOpen = false;
+		intent = null;
+		let destination = "";
+		let error = "";
+		try {
+			destination = defaultFileDestination(next, options.index());
+		} catch (cause) {
+			error = message$4(cause);
+		}
+		state = {
+			request: next,
+			destination,
+			phase: "editing",
+			plan: null,
+			result: null,
+			error
+		};
+		changed();
+		if (!error && (next.action === "delete" || next.action === "restore" || runImmediately)) submit();
+	}
+	async function submit() {
+		if (!state || busy()) return;
+		if (state.phase === "confirming") {
+			await apply();
+			return;
+		}
+		try {
+			let next = state.result && intent ? remainingMutationIntent(intent, state.result) : fileActionIntent(state.request, state.destination, options.index());
+			if (!next) return;
+			await prepare(next, !["delete", "restore"].includes(next.kind));
+		} catch (cause) {
+			if (state) state = {
+				...state,
+				error: message$4(cause),
+				phase: "editing"
+			};
+			changed();
+		}
+	}
+	async function loadRecoveries() {
+		recoveryRequest?.abort();
+		let controller = new AbortController();
+		recoveryRequest = controller;
+		let signal = AbortSignal.any([options.signal, controller.signal]);
+		recoveryLoading = true;
+		recoveryError = "";
+		changed();
+		try {
+			let next = await options.transport.recoveries(signal);
+			if (!signal.aborted) recoveries = next;
+		} catch (cause) {
+			if (!signal.aborted) recoveryError = message$4(cause);
+		} finally {
+			if (recoveryRequest === controller) {
+				recoveryLoading = false;
+				changed();
+			}
+		}
+	}
+	options.signal.addEventListener("abort", () => {
+		request?.abort();
+		recoveryRequest?.abort();
+	}, { once: true });
+	return {
+		get state() {
+			return state;
+		},
+		get busy() {
+			return busy();
+		},
+		get recovery() {
+			return {
+				open: recoveryOpen,
+				recoveries,
+				loading: recoveryLoading,
+				error: recoveryError
+			};
+		},
+		open,
+		close,
+		submit,
+		destination(value) {
+			if (!state || busy()) return;
+			intent = null;
+			state = {
+				...state,
+				destination: value,
+				plan: null,
+				result: null,
+				phase: "editing",
+				error: ""
+			};
+			changed();
+		},
+		recoveries() {
+			if (busy()) return;
+			close();
+			recoveryOpen = true;
+			loadRecoveries();
+			changed();
+		},
+		refreshRecoveries: loadRecoveries,
+		closeRecoveries() {
+			recoveryRequest?.abort();
+			recoveryOpen = false;
+			changed();
+		}
+	};
+}
+//#endregion
+//#region app/client/project-file-review-data.ts
+/**
+* Writes a review comparison as URL parameters.
+* @param comparison - The working tree, the staged changes or two commits.
+* @returns The parameters.
+*/
+function comparisonQuery(comparison) {
+	return new URLSearchParams(comparison.mode === "commits" ? {
+		mode: comparison.mode,
+		base: comparison.base,
+		target: comparison.target
+	} : { mode: comparison.mode });
+}
+/**
+* Reads a bounded page with at most three in-flight diffs and a shared cancellation signal.
+* @param snapshot - Pinned comparison metadata returned by the server.
+* @param paths - A bounded page of paths belonging to that snapshot.
+* @param token - Current project capability.
+* @param signal - Owning selection/request lifetime.
+* @param fetcher - Injectable transport for deterministic concurrency and stale-data checks.
+* @returns Exact source snapshots plus explicit per-file failures.
+*/
+async function readReviewPage(snapshot, paths, token, signal, fetcher = fetch) {
+	if (paths.length > 20 || paths.some((path) => !snapshot.entries.some((entry) => entry.path === path))) throw new FilesRequestError("The selected files are outside this comparison page.", "input");
+	let result = /* @__PURE__ */ new Map();
+	let failures = {};
+	let cursor = 0;
+	let retainedBytes = 0;
+	let controller = new AbortController();
+	let lifetime = AbortSignal.any([signal, controller.signal]);
+	let fatal;
+	async function worker() {
+		try {
+			while (cursor < paths.length) {
+				lifetime.throwIfAborted();
+				let path = paths[cursor++];
+				let query = comparisonQuery(snapshot.comparison);
+				query.set("path", path);
+				query.set("expectedRevision", snapshot.revision);
+				try {
+					let diff = await requestFiles(`${routes.fileReviewApi.diff.href()}?${query}`, token, lifetime, parseReviewDiff, fetcher);
+					if (diff.entry.path !== path || diff.metadataRevision !== snapshot.revision || JSON.stringify(diff.comparison) !== JSON.stringify(snapshot.comparison)) throw new FilesRequestError("The comparison changed while reading. Refresh before continuing.", "changed", 409);
+					let bytes = [
+						diff.oldFile,
+						diff.newFile,
+						diff.conflict?.base,
+						diff.conflict?.ours,
+						diff.conflict?.theirs
+					].reduce((total, file) => total + (file?.contents?.length ?? 0) * 2, 0);
+					if (retainedBytes + bytes > 33554432) failures[path] = "This page reached its memory limit. Open this file individually.";
+					else {
+						retainedBytes += bytes;
+						result.set(path, diff);
+					}
+				} catch (cause) {
+					if (lifetime.aborted || cause instanceof FilesRequestError && (cause.status === 409 || cause.status === 401 || cause.status === 403)) throw cause;
+					failures[path] = cause instanceof Error ? cause.message : "Could not read this comparison.";
+				}
+			}
+		} catch (cause) {
+			fatal ??= cause;
+			controller.abort(cause);
+		}
+	}
+	await Promise.all(Array.from({ length: Math.min(3, paths.length) }, worker));
+	if (fatal) throw fatal;
+	signal.throwIfAborted();
+	return {
+		diffs: paths.flatMap((path) => result.get(path) ?? []),
+		failures
+	};
+}
+//#endregion
+//#region app/client/file-drafts.ts
+/** Drafts kept as UI preferences, which stay in this browser. */
+var preferenceDraftStorage = {
+	getItem: (key) => {
+		let value = readPreference(key);
+		return typeof value === "string" ? value : null;
+	},
+	setItem: (key, value) => writePreference(key, value)
+};
+var maxDrafts = 16;
+var maxDraftBytes = maxDrafts * maxFileSaveBytes * 2;
+var maxStoredCharacters = 3145728;
+var encoder = new TextEncoder();
+/**
+* Whether a draft differs from the contents it was made against.
+* @param draft - The draft.
+* @returns True when it has unsaved changes.
+*/
+function draftDirty(draft) {
+	return draft.contents !== draft.baseContents;
+}
+function bytes(draft) {
+	return encoder.encode(draft.contents).length + encoder.encode(draft.baseContents).length;
+}
+function within(path, parent) {
+	return path === parent || path.startsWith(`${parent}/`);
+}
+/**
+* Strict project-bound draft records never authorize writes without a live server revision.
+* @param value - Serialized local browser record.
+* @param projectId - Expected connected project identity.
+* @returns Validated draft entries.
+*/
+function parseDrafts(value, projectId) {
+	if (!value) return [];
+	if (value.length > maxStoredCharacters) throw new Error("The local draft record exceeds its limit.");
+	let parsed = JSON.parse(value);
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("Invalid local draft record.");
+	let record = parsed;
+	if (record.version !== 1 || record.projectId !== projectId || !Array.isArray(record.drafts) || record.drafts.length > maxDrafts || Object.keys(record).some((key) => ![
+		"version",
+		"projectId",
+		"drafts"
+	].includes(key))) throw new Error("Invalid local draft record.");
+	let seen = /* @__PURE__ */ new Set();
+	let total = 0;
+	return record.drafts.map((input) => {
+		if (!input || typeof input !== "object" || Array.isArray(input)) throw new Error("Invalid local draft.");
+		let item = input;
+		if (Object.keys(item).some((key) => ![
+			"id",
+			"path",
+			"baseRevision",
+			"baseContents",
+			"contents",
+			"updatedAt"
+		].includes(key)) || typeof item.id !== "string" || !/^[a-zA-Z0-9-]{1,80}$/.test(item.id) || !Number.isSafeInteger(item.updatedAt) || Number(item.updatedAt) < 0) throw new Error("Invalid local draft.");
+		parseFileSaveRequest({
+			path: item.path,
+			expectedRevision: item.baseRevision,
+			contents: item.baseContents
+		});
+		parseFileSaveRequest({
+			path: item.path,
+			expectedRevision: item.baseRevision,
+			contents: item.contents
+		});
+		let draft = item;
+		if (seen.has(draft.path)) throw new Error("Duplicate local draft path.");
+		seen.add(draft.path);
+		total += bytes(draft);
+		if (total > maxDraftBytes) throw new Error("The local drafts exceed their memory limit.");
+		return { ...draft };
+	});
+}
+/**
+* Bounded memory retains drafts even when browser storage fails. Nothing dirty is silently evicted.
+* @param projectId - Connected project identity.
+* @param storage - Optional injectable browser persistence.
+* @param now - Clock for draft modification times.
+* @returns Draft storage and explicit mutation guards.
+*/
+function createFileDrafts(projectId, storage, now = Date.now) {
+	let drafts = /* @__PURE__ */ new Map();
+	let warning = "";
+	let key = `bud:drafts:${projectId}:v1`;
+	try {
+		for (let draft of parseDrafts(storage?.getItem(key) ?? null, projectId)) drafts.set(draft.path, draft);
+	} catch {
+		warning = "Local drafts could not be read. The stored record has been left untouched.";
+	}
+	let unreadable = Boolean(warning);
+	function persist() {
+		if (unreadable) return false;
+		let record = JSON.stringify({
+			version: 1,
+			projectId,
+			drafts: [...drafts.values()].filter(draftDirty)
+		});
+		try {
+			if (!storage || record.length > maxStoredCharacters) throw new Error("Storage unavailable");
+			storage.setItem(key, record);
+			warning = "";
+			return true;
+		} catch {
+			warning = "This draft is kept in this tab only. Browser storage is unavailable or full; save or download it before closing the tab.";
+			return false;
+		}
+	}
+	function put(draft) {
+		if (encoder.encode(draft.contents).length > 2097152 || !draft.contents.isWellFormed() || draft.contents.includes("\0")) throw new Error("This draft exceeds the text editor limit or contains unsupported text. Undo the last edit before saving.");
+		let clean = [...drafts.values()].filter((item) => item.path !== draft.path && !draftDirty(item));
+		for (let item of clean) drafts.delete(item.path);
+		let others = [...drafts.values()].filter((item) => item.path !== draft.path);
+		if (others.length >= maxDrafts || others.reduce((sum, item) => sum + bytes(item), bytes(draft)) > maxDraftBytes) throw new Error("Save or discard another draft before editing more files. Your existing drafts have been kept.");
+		drafts.set(draft.path, draft);
+		persist();
+		return draft;
+	}
+	return {
+		get warning() {
+			return warning;
+		},
+		get dirty() {
+			return [...drafts.values()].filter(draftDirty);
+		},
+		get(path) {
+			return drafts.get(path);
+		},
+		open(path, revision, contents) {
+			let previous = drafts.get(path);
+			if (previous && draftDirty(previous)) return previous;
+			parseFileSaveRequest({
+				path,
+				expectedRevision: revision,
+				contents
+			});
+			return put({
+				id: crypto.randomUUID(),
+				path,
+				baseRevision: revision,
+				baseContents: contents,
+				contents,
+				updatedAt: now()
+			});
+		},
+		change(path, contents) {
+			let draft = drafts.get(path);
+			if (!draft) throw new Error("This draft is no longer open.");
+			return put({
+				...draft,
+				contents,
+				updatedAt: now()
+			});
+		},
+		acknowledge(path, savedContents, revision) {
+			let draft = drafts.get(path);
+			if (!draft) return;
+			return put({
+				...draft,
+				baseRevision: revision,
+				baseContents: savedContents,
+				updatedAt: now()
+			});
+		},
+		rebase(path, revision, contents) {
+			let draft = drafts.get(path);
+			if (!draft) throw new Error("This draft is no longer open.");
+			return put({
+				...draft,
+				id: crypto.randomUUID(),
+				baseRevision: revision,
+				baseContents: contents,
+				updatedAt: now()
+			});
+		},
+		discard(path) {
+			drafts.delete(path);
+			persist();
+		},
+		persist,
+		beforeMutation(intent, plan) {
+			let dirty = [...drafts.values()].filter(draftDirty);
+			if (intent.kind === "delete" && dirty.some((draft) => intent.paths.some((path) => within(draft.path, path)))) return "Save or discard the unsaved drafts in this selection before deleting it.";
+			if (intent.kind === "restore" && dirty.some((draft) => plan.items.some((item) => item.destination && within(draft.path, item.destination)))) return "Save or discard the unsaved drafts at these original paths before restoring them.";
+			if (intent.kind === "move") {
+				if (dirty.some((draft) => intent.entries.some((entry) => within(draft.path, entry.destination) && !within(draft.path, entry.path)))) return "A destination has an unsaved draft. Save or discard it before moving files here.";
+				if (dirty.some((draft) => intent.entries.some((entry) => within(draft.path, entry.path))) && !persist()) return "Save or download your drafts before moving these files; local draft storage is unavailable.";
+			}
+			return null;
+		},
+		afterMutation(intent, result) {
+			if (intent.kind !== "move") return;
+			let changes = result.items.filter((item) => item.status === "applied" && item.source && item.destination);
+			let moved = [];
+			let next = new Map(drafts);
+			for (let draft of drafts.values()) {
+				let item = changes.find((item) => within(draft.path, item.source));
+				if (!item) continue;
+				let path = parseFilePath(item.destination + draft.path.slice(item.source.length));
+				moved.push({
+					draft,
+					path
+				});
+				next.delete(draft.path);
+			}
+			for (let { draft, path } of moved) {
+				let destination = next.get(path);
+				if (destination && draftDirty(destination)) throw new Error("The destination acquired an unsaved draft while the move was running. Both drafts remain available at their original paths; download or review them before continuing.");
+				next.set(path, {
+					...draft,
+					id: crypto.randomUUID(),
+					path
+				});
+			}
+			drafts = next;
+			persist();
+		}
+	};
+}
+var openProjects = /* @__PURE__ */ new Map();
+var unloadWarningInstalled = false;
+/**
+* Mount-time only: retain unsaved data through client route replacement, including storage
+* failures.
+* @param projectId - Connected project identity.
+* @param storage - Browser persistence for this tab.
+* @returns The bounded shared draft owner for the project.
+*/
+function projectFileDrafts(projectId, storage) {
+	if (!unloadWarningInstalled) {
+		unloadWarningInstalled = true;
+		window.addEventListener("beforeunload", (event) => {
+			if ([...openProjects.values()].some((drafts) => drafts.dirty.length)) {
+				for (let drafts of openProjects.values()) drafts.persist();
+				event.preventDefault();
+				event.returnValue = "";
+			}
+		});
+	}
+	let existing = openProjects.get(projectId);
+	if (existing) return existing;
+	for (let [id, drafts] of openProjects) if (!drafts.dirty.length) openProjects.delete(id);
+	if (openProjects.size >= 4) throw new Error("Save or discard drafts in another project before opening more editors.");
+	let drafts = createFileDrafts(projectId, storage);
+	openProjects.set(projectId, drafts);
+	return drafts;
+}
+//#endregion
+//#region app/client/file-editor-controller.ts
+function message$3(cause) {
+	return cause instanceof Error ? cause.message : "The file could not be saved. Your draft has been kept.";
+}
+function readable(document, path) {
+	if (document.entry.path !== path) throw new Error("The source response belongs to another file.");
+	if (document.contents === null || !document.revision) throw new Error("Only regular UTF-8 text files within the editor size limit can be edited.");
+	return {
+		revision: document.revision,
+		contents: document.contents
+	};
+}
+function inside(path, parent) {
+	return path === parent || path.startsWith(`${parent}/`);
+}
+/**
+* Keeps acknowledged bytes separate from live drafts, including edits made during a save.
+* @param options - Scoped transport, draft owner and application notifications.
+* @returns Explicit editor, save and conflict commands.
+*/
+function createFileEditorController(options) {
+	let state = null;
+	let opening = false;
+	let requestedPath = null;
+	let openError = "";
+	let request;
+	let saves = /* @__PURE__ */ new Set();
+	let generation = 0;
+	function changed() {
+		if (!options.signal.aborted) options.onChange();
+	}
+	function close() {
+		request?.abort();
+		generation++;
+		state = null;
+		requestedPath = null;
+		opening = false;
+		openError = "";
+		options.drafts.persist();
+		changed();
+	}
+	function closeOtherPath(path) {
+		if (requestedPath !== path) close();
+	}
+	function observe(document) {
+		if (!state || state.draft.path !== document.entry.path || state.saving || state.latest) return;
+		if (document.revision !== state.draft.baseRevision) {
+			state = {
+				...state,
+				conflict: true,
+				error: "This file changed outside the editor. Your draft has been kept. Compare with the latest file before saving."
+			};
+			changed();
+		}
+	}
+	async function begin(path, mode = "file", baseline) {
+		request?.abort();
+		let controller = new AbortController();
+		request = controller;
+		let signal = AbortSignal.any([controller.signal, options.signal]);
+		let turn = ++generation;
+		requestedPath = path;
+		opening = true;
+		openError = "";
+		changed();
+		try {
+			let document = await options.read(path, signal);
+			signal.throwIfAborted();
+			let current = readable(document, path);
+			let draft = options.drafts.open(path, current.revision, current.contents);
+			let conflict = draft.baseRevision !== current.revision;
+			let useIndex = mode === "diff" && baseline?.workingRevision === current.revision;
+			state = {
+				key: `${draft.id}:${turn}`,
+				draft,
+				file: {
+					name: path,
+					contents: draft.contents
+				},
+				oldFile: useIndex ? baseline.file : {
+					name: path,
+					contents: draft.baseContents
+				},
+				mode,
+				baselineLabel: useIndex ? "Index" : "Opened version",
+				saving: saves.has(path),
+				conflict,
+				latest: null,
+				error: conflict ? "This recovered draft belongs to an older file version. Compare it with the latest file before saving." : "",
+				status: draftDirty(draft) ? "Recovered unsaved draft." : ""
+			};
+		} catch (cause) {
+			if (!signal.aborted) {
+				let retained = options.drafts.get(path);
+				if (retained && draftDirty(retained)) state = {
+					key: `${retained.id}:recovery:${turn}`,
+					draft: retained,
+					file: {
+						name: path,
+						contents: retained.contents
+					},
+					oldFile: {
+						name: path,
+						contents: retained.baseContents
+					},
+					mode: "file",
+					baselineLabel: "Opened version",
+					saving: saves.has(path),
+					conflict: true,
+					latest: null,
+					error: `The current project file could not be read. ${message$3(cause)}`,
+					status: "Your unsaved draft is available below. Download it, or restore the project file and compare with its latest contents before saving."
+				};
+				else openError = message$3(cause);
+			}
+		} finally {
+			if (turn === generation) {
+				opening = false;
+				changed();
+			}
+		}
+	}
+	function change(contents) {
+		if (!state) return;
+		try {
+			let draft = options.drafts.change(state.draft.path, contents);
+			state = {
+				...state,
+				draft,
+				status: "",
+				error: state.conflict ? state.error : ""
+			};
+		} catch (cause) {
+			state = {
+				...state,
+				error: message$3(cause)
+			};
+		}
+		changed();
+	}
+	async function save() {
+		if (!state || state.saving || state.conflict || state.latest || !draftDirty(state.draft)) return;
+		let draft = state.draft;
+		saves.add(draft.path);
+		state = {
+			...state,
+			saving: true,
+			error: "",
+			status: ""
+		};
+		changed();
+		try {
+			let result = await options.save({
+				path: draft.path,
+				expectedRevision: draft.baseRevision,
+				contents: draft.contents
+			}, options.signal);
+			if (result.path !== draft.path || result.previousRevision !== draft.baseRevision) throw new Error("The save response belongs to a different file revision. Check the latest file before retrying.");
+			let next = options.drafts.acknowledge(draft.path, draft.contents, result.revision);
+			if (state?.draft.path === draft.path && next) {
+				state = {
+					...state,
+					draft: next,
+					status: "",
+					error: ""
+				};
+				if (result.refresh === "failed") toast.error("Saved, but the file browser could not refresh", { description: "Refresh it before continuing." });
+				else if (draftDirty(next)) toast.success("Saved to your project", { description: "Newer edits are still unsaved." });
+				else toast.success("Saved to your project");
+			}
+			options.onSaved();
+		} catch (cause) {
+			if (state?.draft.path === draft.path) state = {
+				...state,
+				error: message$3(cause),
+				conflict: true
+			};
+		} finally {
+			saves.delete(draft.path);
+			if (state?.draft.path === draft.path) state = {
+				...state,
+				saving: false
+			};
+			changed();
+		}
+	}
+	async function checkLatest() {
+		if (!state || state.saving) return;
+		let previous = state;
+		request?.abort();
+		let controller = new AbortController();
+		request = controller;
+		let signal = AbortSignal.any([controller.signal, options.signal]);
+		let turn = ++generation;
+		try {
+			let document = await options.read(previous.draft.path, signal);
+			signal.throwIfAborted();
+			let current = readable(document, previous.draft.path);
+			if (!state || state.draft.path !== previous.draft.path) return;
+			let draft = options.drafts.get(previous.draft.path);
+			state = {
+				...state,
+				key: `${draft.id}:merge:${turn}`,
+				file: {
+					name: draft.path,
+					contents: draft.contents
+				},
+				oldFile: {
+					name: draft.path,
+					contents: current.contents
+				},
+				mode: "diff",
+				baselineLabel: "Latest file",
+				latest: document,
+				conflict: true,
+				error: "",
+				status: "Your draft is on the new side. No file is changed until you review it and save."
+			};
+		} catch (cause) {
+			if (!signal.aborted && state) state = {
+				...state,
+				error: message$3(cause)
+			};
+		} finally {
+			changed();
+		}
+	}
+	function acceptMerge() {
+		if (!state?.latest) return;
+		let latest = readable(state.latest, state.draft.path);
+		let draft = options.drafts.rebase(state.draft.path, latest.revision, latest.contents);
+		state = {
+			...state,
+			draft,
+			latest: null,
+			conflict: false,
+			error: "",
+			status: "Reviewed against the latest file. Save when your merged draft is ready."
+		};
+		changed();
+	}
+	async function discard() {
+		if (!state || state.saving) return;
+		let path = state.draft.path;
+		options.drafts.discard(path);
+		close();
+		await begin(path);
+	}
+	return {
+		get state() {
+			return state;
+		},
+		get opening() {
+			return opening;
+		},
+		get openError() {
+			return openError;
+		},
+		begin,
+		change,
+		save,
+		close,
+		closeOtherPath,
+		observe,
+		checkLatest,
+		acceptMerge,
+		discard,
+		guard: {
+			async beforeApply(intent, plan, signal) {
+				signal.throwIfAborted();
+				if ([...saves].some((path) => plan.items.some((item) => item.source && inside(path, item.source) || item.destination && inside(path, item.destination)))) return "Wait for the file save to finish before changing these paths.";
+				return options.drafts.beforeMutation(intent, plan);
+			},
+			afterApply(intent, result) {
+				options.drafts.afterMutation(intent, result);
+				if (state && intent.kind === "move" && result.items.some((item) => item.status === "applied" && item.source && inside(state.draft.path, item.source))) close();
+				changed();
+			}
+		}
+	};
+}
+//#endregion
+//#region app/client/file-review-actions-controller.ts
+function message$2(cause) {
+	return cause instanceof Error ? cause.message : "The review action could not be completed. Refresh and inspect retained undo before trying again.";
+}
+/**
+* Runs review actions, such as staging or discarding changes, one at a time: plans one, applies
+* it and lists recoveries, dropping the answers of superseded requests.
+* @param options - The component's lifetime, the Files API calls and the callbacks.
+* @returns The controller and its dialog state.
+*/
+function createFileReviewActionsController(options) {
+	let state = null, request, generation = 0;
+	function changed() {
+		if (!options.signal.aborted) options.onChange();
+	}
+	function start(phase) {
+		request?.abort();
+		request = new AbortController();
+		generation++;
+		state = {
+			phase,
+			plan: null,
+			result: null,
+			recoveries: null,
+			error: ""
+		};
+		changed();
+		return {
+			signal: AbortSignal.any([options.signal, request.signal]),
+			turn: generation
+		};
+	}
+	function close() {
+		if (state?.phase === "applying") return;
+		request?.abort();
+		generation++;
+		state = null;
+		changed();
+	}
+	async function prepare(intent) {
+		if (state?.phase === "applying") return;
+		let { signal, turn } = start("preparing");
+		try {
+			if (intent.kind !== "undo") options.guard([intent.path], intent.kind === "discard" ? "worktree" : "index");
+			let plan = await options.prepare(intent, signal);
+			signal.throwIfAborted();
+			if (plan.kind !== intent.kind || intent.kind !== "undo" && !plan.paths.includes(intent.path)) throw new Error("The prepared review belongs to a different action or file.");
+			options.guard(plan.paths, plan.target);
+			if (turn === generation) state = {
+				phase: "ready",
+				plan,
+				result: null,
+				recoveries: null,
+				error: ""
+			};
+		} catch (cause) {
+			if (!signal.aborted && turn === generation) state = {
+				phase: "error",
+				plan: null,
+				result: null,
+				recoveries: null,
+				error: message$2(cause)
+			};
+		} finally {
+			if (turn === generation) changed();
+		}
+	}
+	async function apply() {
+		if (state?.phase !== "ready" || !state.plan) return;
+		let plan = state.plan, turn = generation, signal = AbortSignal.any([options.signal, request.signal]);
+		try {
+			options.guard(plan.paths, plan.target);
+			state = {
+				...state,
+				phase: "applying",
+				error: ""
+			};
+			changed();
+			let result = await options.apply({
+				id: plan.id,
+				revision: plan.revision
+			}, signal);
+			signal.throwIfAborted();
+			if (result.id !== plan.id || result.target !== plan.target || result.changedPaths.some((path) => !plan.paths.includes(path))) throw new Error("The write response could not be confirmed. Refresh and inspect retained undo.");
+			if (turn === generation) {
+				let refreshError = "";
+				try {
+					await options.onApplied(result);
+				} catch (cause) {
+					refreshError = message$2(cause);
+				}
+				signal.throwIfAborted();
+				if (turn === generation) state = {
+					...state,
+					phase: "done",
+					result,
+					error: refreshError
+				};
+			}
+		} catch (cause) {
+			if (!signal.aborted && turn === generation && state) state = {
+				...state,
+				phase: "error",
+				error: message$2(cause)
+			};
+		} finally {
+			if (turn === generation) changed();
+		}
+	}
+	async function recoveries() {
+		if (state?.phase === "applying") return;
+		let { signal, turn } = start("preparing");
+		try {
+			let items = await options.recoveries(signal);
+			if (!signal.aborted && turn === generation) state = {
+				phase: "recoveries",
+				plan: null,
+				result: null,
+				recoveries: items,
+				error: ""
+			};
+		} catch (cause) {
+			if (!signal.aborted && turn === generation) state = {
+				phase: "error",
+				plan: null,
+				result: null,
+				recoveries: null,
+				error: message$2(cause)
+			};
+		} finally {
+			if (turn === generation) changed();
+		}
+	}
+	options.signal.addEventListener("abort", () => {
+		request?.abort();
+		state = null;
+	}, { once: true });
+	return {
+		get state() {
+			return state;
+		},
+		prepare,
+		apply,
+		recoveries,
+		close
+	};
+}
+//#endregion
+//#region app/client/project-code-comments.ts
+/**
+* Where a code conversation's lines are in the review, for selecting them.
+* @param location - The conversation's anchor as it resolves in the current source.
+* @returns The lines and their revision, or null when the anchor is outdated.
+*/
+function codeConversationPosition(location) {
+	if (location.resolution.state === "outdated") return null;
+	return {
+		selection: {
+			path: location.source.viewPath ?? location.source.path,
+			start: location.resolution.startLine,
+			end: location.resolution.endLine,
+			...location.source.side ? { side: location.source.side === "old" ? "deletions" : "additions" } : {}
+		},
+		revision: location.resolution.revision
+	};
+}
+/**
+* The sources a review can be commented on: the shown source, the open file, or both sides of
+* every diff.
+* @param document - The open file, if any.
+* @param diffs - The shown diffs.
+* @param source - The shown source at a commit, if any.
+* @returns The commentable sources.
+*/
+function reviewCommentSources(document, diffs, source) {
+	if (source) return [{
+		path: source.path,
+		revision: source.file?.revision ?? null,
+		contents: source.file?.contents ?? null,
+		commit: source.commit
+	}];
+	if (document) return [{
+		path: document.entry.path,
+		revision: document.revision,
+		contents: document.contents,
+		commit: null
+	}];
+	return diffs.flatMap((diff) => [{
+		path: diff.oldFile?.name ?? diff.entry.originalPath ?? diff.entry.path,
+		revision: diff.oldFile?.revision ?? null,
+		contents: diff.oldFile?.contents ?? null,
+		viewPath: diff.entry.path,
+		side: "old",
+		commit: diff.base
+	}, {
+		path: diff.entry.path,
+		previousPath: diff.entry.originalPath,
+		revision: diff.newFile?.revision ?? null,
+		contents: diff.newFile?.contents ?? null,
+		viewPath: diff.entry.path,
+		side: "new",
+		commit: diff.target
+	}]);
+}
+/**
+* Anchors selected lines to their exact source revision for a new code comment.
+* @param selection - Consecutive lines on one side.
+* @param sources - The commentable sources.
+* @param expectedRevision - The revision the selection was made in, when known.
+* @returns The code anchor.
+*/
+function captureCodeSelection(selection, sources, expectedRevision) {
+	if (selection.endSide && selection.endSide !== selection.side) throw new Error("Select consecutive lines on one side before commenting.");
+	let side = selection.side === "deletions" ? "old" : "new";
+	let source = sources.find((source) => (source.viewPath ?? source.path) === selection.path && (!source.side || source.side === side));
+	if (!source || source.contents === null || !source.revision) throw new Error("Comments require readable text with an exact source revision.");
+	if (expectedRevision && source.revision !== expectedRevision) throw new Error("Those lines belong to an older source. Select them again before commenting.");
+	return createCodeAnchor({
+		path: source.path,
+		revision: source.revision,
+		commit: source.commit ?? null,
+		side,
+		startLine: Math.min(selection.start, selection.end),
+		endLine: Math.max(selection.start, selection.end)
+	}, source.contents);
+}
+//#endregion
+//#region app/client/file-search-controller.ts
+/**
+* Writes a search query as the search API's URL parameters.
+* @param query - The validated query.
+* @returns The parameters, with one `include` and `exclude` entry for each pattern.
+*/
+function fileSearchParameters(query) {
+	let params = new URLSearchParams({
+		query: query.query,
+		regex: String(query.regex),
+		caseSensitive: String(query.caseSensitive),
+		wholeWord: String(query.wholeWord),
+		directory: query.directory,
+		includeDotfiles: String(query.includeDotfiles),
+		includeIgnored: String(query.includeIgnored),
+		limit: String(query.limit)
+	});
+	for (let value of query.include) params.append("include", value);
+	for (let value of query.exclude) params.append("exclude", value);
+	return params;
+}
+/**
+* Superseded and cancelled requests never publish their result or error.
+* @param options - Component lifetime, validated transport and render notification.
+* @returns A single request owner and its observable search state.
+*/
+function createFileSearchController(options) {
+	let active;
+	let state = {
+		loading: false,
+		result: null,
+		error: "",
+		notice: ""
+	};
+	function notify() {
+		if (!options.signal.aborted) options.onChange();
+	}
+	function cancel(notice = "Search cancelled.") {
+		active?.abort();
+		active = void 0;
+		state = {
+			...state,
+			loading: false,
+			notice,
+			error: ""
+		};
+		notify();
+	}
+	options.signal.addEventListener("abort", () => cancel(""), { once: true });
+	return {
+		get state() {
+			return state;
+		},
+		cancel,
+		async search(input) {
+			cancel("");
+			let owner = new AbortController();
+			active = owner;
+			let signal = AbortSignal.any([owner.signal, options.signal]);
+			state = {
+				loading: true,
+				result: null,
+				error: "",
+				notice: ""
+			};
+			notify();
+			try {
+				let query = parseFileSearchQuery(input);
+				let result = await options.request(query, signal);
+				if (fileSearchParameters(result.query).toString() !== fileSearchParameters(query).toString()) throw new FilesRequestError("The service returned results for a different search.", "response");
+				if (signal.aborted || active !== owner) return;
+				state = {
+					loading: false,
+					result,
+					error: "",
+					notice: ""
+				};
+			} catch (cause) {
+				if (signal.aborted || active !== owner) return;
+				state = {
+					loading: false,
+					result: null,
+					error: cause instanceof Error ? cause.message : "Could not search this project.",
+					notice: ""
+				};
+			} finally {
+				if (active === owner) {
+					active = void 0;
+					notify();
+				}
+				owner.abort();
+			}
+		}
+	};
+}
+/**
+* Search offsets only navigate the exact on-disk version that produced them.
+* @param document - Current complete file response.
+* @param match - Captured search result with revision and coordinates.
+* @returns A verified source-review position, or an explicit outdated-result error.
+*/
+function searchMatchPosition(document, match) {
+	if (document.entry.path !== match.path || document.revision !== match.revision || document.entry.content !== "text" || typeof document.contents !== "string" || match.start < 0 || match.end < match.start || match.end > document.contents.length) throw new Error("This search result is outdated. Search again to locate the current text; any unsaved draft is retained.");
+	let position = (offset) => {
+		let line = 1, start = 0;
+		for (let ending of document.contents.matchAll(/\r\n|\r|\n/g)) {
+			let next = ending.index + ending[0].length;
+			if (next > offset) break;
+			line++;
+			start = next;
+		}
+		return {
+			line,
+			column: offset - start + 1
+		};
+	};
+	let before = position(match.start), end = position(match.end);
+	if (before.line !== match.startLine || before.column !== match.startColumn || end.line !== match.endLine || end.column !== match.endColumn) throw new Error("This search result has invalid coordinates. Search again.");
+	return {
+		page: 0,
+		scroll: 0,
+		revision: match.revision,
+		selection: {
+			path: match.path,
+			start: match.startLine,
+			end: Math.max(match.startLine, match.endLine - Number(match.endColumn === 1 && match.endLine > match.startLine))
+		}
+	};
+}
+//#endregion
+//#region app/client/project-file-review.tsx
+function message$1(cause) {
+	return cause instanceof Error ? cause.message : "Could not read the project.";
+}
+/**
+* Owns validated review requests, the worker pool and bounded project view persistence.
+* @param handle - Selected path and the connected project's public capability.
+* @returns The review render function.
+*/
+function ProjectFileReview(handle) {
+	let project = handle.props.project;
+	let session = {
+		version: 1,
+		projectId: project.id,
+		view: defaultReviewView(),
+		positions: {}
+	};
+	let document = null;
+	let snapshot = null;
+	let diffs = [];
+	let failures = {};
+	let error = "";
+	let loading = false;
+	let history = null;
+	let historyOpen = false;
+	let historyLoading = false;
+	let historyError = "";
+	let theme = "light";
+	let pool;
+	let poolSettled = false;
+	let request;
+	let historyRequest;
+	let persistTimer;
+	let mounted = false;
+	let renderedHref = "";
+	let renderedConversation;
+	let pendingHref;
+	let lastKey = "";
+	let displayedKey = "";
+	let historyKey = "";
+	let refresh = handle.props.refresh;
+	let appliedHighlights = "";
+	let drafts;
+	let editor;
+	let preferences = defaultEditorPreferences();
+	let observedPath = handle.props.path;
+	let actions;
+	let merge;
+	let historical = null;
+	let source = null;
+	let panelOpen = false, selectedThread, draftAnchor;
+	let commentError = "", requestedThread = null, appliedThread = null;
+	let commentSources = [], commentLocations = [];
+	let sourceSignature = "", locationsVersion;
+	let pendingFocus = null;
+	let editorLocations;
+	let locatedEditor;
+	let searchSelectionId = 0, searchNotice = "";
+	let pendingSearch;
+	let commentReturnFocus;
+	let host;
+	let reportedDrafts = "";
+	let reportedComments = false;
+	let store = handle.props.store;
+	if (!store) projectStore(project).then((opened) => {
+		store = opened;
+	});
+	function openComments() {
+		if (!panelOpen) {
+			let active = window.document.activeElement;
+			while (active?.shadowRoot?.activeElement) active = active.shadowRoot.activeElement;
+			commentReturnFocus = active instanceof HTMLElement ? active : void 0;
+		}
+		panelOpen = true;
+	}
+	function closeComments() {
+		panelOpen = false;
+		draftAnchor = void 0;
+		changed();
+		handle.queueTask(() => {
+			(commentReturnFocus?.isConnected ? commentReturnFocus : host?.querySelector("diffs-container")?.shadowRoot?.querySelector("[contenteditable=true]") ?? host?.querySelector("[data-bud-code-review]"))?.focus({ preventScroll: true });
+			commentReturnFocus = void 0;
+		});
+	}
+	function changed() {
+		if (!handle.signal.aborted) handle.update();
+	}
+	function context() {
+		return historical ? JSON.stringify([reviewContextKey(session.view, handle.props.path), historical.commit]) : reviewContextKey(session.view, handle.props.path);
+	}
+	function position() {
+		return session.positions[context()] ?? defaultReviewPosition();
+	}
+	function persist() {
+		clearTimeout(persistTimer);
+		persistTimer = setTimeout(() => writePreference(`bud:review:${project.id}:v1`, JSON.stringify(session)), 200);
+	}
+	function savePosition(change, render = false) {
+		let previous = position();
+		let next = {
+			...previous,
+			...change
+		};
+		session = rememberReviewPosition(session, context(), next);
+		persist();
+		if (render || JSON.stringify(previous.selection) !== JSON.stringify(next.selection) || previous.revision !== next.revision) changed();
+	}
+	function location() {
+		let href = reviewHref(handle.props.path, session.view);
+		if (window.location.pathname + window.location.search + window.location.hash !== href) {
+			pendingHref = new URL(href, window.location.origin).href;
+			window.history.pushState({ ...window.history.state }, "", href);
+		}
+	}
+	function changeView(change) {
+		historical = null;
+		source = null;
+		session = {
+			...session,
+			view: {
+				...session.view,
+				...change
+			}
+		};
+		persist();
+		location();
+		changed();
+	}
+	let reading;
+	async function load() {
+		let finishRead;
+		reading = new Promise((resolve) => {
+			finishRead = resolve;
+		});
+		request?.abort();
+		let controller = new AbortController();
+		request = controller;
+		let signal = AbortSignal.any([handle.signal, controller.signal]);
+		let selected = handle.props.path;
+		let settings = session.view;
+		let immutable = historical && historical.path === selected ? historical : null;
+		let key = context();
+		let nextDisplay = JSON.stringify([
+			key,
+			position().page,
+			selected
+		]);
+		let comparison = reviewComparison(settings);
+		loading = true;
+		error = "";
+		if (displayedKey !== nextDisplay) {
+			document = null;
+			snapshot = null;
+			diffs = [];
+			source = null;
+			failures = {};
+		}
+		changed();
+		try {
+			if (immutable) {
+				let next = await requestFiles(`${routes.fileReviewApi.source.href()}?${new URLSearchParams(immutable)}`, project.token, signal, parseReviewSource);
+				if (next.path !== immutable.path || next.commit !== immutable.commit) throw new FilesRequestError("The source response belongs to another commit or file.", "response");
+				if (!signal.aborted) {
+					source = next;
+					displayedKey = nextDisplay;
+				}
+			} else if (!comparison) {
+				if (selected) {
+					let stored = displayedKey !== nextDisplay && store ? storedDocument(store, selected) : null;
+					if (stored) {
+						document = stored;
+						displayedKey = nextDisplay;
+						loading = false;
+						changed();
+					}
+					let next = await requestFiles(`${routes.filesApi.read.href()}?${new URLSearchParams({ path: selected })}`, project.token, signal, parseFileDocument);
+					if (next.entry.path !== selected) throw new FilesRequestError("The source response belongs to another file.", "response");
+					if (store) storeDocument(store, next).catch(() => {});
+					if (!signal.aborted) {
+						document = document?.revision === next.revision && document.entry.path === next.entry.path ? document : next;
+						displayedKey = nextDisplay;
+						editor?.observe(next);
+						if (pendingSearch?.path === selected) {
+							let match = pendingSearch;
+							pendingSearch = void 0;
+							try {
+								savePosition(searchMatchPosition(next, match), true);
+								searchNotice = `Search match at ${match.startLine}:${match.startColumn}. Any unsaved draft is retained.`;
+							} catch (cause) {
+								searchNotice = message$1(cause);
+							}
+						}
+					}
+				}
+			} else for (let attempt = 0; attempt < 2; attempt++) {
+				let next = await requestFiles(`${routes.fileReviewApi.compare.href()}?${comparisonQuery(comparison)}`, project.token, signal, parseReviewSnapshot);
+				if (next.comparison.mode !== comparison.mode) throw new FilesRequestError("The service returned a different comparison.", "response");
+				let page = Math.min(position().page, Math.max(0, Math.ceil(next.entries.length / 20) - 1));
+				let restoredPath = position().selection?.path;
+				if (restoredPath && settings.multiple && next.entries.some((entry) => entry.path === restoredPath)) page = Math.floor(next.entries.findIndex((entry) => entry.path === restoredPath) / 20);
+				if (page !== position().page) savePosition({
+					...position(),
+					page
+				});
+				let paths = settings.multiple ? next.entries.slice(page * 20, (page + 1) * 20).map((entry) => entry.path) : next.entries.filter((entry) => entry.path === selected).map((entry) => entry.path);
+				try {
+					let result = await readReviewPage(next, paths, project.token, signal);
+					if (!signal.aborted && context() === key) {
+						snapshot = next;
+						diffs = result.diffs;
+						failures = result.failures;
+						displayedKey = JSON.stringify([
+							key,
+							page,
+							selected
+						]);
+					}
+					break;
+				} catch (cause) {
+					if (attempt === 0 && cause instanceof FilesRequestError && cause.status === 409) continue;
+					throw cause;
+				}
+			}
+		} catch (cause) {
+			if (!signal.aborted) error = message$1(cause);
+		} finally {
+			if (request === controller) {
+				loading = false;
+				changed();
+			}
+			finishRead();
+		}
+	}
+	async function loadHistory(older = false) {
+		historyRequest?.abort();
+		let path = handle.props.path;
+		if (!path) {
+			history = null;
+			return;
+		}
+		let controller = new AbortController();
+		historyRequest = controller;
+		let signal = AbortSignal.any([handle.signal, controller.signal]);
+		let query = new URLSearchParams({
+			path,
+			limit: "25"
+		});
+		if (older && history?.nextCursor && history.revision) {
+			query.set("revision", history.revision);
+			query.set("cursor", history.nextCursor);
+		} else if (session.view.mode === "commits") query.set("revision", session.view.target);
+		historyLoading = true;
+		historyError = "";
+		changed();
+		try {
+			let next = await requestFiles(`${routes.fileReviewApi.history.href()}?${query}`, project.token, signal, parseReviewHistory);
+			if (next.path !== path) throw new FilesRequestError("The history response belongs to another path.", "response");
+			if (!signal.aborted) history = next;
+		} catch (cause) {
+			if (!signal.aborted) historyError = message$1(cause);
+		} finally {
+			if (historyRequest === controller) {
+				historyLoading = false;
+				changed();
+			}
+		}
+	}
+	function selectPath(path) {
+		if (session.view.multiple && snapshot) {
+			let index = snapshot.entries.findIndex((entry) => entry.path === path);
+			savePosition({
+				...defaultReviewPosition(),
+				page: Math.max(0, Math.floor(index / 20))
+			});
+			lastKey = "";
+		}
+		handle.props.onSelect(path);
+		changed();
+	}
+	function historyRevision(commit, action) {
+		let endpoints = action === "parent" && commit.parents[0] ? {
+			base: commit.parents[0],
+			target: commit.commit
+		} : action === "base" ? { base: commit.commit } : { target: commit.commit };
+		historyOpen = false;
+		changeView({
+			mode: "commits",
+			...endpoints
+		});
+		if (commit.path !== handle.props.path) handle.props.onSelect(commit.path);
+	}
+	async function startEditor() {
+		let path = handle.props.path;
+		let mode = session.view.mode;
+		if (!path || !editor) return;
+		if (mode === "working") {
+			if (!snapshot || snapshot.comparison.mode !== "working") await load();
+			while (loading && reading) {
+				await reading;
+				if (handle.signal.aborted || handle.props.path !== path || session.view.mode !== mode) return;
+			}
+			if (handle.signal.aborted || handle.props.path !== path || session.view.mode !== mode) return;
+		}
+		let diff = diffs.find((diff) => diff.entry.path === path);
+		let working = session.view.mode === "working" && diff?.newFile?.contents !== null && diff?.newFile?.revision;
+		editor.begin(path, working ? "diff" : "file", working ? {
+			workingRevision: diff.newFile.revision,
+			file: diff.oldFile?.contents !== null && diff.oldFile ? {
+				name: diff.oldFile.name,
+				contents: diff.oldFile.contents
+			} : null
+		} : void 0);
+	}
+	function setPreferences(value) {
+		preferences = value;
+		writePreference("bud:editor-preferences:v1", JSON.stringify(value));
+		changed();
+	}
+	function downloadDraft() {
+		let draft = editor?.state?.draft;
+		if (!draft) return;
+		let url = URL.createObjectURL(new Blob([new TextEncoder().encode(draft.contents)], { type: "application/octet-stream" }));
+		let link = window.document.createElement("a");
+		link.href = url;
+		link.download = draft.path.split("/").at(-1) ?? "draft.txt";
+		link.click();
+		setTimeout(() => URL.revokeObjectURL(url), 0);
+	}
+	async function resolveConflict(diff) {
+		let identity = reviewConflictIdentity(diff.conflict);
+		if (!identity || !editor) return;
+		if (diff.entry.path !== handle.props.path) handle.props.onSelect(diff.entry.path);
+		merge = {
+			path: diff.entry.path,
+			conflict: identity
+		};
+		await editor.begin(diff.entry.path);
+		changed();
+	}
+	function selectDiscussion(thread, original = false) {
+		if (!isCodeConversation(thread)) {
+			window.location.assign(conversationHref(thread.id));
+			return;
+		}
+		selectedThread = thread.id;
+		handle.props.comments.loadThread(thread.id);
+		openComments();
+		draftAnchor = void 0;
+		commentError = "";
+		let located = commentLocations.find((entry) => entry.thread.id === thread.id);
+		if (editor?.state?.draft.path === thread.anchor.path && !original) {
+			changed();
+			return;
+		}
+		let needsOldSide = thread.anchor.side === "old" && located?.source.side === void 0 && located?.resolution.state === "outdated";
+		let usable = !original && !needsOldSide ? located : void 0;
+		let path = usable?.source.viewPath ?? usable?.source.path ?? thread.anchor.path;
+		if (thread.anchor.commit && (original || !usable)) {
+			historical = {
+				path: thread.anchor.path,
+				commit: thread.anchor.commit
+			};
+			path = thread.anchor.path;
+			session = {
+				...session,
+				view: {
+					...session.view,
+					mode: "source",
+					multiple: false
+				}
+			};
+			editor?.close();
+		} else if (!usable) {
+			historical = null;
+			session = {
+				...session,
+				view: {
+					...session.view,
+					mode: thread.anchor.side === "old" ? "working" : "source",
+					multiple: false
+				}
+			};
+		}
+		if (path !== handle.props.path) handle.props.onSelect(path);
+		pendingFocus = thread.id;
+		if (!usable || path !== handle.props.path) lastKey = "";
+		changed();
+	}
+	function startComment(selection, fromEditor = false) {
+		if (!handle.props.comments.ready || !handle.props.comments.snapshot.capabilities.create) return;
+		openComments();
+		appliedThread = requestedThread;
+		selectedThread = void 0;
+		commentError = "";
+		try {
+			let editing = editor?.state;
+			if (fromEditor && editing && (draftDirty(editing.draft) || editing.conflict || editing.saving)) throw new Error("Save this draft before creating a code comment. Existing discussions remain available, and your draft is kept.");
+			draftAnchor = captureCodeSelection(selection, fromEditor && editing && selection.side !== "deletions" ? [{
+				path: editing.draft.path,
+				revision: editing.draft.baseRevision,
+				contents: editing.draft.contents,
+				commit: null
+			}] : commentSources, fromEditor ? void 0 : position().revision);
+		} catch (cause) {
+			draftAnchor = void 0;
+			commentError = message$1(cause);
+		}
+		changed();
+	}
+	async function createComment(body) {
+		if (!draftAnchor) throw new Error("Select code lines again before commenting.");
+		if (editor?.state && draftDirty(editor.state.draft)) throw new Error("Save your draft before sending this code comment. The message is kept.");
+		selectedThread = (await handle.props.comments.write({
+			anchor: draftAnchor,
+			body
+		})).thread.id;
+		draftAnchor = void 0;
+		changed();
+	}
+	let mount = ref((node, signal) => {
+		host = node;
+		mounted = true;
+		try {
+			drafts = projectFileDrafts(project.id, preferenceDraftStorage);
+			let saved = readPreference("bud:editor-preferences:v1");
+			preferences = parseEditorPreferences(JSON.parse(typeof saved === "string" ? saved : "null"));
+		} catch (cause) {
+			error = message$1(cause);
+		}
+		if (drafts) {
+			editor = createFileEditorController({
+				signal,
+				drafts,
+				read: (path, signal) => requestFiles(`${routes.filesApi.read.href()}?${new URLSearchParams({ path })}`, project.token, signal, parseFileDocument),
+				save: (body, signal) => requestFiles(routes.fileSavesApi.save.href(), project.token, signal, parseFileSaveResult, fetch, { body }),
+				onChange: changed,
+				onSaved: () => {
+					lastKey = "";
+					changed();
+				}
+			});
+			handle.props.registerDraftGuard?.(editor.guard, signal);
+		}
+		actions = createFileReviewActionsController({
+			signal,
+			prepare: (body, signal) => requestFiles(routes.fileReviewActionsApi.prepare.href(), project.token, signal, parseReviewActionPlan, fetch, { body }),
+			apply: (body, signal) => requestFiles(routes.fileReviewActionsApi.apply.href(), project.token, signal, parseReviewActionResult, fetch, { body }),
+			recoveries: (signal) => requestFiles(routes.fileReviewActionsApi.recoveries.href(), project.token, signal, parseReviewActionRecoveries),
+			guard(paths) {
+				if (editor?.state?.saving) throw new Error("Wait for the current save to finish before reviewing changes.");
+				if (paths.some((path) => {
+					let draft = drafts?.get(path);
+					return draft && draftDirty(draft);
+				})) throw new Error("Save or explicitly discard the unsaved draft for this file before applying review actions. Your draft has been kept.");
+			},
+			async onApplied(result) {
+				if (result.target === "worktree") editor?.close();
+				if (merge && result.changedPaths.includes(merge.path) && result.target === "index") {
+					merge = void 0;
+					editor?.close();
+				}
+				lastKey = JSON.stringify([
+					context(),
+					position().page,
+					handle.props.path
+				]);
+				refresh = handle.props.refresh;
+				let current = load();
+				while (true) {
+					let active = reading;
+					await current;
+					if (handle.signal.aborted || reading === active || !reading) break;
+					current = reading;
+				}
+				if (error) throw new Error(`The write completed, but the review could not refresh: ${error}`);
+			},
+			onChange: changed
+		});
+		window.addEventListener("beforeunload", (event) => {
+			drafts?.persist();
+			if (drafts?.dirty.length) {
+				event.preventDefault();
+				event.returnValue = "";
+			}
+		}, { signal });
+		try {
+			session = parseReviewSession(readPreference(`bud:review:${project.id}:v1`), project.id);
+		} catch {}
+		readLocation(handle.props.href);
+		renderedHref = handle.props.href;
+		let readTheme = () => {
+			theme = window.document.documentElement.dataset.theme === "dark" ? "dark" : "light";
+			changed();
+		};
+		let observer = new MutationObserver(readTheme);
+		observer.observe(window.document.documentElement, {
+			attributes: true,
+			attributeFilter: ["data-theme"]
+		});
+		readTheme();
+		createCodeWorkerPool({
+			signal,
+			renderOptions: {
+				theme: codeThemes,
+				lineDiffType: session.view.highlights
+			}
+		}).then(async (value) => {
+			await value.ready;
+			if (!signal.aborted) {
+				pool = value;
+				poolSettled = true;
+				changed();
+			}
+		}).catch(() => {
+			poolSettled = true;
+			changed();
+		});
+		signal.addEventListener("abort", () => {
+			request?.abort();
+			historyRequest?.abort();
+			observer.disconnect();
+			clearTimeout(persistTimer);
+			pool?.dispose();
+			drafts?.persist();
+			writePreference(`bud:review:${project.id}:v1`, JSON.stringify(session));
+		}, { once: true });
+	});
+	function readLocation(href) {
+		let url = new URL(href);
+		requestedThread = handle.props.conversation?.id ?? null;
+		appliedThread = null;
+		if (!requestedThread) {
+			historical = null;
+			source = null;
+		}
+		let parsed = readReviewLocation(url, project.id);
+		if (readFileLocation(url, project.id).foreign) parsed = { view: {
+			mode: "source",
+			multiple: false
+		} };
+		if (parsed) {
+			session = {
+				...session,
+				view: {
+					...session.view,
+					...parsed.view
+				}
+			};
+			if (parsed.position) session = rememberReviewPosition(session, reviewContextKey(session.view, parsed.position.selection?.path ?? handle.props.path), parsed.position);
+		}
+		lastKey = "";
+	}
+	return () => {
+		if (mounted) {
+			if (renderedHref !== handle.props.href || renderedConversation !== handle.props.conversation?.id) {
+				renderedHref = handle.props.href;
+				renderedConversation = handle.props.conversation?.id;
+				if (pendingHref !== renderedHref) readLocation(renderedHref);
+				pendingHref = void 0;
+			}
+			let target = handle.props.searchSelection;
+			if (target && target.id !== searchSelectionId) {
+				searchSelectionId = target.id;
+				pendingSearch = target.match;
+				searchNotice = "";
+				handle.queueTask(() => {
+					editor?.close();
+					merge = void 0;
+					changeView({
+						mode: "source",
+						multiple: false
+					});
+					lastKey = "";
+					changed();
+				});
+			}
+			if (observedPath !== handle.props.path) {
+				observedPath = handle.props.path;
+				merge = void 0;
+				if (historical?.path !== handle.props.path) {
+					historical = null;
+					source = null;
+				}
+				handle.queueTask(() => editor?.closeOtherPath(handle.props.path));
+			}
+			let key = JSON.stringify([
+				context(),
+				position().page,
+				handle.props.path
+			]);
+			if (key !== lastKey || refresh !== handle.props.refresh) {
+				lastKey = key;
+				refresh = handle.props.refresh;
+				handle.queueTask(() => {
+					load();
+				});
+			}
+			let nextHistoryKey = JSON.stringify([handle.props.path, session.view.mode === "commits" ? session.view.target : handle.props.repository?.head]);
+			if (historyOpen && nextHistoryKey !== historyKey) {
+				historyKey = nextHistoryKey;
+				handle.queueTask(() => {
+					loadHistory();
+				});
+			}
+			if (pool && appliedHighlights !== session.view.highlights) {
+				appliedHighlights = session.view.highlights;
+				let owned = pool;
+				handle.queueTask(() => {
+					owned.pool.setRenderOptions({ lineDiffType: session.view.highlights }).catch((cause) => {
+						if (!handle.signal.aborted) {
+							error = `Could not update highlighting. ${message$1(cause)}`;
+							changed();
+						}
+					});
+				});
+			}
+		}
+		let editing = editor?.state;
+		let comments = handle.props.comments;
+		if (selectedThread && comments.ready) {
+			if (!comments.snapshot.threads.find((thread) => thread.id === selectedThread)?.messagesLoaded && !comments.loadingThread(selectedThread)) {
+				let id = selectedThread;
+				handle.queueTask(() => {
+					comments.loadThread(id);
+				});
+			}
+		}
+		let nextSourceSignature = JSON.stringify([
+			document?.entry.path,
+			document?.revision,
+			source?.path,
+			source?.commit,
+			source?.file?.revision,
+			diffs.map((diff) => diff.revision),
+			editing?.key,
+			editing?.draft.baseRevision
+		]);
+		if (nextSourceSignature !== sourceSignature || locationsVersion !== comments.version) {
+			sourceSignature = nextSourceSignature;
+			locationsVersion = comments.version;
+			commentSources = reviewCommentSources(document, diffs, source);
+			commentLocations = locateCodeConversations(comments.snapshot.threads, commentSources);
+		}
+		if (locatedEditor !== editing?.key) {
+			locatedEditor = editing?.key;
+			editorLocations = void 0;
+		}
+		if (editing && editorLocations) commentLocations = [...editorLocations];
+		if (requestedThread && requestedThread !== appliedThread && comments.loaded && !loading && (document || source || snapshot || error)) {
+			let thread = comments.snapshot.threads.find((thread) => thread.id === requestedThread);
+			if (thread) {
+				appliedThread = requestedThread;
+				handle.queueTask(() => selectDiscussion(thread, handle.props.conversation?.original ?? false));
+			} else {
+				panelOpen = true;
+				let id = requestedThread;
+				handle.queueTask(() => {
+					comments.loadThread(id);
+				});
+			}
+		}
+		if (pendingFocus && !loading) {
+			let location = commentLocations.find((entry) => entry.thread.id === pendingFocus);
+			if (location) {
+				pendingFocus = null;
+				let change = codeConversationPosition(location);
+				if (change) handle.queueTask(() => savePosition(change, true));
+			}
+		}
+		let commentsShown = panelOpen && comments.ready;
+		if (commentsShown !== reportedComments) {
+			reportedComments = commentsShown;
+			handle.queueTask(() => handle.props.onComments?.(commentsShown));
+		}
+		let dirtyPaths = drafts?.dirty.map((draft) => draft.path) ?? [];
+		if (dirtyPaths.join("\0") !== reportedDrafts) {
+			reportedDrafts = dirtyPaths.join("\0");
+			handle.queueTask(() => handle.props.onDrafts?.(dirtyPaths));
+		}
+		let codeComments = {
+			threads: comments.snapshot.threads,
+			locations: commentLocations,
+			version: comments.version,
+			selected: selectedThread,
+			onShow: () => {
+				openComments();
+				changed();
+			},
+			onOpen: (id) => {
+				let thread = comments.snapshot.threads.find((thread) => thread.id === id);
+				if (thread) selectDiscussion(thread);
+			},
+			onCreate: comments.snapshot.capabilities.create ? (selection) => startComment(selection) : void 0,
+			onLocations: (locations) => {
+				if (editor?.state?.key !== editing?.key) return;
+				editorLocations = locations;
+				changed();
+			}
+		};
+		return /* @__PURE__ */ jsxs("div", {
+			class: "flex h-full min-h-0 flex-col",
+			mix: mount,
+			children: [
+				(comments.loaded ? !comments.ready : project.storage.threads?.state !== "ready") ? /* @__PURE__ */ jsx(Text, {
+					as: "p",
+					variant: "ui-caption",
+					tone: "muted",
+					role: "status",
+					class: "shrink-0 border-b border-line px-3 py-1.5",
+					children: commentsUnavailable
+				}) : null,
+				searchNotice ? /* @__PURE__ */ jsx(Text, {
+					as: "p",
+					variant: "ui-caption",
+					role: "status",
+					class: "shrink-0 border-b border-line px-3 py-1.5",
+					children: searchNotice
+				}) : null,
+				editor?.openError ? /* @__PURE__ */ jsx(Text, {
+					as: "p",
+					variant: "ui-caption",
+					role: "alert",
+					class: "shrink-0 border-b border-line px-3 py-1.5 text-red-600 dark:text-red-400",
+					children: editor.openError
+				}) : null,
+				editor?.opening ? /* @__PURE__ */ jsx(Text, {
+					as: "p",
+					variant: "ui-caption",
+					role: "status",
+					class: "sr-only",
+					children: "Reading current file for editing…"
+				}) : null,
+				editing && editor && merge?.path === editing.draft.path ? /* @__PURE__ */ jsx(FileConflictPanel, {
+					chrome: handle.props.chrome,
+					file: {
+						name: editing.draft.path,
+						contents: editing.draft.contents,
+						cacheKey: editing.draft.baseRevision
+					},
+					dirty: draftDirty(editing.draft),
+					saving: editing.saving,
+					stale: editing.conflict,
+					error: editing.error,
+					status: editing.status,
+					theme,
+					workerPool: pool?.pool,
+					onChange: editor.change,
+					onSave: () => {
+						editor?.save();
+					},
+					onMarkResolved: () => {
+						if (merge) actions?.prepare({
+							kind: "mark-resolved",
+							path: merge.path,
+							expectedRevision: editing.draft.baseRevision,
+							conflict: merge.conflict
+						});
+					},
+					onEdit: () => {
+						merge = void 0;
+						editor?.begin(editing.draft.path);
+						changed();
+					},
+					onClose: () => {
+						merge = void 0;
+						editor?.close();
+						lastKey = "";
+						changed();
+					}
+				}, `merge:${editing.key}`) : editing && editor ? /* @__PURE__ */ jsx(FileEditorPanel, {
+					chrome: handle.props.chrome,
+					file: editing.file,
+					oldFile: editing.oldFile,
+					initialMode: editing.mode,
+					sessionKey: editing.key,
+					comments: comments.ready ? {
+						...codeComments,
+						onCreate: comments.snapshot.capabilities.create ? (selection) => startComment(selection, true) : void 0
+					} : void 0,
+					commentRevision: editing.draft.baseRevision,
+					baselineLabel: editing.baselineLabel,
+					dirty: draftDirty(editing.draft),
+					saving: editing.saving,
+					conflict: editing.conflict,
+					reviewingConflict: Boolean(editing.latest),
+					status: editing.status,
+					error: editing.error,
+					storageWarning: drafts?.warning ?? "",
+					preferences,
+					theme,
+					workerPool: pool?.pool,
+					onChange: editor.change,
+					onSave: () => {
+						editor?.save();
+					},
+					onClose: () => {
+						editor?.close();
+						lastKey = "";
+						changed();
+					},
+					onDiscard: () => {
+						editor?.discard();
+					},
+					onDownload: downloadDraft,
+					onCheckLatest: () => {
+						editor?.checkLatest();
+					},
+					onAcceptMerge: editor.acceptMerge,
+					onPreferences: setPreferences
+				}, editing.key) : /* @__PURE__ */ jsx(FileReviewPanel, {
+					chrome: handle.props.chrome,
+					path: handle.props.path,
+					repository: handle.props.repository,
+					contextKey: context(),
+					view: session.view,
+					position: position(),
+					document: poolSettled ? document : null,
+					source: poolSettled ? source : null,
+					comments: comments.ready ? codeComments : void 0,
+					snapshot,
+					diffs: poolSettled ? diffs : [],
+					failures,
+					loading: loading || !poolSettled,
+					error,
+					history,
+					historyOpen,
+					historyLoading,
+					historyError,
+					theme,
+					workerPool: pool?.pool,
+					onEdit: project.files.edit && editor && handle.props.path && !historical ? startEditor : void 0,
+					onReviewAction: actions ? (intent) => {
+						actions?.prepare(intent);
+					} : void 0,
+					onReviewUndo: actions ? () => {
+						actions?.recoveries();
+					} : void 0,
+					onResolve: (diff) => {
+						resolveConflict(diff);
+					},
+					editLabel: handle.props.path && drafts?.get(handle.props.path) && draftDirty(drafts.get(handle.props.path)) ? "Resume draft" : "Edit file",
+					onChange: changeView,
+					onPosition: savePosition,
+					onSelect: selectPath,
+					onPage: (page) => {
+						savePosition({
+							...defaultReviewPosition(),
+							page
+						}, true);
+					},
+					onRetry: () => {
+						load();
+					},
+					onHistory: () => {
+						historyOpen = !historyOpen;
+						if (historyOpen) historyKey = "";
+						else historyRequest?.abort();
+						changed();
+					},
+					onHistoryPage: (older) => {
+						loadHistory(older);
+					},
+					onHistoryRevision: historyRevision,
+					onCopyLink: async (position) => {
+						let path = position.selection?.path ?? handle.props.path;
+						let view = snapshot?.comparison.mode === "commits" ? {
+							...session.view,
+							...snapshot.comparison
+						} : session.view;
+						let href = reviewHref(path, view, position);
+						await navigator.clipboard.writeText(new URL(href, window.location.origin).href);
+					}
+				}),
+				panelOpen && comments.ready ? /* @__PURE__ */ jsx(ConversationSidebar, {
+					threads: comments.snapshot.threads.filter(isCodeConversation),
+					renderThreadLinks: (thread) => /* @__PURE__ */ jsx(ProjectThreadLinks, {
+						part: "links",
+						project,
+						thread,
+						canLink: comments.snapshot.capabilities.link,
+						busy: comments.busy,
+						onChange: async () => {
+							await comments.load();
+							await comments.loadThread(thread.id, true);
+						}
+					}),
+					renderThreadActions: (thread) => /* @__PURE__ */ jsx(ProjectThreadLinks, {
+						part: "action",
+						project,
+						thread,
+						canLink: comments.snapshot.capabilities.link,
+						busy: comments.busy,
+						onChange: async () => {
+							await comments.load();
+							await comments.loadThread(thread.id, true);
+						}
+					}),
+					capabilities: comments.snapshot.capabilities,
+					selected: selectedThread,
+					currentPath: handle.props.path,
+					locations: commentLocations,
+					draft: draftAnchor,
+					loaded: comments.loaded,
+					busy: comments.busy,
+					now: comments.now,
+					error: commentError || comments.error,
+					onSelect: (thread) => selectDiscussion(thread),
+					onCloseThread: () => {
+						selectedThread = void 0;
+						changed();
+					},
+					onClose: closeComments,
+					onWrite: comments.write,
+					onCreate: createComment,
+					onCancelDraft: () => {
+						draftAnchor = void 0;
+						changed();
+					},
+					onReload: () => {
+						comments.load();
+					},
+					onSync: comments.snapshot.capabilities.sync ? () => {
+						comments.sync().catch(() => {});
+					} : void 0,
+					onOriginal: (thread) => selectDiscussion(thread, true),
+					onCopyLink: (thread) => navigator.clipboard.writeText(new URL(conversationHref(thread.id), window.location.origin).href)
+				}) : null,
+				actions?.state ? /* @__PURE__ */ jsx(ReviewActionDialog, {
+					state: actions.state,
+					theme,
+					onApply: () => {
+						actions?.apply();
+					},
+					onClose: actions.close,
+					onUndo: (recoveryId) => {
+						actions?.prepare({
+							kind: "undo",
+							recoveryId
+						});
+					},
+					onRecoveries: () => {
+						actions?.recoveries();
+					}
+				}) : null
+			]
+		});
+	};
+}
+//#endregion
+//#region app/client/project-files.tsx
+function message(error) {
+	return error instanceof Error ? error.message : "Could not load project files.";
+}
+function requestProjectFiles(token, view, signal) {
+	let params = new URLSearchParams({
+		includeIgnored: String(view.includeIgnored),
+		includeDotfiles: "true"
+	});
+	return Promise.all([requestFiles(`${routes.filesApi.index.href()}?${params}`, token, signal, parseFileIndex), requestFiles(routes.fileReviewApi.repository.href(), token, signal, parseReviewRepository)]);
+}
+/**
+* Reads the stored view, the file the URL asks for and the first listing for the screen's load.
+* A listing this browser stored for the same view shows at once.
+* @param project - The connected project.
+* @param signal - The screen's lifetime.
+* @param url - The screen's initial typed location.
+* @returns The listing, or the error the workspace shows until a refresh succeeds.
+*/
+async function loadFiles(project, signal, url) {
+	let view;
+	try {
+		view = parseFileView(readPreference(`bud:files:${project.id}:v1`), project.id);
+	} catch {
+		view = defaultFileView(project.id);
+	}
+	let location = readFileLocation(url, project.id);
+	if (location.explicit) view = rememberFile(view, location.path);
+	let store = await projectStore(project);
+	let stored = storedFiles(store);
+	if (stored && stored.includeIgnored === view.includeIgnored) {
+		let { index, repository } = stored;
+		view = reconcileFileView(view, null, index, repository);
+		return {
+			view,
+			index,
+			repository,
+			error: "",
+			store,
+			stored: true
+		};
+	}
+	try {
+		let [index, repository] = await requestProjectFiles(project.token, view, signal);
+		await saveFiles(store, index, repository, view.includeIgnored);
+		return {
+			view: reconcileFileView(view, null, index, repository),
+			index,
+			repository,
+			error: "",
+			store,
+			stored: false
+		};
+	} catch (cause) {
+		signal.throwIfAborted();
+		return {
+			view,
+			index: null,
+			repository: null,
+			error: message(cause),
+			store,
+			stored: false
+		};
+	}
+}
+/**
+* The server capabilities and browser persistence stay outside the shared navigator.
+* @param handle - The project, its first listing and the component's owned lifecycle.
+* @returns The component render function.
+*/
+function ProjectFiles(handle) {
+	let project = handle.props.project;
+	let { view, index, repository, error, store } = handle.props.initial;
+	let listed = () => {
+		let next = storedFiles(store);
+		if (!next || next.includeIgnored !== view.includeIgnored) return;
+		let previous = view.selected;
+		let retained = view.selected !== null && drafted(view.selected);
+		view = reconcileFileView(view, retained ? null : index, next.index, next.repository);
+		index = next.index;
+		repository = next.repository;
+		if (previous !== view.selected) location(true);
+		changed();
+	};
+	function drafted(path) {
+		try {
+			return projectFileDrafts(project.id, preferenceDraftStorage).dirty.some((draft) => draft.path === path);
+		} catch {
+			return false;
+		}
+	}
+	let subscriptions = [
+		store.listings.subscribeChanges(listed),
+		store.files.subscribeChanges(listed),
+		store.repositories.subscribeChanges(listed)
+	];
+	let loading = false;
+	let renderedHref = handle.props.href;
+	let pendingHref;
+	let deferredLocation = false;
+	let notice = "";
+	let listRequest;
+	let storageTimer;
+	let refreshTimer;
+	let mounted = false;
+	let refreshing = false;
+	let trailingRefresh = false;
+	let settling = false;
+	let pendingContentRefresh = false;
+	let contentRefresh = 0;
+	let searchOpen = false, searchSerial = 0;
+	let searchSelection;
+	let dirty = [];
+	let commentsOpen = false;
+	let search = createFileSearchController({
+		signal: handle.signal,
+		onChange: changed,
+		request: (query, signal) => requestFiles(`${routes.fileSearchApi.search.href()}?${fileSearchParameters(query)}`, project.token, signal, parseFileSearchResult)
+	});
+	function closeSearch() {
+		search.cancel("");
+		searchOpen = false;
+		changed();
+	}
+	let guards = createFileMutationGuards();
+	let comments = createProjectComments({
+		store: projectStore(project),
+		token: project.token,
+		signal: handle.signal,
+		onChange: changed
+	});
+	let countedVersion;
+	let commentCounts = {};
+	let mutations = createFileMutationController({
+		signal: handle.signal,
+		index: () => index,
+		guards,
+		onChange() {
+			if (mutations.state?.phase === "applying") {
+				listRequest?.abort();
+				settling = true;
+			}
+			changed();
+		},
+		transport: {
+			prepare: (intent, signal) => requestFiles(routes.fileMutationsApi.prepare.href(), project.token, signal, parseMutationPlan, fetch, { body: intent }),
+			apply: (plan, signal) => requestFiles(routes.fileMutationsApi.apply.href(), project.token, signal, parseMutationResult, fetch, { body: {
+				id: plan.id,
+				revision: plan.revision
+			} }),
+			recoveries: (signal) => requestFiles(routes.fileMutationsApi.recoveries.href(), project.token, signal, parseRecoveries)
+		},
+		async onApplied(intent, result) {
+			view = mutationFileView(view, intent.kind, result);
+			let count = result.items.filter((item) => item.status === "applied").length;
+			if (count) toast.success(`${count} file action${count === 1 ? "" : "s"} completed`, { description: result.recoveryId ? "Original contents are available in Recovery." : void 0 });
+			else toast.error("The file action could not be applied", { description: "Your project was refreshed." });
+			location(true);
+			persist();
+			pendingContentRefresh = true;
+			await load(true);
+			settling = false;
+		},
+		async onUncertain() {
+			pendingContentRefresh = true;
+			await load(true);
+			settling = false;
+		}
+	});
+	function changed() {
+		if (!handle.signal.aborted) handle.update();
+	}
+	function persist() {
+		clearTimeout(storageTimer);
+		storageTimer = setTimeout(() => writePreference(`bud:files:${project.id}:v1`, JSON.stringify(view)), 200);
+	}
+	function location(replace) {
+		let root = fileHref(null);
+		let conversation = readConversationLocation(window.location.href) === handle.props.conversation?.id;
+		if (!handle.props.active || !conversation && window.location.pathname !== root && !window.location.pathname.startsWith(`${root}/`)) {
+			deferredLocation = true;
+			return;
+		}
+		deferredLocation = false;
+		if (conversation && replace) return;
+		let review = readReviewLocation(conversation ? handle.props.href : window.location.href, project.id);
+		let href = review?.view.mode && review.view.mode !== "source" ? reviewHref(view.selected, {
+			...defaultReviewView(),
+			...review.view
+		}) : fileHref(view.selected);
+		if (window.location.pathname + window.location.search + window.location.hash === href) return;
+		pendingHref = new URL(href, window.location.origin).href;
+		window.history[replace ? "replaceState" : "pushState"]({
+			...window.history.state,
+			budFile: view.selected
+		}, "", href);
+	}
+	function updateView(change) {
+		let next = {
+			...view,
+			...change
+		};
+		let includeChanged = next.includeIgnored !== view.includeIgnored;
+		view = next;
+		persist();
+		changed();
+		if (includeChanged) scheduleRefresh();
+	}
+	function select(path, selection) {
+		let previous = view.selected;
+		view = rememberFile(view, path, selection);
+		notice = "";
+		persist();
+		if (previous !== path) location(false);
+		changed();
+	}
+	function closeTab(path) {
+		if (dirty.includes(path)) {
+			select(path, [path]);
+			toast("Save or discard this draft to close its tab");
+			changed();
+			return;
+		}
+		let previous = view.selected;
+		view = closeFileTab(view, path);
+		persist();
+		if (previous !== view.selected) location(false);
+		changed();
+	}
+	async function load(afterMutation = false) {
+		if (!afterMutation && mutations.state?.phase === "applying") {
+			trailingRefresh = true;
+			return;
+		}
+		if (refreshing) {
+			trailingRefresh = true;
+			return;
+		}
+		refreshing = true;
+		loading = true;
+		error = "";
+		let controller = new AbortController();
+		listRequest = controller;
+		let signal = AbortSignal.any([handle.signal, controller.signal]);
+		changed();
+		try {
+			let [nextIndex, nextRepository] = await requestProjectFiles(project.token, view, signal);
+			if (signal.aborted) return;
+			let previous = view.selected;
+			view = reconcileFileView(view, index, nextIndex, nextRepository);
+			index = nextIndex;
+			repository = nextRepository;
+			await saveFiles(store, nextIndex, nextRepository, view.includeIgnored);
+			persist();
+			if (previous !== view.selected) location(true);
+			if (pendingContentRefresh) contentRefresh++;
+			pendingContentRefresh = false;
+		} catch (cause) {
+			if (!signal.aborted) error = message(cause);
+		} finally {
+			controller.abort();
+			refreshing = false;
+			loading = false;
+			changed();
+			if (trailingRefresh && !handle.signal.aborted) {
+				trailingRefresh = false;
+				scheduleRefresh();
+			}
+		}
+	}
+	function scheduleRefresh() {
+		clearTimeout(refreshTimer);
+		refreshTimer = setTimeout(() => {
+			load();
+		}, 100);
+	}
+	async function refresh() {
+		if (loading) return;
+		let controller = new AbortController();
+		try {
+			await requestFiles(routes.filesApi.refresh.href(), project.token, AbortSignal.any([handle.signal, controller.signal]), parseFileChange);
+			pendingContentRefresh = true;
+			await load();
+		} catch (cause) {
+			if (!handle.signal.aborted) {
+				error = message(cause);
+				changed();
+			}
+		} finally {
+			controller.abort();
+		}
+	}
+	let mount = ref((_node, signal) => {
+		if (mounted) return;
+		mounted = true;
+		let opened = readFileLocation(handle.props.href, project.id);
+		foreignNotice(opened.foreign);
+		if (!opened.foreign && (opened.explicit ? opened.path !== view.selected : !view.selected)) location(true);
+		persist();
+		let stopFiles = projectLive(project.token).subscribe("files", {
+			onEvent(data) {
+				let update = parseFileUpdate(data);
+				pendingContentRefresh = true;
+				if (settling) {
+					trailingRefresh = true;
+					return;
+				}
+				if (update.change.reset || refreshing || view.includeIgnored) return scheduleRefresh();
+				applyFileUpdate(store, update).then(() => {
+					contentRefresh++;
+					pendingContentRefresh = false;
+					changed();
+				});
+			},
+			onResync() {
+				pendingContentRefresh = true;
+				scheduleRefresh();
+			}
+		});
+		if (handle.props.initial.stored) scheduleRefresh();
+		comments.load();
+		signal.addEventListener("abort", () => {
+			stopFiles();
+			for (let subscription of subscriptions) subscription.unsubscribe();
+			listRequest?.abort();
+			clearTimeout(storageTimer);
+			clearTimeout(refreshTimer);
+			writePreference(`bud:files:${project.id}:v1`, JSON.stringify(view));
+		}, { once: true });
+	});
+	function foreignNotice(foreign) {
+		notice = foreign ? "This file link belongs to another project. Choose a file from this project to continue." : "";
+	}
+	return () => {
+		if (renderedHref !== handle.props.href) {
+			renderedHref = handle.props.href;
+			if (pendingHref !== renderedHref) {
+				deferredLocation = false;
+				let selected = readFileLocation(renderedHref, project.id);
+				if (selected.explicit) view = rememberFile(view, selected.path);
+				foreignNotice(selected.foreign);
+			}
+			pendingHref = void 0;
+		}
+		if (deferredLocation && handle.props.active) handle.queueTask(() => location(true));
+		if (countedVersion !== comments.version) {
+			countedVersion = comments.version;
+			commentCounts = codeCommentCounts(comments.snapshot.threads);
+		}
+		return /* @__PURE__ */ jsxs("div", {
+			class: `relative h-full min-h-0 ${commentsOpen ? "md:pe-80" : ""}`,
+			mix: mount,
+			children: [
+				/* @__PURE__ */ jsx(FileWorkspace, {
+					projectName: project.name,
+					view,
+					index,
+					repository,
+					loading,
+					error,
+					notice,
+					commentCounts,
+					dirty,
+					onViewChange: updateView,
+					onSelect: select,
+					onCloseTab: closeTab,
+					onSearch: () => {
+						searchOpen = true;
+						changed();
+					},
+					onRefresh: () => {
+						refresh();
+					},
+					mutations: project.files.edit ? {
+						busy: mutations.busy,
+						open: (request) => mutations.open(request),
+						move: (entries, source) => mutations.open({
+							action: source === "rename" ? "rename" : "move",
+							paths: entries.map((entry) => entry.path),
+							entries
+						}, true),
+						recoveries: () => mutations.recoveries()
+					} : void 0,
+					sidebar: searchOpen ? /* @__PURE__ */ jsx(FileSearchPanel, {
+						...search.state,
+						onSearch: (query) => {
+							search.search(query);
+						},
+						onCancel: () => search.cancel(),
+						onClose: closeSearch,
+						onSelect: (match) => {
+							searchSelection = {
+								id: ++searchSerial,
+								match
+							};
+							select(match.path, [match.path]);
+							if (!window.matchMedia("(min-width: 768px)").matches) closeSearch();
+						}
+					}) : void 0,
+					content: (chrome) => /* @__PURE__ */ jsx(ProjectFileReview, {
+						project,
+						href: handle.props.href,
+						path: view.selected,
+						repository,
+						refresh: contentRefresh,
+						store,
+						chrome,
+						onSelect: (path) => select(path, [path]),
+						onComments: (open) => {
+							commentsOpen = open;
+							changed();
+						},
+						onDrafts: (paths) => {
+							if (paths.join("\0") === dirty.join("\0")) return;
+							dirty = paths;
+							changed();
+						},
+						registerDraftGuard: guards.register,
+						comments,
+						conversation: handle.props.conversation,
+						searchSelection
+					})
+				}),
+				mutations.state ? /* @__PURE__ */ jsx(FileMutationDialog, {
+					state: mutations.state,
+					onDestination: mutations.destination,
+					onSubmit: () => {
+						mutations.submit();
+					},
+					onClose: mutations.close,
+					onRecovery: mutations.recoveries
+				}) : null,
+				mutations.recovery.open ? /* @__PURE__ */ jsx(FileRecoveryDialog, {
+					recoveries: mutations.recovery.recoveries,
+					loading: mutations.recovery.loading,
+					error: mutations.recovery.error,
+					onClose: mutations.closeRecoveries,
+					onRefresh: () => {
+						mutations.refreshRecoveries();
+					},
+					onRestore: (recoveryId, paths) => mutations.open({
+						action: "restore",
+						recoveryId,
+						paths
+					})
+				}) : null
+			]
+		});
+	};
+}
+//#endregion
+//#region app/screens/files.tsx
+var files_default = defineScreen({
+	routes: fileRoutes,
+	load: ({ project, signal, url }) => loadFiles(project, signal, url),
+	render: (files, { project, url, active, conversation }) => /* @__PURE__ */ jsx(ProjectFiles, {
+		project,
+		initial: files,
+		href: url.href,
+		active,
+		conversation
+	})
+});
+//#endregion
+export { files_default as default };