jj-plus 0.10.10

package/dist/extension/timeline-panel.cjs

@@ -0,0 +1,1113 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_constants = require("./constants.cjs");
+const require_blame = require("../shared/blame.cjs");
+const require_resolve_file_path = require("../shared/resolve-file-path.cjs");
+require("./resolve-file-path.cjs");
+const require_timeline_template = require("../webview/timeline-template.cjs");
+const require_line_history = require("../shared/line-history.cjs");
+const require_uri_utils = require("./uri-utils.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 vscode = require("vscode");
+vscode = require_runtime.__toESM(vscode, 1);
+//#region src/extension/timeline-panel.ts
+const LARGE_MULTI_DIFF_CONFIRMATION_THRESHOLD = 200;
+function collectPendingSnapshotHydrationIndexes(session) {
+	return session.entries.reduce((indexes, entry, index) => {
+		if (entry && !entry.isWorkingTree && entry.touchesFile && entry.changeId && !session.snapshotLoadedChangeIds.has(entry.changeId)) indexes.push(index);
+		return indexes;
+	}, []);
+}
+function postTimelineMessage(request) {
+	return Promise.resolve(request.panel.webview.postMessage(request.message));
+}
+async function buildSelectedEntryMultiDiffPlan(request) {
+	const files = [];
+	for (const entryIndex of request.entryIndexes) {
+		const entry = request.sourceEntries[entryIndex];
+		if (!entry) continue;
+		let plan = {
+			title: request.title,
+			files: []
+		};
+		if (entry.isWorkingTree) {
+			const previousEntry = request.sourceEntries[entryIndex - 1];
+			if (!previousEntry) continue;
+			plan = await request.adapter.buildRangeMultiDiffPlan({
+				workspacePath: request.workspacePath,
+				fromEntry: previousEntry,
+				toEntry: entry,
+				comparisonSource: request.comparisonSource,
+				sourceEntries: request.sourceEntries,
+				signal: request.signal
+			});
+		} else plan = await request.adapter.buildRevisionMultiDiffPlan({
+			workspacePath: request.workspacePath,
+			entry,
+			entryIndex,
+			comparisonSource: request.comparisonSource,
+			sourceEntries: request.sourceEntries,
+			signal: request.signal
+		});
+		files.push(...plan.files);
+	}
+	return {
+		title: request.title,
+		files
+	};
+}
+async function resolveTimelineSourcePath(request) {
+	const coerced = require_resolve_file_path.coerceFsPath(request.absolutePath);
+	if (coerced) return coerced;
+	const activeEditor = vscode.window.activeTextEditor;
+	if (activeEditor && isWorkspaceFileUri(activeEditor.document.uri)) return activeEditor.document.uri.fsPath;
+	return pickOpenWorkspaceEditorPath();
+}
+async function pickOpenWorkspaceEditorPath() {
+	const candidates = getOpenWorkspaceEditorCandidates();
+	if (!candidates.length) return;
+	return (await vscode.window.showQuickPick(candidates.map((candidate) => ({
+		label: candidate.label,
+		description: candidate.description,
+		detail: candidate.detail,
+		path: candidate.absolutePath
+	})), { placeHolder: "Select a workspace file to open its revision timeline" }))?.path;
+}
+function getOpenWorkspaceEditorCandidates() {
+	const candidates = [];
+	const seenPaths = /* @__PURE__ */ new Set();
+	for (const group of vscode.window.tabGroups?.all || []) for (const tab of group.tabs) {
+		const uri = getTabUri(tab);
+		if (!uri || uri.scheme !== "file") continue;
+		const workspaceFolder = vscode.workspace.getWorkspaceFolder(uri);
+		if (!workspaceFolder) continue;
+		const absolutePath = uri.fsPath;
+		if (seenPaths.has(absolutePath)) continue;
+		const relativePath = node_path.default.relative(workspaceFolder.uri.fsPath, absolutePath).replace(/\\/g, "/");
+		if (!relativePath || relativePath.startsWith("..")) continue;
+		seenPaths.add(absolutePath);
+		candidates.push({
+			label: node_path.default.basename(absolutePath),
+			description: relativePath,
+			detail: workspaceFolder.name,
+			absolutePath
+		});
+	}
+	return candidates;
+}
+function isWorkspaceFileUri(uri) {
+	return uri.scheme === "file" && Boolean(vscode.workspace.getWorkspaceFolder(uri));
+}
+function getTabUri(tab) {
+	return tab.input?.uri;
+}
+function createTimelinePanelController(args) {
+	const timelineSessions = /* @__PURE__ */ new Map();
+	const panelViewReady = /* @__PURE__ */ new WeakMap();
+	const panelLoadGeneration = /* @__PURE__ */ new WeakMap();
+	let activeTimelinePanel;
+	let timelineDebugState = createEmptyTimelineDebugState();
+	let timelinePreviewGeneration = 0;
+	const lineHistoryStatusBar = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Right, 90);
+	lineHistoryStatusBar.command = require_constants.CLEAR_LINE_HISTORY_COMMAND;
+	lineHistoryStatusBar.tooltip = "Clear line-history filter (show full file timeline)";
+	args.context.subscriptions.push(lineHistoryStatusBar);
+	function syncLineHistoryStatusBar(lineHistory) {
+		if (!lineHistory) {
+			lineHistoryStatusBar.hide();
+			return;
+		}
+		lineHistoryStatusBar.text = `$(git-commit) ${require_line_history.formatStatusBarLineHistoryChip(lineHistory)}`;
+		lineHistoryStatusBar.show();
+	}
+	return {
+		dispose() {
+			for (const panel of timelineSessions.keys()) panel.dispose();
+			timelineSessions.clear();
+			activeTimelinePanel = void 0;
+			timelineDebugState = createEmptyTimelineDebugState();
+			syncLineHistoryStatusBar(null);
+		},
+		async clearLineHistoryFilter() {
+			const panel = activeTimelinePanel;
+			const session = panel ? timelineSessions.get(panel) : void 0;
+			if (!panel || !session?.lineHistory) {
+				if (panel) panel.reveal(void 0, true);
+				return;
+			}
+			await loadSessionIntoPanel({
+				panel,
+				workspacePath: session.workspacePath,
+				absolutePath: session.absolutePath,
+				customRevset: session.customRevset
+			});
+		},
+		getDebugState() {
+			return { ...timelineDebugState };
+		},
+		async getDiffLayoutMetrics() {
+			const panel = activeTimelinePanel;
+			if (!panel) throw new Error("no active timeline panel");
+			return await new Promise((resolve, reject) => {
+				const timeout = setTimeout(() => {
+					subscription.dispose();
+					reject(/* @__PURE__ */ new Error("timed out waiting for webview layout metrics"));
+				}, 8e3);
+				const subscription = panel.webview.onDidReceiveMessage((message) => {
+					if (!message || typeof message !== "object") return;
+					if (Reflect.get(message, "command") !== "layout-metrics") return;
+					const metrics = Reflect.get(message, "metrics");
+					if (!metrics || typeof metrics !== "object") return;
+					clearTimeout(timeout);
+					subscription.dispose();
+					resolve(metrics);
+				});
+				panel.webview.postMessage({ type: "debug-measure-layout" });
+			});
+		},
+		async selectTimelineRange(request) {
+			const panel = activeTimelinePanel;
+			if (!panel) throw new Error("no active timeline panel");
+			const session = timelineSessions.get(panel);
+			if (!session) throw new Error("no active timeline session");
+			await handleTimelineMessage({
+				panel,
+				session,
+				message: {
+					command: "select-entry",
+					fromIndex: request.fromIndex,
+					toIndex: request.toIndex,
+					comparisonSource: request.comparisonSource || "revision"
+				}
+			});
+		},
+		async setLayoutMode(layoutMode) {
+			const panel = activeTimelinePanel;
+			if (!panel) throw new Error("no active timeline panel");
+			const nextPreferences = {
+				...args.getPreferences(),
+				layoutMode: layoutMode === "unified" ? "unified" : "split"
+			};
+			await args.savePreferences(nextPreferences);
+			await postTimelineMessage({
+				panel,
+				message: {
+					type: "debug-set-layout-mode",
+					layoutMode: nextPreferences.layoutMode
+				}
+			});
+		},
+		async openFileRevisionTimeline({ absolutePath, lineHistory, focusRevision }) {
+			const initialPath = await resolveTimelineSourcePath({ absolutePath });
+			if (!initialPath) {
+				vscode.window.showErrorMessage("Open a workspace file to browse its revision timeline");
+				return;
+			}
+			const documentUri = vscode.Uri.file(initialPath);
+			const workspaceFolder = vscode.workspace.getWorkspaceFolder(documentUri);
+			if (!workspaceFolder) {
+				vscode.window.showErrorMessage("The active file must belong to a workspace folder");
+				return;
+			}
+			if (documentUri.scheme !== "file") {
+				vscode.window.showErrorMessage("The revision timeline only supports files on disk");
+				return;
+			}
+			const fileName = node_path.default.basename(documentUri.fsPath);
+			const hadExistingPanel = timelineSessions.size > 0;
+			const panel = createTimelinePanel({ fileName });
+			activeTimelinePanel = panel;
+			panel.webview.html = getTimelineWebviewHtml({
+				context: args.context,
+				webview: panel.webview
+			});
+			panel.title = lineHistory ? `Revision Timeline: ${fileName} (L${lineHistory.startLine}${lineHistory.endLine === lineHistory.startLine ? "" : `–${lineHistory.endLine}`})` : `Revision Timeline: ${fileName}`;
+			timelineDebugState = {
+				...createEmptyTimelineDebugState(),
+				panelOpen: true,
+				panelCount: timelineSessions.size + 1,
+				panelTitle: panel.title,
+				workspacePath: workspaceFolder.uri.fsPath,
+				relativePath: node_path.default.relative(workspaceFolder.uri.fsPath, documentUri.fsPath).replace(/\\/g, "/"),
+				fileName,
+				lineHistory: lineHistory ? {
+					startLine: lineHistory.startLine,
+					endLine: lineHistory.endLine
+				} : null,
+				usesBundledWebview: hasBundledTimelineWebviewAssets({ context: args.context })
+			};
+			if (!hadExistingPanel && shouldMaximizeTimelinePanel()) await maximizeTimelinePanel();
+			await loadSessionIntoPanel({
+				panel,
+				workspacePath: workspaceFolder.uri.fsPath,
+				absolutePath: documentUri.fsPath,
+				lineHistory,
+				customRevset: args.getPreferences().customRevset || void 0,
+				focusRevision
+			});
+			syncLineHistoryStatusBar(lineHistory);
+		}
+	};
+	async function loadSessionIntoPanel(request) {
+		const generation = (panelLoadGeneration.get(request.panel) || 0) + 1;
+		panelLoadGeneration.set(request.panel, generation);
+		const session = await args.service.buildSession({
+			workspacePath: request.workspacePath,
+			absolutePath: request.absolutePath,
+			options: {
+				...request.lineHistory ? { lineHistory: request.lineHistory } : {},
+				...request.customRevset ? { customRevset: request.customRevset } : {}
+			}
+		});
+		if (panelLoadGeneration.get(request.panel) !== generation || request.panel.webview.html === "") return;
+		if (!session.entries.length) {
+			vscode.window.showInformationMessage("No file revisions were found for the active file");
+			if (!timelineSessions.has(request.panel)) request.panel.dispose();
+			return;
+		}
+		timelineSessions.set(request.panel, session);
+		activeTimelinePanel = request.panel;
+		request.panel.title = session.lineHistory ? `Revision Timeline: ${session.fileName} (L${session.lineHistory.startLine}${session.lineHistory.endLine === session.lineHistory.startLine ? "" : `–${session.lineHistory.endLine}`})` : `Revision Timeline: ${session.fileName}`;
+		syncLineHistoryStatusBar(session.lineHistory);
+		timelineDebugState = createDebugState({
+			panel: request.panel,
+			session,
+			lastMessageCommand: timelineDebugState.lastMessageCommand,
+			panelCount: timelineSessions.size
+		});
+		timelineDebugState = {
+			...timelineDebugState,
+			viewReady: panelViewReady.get(request.panel) === true
+		};
+		if (panelViewReady.get(request.panel)) await eagerlyBootstrapTimeline({
+			panel: request.panel,
+			session
+		});
+		if (request.focusRevision) {
+			const match = args.service.mapEntriesForPayload(session.entries).find((entry) => !entry.isWorkingTree && require_blame.revisionMatchesBlame(entry.revision, request.focusRevision));
+			if (match && typeof match.index === "number") {
+				const fromIndex = Math.max(0, match.index - 1);
+				await handleTimelineMessage({
+					panel: request.panel,
+					session,
+					message: {
+						command: "select-entry",
+						fromIndex,
+						toIndex: match.index,
+						comparisonSource: "revision"
+					}
+				});
+			}
+		}
+	}
+	function createTimelinePanel(request) {
+		const panel = vscode.window.createWebviewPanel("jjRangeDiffTimeline", `Revision Timeline: ${request.fileName}`, getTimelineViewColumn(), {
+			enableScripts: true,
+			retainContextWhenHidden: true,
+			enableFindWidget: true,
+			localResourceRoots: [vscode.Uri.joinPath(args.context.extensionUri, "webview"), vscode.Uri.joinPath(args.context.extensionUri, "webview-dist")]
+		});
+		panel.onDidDispose(() => {
+			timelineSessions.get(panel)?.activeActionAbortController?.abort();
+			timelineSessions.delete(panel);
+			if (activeTimelinePanel === panel) {
+				const fallback = [...timelineSessions.entries()].at(-1);
+				if (!fallback) {
+					activeTimelinePanel = void 0;
+					timelineDebugState = createEmptyTimelineDebugState();
+					syncLineHistoryStatusBar(null);
+					return;
+				}
+				activeTimelinePanel = fallback[0];
+				timelineDebugState = createDebugState({
+					panel: fallback[0],
+					session: fallback[1],
+					lastMessageCommand: timelineDebugState.lastMessageCommand,
+					panelCount: timelineSessions.size
+				});
+				syncLineHistoryStatusBar(fallback[1].lineHistory);
+				return;
+			}
+			timelineDebugState = {
+				...timelineDebugState,
+				panelCount: timelineSessions.size
+			};
+		}, void 0, args.context.subscriptions);
+		panel.webview.onDidReceiveMessage(async (message) => {
+			try {
+				activeTimelinePanel = panel;
+				if ((message && typeof message === "object" ? Reflect.get(message, "command") : void 0) === "ready") {
+					panelViewReady.set(panel, true);
+					const session = timelineSessions.get(panel);
+					timelineDebugState = {
+						...session ? createDebugState({
+							panel,
+							session,
+							lastMessageCommand: "ready",
+							panelCount: timelineSessions.size
+						}) : timelineDebugState,
+						viewReady: true,
+						readyCount: (timelineDebugState.readyCount || 0) + 1,
+						lastReadyAt: Date.now(),
+						lastMessageCommand: "ready",
+						panelOpen: true,
+						panelTitle: panel.title
+					};
+					if (session?.entries.length) await eagerlyBootstrapTimeline({
+						panel,
+						session
+					});
+					return;
+				}
+				const session = timelineSessions.get(panel);
+				if (!session) return;
+				await handleTimelineMessage({
+					panel,
+					session,
+					message
+				});
+			} catch (error) {
+				const text = error instanceof Error ? error.message : String(error);
+				vscode.window.showErrorMessage(`Timeline action failed: ${text}`);
+			}
+		}, void 0, args.context.subscriptions);
+		return panel;
+	}
+	async function handleTimelineMessage(request) {
+		if (!request.message || typeof request.message !== "object") return;
+		const command = Reflect.get(request.message, "command");
+		if (typeof command !== "string") return;
+		if (command === "ready") return;
+		if (command === "layout-metrics") return;
+		if (command === "select-entry") {
+			const fromIndex = Number(Reflect.get(request.message, "fromIndex"));
+			const toIndex = Number(Reflect.get(request.message, "toIndex"));
+			const comparisonSource = normalizeComparisonSource(Reflect.get(request.message, "comparisonSource"));
+			if (!Number.isInteger(fromIndex) || !Number.isInteger(toIndex)) return;
+			await sendTimelinePreview({
+				panel: request.panel,
+				session: request.session,
+				fromIndex,
+				toIndex,
+				comparisonSource
+			});
+			return;
+		}
+		if (command === "load-range-overview") {
+			const fromIndex = Number(Reflect.get(request.message, "fromIndex"));
+			const toIndex = Number(Reflect.get(request.message, "toIndex"));
+			const comparisonSource = normalizeComparisonSource(Reflect.get(request.message, "comparisonSource"));
+			const selectedEntryIndexes = Array.isArray(Reflect.get(request.message, "selectedEntryIndexes")) ? Reflect.get(request.message, "selectedEntryIndexes").map((value) => Number(value)).filter((value) => Number.isInteger(value)) : [];
+			if (!Number.isInteger(fromIndex) || !Number.isInteger(toIndex)) return;
+			await sendRangeOverview({
+				panel: request.panel,
+				session: request.session,
+				fromIndex,
+				toIndex,
+				comparisonSource,
+				selectedEntryIndexes
+			});
+			return;
+		}
+		if (command === "load-range-stack") {
+			const fromIndex = Number(Reflect.get(request.message, "fromIndex"));
+			const toIndex = Number(Reflect.get(request.message, "toIndex"));
+			const comparisonSource = normalizeComparisonSource(Reflect.get(request.message, "comparisonSource"));
+			const relativePaths = Array.isArray(Reflect.get(request.message, "relativePaths")) ? Reflect.get(request.message, "relativePaths").map((value) => String(value || "").trim()).filter(Boolean) : [];
+			if (!Number.isInteger(fromIndex) || !Number.isInteger(toIndex) || !relativePaths.length) return;
+			const normalizedFromIndex = Math.max(0, Math.min(fromIndex, toIndex));
+			const normalizedToIndex = Math.max(normalizedFromIndex, Math.max(fromIndex, toIndex));
+			await postTimelineMessage({
+				panel: request.panel,
+				message: {
+					type: "range-stack-previews",
+					payload: {
+						fromIndex: normalizedFromIndex,
+						toIndex: normalizedToIndex,
+						comparisonSource,
+						items: await args.service.getRangeStackPreviews({
+							session: request.session,
+							fromIndex: normalizedFromIndex,
+							toIndex: normalizedToIndex,
+							comparisonSource,
+							relativePaths
+						})
+					}
+				}
+			});
+			return;
+		}
+		if (command === "load-diff-blame") {
+			const fromIndex = Number(Reflect.get(request.message, "fromIndex"));
+			const toIndex = Number(Reflect.get(request.message, "toIndex"));
+			const comparisonSource = normalizeComparisonSource(Reflect.get(request.message, "comparisonSource"));
+			if (!Number.isInteger(fromIndex) || !Number.isInteger(toIndex)) return;
+			const normalizedFromIndex = Math.max(0, Math.min(fromIndex, toIndex));
+			const normalizedToIndex = Math.max(normalizedFromIndex, Math.max(fromIndex, toIndex));
+			const blame = await args.service.getDiffBlame({
+				session: request.session,
+				fromIndex: normalizedFromIndex,
+				toIndex: normalizedToIndex,
+				comparisonSource
+			});
+			await postTimelineMessage({
+				panel: request.panel,
+				message: {
+					type: "diff-blame",
+					payload: {
+						fromIndex: normalizedFromIndex,
+						toIndex: normalizedToIndex,
+						comparisonSource,
+						relativePath: blame.relativePath,
+						lines: blame.lines
+					}
+				}
+			});
+			return;
+		}
+		if (command === "load-file-oplog") {
+			const oplog = await args.service.getFileOpLog({ session: request.session });
+			await postTimelineMessage({
+				panel: request.panel,
+				message: {
+					type: "file-oplog",
+					payload: {
+						relativePath: oplog.relativePath,
+						entries: oplog.entries
+					}
+				}
+			});
+			return;
+		}
+		if (command === "load-revision-tree-files") {
+			const revision = String(Reflect.get(request.message, "revision") || "@");
+			const files = await args.service.loadRevisionTreeFiles({
+				session: request.session,
+				revision
+			});
+			await postTimelineMessage({
+				panel: request.panel,
+				message: {
+					type: "revision-tree-files",
+					payload: {
+						revision,
+						files
+					}
+				}
+			});
+			return;
+		}
+		if (command === "search-history") {
+			const query = String(Reflect.get(request.message, "query") || "");
+			const purpose = Reflect.get(request.message, "purpose") === "sidebar" ? "sidebar" : "history";
+			const result = await args.service.searchFileHistory({
+				session: request.session,
+				query,
+				purpose
+			});
+			await postTimelineMessage({
+				panel: request.panel,
+				message: {
+					type: "history-search",
+					payload: {
+						...result,
+						purpose
+					}
+				}
+			});
+			return;
+		}
+		if (command === "load-entry-diff-counts") {
+			const comparisonSource = normalizeComparisonSource(Reflect.get(request.message, "comparisonSource"));
+			const entryIndexes = Array.isArray(Reflect.get(request.message, "entryIndexes")) ? Reflect.get(request.message, "entryIndexes").map((value) => Number(value)).filter((value) => Number.isInteger(value)) : [];
+			if (!entryIndexes.length) return;
+			await postTimelineMessage({
+				panel: request.panel,
+				message: {
+					type: "entry-diff-counts",
+					payload: {
+						comparisonSource,
+						counts: await args.service.getEntryDiffCounts({
+							session: request.session,
+							entryIndexes,
+							comparisonSource
+						})
+					}
+				}
+			});
+			return;
+		}
+		if (command === "hydrate-snapshot-entries") {
+			const revisionIndexes = Reflect.get(request.message, "revisionIndexes");
+			if (!Array.isArray(revisionIndexes)) return;
+			if (!await args.service.hydrateSnapshotEntries({
+				session: request.session,
+				revisionIndexes: revisionIndexes.map((value) => Number(value)).filter((value) => Number.isInteger(value))
+			})) return;
+			const payload = buildPayload(request.session);
+			await postTimelineMessage({
+				panel: request.panel,
+				message: {
+					type: "snapshot-entries",
+					payload: {
+						snapshotEntries: payload.snapshotEntries,
+						snapshotState: payload.snapshotState
+					}
+				}
+			});
+			return;
+		}
+		if (command === "resolve-nonempty-range") {
+			const candidateIndexes = Reflect.get(request.message, "candidateIndexes");
+			if (!Array.isArray(candidateIndexes)) return;
+			const resolvedRange = await args.service.findNearestNonEmptyVisibleRange({
+				session: request.session,
+				candidateIndexes: candidateIndexes.map((value) => Number(value)).filter((value) => Number.isInteger(value))
+			});
+			await postTimelineMessage({
+				panel: request.panel,
+				message: {
+					type: "resolved-range",
+					payload: resolvedRange
+				}
+			});
+			return;
+		}
+		if (command === "open-editor-diff") {
+			const fromIndex = Number(Reflect.get(request.message, "fromIndex"));
+			const toIndex = Number(Reflect.get(request.message, "toIndex"));
+			const comparisonSource = normalizeComparisonSource(Reflect.get(request.message, "comparisonSource"));
+			if (!Number.isInteger(fromIndex) || !Number.isInteger(toIndex)) return;
+			await openRangeDiffInEditor({
+				session: request.session,
+				fromIndex,
+				toIndex,
+				comparisonSource
+			});
+			return;
+		}
+		if (command === "open-current-file") {
+			await vscode.commands.executeCommand("vscode.open", vscode.Uri.file(request.session.absolutePath), { preview: true });
+			return;
+		}
+		if (command === "open-range-files-diff") {
+			const fromIndex = Number(Reflect.get(request.message, "fromIndex"));
+			const toIndex = Number(Reflect.get(request.message, "toIndex"));
+			const comparisonSource = normalizeComparisonSource(Reflect.get(request.message, "comparisonSource"));
+			const selectedEntryIndexes = Array.isArray(Reflect.get(request.message, "selectedEntryIndexes")) ? Reflect.get(request.message, "selectedEntryIndexes").map((value) => Number(value)).filter((value) => Number.isInteger(value)) : [];
+			if (!Number.isInteger(fromIndex) || !Number.isInteger(toIndex)) return;
+			await openRangeFilesDiff({
+				session: request.session,
+				fromIndex,
+				toIndex,
+				comparisonSource,
+				selectedEntryIndexes
+			});
+			return;
+		}
+		if (command === "open-revision-files-diff") {
+			const entryIndex = Number(Reflect.get(request.message, "entryIndex"));
+			const comparisonSource = normalizeComparisonSource(Reflect.get(request.message, "comparisonSource"));
+			if (!Number.isInteger(entryIndex)) return;
+			await openRevisionFilesDiff({
+				session: request.session,
+				entryIndex,
+				comparisonSource
+			});
+			return;
+		}
+		if (command === "open-revision-remote") {
+			const entryIndex = Number(Reflect.get(request.message, "entryIndex"));
+			const comparisonSource = normalizeComparisonSource(Reflect.get(request.message, "comparisonSource"));
+			if (!Number.isInteger(entryIndex)) return;
+			await openRevisionOnRemote({
+				session: request.session,
+				entryIndex,
+				comparisonSource
+			});
+			return;
+		}
+		if (command === "cancel-active-request") {
+			request.session.activeActionAbortController?.abort();
+			return;
+		}
+		if (command === "switch-file") {
+			const relativePath = String(Reflect.get(request.message, "relativePath") || "").trim();
+			if (!relativePath) return;
+			await loadSessionIntoPanel({
+				panel: request.panel,
+				workspacePath: request.session.workspacePath,
+				absolutePath: node_path.default.join(request.session.workspacePath, relativePath),
+				lineHistory: request.session.lineHistory,
+				customRevset: request.session.customRevset
+			});
+			return;
+		}
+		if (command === "clear-line-history") {
+			await loadSessionIntoPanel({
+				panel: request.panel,
+				workspacePath: request.session.workspacePath,
+				absolutePath: request.session.absolutePath,
+				customRevset: request.session.customRevset
+			});
+			syncLineHistoryStatusBar(null);
+			return;
+		}
+		if (command === "set-custom-revset") {
+			const customRevset = String(Reflect.get(request.message, "customRevset") || "").trim();
+			const nextPreferences = {
+				...args.getPreferences(),
+				customRevset
+			};
+			await args.savePreferences(nextPreferences);
+			await loadSessionIntoPanel({
+				panel: request.panel,
+				workspacePath: request.session.workspacePath,
+				absolutePath: request.session.absolutePath,
+				lineHistory: request.session.lineHistory,
+				customRevset: customRevset || void 0
+			});
+			return;
+		}
+		if (command === "persist-state") {
+			await args.savePreferences({
+				sidebarWidth: Number(Reflect.get(request.message, "sidebarWidth")),
+				sidebarCollapsed: Boolean(Reflect.get(request.message, "sidebarCollapsed")),
+				timelinePaneHeight: Number(Reflect.get(request.message, "timelinePaneHeight")),
+				timelinePaneCollapsed: Boolean(Reflect.get(request.message, "timelinePaneCollapsed")),
+				layoutMode: Reflect.get(request.message, "layoutMode") === "unified" ? "unified" : "split",
+				contentMode: Reflect.get(request.message, "contentMode") === "full" ? "full" : "diffs",
+				comparisonMode: Reflect.get(request.message, "comparisonMode") === "step" ? "step" : "range",
+				comparisonSource: normalizeComparisonSource(Reflect.get(request.message, "comparisonSource")),
+				showIntermediateRevisions: Boolean(Reflect.get(request.message, "showIntermediateRevisions")),
+				preset: normalizeTimelinePreset(Reflect.get(request.message, "preset")),
+				customRevset: String(Reflect.get(request.message, "customRevset") || args.getPreferences().customRevset || ""),
+				themePreference: normalizeThemePreference(Reflect.get(request.message, "themePreference")),
+				heatmapOpen: Boolean(Reflect.get(request.message, "heatmapOpen")),
+				lineDiffType: normalizeLineDiffType(Reflect.get(request.message, "lineDiffType"))
+			});
+			return;
+		}
+		if (command === "refresh") {
+			await loadSessionIntoPanel({
+				panel: request.panel,
+				workspacePath: request.session.workspacePath,
+				absolutePath: request.session.absolutePath,
+				lineHistory: request.session.lineHistory,
+				customRevset: request.session.customRevset
+			});
+			return;
+		}
+	}
+	async function eagerlyBootstrapTimeline(request) {
+		const comparisonSource = normalizeComparisonSource(args.getPreferences().comparisonSource);
+		if (comparisonSource === "snapshot" && request.session.backend === "jj" && request.session.snapshotLoadedChangeIds.size === 0) await args.service.hydrateSnapshotEntries({
+			session: request.session,
+			revisionIndexes: collectPendingSnapshotHydrationIndexes(request.session)
+		});
+		const payload = buildPayload(request.session);
+		await postTimelineMessage({
+			panel: request.panel,
+			message: {
+				type: "timeline-data",
+				payload
+			}
+		});
+		const defaultFromIndex = Math.max(0, payload.defaultIndex - 1);
+		await sendTimelinePreview({
+			panel: request.panel,
+			session: request.session,
+			fromIndex: defaultFromIndex,
+			toIndex: payload.defaultIndex,
+			comparisonSource
+		});
+		enrichSessionInBackground({
+			panel: request.panel,
+			session: request.session
+		});
+	}
+	async function enrichSessionInBackground(request) {
+		const generation = panelLoadGeneration.get(request.panel);
+		const isCurrent = () => panelLoadGeneration.get(request.panel) === generation && timelineSessions.get(request.panel) === request.session;
+		try {
+			if (await args.service.ensureWorkspaceFiles({ session: request.session })) {
+				if (!isCurrent()) return;
+				await postTimelineMessage({
+					panel: request.panel,
+					message: {
+						type: "workspace-files",
+						payload: { workspaceFiles: request.session.workspaceFiles }
+					}
+				});
+			}
+			const expanded = await args.service.expandFileHistory({ session: request.session });
+			const intermediates = await args.service.ensureIntermediateRevisions({ session: request.session });
+			if (!isCurrent() || !expanded && !intermediates) return;
+			await postTimelineMessage({
+				panel: request.panel,
+				message: {
+					type: "entries-updated",
+					payload: {
+						entries: args.service.mapEntriesForPayload(request.session.entries),
+						hasIntermediateRevisions: request.session.entries.some((entry) => !entry.touchesFile)
+					}
+				}
+			});
+		} catch {}
+	}
+	function buildPayload(session) {
+		return args.service.buildPayload({
+			session,
+			preferences: args.getPreferences(),
+			version: args.version,
+			presets: require_constants.TIMELINE_PRESET_DAYS
+		});
+	}
+	async function sendTimelinePreview(request) {
+		const generation = ++timelinePreviewGeneration;
+		const preview = await args.service.getDiffPreview(request);
+		if (generation !== timelinePreviewGeneration) return;
+		await postTimelineMessage({
+			panel: request.panel,
+			message: {
+				type: "diff-preview",
+				payload: preview
+			}
+		});
+	}
+	async function sendRangeOverview(request) {
+		const normalizedFromIndex = Math.max(0, Math.min(request.fromIndex, request.toIndex));
+		const normalizedToIndex = Math.max(normalizedFromIndex, Math.max(request.fromIndex, request.toIndex));
+		const selectedEntryIndexes = request.selectedEntryIndexes || [];
+		await postTimelineMessage({
+			panel: request.panel,
+			message: {
+				type: "range-overview",
+				payload: {
+					fromIndex: normalizedFromIndex,
+					toIndex: normalizedToIndex,
+					comparisonSource: request.comparisonSource,
+					selectedEntryIndexes,
+					items: await args.service.getRangeOverview({
+						session: request.session,
+						fromIndex: normalizedFromIndex,
+						toIndex: normalizedToIndex,
+						comparisonSource: request.comparisonSource,
+						selectedEntryIndexes
+					})
+				}
+			}
+		});
+	}
+	async function openRangeDiffInEditor(request) {
+		const sourceEntries = args.service.getEntriesForSource({
+			session: request.session,
+			comparisonSource: request.comparisonSource
+		});
+		const comparison = args.service.getComparisonEntries({
+			entries: sourceEntries,
+			fromIndex: request.fromIndex,
+			toIndex: request.toIndex
+		});
+		if (!comparison) return;
+		if (!comparison.fromEntry) {
+			const uri = await createRevisionUri({
+				session: request.session,
+				entry: comparison.toEntry
+			});
+			await vscode.commands.executeCommand("vscode.open", uri, { preview: true });
+			return;
+		}
+		const originalUri = require_uri_utils.createSnapshotUri({
+			workspacePath: request.session.workspacePath,
+			revset: comparison.fromEntry.revision,
+			relativePath: await args.service.resolveEntryFilePath({
+				session: request.session,
+				entry: comparison.fromEntry,
+				entryIndex: Math.max(0, Math.min(request.fromIndex, request.toIndex))
+			}),
+			backend: request.session.backend
+		});
+		const modifiedUri = require_uri_utils.createSnapshotUri({
+			workspacePath: request.session.workspacePath,
+			revset: comparison.toEntry.revision,
+			relativePath: await args.service.resolveEntryFilePath({
+				session: request.session,
+				entry: comparison.toEntry,
+				entryIndex: Math.max(request.fromIndex, request.toIndex)
+			}),
+			backend: request.session.backend
+		});
+		const title = `${request.session.fileName}: ${comparison.fromEntry.shortRevision} -> ${comparison.toEntry.shortRevision}`;
+		await vscode.commands.executeCommand("vscode.diff", originalUri, modifiedUri, title, { preview: true });
+	}
+	async function openRangeFilesDiff(request) {
+		await args.service.runSessionAction({
+			session: request.session,
+			action: async (signal) => {
+				const sourceEntries = args.service.getEntriesForSource({
+					session: request.session,
+					comparisonSource: request.comparisonSource
+				});
+				const comparison = args.service.getComparisonEntries({
+					entries: sourceEntries,
+					fromIndex: request.fromIndex,
+					toIndex: request.toIndex
+				});
+				if (!comparison) return;
+				const plan = request.selectedEntryIndexes?.length ? await buildSelectedEntryMultiDiffPlan({
+					adapter: request.session.adapter,
+					workspacePath: request.session.workspacePath,
+					sourceEntries,
+					comparisonSource: request.comparisonSource,
+					entryIndexes: request.selectedEntryIndexes,
+					title: `${comparison.fromEntry.shortRevision}..${comparison.toEntry.shortRevision}`,
+					signal
+				}) : await request.session.adapter.buildRangeMultiDiffPlan({
+					workspacePath: request.session.workspacePath,
+					fromEntry: comparison.fromEntry,
+					toEntry: comparison.toEntry,
+					comparisonSource: request.comparisonSource,
+					sourceEntries,
+					signal
+				});
+				if (!plan.files.length) {
+					vscode.window.showInformationMessage(`No changes found for ${plan.title}`);
+					return;
+				}
+				if (!await confirmMultiDiffOpen({
+					title: plan.title,
+					fileCount: plan.files.length
+				})) return;
+				if (signal.aborted) return;
+				await vscode.commands.executeCommand(require_constants.OPEN_MULTI_DIFF_COMMAND, {
+					title: plan.title,
+					resources: await buildMultiDiffResources({
+						workspacePath: request.session.workspacePath,
+						files: plan.files
+					})
+				});
+			}
+		});
+	}
+	async function openRevisionFilesDiff(request) {
+		await args.service.runSessionAction({
+			session: request.session,
+			action: async (signal) => {
+				const sourceEntries = args.service.getEntriesForSource({
+					session: request.session,
+					comparisonSource: request.comparisonSource
+				});
+				const entry = sourceEntries[request.entryIndex];
+				if (!entry) return;
+				if (entry.isWorkingTree) {
+					await openRangeFilesDiff({
+						session: request.session,
+						fromIndex: Math.max(0, request.entryIndex - 1),
+						toIndex: request.entryIndex,
+						comparisonSource: request.comparisonSource
+					});
+					return;
+				}
+				const plan = await request.session.adapter.buildRevisionMultiDiffPlan({
+					workspacePath: request.session.workspacePath,
+					entry,
+					entryIndex: request.entryIndex,
+					comparisonSource: request.comparisonSource,
+					sourceEntries,
+					signal
+				});
+				if (!plan.files.length) {
+					vscode.window.showInformationMessage(`No files changed in ${entry.shortRevision}`);
+					return;
+				}
+				if (!await confirmMultiDiffOpen({
+					title: plan.title,
+					fileCount: plan.files.length
+				})) return;
+				if (signal.aborted) return;
+				await vscode.commands.executeCommand(require_constants.OPEN_MULTI_DIFF_COMMAND, {
+					title: plan.title,
+					resources: await buildMultiDiffResources({
+						workspacePath: request.session.workspacePath,
+						files: plan.files
+					})
+				});
+			}
+		});
+	}
+	async function openRevisionOnRemote(request) {
+		const entry = args.service.getEntriesForSource({
+			session: request.session,
+			comparisonSource: request.comparisonSource
+		})[request.entryIndex];
+		if (!entry?.remoteUrl) {
+			vscode.window.showInformationMessage("No GitHub remote URL is available for this revision.");
+			return;
+		}
+		await vscode.env.openExternal(vscode.Uri.parse(entry.remoteUrl));
+	}
+	async function buildMultiDiffResources(request) {
+		return Promise.all(request.files.map(async (file) => ({
+			originalUri: require_uri_utils.createSnapshotUri({
+				workspacePath: request.workspacePath,
+				revset: file.originalRevset,
+				relativePath: file.relativePath,
+				backend: file.backend
+			}),
+			modifiedUri: await createTargetUri({
+				workspacePath: request.workspacePath,
+				revset: file.modifiedRevset,
+				relativePath: file.relativePath,
+				backend: file.backend
+			})
+		})));
+	}
+	async function confirmMultiDiffOpen(request) {
+		if (request.fileCount <= LARGE_MULTI_DIFF_CONFIRMATION_THRESHOLD) return true;
+		const confirmLabel = `Open ${request.fileCount} diffs`;
+		return await vscode.window.showWarningMessage(`Open ${request.fileCount} file diffs?`, {
+			modal: true,
+			detail: `${request.title} touches a large number of files. Opening every diff at once may be slow and create a lot of editors.`
+		}, confirmLabel) === confirmLabel;
+	}
+	async function createTargetUri(request) {
+		if (request.revset === "@") {
+			const fileUri = vscode.Uri.file(node_path.default.join(request.workspacePath, request.relativePath));
+			if (await vscode.workspace.fs.stat(fileUri).then(() => true, () => false)) return fileUri;
+		}
+		return require_uri_utils.createSnapshotUri({
+			workspacePath: request.workspacePath,
+			revset: request.revset,
+			relativePath: request.relativePath,
+			backend: request.backend
+		});
+	}
+	async function createRevisionUri(request) {
+		if (request.entry.isWorkingTree) {
+			const fileUri = vscode.Uri.file(request.session.absolutePath);
+			if (await vscode.workspace.fs.stat(fileUri).then(() => true, () => false)) return fileUri;
+		}
+		const entryIndex = request.session.entries.findIndex((candidate) => candidate.id === request.entry.id);
+		const resolvedPath = await args.service.resolveEntryFilePath({
+			session: request.session,
+			entry: request.entry,
+			entryIndex
+		});
+		return require_uri_utils.createSnapshotUri({
+			workspacePath: request.session.workspacePath,
+			revset: request.entry.revision,
+			relativePath: resolvedPath,
+			backend: request.session.backend
+		});
+	}
+}
+function getTimelineWebviewHtml(args) {
+	if (!hasBundledTimelineWebviewAssets({ context: args.context })) return `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta http-equiv="Content-Security-Policy" content="default-src 'none';" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Revision Timeline</title>
+  </head>
+  <body>
+    <p>Webview bundle is missing. Run pnpm build:webview and reopen the timeline.</p>
+  </body>
+</html>`;
+	const appStylePath = vscode.Uri.joinPath(args.context.extensionUri, "webview-dist", "timeline-app.css");
+	const appScriptPath = vscode.Uri.joinPath(args.context.extensionUri, "webview-dist", "timeline-app.js");
+	const workerPath = vscode.Uri.joinPath(args.context.extensionUri, "webview-dist", "pierre-worker-portable.js");
+	return require_timeline_template.renderTimelineDocumentHtml({
+		title: "Revision Timeline",
+		cspSource: args.webview.cspSource,
+		styleHref: String(args.webview.asWebviewUri(appStylePath)),
+		appSrc: String(args.webview.asWebviewUri(appScriptPath)),
+		workerSrc: String(args.webview.asWebviewUri(workerPath))
+	});
+}
+function hasBundledTimelineWebviewAssets(args) {
+	const appStylePath = vscode.Uri.joinPath(args.context.extensionUri, "webview-dist", "timeline-app.css");
+	const appScriptPath = vscode.Uri.joinPath(args.context.extensionUri, "webview-dist", "timeline-app.js");
+	return node_fs.default.existsSync(appStylePath.fsPath) && node_fs.default.existsSync(appScriptPath.fsPath);
+}
+function createEmptyTimelineDebugState() {
+	return {
+		panelOpen: false,
+		panelCount: 0,
+		panelTitle: "",
+		backend: "",
+		workspacePath: "",
+		relativePath: "",
+		fileName: "",
+		entryCount: 0,
+		snapshotEntryCount: 0,
+		lineHistory: null,
+		usesBundledWebview: false,
+		viewReady: false,
+		readyCount: 0,
+		lastMessageCommand: "",
+		lastReadyAt: 0,
+		entries: []
+	};
+}
+function createDebugState(args) {
+	return {
+		panelOpen: true,
+		panelCount: args.panelCount,
+		panelTitle: args.panel.title,
+		backend: args.session.backend,
+		workspacePath: args.session.workspacePath,
+		relativePath: args.session.relativePath,
+		fileName: args.session.fileName,
+		entryCount: args.session.entries.length,
+		snapshotEntryCount: args.session.snapshotEntries.length,
+		lineHistory: args.session.lineHistory ? {
+			startLine: args.session.lineHistory.startLine,
+			endLine: args.session.lineHistory.endLine
+		} : null,
+		usesBundledWebview: true,
+		viewReady: false,
+		readyCount: 0,
+		lastMessageCommand: args.lastMessageCommand,
+		lastReadyAt: 0,
+		entries: args.session.entries.map((entry) => ({
+			index: entry.index ?? 0,
+			description: entry.description,
+			shortRevision: entry.shortRevision
+		}))
+	};
+}
+function normalizeComparisonSource(value) {
+	return value === "snapshot" ? "snapshot" : "revision";
+}
+function normalizeThemePreference(value) {
+	return value === "light" || value === "dark" ? value : "auto";
+}
+function normalizeLineDiffType(value) {
+	return value === "word" || value === "char" || value === "none" || value === "word-alt" ? value : "word-alt";
+}
+function normalizeTimelinePreset(value) {
+	return typeof value === "string" && value in require_constants.TIMELINE_PRESET_DAYS ? value : "year";
+}
+async function maximizeTimelinePanel() {
+	try {
+		await vscode.commands.executeCommand("workbench.action.toggleMaximizeEditorGroup");
+	} catch {}
+}
+function shouldMaximizeTimelinePanel() {
+	return getEditorGroupCount() > 1;
+}
+function getTimelineViewColumn() {
+	return shouldMaximizeTimelinePanel() ? vscode.ViewColumn.Beside : vscode.ViewColumn.Active;
+}
+function getEditorGroupCount() {
+	const groups = vscode.window.tabGroups?.all;
+	return Array.isArray(groups) && groups.length ? groups.length : 1;
+}
+//#endregion
+exports.createTimelinePanelController = createTimelinePanelController;
+
+//# sourceMappingURL=timeline-panel.cjs.map