jj-plus 0.10.10

package/dist/standalone/server.cjs

@@ -0,0 +1,1733 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_package = require("../package.cjs");
+const require_history_helpers = require("../shared/history-helpers.cjs");
+const require_non_textual_details = require("../shared/non-textual-details.cjs");
+const require_diff_stats = require("../shared/diff-stats.cjs");
+const require_file_oplog = require("../shared/file-oplog.cjs");
+const require_timeline_model = require("../shared/timeline-model.cjs");
+let node_fs = require("node:fs");
+node_fs = require_runtime.__toESM(node_fs, 1);
+let node_path = require("node:path");
+node_path = require_runtime.__toESM(node_path, 1);
+let node_child_process = require("node:child_process");
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = require_runtime.__toESM(node_fs_promises, 1);
+let node_http = require("node:http");
+node_http = require_runtime.__toESM(node_http, 1);
+let node_os = require("node:os");
+node_os = require_runtime.__toESM(node_os, 1);
+let node_url = require("node:url");
+//#region src/standalone/server.ts
+const execFileAsync = (0, require("node:util").promisify)(node_child_process.execFile);
+const __dirname$1 = node_path.default.dirname((0, node_url.fileURLToPath)(require("url").pathToFileURL(__filename).href));
+const rootDir = node_path.default.resolve(__dirname$1, "..", "..");
+const distDir = node_path.default.join(rootDir, "webview-dist");
+const displayLocale = "en-US";
+const displayTimeZone = Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+const monthFormatter = new Intl.DateTimeFormat(displayLocale, {
+	month: "long",
+	timeZone: displayTimeZone
+});
+const shortDateFormatter = new Intl.DateTimeFormat(displayLocale, {
+	month: "short",
+	day: "numeric",
+	year: "numeric",
+	timeZone: displayTimeZone
+});
+const subtitleDateFormatter = new Intl.DateTimeFormat(displayLocale, {
+	year: "numeric",
+	month: "numeric",
+	day: "numeric",
+	hour: "numeric",
+	minute: "2-digit",
+	second: "2-digit",
+	hour12: true,
+	timeZone: displayTimeZone
+});
+const timelinePresets = {
+	year: 365,
+	"7d": 7,
+	"30d": 30,
+	"90d": 90,
+	all: Number.POSITIVE_INFINITY
+};
+const ignoredWorkspaceEntries = /* @__PURE__ */ new Set([
+	".git",
+	".jj",
+	"node_modules",
+	"webview-dist",
+	".e2e-runtime"
+]);
+const distAssets = [
+	"index.html",
+	"timeline-app.js",
+	"timeline-app.css",
+	"pierre-worker-portable.js"
+];
+async function startStandaloneTimelineServer(args) {
+	await ensureDistReady();
+	const runtime = await createStandaloneRuntime({
+		workspacePath: args.workspacePath,
+		filePath: args.filePath
+	});
+	const server = node_http.default.createServer((request, response) => {
+		handleRequest({
+			request,
+			response,
+			runtime,
+			verbose: args.verbose === true
+		});
+	});
+	await new Promise((resolve, reject) => {
+		server.once("error", reject);
+		server.listen(args.port || 0, "127.0.0.1", () => {
+			server.off("error", reject);
+			resolve();
+		});
+	});
+	const address = server.address();
+	const url = `http://127.0.0.1:${typeof address === "object" && address ? address.port : args.port || 0}/?standalone=1`;
+	if (args.openBrowser !== false) try {
+		await openTarget(url);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		process.stderr.write(`Failed to open the browser automatically: ${message}\n`);
+	}
+	return {
+		url,
+		async close() {
+			await new Promise((resolve, reject) => {
+				server.close((error) => {
+					if (error) {
+						reject(error);
+						return;
+					}
+					resolve();
+				});
+			});
+		}
+	};
+}
+async function createStandaloneRuntime(args) {
+	const repoContext = await resolveRepoContext(args.workspacePath);
+	const absoluteFilePath = node_path.default.resolve(args.filePath);
+	const relativePath = node_path.default.relative(repoContext.repoRoot, absoluteFilePath);
+	if (!relativePath || relativePath.startsWith("..")) throw new Error(`The file must be inside the repository root: ${repoContext.repoRoot}`);
+	const preferencesByPath = /* @__PURE__ */ new Map();
+	const fileCache = /* @__PURE__ */ new Map();
+	const rangeOverviewCache = /* @__PURE__ */ new Map();
+	let activeRelativePath = normalizePath(relativePath);
+	return { async handleCommand(command) {
+		switch (command.command) {
+			case "ready": return emitTimeline();
+			case "refresh":
+				fileCache.delete(activeRelativePath);
+				clearRangeOverviewCache(activeRelativePath);
+				return emitTimeline();
+			case "switch-file":
+				activeRelativePath = normalizePath(command.relativePath);
+				await getActiveFileFixture();
+				return emitTimeline();
+			case "persist-state":
+				preferencesByPath.set(activeRelativePath, extractPersistedPreferences(command));
+				return [];
+			case "select-entry": return [{
+				type: "diff-preview",
+				payload: getFixturePreview({
+					fileFixture: await getActiveFileFixture(),
+					fromIndex: command.fromIndex,
+					toIndex: command.toIndex,
+					comparisonSource: command.comparisonSource
+				})
+			}];
+			case "load-range-overview": {
+				const fileFixture = await getActiveFileFixture();
+				const normalizedFromIndex = Math.max(0, Math.min(command.fromIndex, command.toIndex));
+				const normalizedToIndex = Math.max(normalizedFromIndex, Math.max(command.fromIndex, command.toIndex));
+				const comparisonSource = command.comparisonSource === "snapshot" ? "snapshot" : "revision";
+				const selectedEntryIndexes = command.selectedEntryIndexes || [];
+				const overviewKey = `${activeRelativePath}:${comparisonSource}:${normalizedFromIndex}:${normalizedToIndex}:${selectedEntryIndexes.join(",") || "all"}`;
+				let items = rangeOverviewCache.get(overviewKey);
+				if (!items) {
+					items = await buildRangeOverview({
+						repoRoot: repoContext.repoRoot,
+						fileFixture,
+						currentRelativePath: activeRelativePath,
+						fromIndex: normalizedFromIndex,
+						toIndex: normalizedToIndex,
+						comparisonSource,
+						selectedEntryIndexes
+					});
+					rangeOverviewCache.set(overviewKey, items);
+				}
+				return [{
+					type: "range-overview",
+					payload: {
+						fromIndex: normalizedFromIndex,
+						toIndex: normalizedToIndex,
+						comparisonSource,
+						selectedEntryIndexes,
+						items
+					}
+				}];
+			}
+			case "load-range-stack": {
+				const normalizedFromIndex = Math.max(0, Math.min(command.fromIndex, command.toIndex));
+				const normalizedToIndex = Math.max(normalizedFromIndex, Math.max(command.fromIndex, command.toIndex));
+				const comparisonSource = command.comparisonSource === "snapshot" ? "snapshot" : "revision";
+				const items = [];
+				for (const stackPath of command.relativePaths) {
+					const normalizedPath = normalizePath(stackPath);
+					const fileFixture = normalizedPath === activeRelativePath ? await getActiveFileFixture() : await getFileFixture(normalizedPath);
+					items.push({
+						relativePath: normalizedPath,
+						preview: getFixturePreview({
+							fileFixture,
+							fromIndex: normalizedFromIndex,
+							toIndex: normalizedToIndex,
+							comparisonSource
+						})
+					});
+				}
+				return [{
+					type: "range-stack-previews",
+					payload: {
+						fromIndex: normalizedFromIndex,
+						toIndex: normalizedToIndex,
+						comparisonSource,
+						items
+					}
+				}];
+			}
+			case "search-history": {
+				const entries = (await getActiveFileFixture()).timelineData.entries.filter((entry) => !entry.isWorkingTree);
+				const tip = entries[Math.max(0, entries.length - 1)];
+				const introducedAt = (entries[Math.max(0, entries.length - 2)] || tip)?.index ?? 0;
+				const tipIndex = tip?.index ?? introducedAt;
+				const hits = [{
+					entryIndex: introducedAt,
+					kind: "introduced"
+				}];
+				if (tipIndex !== introducedAt) hits.push({
+					entryIndex: tipIndex,
+					kind: "present"
+				});
+				return [{
+					type: "history-search",
+					payload: {
+						query: command.query,
+						introducedAt,
+						removedAt: null,
+						hits,
+						purpose: command.purpose === "sidebar" ? "sidebar" : "history"
+					}
+				}];
+			}
+			case "load-revision-tree-files": {
+				const fileFixture = await getActiveFileFixture();
+				return [{
+					type: "revision-tree-files",
+					payload: {
+						revision: command.revision,
+						files: fileFixture.timelineData.workspaceFiles || []
+					}
+				}];
+			}
+			case "load-file-oplog": {
+				const fileFixture = await getActiveFileFixture();
+				if (fileFixture.timelineData.backend !== "jj") return [{
+					type: "file-oplog",
+					payload: {
+						relativePath: fileFixture.timelineData.relativePath,
+						entries: []
+					}
+				}];
+				try {
+					const { stdout } = await run({
+						command: "jj",
+						args: [
+							"op",
+							"log",
+							"--limit",
+							"80",
+							"-T",
+							require_file_oplog.JJ_OP_LOG_TEMPLATE
+						],
+						cwd: fileFixture.timelineData.workspacePath || process.cwd()
+					});
+					const fileEntries = [...fileFixture.timelineData.snapshotEntries || [], ...fileFixture.timelineData.entries.filter((entry) => Boolean(entry.operationId))];
+					return [{
+						type: "file-oplog",
+						payload: {
+							relativePath: fileFixture.timelineData.relativePath,
+							entries: require_file_oplog.filterFileOpLogPeek({
+								opLog: require_file_oplog.parseJjOpLogOutput(stdout),
+								fileEntries,
+								relativePath: fileFixture.timelineData.relativePath,
+								limit: 12
+							})
+						}
+					}];
+				} catch {
+					return [{
+						type: "file-oplog",
+						payload: {
+							relativePath: fileFixture.timelineData.relativePath,
+							entries: []
+						}
+					}];
+				}
+			}
+			case "load-entry-diff-counts": {
+				const fileFixture = await getActiveFileFixture();
+				return [{
+					type: "entry-diff-counts",
+					payload: {
+						comparisonSource: command.comparisonSource,
+						counts: await Promise.all(command.entryIndexes.map(async (entryIndex) => ({
+							entryIndex,
+							diffCount: await getStandaloneEntryDiffCount({
+								repoRoot: repoContext.repoRoot,
+								fileFixture,
+								entryIndex,
+								comparisonSource: command.comparisonSource
+							})
+						})))
+					}
+				}];
+			}
+			case "resolve-nonempty-range": return [{
+				type: "resolved-range",
+				payload: resolveNonEmptyRange(await getActiveFileFixture(), command.candidateIndexes)
+			}];
+			case "hydrate-snapshot-entries": {
+				const fileFixture = await getActiveFileFixture();
+				return [{
+					type: "snapshot-entries",
+					payload: {
+						snapshotEntries: clone(fileFixture.timelineData.snapshotEntries),
+						snapshotState: clone(fileFixture.timelineData.snapshotState || { loadedChangeIds: [] })
+					}
+				}];
+			}
+			case "open-current-file":
+				await openTarget(node_path.default.join(repoContext.repoRoot, activeRelativePath));
+				return [];
+			case "open-editor-diff":
+			case "open-range-files-diff":
+				if (command.command === "open-range-files-diff" && command.editorCommand) {
+					const fileFixture = await getActiveFileFixture();
+					const plan = await buildStandaloneRangeMultiDiffPlan({
+						repoRoot: repoContext.repoRoot,
+						fileFixture,
+						fromIndex: command.fromIndex,
+						toIndex: command.toIndex,
+						comparisonSource: command.comparisonSource,
+						selectedEntryIndexes: command.selectedEntryIndexes || []
+					});
+					if (plan.files.length) await openMultiDiffWithEditor({
+						repoRoot: repoContext.repoRoot,
+						editorCommand: command.editorCommand,
+						files: plan.files
+					});
+					return [];
+				}
+				await openPreviewDocument({
+					preview: getFixturePreview({
+						fileFixture: await getActiveFileFixture(),
+						fromIndex: command.fromIndex,
+						toIndex: command.toIndex,
+						comparisonSource: command.comparisonSource
+					}),
+					relativePath: activeRelativePath
+				});
+				return [];
+			case "open-revision-files-diff": {
+				if (command.editorCommand) {
+					const fileFixture = await getActiveFileFixture();
+					const plan = await buildStandaloneEntryMultiDiffPlan({
+						repoRoot: repoContext.repoRoot,
+						fileFixture,
+						entryIndex: command.entryIndex,
+						comparisonSource: command.comparisonSource
+					});
+					if (plan.files.length) await openMultiDiffWithEditor({
+						repoRoot: repoContext.repoRoot,
+						editorCommand: command.editorCommand,
+						files: plan.files
+					});
+					return [];
+				}
+				const preview = getUnitPreview({
+					fileFixture: await getActiveFileFixture(),
+					entryIndex: command.entryIndex,
+					comparisonSource: command.comparisonSource
+				});
+				if (preview) await openPreviewDocument({
+					preview,
+					relativePath: activeRelativePath
+				});
+				return [];
+			}
+			case "open-revision-remote": {
+				const fileFixture = await getActiveFileFixture();
+				const entry = require_timeline_model.getEntriesForSource(fileFixture.timelineData, command.comparisonSource).find((candidate) => candidate.index === command.entryIndex);
+				if (entry?.remoteUrl) await openTarget(entry.remoteUrl);
+				return [];
+			}
+			default: return [];
+		}
+	} };
+	async function emitTimeline() {
+		const fileFixture = await getActiveFileFixture();
+		const timelineData = withPersistedPreferences(fileFixture.timelineData);
+		const defaultFromIndex = Math.max(0, timelineData.defaultIndex - 1);
+		const messages = [{
+			type: "timeline-data",
+			payload: timelineData
+		}, {
+			type: "diff-preview",
+			payload: getFixturePreview({
+				fileFixture,
+				fromIndex: defaultFromIndex,
+				toIndex: timelineData.defaultIndex,
+				comparisonSource: timelineData.preferences.comparisonSource || "revision"
+			})
+		}];
+		if (timelineData.backend === "jj") messages.push({
+			type: "snapshot-entries",
+			payload: {
+				snapshotEntries: clone(fileFixture.timelineData.snapshotEntries || []),
+				snapshotState: clone(fileFixture.timelineData.snapshotState || { loadedChangeIds: [] })
+			}
+		});
+		return messages;
+	}
+	async function getActiveFileFixture() {
+		return getFileFixture(activeRelativePath);
+	}
+	async function getFileFixture(relativeFilePath) {
+		const normalizedRelativePath = normalizePath(relativeFilePath);
+		if (!fileCache.has(normalizedRelativePath)) {
+			const nextFixture = await buildFileFixture({
+				backend: repoContext.backend,
+				relativePath: normalizedRelativePath,
+				repoRoot: repoContext.repoRoot,
+				remoteBaseUrl: repoContext.remoteBaseUrl
+			});
+			fileCache.set(normalizedRelativePath, nextFixture);
+		}
+		return fileCache.get(normalizedRelativePath);
+	}
+	function withPersistedPreferences(timelineData) {
+		const persistedPreferences = preferencesByPath.get(timelineData.relativePath) || {};
+		return {
+			...clone(timelineData),
+			preferences: {
+				...clone(timelineData.preferences),
+				...persistedPreferences
+			}
+		};
+	}
+	function clearRangeOverviewCache(relativeFilePath) {
+		for (const cacheKey of rangeOverviewCache.keys()) if (cacheKey.startsWith(`${relativeFilePath}:`)) rangeOverviewCache.delete(cacheKey);
+	}
+}
+async function handleRequest(args) {
+	try {
+		const requestUrl = new URL(args.request.url || "/", "http://127.0.0.1");
+		if (args.request.method === "POST" && requestUrl.pathname === "/api/command") {
+			const command = await readJsonBody(args.request);
+			const messages = await args.runtime.handleCommand(command);
+			writeJson(args.response, 200, { messages });
+			return;
+		}
+		if (args.request.method !== "GET" && args.request.method !== "HEAD") {
+			writeJson(args.response, 405, { error: "Method Not Allowed" });
+			return;
+		}
+		const targetPath = resolveStaticPath(requestUrl.pathname);
+		if (!targetPath) {
+			writeJson(args.response, 403, { error: "Forbidden" });
+			return;
+		}
+		if (!node_fs.default.existsSync(targetPath) || !node_fs.default.statSync(targetPath).isFile()) {
+			writeJson(args.response, 404, { error: "Not Found" });
+			return;
+		}
+		const body = await node_fs_promises.default.readFile(targetPath);
+		args.response.writeHead(200, {
+			"content-type": getContentType(targetPath),
+			"cache-control": "no-store"
+		});
+		if (args.request.method === "HEAD") {
+			args.response.end();
+			return;
+		}
+		args.response.end(body);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		if (args.verbose) process.stderr.write(`Standalone timeline request failed: ${message}\n`);
+		writeJson(args.response, 500, { error: message });
+	}
+}
+async function buildFileFixture(args) {
+	const workspaceFiles = await getWorkspaceFiles(args.repoRoot);
+	const entries = args.backend === "jj" ? await getJjEntries({
+		repoRoot: args.repoRoot,
+		relativePath: args.relativePath,
+		remoteBaseUrl: args.remoteBaseUrl
+	}) : await getGitEntries({
+		repoRoot: args.repoRoot,
+		relativePath: args.relativePath,
+		remoteBaseUrl: args.remoteBaseUrl
+	});
+	const snapshotEntries = args.backend === "jj" ? await getJjSnapshotEntries({
+		repoRoot: args.repoRoot,
+		relativePath: args.relativePath,
+		revisionEntries: entries,
+		remoteBaseUrl: args.remoteBaseUrl
+	}) : [];
+	const loadedChangeIds = args.backend === "jj" ? [...new Set(entries.map((entry) => entry.changeId).filter(Boolean))] : [];
+	const snapshotSourceEntries = args.backend === "jj" ? composeSnapshotEntries({
+		revisionEntries: entries,
+		snapshotEntries,
+		loadedChangeIds: new Set(loadedChangeIds)
+	}) : entries;
+	const defaultIndex = Math.max(0, entries.length - 1);
+	const pathCache = /* @__PURE__ */ new Map();
+	const contentCache = /* @__PURE__ */ new Map();
+	return {
+		timelineData: {
+			backend: args.backend,
+			workspacePath: args.repoRoot,
+			relativePath: args.relativePath,
+			fileName: node_path.default.basename(args.relativePath),
+			version: require_package.version,
+			presets: timelinePresets,
+			defaultIndex,
+			latestIndex: defaultIndex,
+			preferences: {
+				sidebarWidth: 280,
+				layoutMode: "split",
+				contentMode: "diffs",
+				comparisonMode: "range",
+				comparisonSource: args.backend === "jj" ? "snapshot" : "revision",
+				preset: "90d",
+				showIntermediateRevisions: true
+			},
+			workspaceFiles,
+			hasIntermediateRevisions: entries.some((entry) => !entry.touchesFile),
+			entries,
+			snapshotEntries,
+			snapshotState: { loadedChangeIds }
+		},
+		previews: {
+			revision: await buildPreviewMap({
+				repoRoot: args.repoRoot,
+				entries,
+				backend: args.backend,
+				relativePath: args.relativePath,
+				comparisonSource: "revision",
+				pathCache,
+				contentCache
+			}),
+			snapshot: args.backend === "jj" ? await buildPreviewMap({
+				repoRoot: args.repoRoot,
+				entries: snapshotSourceEntries,
+				backend: args.backend,
+				relativePath: args.relativePath,
+				comparisonSource: "snapshot",
+				pathCache,
+				contentCache
+			}) : await buildPreviewMap({
+				repoRoot: args.repoRoot,
+				entries,
+				backend: args.backend,
+				relativePath: args.relativePath,
+				comparisonSource: "revision",
+				pathCache,
+				contentCache
+			})
+		}
+	};
+}
+async function getGitEntries(args) {
+	const touchingEntries = await getGitHistoryEntries(args);
+	const entries = touchingEntries.length >= 2 ? mergeTimelineEntries(await getGitRepositoryEntries(args), touchingEntries) : touchingEntries;
+	seedLatestEntryPath(entries, args.relativePath);
+	const workingTreeEntry = await makeWorkingTreeEntry({
+		repoRoot: args.repoRoot,
+		previousEntry: entries.at(-1),
+		relativePath: args.relativePath,
+		backend: "git",
+		remoteBaseUrl: args.remoteBaseUrl
+	});
+	if (workingTreeEntry) entries.push(workingTreeEntry);
+	return reindexEntries(entries);
+}
+async function getGitHistoryEntries(args) {
+	const { stdout } = await run({
+		command: "git",
+		args: [
+			"log",
+			"--follow",
+			"--reverse",
+			"--decorate=short",
+			"--date=iso-strict",
+			"--format=%H%x09%ad%x09%an%x09%D%x09%s",
+			"--max-count=200",
+			"--",
+			args.relativePath
+		],
+		cwd: args.repoRoot
+	});
+	const revisions = stdout.trim().split(/\r?\n/).filter(Boolean);
+	const entries = [];
+	for (const [index, line] of revisions.entries()) {
+		const [revision, authorDate, authorName, branchNames, description] = line.split("	");
+		entries.push(makeEntry({
+			id: revision || "",
+			index,
+			revision: revision || "",
+			shortRevision: (revision || "").slice(0, 8),
+			changeId: void 0,
+			branchNames: require_history_helpers.parseGitBranchNames(branchNames || ""),
+			authorDate: authorDate || "",
+			authorName: authorName || "",
+			description: description || "",
+			touchesFile: true,
+			isWorkingTree: false,
+			filePath: args.relativePath,
+			remoteBaseUrl: args.remoteBaseUrl
+		}));
+	}
+	return entries;
+}
+async function getGitRepositoryEntries(args) {
+	const { stdout } = await run({
+		command: "git",
+		args: [
+			"log",
+			"--reverse",
+			"--decorate=short",
+			"--date=iso-strict",
+			"--format=%H%x09%ad%x09%an%x09%D%x09%s",
+			"--max-count=200"
+		],
+		cwd: args.repoRoot
+	});
+	const revisions = stdout.trim().split(/\r?\n/).filter(Boolean);
+	const entries = [];
+	for (const [index, line] of revisions.entries()) {
+		const [revision, authorDate, authorName, branchNames, description] = line.split("	");
+		entries.push(makeEntry({
+			id: revision || "",
+			index,
+			revision: revision || "",
+			shortRevision: (revision || "").slice(0, 8),
+			changeId: void 0,
+			branchNames: require_history_helpers.parseGitBranchNames(branchNames || ""),
+			authorDate: authorDate || "",
+			authorName: authorName || "",
+			description: description || "",
+			touchesFile: false,
+			isWorkingTree: false,
+			filePath: void 0,
+			remoteBaseUrl: args.remoteBaseUrl
+		}));
+	}
+	return entries;
+}
+async function getJjEntries(args) {
+	const { stdout } = await run({
+		command: "jj",
+		args: [
+			"log",
+			"--no-graph",
+			"--reversed",
+			"--limit",
+			"100",
+			"-T",
+			require_history_helpers.buildJjHistoryLogTemplate()
+		],
+		cwd: args.repoRoot
+	});
+	const revisions = stdout.trim().split(/\r?\n/).filter(Boolean);
+	const entries = [];
+	for (const [index, line] of revisions.entries()) {
+		const parsed = require_history_helpers.parseJjHistoryLine(line);
+		if (/^0+$/u.test(parsed.revision || "")) continue;
+		const touchesFile = await jjTouchesFile({
+			repoRoot: args.repoRoot,
+			revision: parsed.revision || "",
+			relativePath: args.relativePath
+		});
+		entries.push(makeEntry({
+			...parsed,
+			index,
+			touchesFile,
+			filePath: args.relativePath,
+			remoteBaseUrl: args.remoteBaseUrl
+		}));
+	}
+	const lastEntry = entries.at(-1);
+	if (lastEntry && !lastEntry.description) {
+		lastEntry.revision = "WORKTREE";
+		lastEntry.shortRevision = "Current";
+		lastEntry.description = "Working tree";
+		lastEntry.isWorkingTree = true;
+		lastEntry.changeId = void 0;
+		lastEntry.remoteUrl = void 0;
+	}
+	seedLatestEntryPath(entries, args.relativePath);
+	const workingTreeEntry = await makeWorkingTreeEntry({
+		repoRoot: args.repoRoot,
+		previousEntry: entries.at(-1),
+		relativePath: args.relativePath,
+		backend: "jj",
+		remoteBaseUrl: args.remoteBaseUrl
+	});
+	if (workingTreeEntry) entries.push(workingTreeEntry);
+	return reindexEntries(dedupeAdjacentTimelineEntries(entries));
+}
+async function getJjSnapshotEntries(args) {
+	const snapshotEntries = [];
+	for (const entry of args.revisionEntries) {
+		if (!entry.changeId || entry.isWorkingTree || !entry.touchesFile) continue;
+		let stdout = "";
+		try {
+			({stdout} = await run({
+				command: "jj",
+				args: [
+					"evolog",
+					"--no-graph",
+					"--summary",
+					"--limit",
+					"100",
+					"-r",
+					entry.revision
+				],
+				cwd: args.repoRoot
+			}));
+		} catch {
+			continue;
+		}
+		const evolutionEntries = require_history_helpers.parseJjEvolutionSummaryEntries(stdout).filter((evolutionEntry) => require_history_helpers.parseJjSummaryChangedPaths(evolutionEntry.summaryLines).includes(args.relativePath)).map((evolutionEntry, evolutionIndex) => makeEntry({
+			id: `snapshot:${entry.changeId}:${evolutionEntry.operationId || evolutionEntry.changeKey || evolutionEntry.revision}:${evolutionIndex}`,
+			index: 0,
+			revision: evolutionEntry.revision,
+			shortRevision: require_history_helpers.normalizeSnapshotOperationKey(evolutionEntry.changeKey) || evolutionEntry.revision.slice(0, 8),
+			changeId: entry.changeId,
+			bookmarkNames: evolutionEntry.bookmarkNames,
+			authorDate: normalizeSnapshotAuthorDate(evolutionEntry.authorDate, entry.authorDate),
+			authorName: evolutionEntry.authorName || entry.authorName,
+			description: normalizeSnapshotDescription(evolutionEntry.description, evolutionEntry.operationDescription),
+			touchesFile: true,
+			isWorkingTree: false,
+			filePath: args.relativePath,
+			operationId: evolutionEntry.operationId,
+			operationIndex: evolutionEntry.operationIndex,
+			operationKey: evolutionEntry.changeKey,
+			remoteBaseUrl: args.remoteBaseUrl
+		}));
+		snapshotEntries.push(...evolutionEntries);
+	}
+	snapshotEntries.sort((left, right) => left.timestamp - right.timestamp || left.revision.localeCompare(right.revision));
+	return reindexEntries(snapshotEntries);
+}
+function composeSnapshotEntries(args) {
+	if (!args.loadedChangeIds.size) return args.revisionEntries;
+	const snapshotEntriesByChangeId = args.snapshotEntries.reduce((groups, entry) => {
+		if (!entry.changeId) return groups;
+		const existing = groups.get(entry.changeId) || [];
+		existing.push(entry);
+		groups.set(entry.changeId, existing);
+		return groups;
+	}, /* @__PURE__ */ new Map());
+	return reindexEntries(args.revisionEntries.flatMap((entry) => {
+		if (!entry.changeId || entry.isWorkingTree || !entry.touchesFile || !args.loadedChangeIds.has(entry.changeId)) return [entry];
+		return snapshotEntriesByChangeId.get(entry.changeId) || [entry];
+	}));
+}
+function seedLatestEntryPath(entries, relativePath) {
+	for (const entry of entries) if (!entry.isWorkingTree && entry.filePath) delete entry.filePath;
+	for (let index = entries.length - 1; index >= 0; index -= 1) {
+		const entry = entries[index];
+		if (!entry || entry.isWorkingTree || !entry.touchesFile) continue;
+		entry.filePath = relativePath;
+		break;
+	}
+}
+function mergeTimelineEntries(repositoryEntries, fileEntries) {
+	const touchingByRevision = new Map(fileEntries.map((entry) => [entry.revision, entry]));
+	const repoIndexes = fileEntries.map((entry) => repositoryEntries.findIndex((candidate) => candidate.revision === entry.revision)).filter((index) => index >= 0);
+	if (!repoIndexes.length) return fileEntries;
+	const startIndex = Math.min(...repoIndexes);
+	const endIndex = Math.max(...repoIndexes);
+	const merged = repositoryEntries.slice(startIndex, endIndex + 1).map((entry) => touchingByRevision.get(entry.revision) || entry);
+	for (const entry of fileEntries) if (!merged.some((candidate) => candidate.revision === entry.revision)) merged.push(entry);
+	return merged.toSorted((left, right) => left.timestamp - right.timestamp || left.revision.localeCompare(right.revision));
+}
+function dedupeAdjacentTimelineEntries(entries) {
+	return entries.reduce((deduped, entry) => {
+		const previousEntry = deduped.at(-1);
+		if (!previousEntry?.changeId || previousEntry.changeId !== entry.changeId) {
+			deduped.push(entry);
+			return deduped;
+		}
+		if (!previousEntry.touchesFile && entry.touchesFile) deduped[deduped.length - 1] = entry;
+		return deduped;
+	}, []);
+}
+async function buildPreviewMap(args) {
+	const previews = {};
+	for (let toIndex = 1; toIndex < args.entries.length; toIndex += 1) for (let fromIndex = 0; fromIndex < toIndex; fromIndex += 1) previews[`${fromIndex}:${toIndex}`] = await buildPreview({
+		repoRoot: args.repoRoot,
+		entries: args.entries,
+		backend: args.backend,
+		relativePath: args.relativePath,
+		comparisonSource: args.comparisonSource,
+		fromIndex,
+		toIndex,
+		pathCache: args.pathCache,
+		contentCache: args.contentCache
+	});
+	return previews;
+}
+async function buildPreview(args) {
+	const fromEntry = args.entries[args.fromIndex];
+	const toEntry = args.entries[args.toIndex];
+	const beforePath = await resolveEntryFilePath({
+		repoRoot: args.repoRoot,
+		backend: args.backend,
+		entries: args.entries,
+		entryIndex: args.fromIndex,
+		relativePath: args.relativePath,
+		pathCache: args.pathCache
+	});
+	const afterPath = await resolveEntryFilePath({
+		repoRoot: args.repoRoot,
+		backend: args.backend,
+		entries: args.entries,
+		entryIndex: args.toIndex,
+		relativePath: args.relativePath,
+		pathCache: args.pathCache
+	});
+	const beforeText = await getEntryContent({
+		repoRoot: args.repoRoot,
+		backend: args.backend,
+		entries: args.entries,
+		entryIndex: args.fromIndex,
+		relativePath: args.relativePath,
+		pathCache: args.pathCache,
+		contentCache: args.contentCache
+	});
+	const afterText = await getEntryContent({
+		repoRoot: args.repoRoot,
+		backend: args.backend,
+		entries: args.entries,
+		entryIndex: args.toIndex,
+		relativePath: args.relativePath,
+		pathCache: args.pathCache,
+		contentCache: args.contentCache
+	});
+	const stats = require_diff_stats.computeDiffStats(beforeText, afterText);
+	return {
+		index: args.toIndex,
+		title: `${fromEntry?.shortRevision || ""} -> ${toEntry?.shortRevision || ""}`,
+		subtitle: toEntry?.isWorkingTree ? "Working tree" : `${subtitleDateFormatter.format(new Date(toEntry?.authorDate || 0))} · ${toEntry?.description || ""}`,
+		diffCount: 0,
+		additions: stats.additions,
+		deletions: stats.deletions,
+		hunkCount: stats.hunkCount,
+		hasChanges: stats.hasChanges,
+		fromIndex: args.fromIndex,
+		toIndex: args.toIndex,
+		comparisonSource: args.comparisonSource,
+		beforePath,
+		afterPath,
+		beforeText,
+		afterText,
+		nonTextualDetails: stats.hasChanges ? [] : require_non_textual_details.buildNonTextualDetails({
+			beforeText,
+			afterText,
+			beforePath,
+			afterPath,
+			isWorkingTree: toEntry?.isWorkingTree
+		})
+	};
+}
+async function getEntryContent(args) {
+	const entry = args.entries[args.entryIndex];
+	if (!entry) return "";
+	const resolvedPath = entry.isWorkingTree ? args.relativePath : await resolveEntryFilePath(args);
+	const cacheKey = `${entry.revision}:${resolvedPath}`;
+	if (args.contentCache.has(cacheKey)) return args.contentCache.get(cacheKey) || "";
+	let content = "";
+	if (entry.isWorkingTree) {
+		try {
+			content = await node_fs_promises.default.readFile(node_path.default.join(args.repoRoot, args.relativePath), "utf8");
+		} catch (error) {
+			if (!isMissingFileError(error)) throw error;
+		}
+		args.contentCache.set(cacheKey, content);
+		return content;
+	}
+	content = args.backend === "jj" ? await showJjFileAtRevision({
+		repoRoot: args.repoRoot,
+		revision: entry.revision,
+		relativePath: resolvedPath
+	}) : await showGitFileAtRevision({
+		repoRoot: args.repoRoot,
+		revision: entry.revision,
+		relativePath: resolvedPath
+	});
+	args.contentCache.set(cacheKey, content);
+	return content;
+}
+async function resolveEntryFilePath(args) {
+	const entry = args.entries[args.entryIndex];
+	if (!entry || entry.isWorkingTree) return args.relativePath;
+	if (entry.filePath) return entry.filePath;
+	await ensureEntryFilePath(args);
+	return entry.filePath || args.relativePath;
+}
+async function ensureEntryFilePath(args) {
+	const targetEntry = args.entries[args.entryIndex];
+	if (!targetEntry || targetEntry.filePath || targetEntry.isWorkingTree) return;
+	let knownIndex = -1;
+	for (let index = args.entryIndex + 1; index < args.entries.length; index += 1) if (args.entries[index]?.filePath) {
+		knownIndex = index;
+		break;
+	}
+	if (knownIndex < 0) {
+		targetEntry.filePath = args.relativePath;
+		return;
+	}
+	let currentPath = args.entries[knownIndex].filePath || args.relativePath;
+	for (let index = knownIndex; index > args.entryIndex; index -= 1) {
+		const currentEntry = args.entries[index];
+		const previousEntry = args.entries[index - 1];
+		if (!previousEntry) break;
+		if (!previousEntry.filePath) {
+			let previousPath = currentPath;
+			if (currentEntry.touchesFile && !currentEntry.isWorkingTree) previousPath = await resolvePreviousPathAcrossRevision({
+				repoRoot: args.repoRoot,
+				backend: args.backend,
+				revision: currentEntry.revision,
+				currentPath,
+				pathCache: args.pathCache
+			});
+			previousEntry.filePath = previousPath;
+		}
+		currentPath = previousEntry.filePath || currentPath;
+	}
+}
+async function resolvePreviousPathAcrossRevision(args) {
+	const cacheKey = `${args.revision}:${args.currentPath}`;
+	if (args.pathCache.has(cacheKey)) return args.pathCache.get(cacheKey) || args.currentPath;
+	const previousPath = args.backend === "git" ? await resolveGitPreviousPath({
+		repoRoot: args.repoRoot,
+		revision: args.revision,
+		currentPath: args.currentPath
+	}) : await resolveJjPreviousPath({
+		repoRoot: args.repoRoot,
+		revision: args.revision,
+		currentPath: args.currentPath
+	});
+	args.pathCache.set(cacheKey, previousPath);
+	return previousPath;
+}
+async function resolveGitPreviousPath(args) {
+	const { stdout } = await run({
+		command: "git",
+		args: [
+			"diff-tree",
+			"--root",
+			"--no-commit-id",
+			"--name-status",
+			"--find-renames",
+			"-r",
+			args.revision
+		],
+		cwd: args.repoRoot
+	});
+	for (const line of stdout.split(/\r?\n/u).map((value) => value.trim()).filter(Boolean)) {
+		const [, fromPath = "", toPath = ""] = line.split("	");
+		if (toPath === args.currentPath) return fromPath || args.currentPath;
+	}
+	return args.currentPath;
+}
+async function resolveJjPreviousPath(args) {
+	try {
+		const { stdout } = await run({
+			command: "jj",
+			args: [
+				"diff",
+				"--summary",
+				"-r",
+				args.revision
+			],
+			cwd: args.repoRoot
+		});
+		const rename = require_history_helpers.parseJjSummaryRenameLines(stdout).find((entry) => entry.toPath === args.currentPath);
+		return rename ? rename.fromPath : args.currentPath;
+	} catch {
+		return args.currentPath;
+	}
+}
+async function showGitFileAtRevision(args) {
+	try {
+		const { stdout } = await run({
+			command: "git",
+			args: ["show", `${args.revision}:${args.relativePath}`],
+			cwd: args.repoRoot
+		});
+		return stdout;
+	} catch (error) {
+		if (isMissingFileAtRevisionError(error)) return "";
+		throw error;
+	}
+}
+async function showJjFileAtRevision(args) {
+	try {
+		const { stdout } = await run({
+			command: "jj",
+			args: [
+				"file",
+				"show",
+				"-r",
+				args.revision,
+				require_history_helpers.toJjRootFileFileset(args.relativePath)
+			],
+			cwd: args.repoRoot
+		});
+		return stdout;
+	} catch (error) {
+		if (isMissingFileAtRevisionError(error)) return "";
+		throw error;
+	}
+}
+async function jjTouchesFile(args) {
+	const { stdout } = await run({
+		command: "jj",
+		args: [
+			"diff",
+			"--name-only",
+			"-r",
+			args.revision
+		],
+		cwd: args.repoRoot
+	});
+	return stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).includes(args.relativePath);
+}
+async function listGitRevisionFiles(args) {
+	const { stdout } = await run({
+		command: "git",
+		args: [
+			"diff-tree",
+			"--root",
+			"--no-commit-id",
+			"--name-only",
+			"-r",
+			args.revision
+		],
+		cwd: args.repoRoot
+	});
+	return stdout.split(/\r?\n/u).map((line) => line.trim()).filter(Boolean);
+}
+async function resolveGitParentRevision(args) {
+	try {
+		const { stdout } = await run({
+			command: "git",
+			args: ["rev-parse", `${args.revision}^`],
+			cwd: args.repoRoot
+		});
+		return stdout.trim() || void 0;
+	} catch {
+		return;
+	}
+}
+async function listGitWorkingTreeFiles(args) {
+	const files = /* @__PURE__ */ new Set();
+	try {
+		const { stdout } = await run({
+			command: "git",
+			args: [
+				"diff",
+				"--name-only",
+				"HEAD",
+				"--"
+			],
+			cwd: args.repoRoot
+		});
+		for (const relativePath of stdout.split(/\r?\n/u).map((line) => line.trim()).filter(Boolean)) files.add(relativePath);
+	} catch {}
+	return [...files].toSorted((left, right) => left.localeCompare(right));
+}
+async function listJjRevisionFiles(args) {
+	const { stdout } = await run({
+		command: "jj",
+		args: [
+			"diff",
+			"--name-only",
+			"-r",
+			args.revision
+		],
+		cwd: args.repoRoot
+	});
+	return stdout.split(/\r?\n/u).map((line) => line.trim()).filter(Boolean);
+}
+async function listJjChangedFiles(args) {
+	const { stdout } = await run({
+		command: "jj",
+		args: [
+			"diff",
+			"--name-only",
+			"--from",
+			args.base,
+			"--to",
+			args.target
+		],
+		cwd: args.repoRoot
+	});
+	return stdout.split(/\r?\n/u).map((line) => line.trim()).filter(Boolean);
+}
+async function buildStandaloneEntryMultiDiffPlan(args) {
+	const backend = args.fileFixture.timelineData.backend;
+	const sourceEntries = require_timeline_model.getEntriesForSource(args.fileFixture.timelineData, args.comparisonSource);
+	const entry = sourceEntries[args.entryIndex];
+	if (!entry) return {
+		title: "",
+		files: []
+	};
+	if (backend === "git") {
+		if (entry.isWorkingTree) {
+			const previousEntry = sourceEntries[Math.max(0, args.entryIndex - 1)];
+			if (!previousEntry) return {
+				title: entry.shortRevision,
+				files: []
+			};
+			const files = await listGitWorkingTreeFiles({ repoRoot: args.repoRoot });
+			return {
+				title: `${previousEntry.shortRevision}..${entry.shortRevision}`,
+				files: files.map((relativePath) => ({
+					relativePath,
+					originalRevset: previousEntry.revision,
+					modifiedRevset: "@",
+					backend
+				}))
+			};
+		}
+		const files = await listGitRevisionFiles({
+			repoRoot: args.repoRoot,
+			revision: entry.revision
+		});
+		const parentRevision = await resolveGitParentRevision({
+			repoRoot: args.repoRoot,
+			revision: entry.revision
+		});
+		return {
+			title: entry.shortRevision,
+			files: files.map((relativePath) => ({
+				relativePath,
+				originalRevset: parentRevision || "EMPTY",
+				modifiedRevset: entry.revision,
+				backend
+			}))
+		};
+	}
+	if (entry.isWorkingTree) {
+		const previousEntry = sourceEntries[Math.max(0, args.entryIndex - 1)];
+		if (!previousEntry) return {
+			title: entry.shortRevision,
+			files: []
+		};
+		const files = await listJjChangedFiles({
+			repoRoot: args.repoRoot,
+			base: previousEntry.revision,
+			target: "@"
+		});
+		return {
+			title: `${previousEntry.shortRevision}..${entry.shortRevision}`,
+			files: files.map((relativePath) => ({
+				relativePath,
+				originalRevset: previousEntry.revision,
+				modifiedRevset: "@",
+				backend
+			}))
+		};
+	}
+	const baseRevision = args.comparisonSource === "snapshot" ? sourceEntries[Math.max(0, args.entryIndex - 1)]?.revision || `${entry.revision}-` : `${entry.revision}-`;
+	const files = args.comparisonSource === "snapshot" ? await listJjChangedFiles({
+		repoRoot: args.repoRoot,
+		base: baseRevision,
+		target: entry.revision
+	}) : await listJjRevisionFiles({
+		repoRoot: args.repoRoot,
+		revision: entry.revision
+	});
+	return {
+		title: entry.shortRevision,
+		files: files.map((relativePath) => ({
+			relativePath,
+			originalRevset: baseRevision,
+			modifiedRevset: entry.revision,
+			backend
+		}))
+	};
+}
+async function buildStandaloneRangeMultiDiffPlan(args) {
+	const sourceEntries = require_timeline_model.getEntriesForSource(args.fileFixture.timelineData, args.comparisonSource);
+	const fromEntry = sourceEntries[Math.min(args.fromIndex, args.toIndex)];
+	const toEntry = sourceEntries[Math.max(args.fromIndex, args.toIndex)];
+	const title = fromEntry && toEntry ? `${fromEntry.shortRevision}..${toEntry.shortRevision}` : "Selection";
+	if (!args.selectedEntryIndexes.length) return {
+		title,
+		files: []
+	};
+	return {
+		title,
+		files: (await Promise.all(args.selectedEntryIndexes.map((entryIndex) => buildStandaloneEntryMultiDiffPlan({
+			repoRoot: args.repoRoot,
+			fileFixture: args.fileFixture,
+			entryIndex,
+			comparisonSource: args.comparisonSource
+		})))).flatMap((plan) => plan.files)
+	};
+}
+async function getStandaloneEntryDiffCount(args) {
+	return (await buildStandaloneEntryMultiDiffPlan(args)).files.length;
+}
+async function openMultiDiffWithEditor(args) {
+	const { command, args: baseArgs } = parseEditorCommand(args.editorCommand);
+	const tempRoot = node_path.default.join(node_os.default.tmpdir(), "jj-plus-editor", `${Date.now()}`);
+	await node_fs_promises.default.mkdir(tempRoot, { recursive: true });
+	for (const [index, file] of args.files.entries()) {
+		const originalPath = await materializeEditorDiffSide({
+			repoRoot: args.repoRoot,
+			backend: file.backend,
+			revset: file.originalRevset,
+			relativePath: file.relativePath,
+			tempRoot,
+			suffix: `${index}-original`
+		});
+		const modifiedPath = await materializeEditorDiffSide({
+			repoRoot: args.repoRoot,
+			backend: file.backend,
+			revset: file.modifiedRevset,
+			relativePath: file.relativePath,
+			tempRoot,
+			suffix: `${index}-modified`
+		});
+		await spawnDetached(command, [
+			...baseArgs,
+			"--reuse-window",
+			"--diff",
+			originalPath,
+			modifiedPath
+		]);
+	}
+}
+async function materializeEditorDiffSide(args) {
+	const safePath = args.relativePath.replace(/[^a-zA-Z0-9._/-]+/g, "_");
+	const targetPath = node_path.default.join(args.tempRoot, `${args.suffix}-${safePath}`);
+	await node_fs_promises.default.mkdir(node_path.default.dirname(targetPath), { recursive: true });
+	const content = await readStandaloneRevsetFile({
+		repoRoot: args.repoRoot,
+		backend: args.backend,
+		revset: args.revset,
+		relativePath: args.relativePath
+	});
+	await node_fs_promises.default.writeFile(targetPath, content, "utf8");
+	return targetPath;
+}
+async function readStandaloneRevsetFile(args) {
+	if (args.revset === "EMPTY") return "";
+	if (args.revset === "@") try {
+		return await node_fs_promises.default.readFile(node_path.default.join(args.repoRoot, args.relativePath), "utf8");
+	} catch (error) {
+		if (isMissingFileError(error)) return "";
+		throw error;
+	}
+	return args.backend === "jj" ? showJjFileAtRevision({
+		repoRoot: args.repoRoot,
+		revision: args.revset,
+		relativePath: args.relativePath
+	}) : showGitFileAtRevision({
+		repoRoot: args.repoRoot,
+		revision: args.revset,
+		relativePath: args.relativePath
+	});
+}
+function parseEditorCommand(editorCommand) {
+	const parts = editorCommand.trim().split(/\s+/u).filter(Boolean);
+	if (!parts.length) throw new Error("Missing editor command.");
+	return {
+		command: parts[0],
+		args: parts.slice(1)
+	};
+}
+async function spawnDetached(command, args) {
+	await new Promise((resolve, reject) => {
+		const child = (0, node_child_process.spawn)(command, args, {
+			detached: true,
+			stdio: "ignore"
+		});
+		child.once("error", reject);
+		child.once("spawn", () => {
+			child.unref();
+			resolve();
+		});
+	});
+}
+async function buildRangeOverview(args) {
+	const sourceEntries = require_timeline_model.getEntriesForSource(args.fileFixture.timelineData, args.comparisonSource);
+	const workspaceFileSet = new Set(args.fileFixture.timelineData.workspaceFiles || []);
+	const countedPaths = /* @__PURE__ */ new Map();
+	const entryIndexesToScan = args.selectedEntryIndexes?.length ? args.selectedEntryIndexes : Array.from({ length: args.toIndex - args.fromIndex }, (_, index) => args.fromIndex + index + 1);
+	for (const index of entryIndexesToScan) {
+		const entry = sourceEntries[index];
+		if (!entry) continue;
+		const changedFiles = args.fileFixture.timelineData.backend === "git" ? entry.isWorkingTree ? await listGitWorkingTreeFiles({ repoRoot: args.repoRoot }) : await listGitRevisionFiles({
+			repoRoot: args.repoRoot,
+			revision: entry.revision
+		}) : entry.isWorkingTree ? await listJjRevisionFiles({
+			repoRoot: args.repoRoot,
+			revision: "@"
+		}) : await listJjRevisionFiles({
+			repoRoot: args.repoRoot,
+			revision: entry.revision
+		});
+		for (const relativePath of changedFiles) {
+			if (!relativePath || !workspaceFileSet.has(relativePath) && relativePath !== args.currentRelativePath) continue;
+			countedPaths.set(relativePath, (countedPaths.get(relativePath) || 0) + 1);
+		}
+	}
+	return [...countedPaths.entries()].map(([relativePath, changeCount]) => ({
+		relativePath,
+		changeCount,
+		isCurrentFile: relativePath === args.currentRelativePath
+	})).toSorted((left, right) => {
+		if (left.changeCount !== right.changeCount) return right.changeCount - left.changeCount;
+		if (left.isCurrentFile !== right.isCurrentFile) return Number(right.isCurrentFile) - Number(left.isCurrentFile);
+		return left.relativePath.localeCompare(right.relativePath);
+	}).slice(0, 150);
+}
+async function getWorkspaceFiles(repoRoot) {
+	try {
+		const { stdout } = await run({
+			command: "jj",
+			args: ["file", "list"],
+			cwd: repoRoot
+		});
+		return stdout.split(/\r?\n/).filter(Boolean).toSorted((left, right) => left.localeCompare(right));
+	} catch {
+		try {
+			const { stdout } = await run({
+				command: "git",
+				args: ["ls-files", "--cached"],
+				cwd: repoRoot
+			});
+			return stdout.split(/\r?\n/).filter(Boolean).toSorted((left, right) => left.localeCompare(right));
+		} catch {
+			const files = [];
+			await collectWorkspaceFiles({
+				repoRoot,
+				currentDir: repoRoot,
+				files
+			});
+			return files.toSorted((left, right) => left.localeCompare(right));
+		}
+	}
+}
+async function collectWorkspaceFiles(args) {
+	const entries = await node_fs_promises.default.readdir(args.currentDir, { withFileTypes: true });
+	for (const entry of entries) {
+		if (ignoredWorkspaceEntries.has(entry.name)) continue;
+		const absolutePath = node_path.default.join(args.currentDir, entry.name);
+		if (entry.isDirectory()) {
+			await collectWorkspaceFiles({
+				repoRoot: args.repoRoot,
+				currentDir: absolutePath,
+				files: args.files
+			});
+			continue;
+		}
+		if (!entry.isFile()) continue;
+		args.files.push(normalizePath(node_path.default.relative(args.repoRoot, absolutePath)));
+	}
+}
+async function makeWorkingTreeEntry(args) {
+	let content = "";
+	let stats = null;
+	try {
+		stats = await node_fs_promises.default.stat(node_path.default.join(args.repoRoot, args.relativePath));
+		content = await node_fs_promises.default.readFile(node_path.default.join(args.repoRoot, args.relativePath), "utf8");
+	} catch (error) {
+		if (!isMissingFileError(error)) throw error;
+	}
+	const previousContent = args.previousEntry ? args.previousEntry.isWorkingTree ? content : args.backend === "jj" ? await showJjFileAtRevision({
+		repoRoot: args.repoRoot,
+		revision: args.previousEntry.revision,
+		relativePath: args.previousEntry.filePath || args.relativePath
+	}) : await showGitFileAtRevision({
+		repoRoot: args.repoRoot,
+		revision: args.previousEntry.revision,
+		relativePath: args.previousEntry.filePath || args.relativePath
+	}) : "";
+	if (content === previousContent) return null;
+	return makeEntry({
+		id: `working-tree:${args.relativePath}`,
+		index: args.previousEntry ? (args.previousEntry.index || 0) + 1 : 0,
+		revision: "WORKTREE",
+		shortRevision: "Current",
+		changeId: void 0,
+		authorDate: (stats?.mtime || /* @__PURE__ */ new Date()).toISOString(),
+		authorName: process.env.GIT_AUTHOR_NAME || process.env.USER || "CLI User",
+		description: "Working tree",
+		touchesFile: true,
+		isWorkingTree: true,
+		filePath: args.relativePath,
+		remoteBaseUrl: args.remoteBaseUrl
+	});
+}
+function makeEntry(args) {
+	const timestamp = Date.parse(args.authorDate);
+	return {
+		id: args.id,
+		index: args.index,
+		revision: args.revision,
+		shortRevision: args.shortRevision,
+		changeId: args.changeId,
+		bookmarkNames: args.bookmarkNames,
+		branchNames: args.branchNames,
+		authorDate: args.authorDate,
+		authorName: args.authorName,
+		description: args.description || "",
+		isWorkingTree: args.isWorkingTree,
+		touchesFile: args.touchesFile,
+		timestamp,
+		filePath: args.filePath,
+		operationId: args.operationId,
+		operationIndex: args.operationIndex,
+		operationKey: args.operationKey,
+		monthLabel: monthFormatter.format(timestamp),
+		shortDate: shortDateFormatter.format(timestamp),
+		relativeDate: relativeTime(timestamp),
+		hasPreviousEntry: args.index > 0,
+		remoteUrl: args.isWorkingTree || !args.remoteBaseUrl ? void 0 : `${args.remoteBaseUrl}/commit/${args.revision}`,
+		...args.isEmpty ? { isEmpty: true } : {},
+		...args.hasConflict ? { hasConflict: true } : {},
+		...args.isImmutable ? { isImmutable: true } : {}
+	};
+}
+function reindexEntries(entries) {
+	return entries.map((entry, index) => ({
+		...entry,
+		index,
+		hasPreviousEntry: index > 0
+	}));
+}
+function normalizeSnapshotAuthorDate(authorDate, fallbackAuthorDate) {
+	const value = String(authorDate || "").trim();
+	if (value && !Number.isNaN(Date.parse(value))) return value;
+	return fallbackAuthorDate;
+}
+function normalizeSnapshotDescription(description, operationDescription) {
+	const trimmed = String(description || "").trim();
+	if (!trimmed || trimmed === "(no description set)" || trimmed === "(empty) (no description set)") return operationDescription || "Snapshot";
+	return trimmed;
+}
+function relativeTime(timestamp) {
+	const deltaHours = Math.round((Date.now() - timestamp) / 36e5);
+	if (deltaHours <= 1) return "this minute";
+	if (deltaHours < 36) return "yesterday";
+	if (deltaHours < 720) return `${Math.round(deltaHours / 24)} days ago`;
+	return `${Math.round(deltaHours / 720)} months ago`;
+}
+async function resolveRepoContext(workspacePath) {
+	const [gitResult, jjResult] = await Promise.allSettled([run({
+		command: "git",
+		args: ["rev-parse", "--show-toplevel"],
+		cwd: workspacePath
+	}), run({
+		command: "jj",
+		args: ["root"],
+		cwd: workspacePath
+	})]);
+	const gitRoot = gitResult.status === "fulfilled" ? gitResult.value.stdout.trim() : void 0;
+	const jjRoot = jjResult.status === "fulfilled" ? jjResult.value.stdout.trim() : void 0;
+	const backend = require_history_helpers.resolvePreferredHistoryBackend({
+		workspacePath,
+		gitRoot,
+		jjRoot
+	});
+	if (backend === "jj" && jjRoot) return {
+		backend: "jj",
+		repoRoot: jjRoot,
+		remoteBaseUrl: await resolveRemoteBaseUrl(jjRoot)
+	};
+	if (backend === "git" && gitRoot) return {
+		backend: "git",
+		repoRoot: gitRoot,
+		remoteBaseUrl: await resolveRemoteBaseUrl(gitRoot)
+	};
+	throw new Error("Standalone timeline requires a Git or JJ repository.");
+}
+async function resolveRemoteBaseUrl(repoRoot) {
+	try {
+		const { stdout } = await run({
+			command: "git",
+			args: [
+				"remote",
+				"get-url",
+				"origin"
+			],
+			cwd: repoRoot
+		});
+		return require_history_helpers.getGitHubRemoteBaseUrl(stdout.trim());
+	} catch {
+		return;
+	}
+}
+function extractPersistedPreferences(command) {
+	return {
+		sidebarWidth: command.sidebarWidth,
+		sidebarCollapsed: command.sidebarCollapsed,
+		timelinePaneHeight: command.timelinePaneHeight,
+		timelinePaneCollapsed: command.timelinePaneCollapsed,
+		layoutMode: command.layoutMode,
+		contentMode: command.contentMode,
+		comparisonMode: command.comparisonMode,
+		comparisonSource: command.comparisonSource,
+		showIntermediateRevisions: command.showIntermediateRevisions,
+		preset: command.preset,
+		themePreference: command.themePreference,
+		heatmapOpen: command.heatmapOpen === true,
+		lineDiffType: command.lineDiffType
+	};
+}
+function getFixturePreview(args) {
+	const normalizedFromIndex = Math.min(args.fromIndex, args.toIndex);
+	const normalizedToIndex = Math.max(args.fromIndex, args.toIndex);
+	const key = `${normalizedFromIndex}:${normalizedToIndex}`;
+	const preview = (args.fileFixture.previews[args.comparisonSource] || args.fileFixture.previews.revision || {})[key];
+	if (preview) return clone(preview);
+	return {
+		index: normalizedToIndex,
+		title: "No diff available",
+		subtitle: "",
+		diffCount: 0,
+		additions: 0,
+		deletions: 0,
+		hunkCount: 0,
+		hasChanges: false,
+		fromIndex: normalizedFromIndex,
+		toIndex: normalizedToIndex,
+		comparisonSource: args.comparisonSource,
+		beforePath: "",
+		afterPath: "",
+		beforeText: "",
+		afterText: "",
+		nonTextualDetails: []
+	};
+}
+function resolveNonEmptyRange(fileFixture, candidateIndexes) {
+	const previewMap = fileFixture.previews.revision || {};
+	for (let index = candidateIndexes.length - 1; index > 0; index -= 1) {
+		const fromIndex = candidateIndexes[index - 1];
+		const toIndex = candidateIndexes[index];
+		if (previewMap[`${Math.min(fromIndex, toIndex)}:${Math.max(fromIndex, toIndex)}`]?.hasChanges) return {
+			fromIndex,
+			toIndex
+		};
+	}
+	return null;
+}
+function getUnitPreview(args) {
+	const sourceEntries = require_timeline_model.getEntriesForSource(args.fileFixture.timelineData, args.comparisonSource);
+	const currentIndex = sourceEntries.findIndex((entry) => entry.index === args.entryIndex);
+	if (currentIndex <= 0) return null;
+	return getFixturePreview({
+		fileFixture: args.fileFixture,
+		fromIndex: sourceEntries[currentIndex - 1].index || 0,
+		toIndex: sourceEntries[currentIndex].index || 0,
+		comparisonSource: args.comparisonSource
+	});
+}
+async function openPreviewDocument(args) {
+	const previewDirectory = node_path.default.join(node_os.default.tmpdir(), "jj-plus-previews");
+	await node_fs_promises.default.mkdir(previewDirectory, { recursive: true });
+	const sanitizedPath = args.relativePath.replace(/[^a-zA-Z0-9._-]+/g, "_");
+	const previewPath = node_path.default.join(previewDirectory, `${Date.now()}-${sanitizedPath}.diff.txt`);
+	await node_fs_promises.default.writeFile(previewPath, renderPreviewText(args.preview, args.relativePath), "utf8");
+	await openTarget(previewPath);
+}
+function renderPreviewText(preview, relativePath) {
+	const summary = `+${preview.additions} -${preview.deletions} ${preview.hunkCount} hunks`;
+	const detailLines = preview.nonTextualDetails?.length ? [...preview.nonTextualDetails, ""] : [];
+	const pathLines = [
+		`--- ${preview.beforePath || relativePath}`,
+		`+++ ${preview.afterPath || relativePath}`,
+		""
+	];
+	const contentLines = [
+		"===== before =====",
+		preview.beforeText,
+		"===== after =====",
+		preview.afterText
+	];
+	return [
+		relativePath,
+		preview.title,
+		preview.subtitle,
+		summary,
+		"",
+		...detailLines,
+		...pathLines,
+		...contentLines,
+		""
+	].join("\n");
+}
+async function openTarget(target) {
+	const launcher = getSystemLauncher(target);
+	await new Promise((resolve, reject) => {
+		const child = (0, node_child_process.spawn)(launcher.command, launcher.args, {
+			detached: true,
+			stdio: "ignore"
+		});
+		child.once("error", reject);
+		child.once("spawn", () => {
+			child.unref();
+			resolve();
+		});
+	});
+}
+function getSystemLauncher(target) {
+	if (process.platform === "darwin") return {
+		command: "open",
+		args: [target]
+	};
+	if (process.platform === "win32") return {
+		command: "cmd",
+		args: [
+			"/c",
+			"start",
+			"",
+			target
+		]
+	};
+	return {
+		command: "xdg-open",
+		args: [target]
+	};
+}
+async function ensureDistReady() {
+	const assetPaths = distAssets.map((assetPath) => node_path.default.join(distDir, assetPath));
+	if (!assetPaths.every((assetPath) => node_fs.default.existsSync(assetPath)) || await isDistStale(assetPaths)) await buildWebviewDist();
+	if (!assetPaths.every((assetPath) => node_fs.default.existsSync(assetPath))) throw new Error("Missing webview-dist assets. Run pnpm build:webview before launching the standalone timeline.");
+}
+async function isDistStale(assetPaths) {
+	const sourcePaths = await collectBuildInputFiles(node_path.default.join(rootDir, "webview"));
+	return (sourcePaths.length ? Math.max(...await Promise.all(sourcePaths.map((filePath) => node_fs_promises.default.stat(filePath).then((stats) => stats.mtimeMs)))) : 0) > Math.min(...await Promise.all(assetPaths.map((assetPath) => node_fs_promises.default.stat(assetPath).then((stats) => stats.mtimeMs))));
+}
+async function collectBuildInputFiles(currentPath) {
+	const entries = await node_fs_promises.default.readdir(currentPath, { withFileTypes: true });
+	const filePaths = [];
+	for (const entry of entries) {
+		const absolutePath = node_path.default.join(currentPath, entry.name);
+		if (entry.isDirectory()) {
+			filePaths.push(...await collectBuildInputFiles(absolutePath));
+			continue;
+		}
+		if (entry.isFile()) filePaths.push(absolutePath);
+	}
+	return filePaths;
+}
+async function buildWebviewDist() {
+	const pnpmCommand = process.platform === "win32" ? "pnpm.cmd" : "pnpm";
+	try {
+		await run({
+			command: pnpmCommand,
+			args: ["build:webview"],
+			cwd: rootDir
+		});
+		return;
+	} catch (error) {
+		if ((error && typeof error === "object" && "code" in error ? error.code : void 0) === "ENOENT") try {
+			await run({
+				command: "corepack",
+				args: ["pnpm", "build:webview"],
+				cwd: rootDir
+			});
+			return;
+		} catch {}
+		const cause = error instanceof Error ? error : new Error(String(error));
+		cause.message = `Failed to build the standalone webview assets automatically: ${cause.message}`;
+		throw cause;
+	}
+}
+function resolveStaticPath(requestPath) {
+	const decodedPath = decodeURIComponent(requestPath === "/" ? "/index.html" : requestPath);
+	const candidatePath = node_path.default.normalize(node_path.default.join(distDir, decodedPath));
+	if (candidatePath !== distDir && !candidatePath.startsWith(`${distDir}${node_path.default.sep}`)) return null;
+	return candidatePath;
+}
+function getContentType(filePath) {
+	const extension = node_path.default.extname(filePath).toLowerCase();
+	if (extension === ".html") return "text/html; charset=utf-8";
+	if (extension === ".js") return "application/javascript; charset=utf-8";
+	if (extension === ".css") return "text/css; charset=utf-8";
+	if (extension === ".json") return "application/json; charset=utf-8";
+	if (extension === ".svg") return "image/svg+xml";
+	return "application/octet-stream";
+}
+async function readJsonBody(request) {
+	const chunks = [];
+	let totalBytes = 0;
+	for await (const chunk of request) {
+		const bufferChunk = typeof chunk === "string" ? Buffer.from(chunk) : Buffer.from(chunk);
+		totalBytes += bufferChunk.length;
+		if (totalBytes > 1048576) throw new Error("Request body is too large.");
+		chunks.push(bufferChunk);
+	}
+	const text = Buffer.concat(chunks).toString("utf8");
+	return text ? JSON.parse(text) : {};
+}
+function writeJson(response, statusCode, payload) {
+	response.writeHead(statusCode, {
+		"content-type": "application/json; charset=utf-8",
+		"cache-control": "no-store"
+	});
+	response.end(JSON.stringify(payload));
+}
+function isMissingFileAtRevisionError(error) {
+	const message = error instanceof Error ? error.message : String(error);
+	return /exists on disk, but not in/i.test(message) || /path .* does not exist in/i.test(message) || /no such path/i.test(message) || /no matching entries/i.test(message) || /No such file or directory/i.test(message) || /Path .* not found/i.test(message);
+}
+function isMissingFileError(error) {
+	return Boolean(error && typeof error === "object" && "code" in error && error.code === "ENOENT");
+}
+function normalizePath(relativePath) {
+	return relativePath.split(node_path.default.sep).join("/");
+}
+function clone(value) {
+	return JSON.parse(JSON.stringify(value));
+}
+async function run(args) {
+	return execFileAsync(args.command, args.args, {
+		cwd: args.cwd,
+		env: {
+			...process.env,
+			...args.env
+		}
+	});
+}
+//#endregion
+exports.renderPreviewText = renderPreviewText;
+exports.startStandaloneTimelineServer = startStandaloneTimelineServer;
+
+//# sourceMappingURL=server.cjs.map