@moritzwilksch/diffle 0.1.8 → 0.2.0

package/dist/server/main.js

@@ -11,6 +11,7 @@ import { copyFile, lstat, mkdir, mkdtemp, open, readFile, readlink, realpath, re
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { homedir, hostname, tmpdir } from "node:os";
 import { createServer } from "node:http";
+import { getAssetKeys, getRawAsset, isSea } from "node:sea";
 import { Http2ServerRequest, constants as constants$1 } from "http2";
 import { Readable } from "stream";
 import crypto from "crypto";
@@ -3951,7 +3952,7 @@ function generateCompletion(program, { shell, executable = program.name() }) {
 }
 //#endregion
 //#region package.json
-var version$1 = "0.1.8";
+var version$1 = "0.2.0";
 //#endregion
 //#region src/server/comments/anchor.ts
 function splitLines(contents) {
@@ -4108,6 +4109,12 @@ function patchArgs(oldRev) {
 }
 /** An idle `cat-file --batch` is reaped after this long; the next request respawns one. */
 const CAT_FILE_IDLE_MS = 2e3;
+/**
+* `git range-diff` pairs two commits while the diff between their patches costs less than this
+* percentage of a patch's size. Git's default of 60 leaves a reworded three-line commit unpaired,
+* since the message change alone outweighs it; at 100 the message may change as much as the patch.
+*/
+const CREATION_FACTOR = 100;
 var GitError = class extends Error {
 	args;
 	code;
@@ -4184,6 +4191,16 @@ var GitRepo = class GitRepo {
 			`${rev}^{commit}`
 		])).trim();
 	}
+	/** The tree a commit points at. */
+	async tree(rev) {
+		return (await this.text([
+			"rev-parse",
+			"--verify",
+			"--quiet",
+			"--end-of-options",
+			`${rev}^{tree}`
+		])).trim();
+	}
 	/** Commit messages for two ancestor offsets, pinned to one HEAD. */
 	async lastCommitsPreview(oldOffset, newOffset) {
 		const head = await this.commitInfo("HEAD");
@@ -4198,6 +4215,7 @@ var GitRepo = class GitRepo {
 			new: next
 		};
 	}
+	/** A commit's hash, abbreviation and full message; null when `rev` names no commit. */
 	async commitInfo(rev) {
 		let sha;
 		try {
@@ -4221,6 +4239,66 @@ var GitRepo = class GitRepo {
 			message: output.slice(separator + 1).trimEnd()
 		};
 	}
+	/**
+	* `sha`'s first parent, and the commit toward HEAD whose first parent it is. The
+	* child is null at HEAD, on an unborn branch, or when `sha` is off HEAD's
+	* first-parent line, e.g. on a merged side branch.
+	*/
+	async commitNeighbours(sha) {
+		const [parent, list] = await Promise.all([this.resolve(`${sha}^`).catch((e) => {
+			if (e instanceof GitError && e.code === 1) return null;
+			throw e;
+		}), this.text([
+			"rev-list",
+			"--first-parent",
+			"--ancestry-path",
+			"--parents",
+			`${sha}..HEAD`,
+			"--"
+		]).catch(() => "")]);
+		const [child, firstParent] = list.trim().split("\n").pop()?.split(" ") ?? [];
+		return {
+			parent,
+			child: child && firstParent === sha ? child : null
+		};
+	}
+	/** The commits a revision range such as `a..b` or `c^!` selects, oldest first: the newest `limit`, and the total. */
+	async rangeCommits(range, limit) {
+		const [count, log] = await Promise.all([this.text([
+			"rev-list",
+			"--count",
+			"--end-of-options",
+			range,
+			"--"
+		]), this.text([
+			"log",
+			"-z",
+			"--no-show-signature",
+			"--reverse",
+			`--max-count=${limit}`,
+			"--format=%H%x00%h%x00%an%x00%ae%x00%at%x00%B",
+			"--end-of-options",
+			range,
+			"--"
+		])]);
+		const fields = log.split("\0");
+		const list = [];
+		for (let i = 0; i + 5 < fields.length; i += 6) {
+			const [sha = "", short = "", author = "", email = "", time = "", message = ""] = fields.slice(i, i + 6);
+			list.push({
+				sha,
+				short,
+				message: message.trimEnd(),
+				author,
+				email,
+				date: Number(time) * 1e3
+			});
+		}
+		return {
+			list,
+			total: Number(count.trim())
+		};
+	}
 	/** The empty tree under the repository's hash algorithm: the old side of an unborn branch. */
 	async emptyTree() {
 		return (await this.text([
@@ -4238,6 +4316,89 @@ var GitRepo = class GitRepo {
 			b
 		])).trim();
 	}
+	/**
+	* Replays what `head` changed since `base` onto `onto`, in memory: the resulting tree, and the
+	* paths the merge could not settle, which the tree holds with conflict markers. `--write-tree`
+	* needs git 2.38. With `-z`, the tree, each conflicted path and the sections end in NUL.
+	*/
+	async replay(base, onto, head) {
+		const [tree = "", ...rest] = (await this.text([
+			"merge-tree",
+			"--write-tree",
+			"-z",
+			"--name-only",
+			`--merge-base=${base}`,
+			"--end-of-options",
+			onto,
+			head
+		], { okCodes: [1] })).split("\0");
+		const conflicts = [];
+		for (const path of rest) {
+			if (path === "") break;
+			conflicts.push(path);
+		}
+		return {
+			tree,
+			conflicts
+		};
+	}
+	/**
+	* How `git range-diff` pairs the commits of two ranges, in its output order: abbreviated
+	* hashes, null for the side a commit has no counterpart on, and its marker (`=` identical,
+	* `!` changed, `<` only in the first range, `>` only in the second). Summary only, no patches.
+	* Ranges are given as hashes: range-diff learnt `--end-of-options` only in git 2.44.
+	*/
+	async rangeDiff(oldRange, newRange) {
+		const out = await this.text([
+			"range-diff",
+			"-s",
+			"--no-color",
+			`--creation-factor=${CREATION_FACTOR}`,
+			oldRange,
+			newRange
+		]);
+		const pairs = [];
+		for (const line of out.split("\n")) {
+			const m = /^\s*(?:\d+:\s+([0-9a-f]+)|-:\s+-+)\s+([=!<>])\s+(?:\d+:\s+([0-9a-f]+)|-:\s+-+)\s/.exec(line);
+			if (m) pairs.push({
+				old: m[1] ?? null,
+				new: m[3] ?? null,
+				marker: m[2]
+			});
+		}
+		return pairs;
+	}
+	/** Each commit's stable patch id, so two commits with the same change under different messages compare equal. */
+	async patchIds(shas) {
+		const ids = /* @__PURE__ */ new Map();
+		if (!shas.length) return ids;
+		const patches = await this.exec([
+			"log",
+			"-p",
+			"--no-walk",
+			"--no-show-signature",
+			"--format=%H",
+			"--end-of-options",
+			...shas
+		]);
+		for (const line of (await this.text(["patch-id", "--stable"], { input: patches })).split("\n")) {
+			const [id, sha] = line.split(" ");
+			if (id && sha) ids.set(sha, id);
+		}
+		return ids;
+	}
+	/**
+	* Points refs at objects so they survive `gc` and a force-push, or with null deletes them. Refs
+	* must stay inside `refs/diffle/iterations/`: nothing the user owns moves.
+	*/
+	async pin(refs) {
+		const lines = [];
+		for (const [ref, sha] of Object.entries(refs)) {
+			if (!ref.startsWith("refs/diffle/iterations/")) throw new GitError(`refusing to update ${ref}`, ["update-ref"], null, "");
+			lines.push(sha === null ? `delete ${ref}\n` : `update ${ref} ${sha}\n`);
+		}
+		if (lines.length) await this.exec(["update-ref", "--stdin"], { input: lines.join("") });
+	}
 	/** origin/HEAD → main → master. */
 	async defaultBranch() {
 		try {
@@ -11828,6 +11989,20 @@ const ZodRecord = /*@__PURE__*/ $constructor("ZodRecord", (inst, def) => {
 	inst.keyType = def.keyType;
 	inst.valueType = def.valueType;
 });
+function record(keyType, valueType, params) {
+	if (!valueType || !valueType._zod) return new ZodRecord({
+		type: "record",
+		keyType: string(),
+		valueType: keyType,
+		...normalizeParams(valueType)
+	});
+	return new ZodRecord({
+		type: "record",
+		keyType,
+		valueType,
+		...normalizeParams(params)
+	});
+}
 function partialRecord(keyType, valueType, params) {
 	return new ZodRecord({
 		type: "record",
@@ -12099,14 +12274,48 @@ const ModeRequestSchema = discriminatedUnion("kind", [
 	object({
 		kind: literal("revspec"),
 		args: string().array()
+	}),
+	object({
+		kind: literal("focus"),
+		commit: string().nullable()
+	}),
+	object({
+		kind: literal("interdiff"),
+		from: number().int().positive(),
+		to: number().int().positive()
+	}),
+	object({
+		kind: literal("pair"),
+		commit: string().nullable()
 	})
 ]);
-/** A comparison; both endpoints accept a Git revision or "worktree". */
-const ModeSpecSchema = object({
+/**
+* One state of a reviewed range: its resolved endpoints when a snapshot of it was taken. A new
+* one is recorded whenever the endpoints differ from the last, so a push, rebase or amend
+* yields the next iteration; the commits are pinned under `refs/diffle/iterations/`.
+*/
+const IterationSchema = object({
+	/** 1-based, in recording order. */
+	n: number(),
+	oldSha: string(),
+	newSha: string(),
+	/** Epoch milliseconds. */
+	recordedAt: number()
+});
+/**
+* How the old side is derived: `old` itself, merge-base(old, new) with worktree
+* taken as HEAD, or new's first parent (the empty tree for a root commit).
+*/
+const ComparisonBaseSchema = _enum([
+	"direct",
+	"merge-base",
+	"parent"
+]);
+/** A comparison; both endpoints accept a Git revision or "worktree". Under `parent`, both name the one commit. */
+const ComparisonSchema = object({
 	old: string(),
 	new: string(),
-	/** Compare merge-base(old, new) to new; worktree uses HEAD for the merge base. */
-	mergeBase: boolean(),
+	base: ComparisonBaseSchema,
 	live: _enum([
 		"worktree",
 		"refs",
@@ -12115,10 +12324,88 @@ const ModeSpecSchema = object({
 	/** Fixed when the comparison is entered; discovery never changes comment storage. */
 	commentKey: string()
 });
-/** Display comparison endpoints with branch names instead of internal ref namespaces. */
+const CommitInfoSchema = object({
+	sha: string(),
+	short: string(),
+	message: string()
+});
+/** A single reviewed commit and its neighbours along HEAD's first-parent history, for stepping through it. */
+const ReviewedCommitSchema = CommitInfoSchema.extend({
+	/** First parent; null for a root commit. */
+	parent: string().nullable(),
+	/** The commit whose first parent this is, toward HEAD; null at HEAD or off HEAD's first-parent line. */
+	child: string().nullable()
+});
+/** One commit of the compared range. */
+const RangeCommitSchema = CommitInfoSchema.extend({
+	author: string(),
+	email: string(),
+	/** Author date, epoch milliseconds. */
+	date: number()
+});
+/** How a commit of the older iteration relates to one of the newer, as `git range-diff` pairs them. */
+const PairStatusSchema = _enum([
+	"identical",
+	"changed",
+	"message",
+	"added",
+	"dropped"
+]);
+/**
+* One row of a range-diff: `identical` and `changed` pairs have both commits, a `message` pair
+* the same patch under a new message, an `added` commit no old side and a `dropped` one no new side.
+*/
+const RangePairSchema = object({
+	old: RangeCommitSchema.nullable(),
+	new: RangeCommitSchema.nullable(),
+	status: PairStatusSchema
+});
+/**
+* Two iterations of a range compared. The old side is `from`'s head replayed onto `to`'s base
+* (a tree, not a commit), so a rebase in between does not show up as the upstream's changes;
+* the new side is `to`'s head.
+*/
+const InterdiffSchema = object({
+	from: IterationSchema,
+	to: IterationSchema,
+	/** Paths the replay could not merge; they carry conflict markers on the old side. */
+	conflicts: string().array(),
+	/** The two ranges' commits paired, in `git range-diff` order: the newer range's, dropped commits where they were. */
+	pairs: RangePairSchema.array()
+});
+/**
+* One pair of an interdiff shown alone: `new` against `old` replayed onto `new`'s parent, so the
+* pair's own amendments show without the rebase; an added commit (`old` null) against its parent.
+*/
+const PairSpecSchema = object({
+	old: string().nullable(),
+	new: string(),
+	conflicts: string().array()
+});
+const ModeSpecSchema = ComparisonSchema.extend({
+	/** Set while one commit of a range is focused, or two of its iterations compared: the range, whose commits the snapshot keeps listing. */
+	within: ComparisonSchema.optional(),
+	interdiff: InterdiffSchema.optional(),
+	/** Set with `interdiff` while one of its pairs is shown. */
+	pair: PairSpecSchema.optional()
+});
+/**
+* Display comparison endpoints with branch names instead of internal ref namespaces; a single commit as
+* `<sha>^!`, as `<range> @ <sha>` when focused within a range, as `<range> #1→#2` for an interdiff and
+* `<range> #1→#2 @ <sha>` for one of its pairs.
+*/
 function comparisonLabel(mode) {
-	const name = (rev) => rev.replace(/^refs\/diffle\/[^/]+\/\d+\/(?:base|head)\//, "").replace(/^refs\/(?:heads|remotes)\//, "");
-	return `${name(mode.old)}${mode.mergeBase ? "..." : ".."}${name(mode.new)}`;
+	if (mode.within && mode.interdiff) {
+		const label = `${comparisonLabel(mode.within)} #${mode.interdiff.from.n}→#${mode.interdiff.to.n}`;
+		return mode.pair ? `${label} @ ${mode.pair.new.slice(0, 7)}` : label;
+	}
+	if (mode.within) return `${comparisonLabel(mode.within)} @ ${mode.new.slice(0, 7)}`;
+	if (mode.base === "parent") return `${mode.new.slice(0, 7)}^!`;
+	return `${refName(mode.old)}${mode.base === "merge-base" ? "..." : ".."}${refName(mode.new)}`;
+}
+/** A comparison endpoint as the user named it: without diffle's PR namespace or `refs/heads/`. */
+function refName(rev) {
+	return rev.replace(/^refs\/diffle\/[^/]+\/\d+\/(?:base|head)\//, "").replace(/^refs\/(?:heads|remotes)\//, "");
 }
 const GithubPullRequestSchema = object({
 	repository: string(),
@@ -12168,6 +12455,18 @@ const ChangedFileSchema = object({
 	/** A gitlink (mode 160000): `blob` is the recorded commit, the patch shows the commit-id change, and there is no file to open. */
 	submodule: literal(true).optional()
 });
+/**
+* The commits a comparison spans: old..new, with the worktree taken as HEAD, or the one commit under `parent`.
+* A focused commit lists its range's.
+*/
+const RangeCommitsSchema = object({
+	/** Oldest first; the newest MAX_RANGE_COMMITS when there are more. */
+	list: RangeCommitSchema.array(),
+	total: number(),
+	/** The spanned comparison's resolved endpoints: the snapshot's own, or the range's when a commit is focused. */
+	oldSha: string(),
+	newSha: string()
+});
 object({
 	root: string(),
 	mode: ModeSpecSchema,
@@ -12182,7 +12481,23 @@ object({
 	context: number(),
 	changed: ChangedFileSchema.array(),
 	/** All paths on the new side: the new commit's tree, or index ∪ untracked for the worktree. Sorted. */
-	tree: string().array()
+	tree: string().array(),
+	/** The reviewed commit when the comparison is a single commit against its parent; otherwise null. */
+	commit: ReviewedCommitSchema.nullable(),
+	commits: RangeCommitsSchema,
+	/** The recorded iterations of the range `commits` spans, oldest first; empty for comparisons that are not followed. */
+	iterations: IterationSchema.array()
+});
+/**
+* The compared refs resolve elsewhere than when the shown snapshot was taken. A refs-live
+* comparison is not recomputed under the reviewer; it reloads on request.
+*/
+const MovedSchema = object({
+	/** The snapshot a reload would supersede. */
+	version: number(),
+	/** Where the comparison `Snapshot.commits` spans resolves now. */
+	oldSha: string(),
+	newSha: string()
 });
 /** Body of `POST /api/patch`: the changed files whose patches to return, concatenated. Unknown paths are skipped. */
 const PatchRequestSchema = object({ paths: string().array().max(200) });
@@ -12279,11 +12594,6 @@ const ViewedEntrySchema = object({
 	blob: string(),
 	viewed: boolean()
 });
-const CommitInfoSchema = object({
-	sha: string(),
-	short: string(),
-	message: string()
-});
 object({
 	old: CommitInfoSchema.nullable(),
 	new: CommitInfoSchema.nullable()
@@ -12319,11 +12629,24 @@ object({
 	matches: SearchMatchSchema.array(),
 	truncated: boolean()
 });
+/**
+* How a review between refs reacts when one of them moves. `on`: recompute at once, as a worktree
+* review follows edits. `off`: announce the move and wait for Reload. `auto`: wait for Reload when an
+* endpoint names a branch, whose pushes and rebases should not swap the review out under the
+* reviewer; recompute at once otherwise (a detached HEAD, a tag, an expression).
+*/
+const FollowRefsSchema = _enum([
+	"on",
+	"auto",
+	"off"
+]);
 object({
 	/** Globs (picomatch syntax) for files that start viewed + collapsed. Empty by default. */
 	autoViewed: string().array(),
 	/** Unchanged lines shown around each change (git -U). Default 5. */
 	contextLines: number(),
+	/** When a review between refs recomputes as its refs move; see `FollowRefsSchema`. Default auto. */
+	followRefs: FollowRefsSchema,
 	/**
 	* Language server command per language, replacing the built-in candidate for it; an empty
 	* string disables the language. Read-only over HTTP; set with `diffle config set-lsp`.
@@ -12333,6 +12656,7 @@ object({
 const DEFAULT_USER_CONFIG = {
 	autoViewed: [],
 	contextLines: 5,
+	followRefs: "auto",
 	lspCommands: {}
 };
 /** A point in a new-side file. LSP semantics: the column counts UTF-16 units, like a JS string index. */
@@ -12403,6 +12727,18 @@ object({
 object({ 
 /** Null when the position is not inside a token or the server does not classify tokens. */
 kind: string().nullable() });
+object({ occurrences: object({
+	line: number().int().positive(),
+	col: number().int().nonnegative(),
+	endLine: number().int().positive(),
+	endCol: number().int().nonnegative(),
+	/** LSP DocumentHighlightKind: a plain textual match, a read, or a write. */
+	kind: _enum([
+		"text",
+		"read",
+		"write"
+	])
+}).array() });
 object({
 	name: string(),
 	/** LSP SymbolKind number; the client maps it to a label. */
@@ -12425,6 +12761,10 @@ discriminatedUnion("type", [
 		type: literal("snapshot"),
 		version: number()
 	}),
+	object({
+		type: literal("moved"),
+		moved: MovedSchema.nullable()
+	}),
 	object({ type: literal("threads") }),
 	object({ type: literal("viewed") }),
 	object({ type: literal("config") }),
@@ -12518,7 +12858,8 @@ function noServer(lsp, language) {
 /** Writable HTTP config fields; unknown keys, including CLI-only lspCommands, are stripped. */
 const ConfigUpdateSchema = object({
 	autoViewed: string().array().optional(),
-	contextLines: number().int().min(0).max(1e4).optional()
+	contextLines: number().int().min(0).max(1e4).optional(),
+	followRefs: FollowRefsSchema.optional()
 });
 const ResolvedRequestSchema = object({ resolved: boolean() });
 const ViewedBulkRequestSchema = object({ entries: ViewedEntrySchema.array() });
@@ -12564,6 +12905,76 @@ const ClearThreadsQuerySchema = object({ stale: literal("1").optional() });
 const PatchQuerySchema = object({ path: string().optional() });
 object({ error: string() });
 //#endregion
+//#region src/shared/fuzzy.ts
+const MATCH = 1;
+const WORD_START = 8;
+const CONSECUTIVE = 4;
+const GAP = 1;
+/**
+* Score `candidate` against `query`, matched case-insensitively as an ordered subsequence;
+* null when it does not match. Higher is better: matches at word starts (after `_-./`, camelCase
+* humps, digit runs) and unbroken runs count most, so `AbsBuiFa` finds `AbstractBuilderFactory`
+* and `evruca` finds `evaluate_run_cases.py`.
+*/
+function fuzzyScore(query, candidate) {
+	const q = Array.from(query.toLowerCase());
+	const chars = Array.from(candidate);
+	const n = q.length;
+	const m = chars.length;
+	if (n === 0) return 0;
+	if (n > m) return null;
+	const lower = chars.map((ch) => ch.toLowerCase());
+	const bonus = chars.map((ch, j) => MATCH + wordStart(chars[j - 1], ch));
+	let prev = new Float64Array(m).fill(-Infinity);
+	for (let i = 0; i < n; i++) {
+		const cur = new Float64Array(m).fill(-Infinity);
+		let carry = -Infinity;
+		for (let j = i; j < m; j++) {
+			if (i > 0) carry = Math.max(carry - GAP, prev[j - 1]);
+			if (lower[j] !== q[i]) continue;
+			cur[j] = (i === 0 ? 0 : Math.max(carry, prev[j - 1] + CONSECUTIVE)) + bonus[j];
+		}
+		prev = cur;
+	}
+	const best = Math.max(...prev);
+	return best === -Infinity ? null : best;
+}
+function wordStart(before, ch) {
+	if (before === void 0) return 10;
+	if (!ALNUM.test(before)) return WORD_START;
+	if (UPPER.test(ch) && !UPPER.test(before)) return WORD_START;
+	if (DIGIT.test(ch) && !DIGIT.test(before)) return WORD_START;
+	return 0;
+}
+const ALNUM = /[\p{L}\p{N}]/u;
+const UPPER = /\p{Lu}/u;
+const DIGIT = /\p{N}/u;
+/**
+* `items` whose `key` matches `query`, best first; ties prefer the shorter key, then input order.
+* A blank query keeps every item in order.
+*/
+function fuzzyFilter(items, query, key) {
+	const q = query.trim();
+	if (!q) return [...items];
+	const scored = [];
+	for (const item of items) {
+		const k = key(item);
+		const score = fuzzyScore(q, k);
+		if (score !== null) scored.push({
+			item,
+			score,
+			length: k.length
+		});
+	}
+	return scored.sort((a, b) => b.score - a.score || a.length - b.length).map((s) => s.item);
+}
+/** `fuzzyFilter`'s order, followed by the items it rejects in input order: re-ranks hits another matcher chose. */
+function fuzzyRank(items, query, key) {
+	const matched = fuzzyFilter(items, query, key);
+	const kept = new Set(matched);
+	return [...matched, ...items.filter((item) => !kept.has(item))];
+}
+//#endregion
 //#region src/server/lsp/hover.ts
 /**
 * One markdown document for the tooltip, or null when the server sent nothing
@@ -13133,6 +13544,30 @@ var LspBridge = class LspBridge {
 		}
 		return { kind: null };
 	}
+	/**
+	* Where else the symbol at `pos` occurs in its file, via `textDocument/documentHighlight`,
+	* so scope and shadowing are the server's call. A server without the method, or a
+	* position holding no symbol, yields no occurrences: the answer is advisory.
+	*/
+	async occurrences(pos) {
+		let result;
+		try {
+			result = await this.query("textDocument/documentHighlight", {
+				textDocument: { uri: this.uri(pos.path) },
+				position: toLsp(pos)
+			}, pos.path);
+		} catch (e) {
+			if (e instanceof LspUnavailableError) throw e;
+			return { occurrences: [] };
+		}
+		return { occurrences: (result ?? []).map(({ range: { start, end }, kind }) => ({
+			line: start.line + 1,
+			col: start.character,
+			endLine: end.line + 1,
+			endCol: end.character,
+			kind: kind === 3 ? "write" : kind === 2 ? "read" : "text"
+		})) };
+	}
 	async references(pos, opts = {}) {
 		const result = await this.query("textDocument/references", {
 			textDocument: { uri: this.uri(pos.path) },
@@ -13215,7 +13650,7 @@ var LspBridge = class LspBridge {
 	}
 	/**
 	* Symbols the server knows for `query`, limited to paths the snapshot
-	* exposes. Membership comes from `has`, never from reading the file: a
+	* exposes, best `fuzzyRank` match first. Membership comes from `has`, never from reading the file: a
 	* per-keystroke search must not read every hit's text.
 	*/
 	async workspaceSymbols(query, limit = 200) {
@@ -13227,7 +13662,7 @@ var LspBridge = class LspBridge {
 		const seen = /* @__PURE__ */ new Set();
 		result.forEach((s, i) => {
 			const path = paths[i];
-			if (path == null || !inside.get(path) || out.length >= limit) return;
+			if (path == null || !inside.get(path)) return;
 			const start = "range" in s.location ? s.location.range.start : {
 				line: 0,
 				character: 0
@@ -13246,7 +13681,7 @@ var LspBridge = class LspBridge {
 				col: start.character
 			});
 		});
-		return out;
+		return fuzzyRank(out, query, (s) => s.name).slice(0, limit);
 	}
 	/**
 	* Contents of a file outside the snapshot that a recent result named as
@@ -13360,6 +13795,7 @@ var LspBridge = class LspBridge {
 						definition: { linkSupport: true },
 						typeDefinition: { linkSupport: true },
 						references: {},
+						documentHighlight: {},
 						hover: { contentFormat: ["markdown", "plaintext"] },
 						documentSymbol: { hierarchicalDocumentSymbolSupport: true },
 						semanticTokens: {
@@ -13945,11 +14381,14 @@ var LspPool = class {
 	async references(pos) {
 		return this.bridgeFor(pos.path).references(pos);
 	}
+	async occurrences(pos) {
+		return this.bridgeFor(pos.path).occurrences(pos);
+	}
 	async documentSymbols(path) {
 		return this.bridgeFor(path).documentSymbols(path);
 	}
 	/**
-	* Symbols matching `query` from every running server, in server order. One server
+	* Symbols matching `query` from every running server, best `fuzzyRank` match first. One server
 	* failing drops its share; only an outage everywhere is an error.
 	*/
 	async workspaceSymbols(query, limit = 200) {
@@ -13959,7 +14398,7 @@ var LspPool = class {
 		const out = results.flatMap((r) => r.status === "fulfilled" ? r.value : []);
 		const failed = results.find((r) => r.status === "rejected");
 		if (!out.length && failed) throw failed.reason;
-		return out.slice(0, limit);
+		return fuzzyRank(out, query, (s) => s.name).slice(0, limit);
 	}
 	/**
 	* Keeps the diff's files open in the server for their language, starting one for each
@@ -14044,6 +14483,7 @@ const WORKTREE = "worktree";
 *   "a..b"   → a vs b
 *   "a...b"  → merge-base(a, b) vs b
 *   "a" "b"  → a vs b
+*   "a^!"    → a vs its first parent: the one commit, as git show shows it
 * Empty sides default to HEAD. Either side accepts "worktree" for the uncommitted
 * tree; a merge base against it is taken against HEAD, the commit it sits on.
 */
@@ -14052,34 +14492,45 @@ function parseRevspec(args) {
 	if (args.length === 2) {
 		const [a, b] = args;
 		if (a.includes("..") || b.includes("..")) throw new RevspecError("cannot combine \"..\" with two revisions");
+		if (a.endsWith("^!") || b.endsWith("^!")) throw new RevspecError("cannot combine \"^!\" with two revisions");
 		return {
 			old: a,
 			new: b,
-			mergeBase: false
+			base: "direct"
 		};
 	}
 	const arg = args[0];
+	if (arg.endsWith("^!")) {
+		const commit = arg.slice(0, -2) || "HEAD";
+		if (commit.includes("..")) throw new RevspecError("cannot combine \"^!\" with \"..\"");
+		if (commit === WORKTREE) throw new RevspecError("the worktree is not a commit");
+		return {
+			old: commit,
+			new: commit,
+			base: "parent"
+		};
+	}
 	const three = arg.indexOf("...");
 	if (three !== -1) return {
 		old: arg.slice(0, three) || "HEAD",
 		new: arg.slice(three + 3) || "HEAD",
-		mergeBase: true
+		base: "merge-base"
 	};
 	const two = arg.indexOf("..");
 	if (two !== -1) return {
 		old: arg.slice(0, two) || "HEAD",
 		new: arg.slice(two + 2) || "HEAD",
-		mergeBase: false
+		base: "direct"
 	};
 	if (arg === WORKTREE) return {
 		old: "HEAD",
 		new: WORKTREE,
-		mergeBase: false
+		base: "direct"
 	};
 	return {
 		old: arg,
 		new: "HEAD",
-		mergeBase: true
+		base: "merge-base"
 	};
 }
 var RevspecError = class extends Error {};
@@ -17418,6 +17869,14 @@ function createApi(deps) {
 		await next();
 	});
 	app.get("/api/snapshot", async (c) => c.json(await session.snapshotter.current()));
+	app.get("/api/moved", (c) => c.json(session.moved));
+	app.post("/api/reload", async (c) => c.json(await session.reload()));
+	app.delete("/api/iterations", async (c) => c.json(await session.clearIterations()));
+	app.delete("/api/iterations/:n", async (c) => {
+		const n = Number(c.req.param("n"));
+		if (!Number.isInteger(n) || n < 1) throw new RevspecError(`not an iteration number: ${c.req.param("n")}`);
+		return c.json(await session.deleteIteration(n));
+	});
 	app.post("/api/mode", async (c) => {
 		const req = ModeRequestSchema.parse(await readJson(c));
 		return c.json(await session.switchMode(req));
@@ -17613,6 +18072,12 @@ function createApi(deps) {
 		if ("error" in r) return c.json({ error: r.error }, 409);
 		return c.json(await r.lsp.references(pos));
 	});
+	app.post("/api/lsp/occurrences", async (c) => {
+		const pos = LspPositionSchema.parse(await readJson(c));
+		const r = await lspFor(pos.path);
+		if ("error" in r) return c.json({ error: r.error }, 409);
+		return c.json(await r.lsp.occurrences(pos));
+	});
 	app.get("/api/lsp/symbols", async (c) => {
 		const { path, q: query } = SymbolsQuerySchema.parse(c.req.query());
 		const r = await lspFor(path);
@@ -17625,6 +18090,7 @@ function createApi(deps) {
 		await deps.config.set(body);
 		hub.broadcast({ type: "config" });
 		if (body.contextLines != null) await session.setContext(deps.config.get().contextLines);
+		if (body.followRefs != null) session.setFollowRefs(deps.config.get().followRefs);
 		return c.json(effectiveConfig(deps));
 	});
 	return app;
@@ -17705,7 +18171,8 @@ var Server = class {
 		app.use("/api/*", compress());
 		app.route("/", createApi(this.deps));
 		app.all("/api/*", (c) => c.json({ error: "API endpoint not found. Restart diffle to load the latest server." }, 404));
-		if (!this.opts.dev) {
+		if (!this.opts.dev && isSea()) app.get("*", serveEmbedded);
+		else if (!this.opts.dev) {
 			const clientDir = resolveClientDir();
 			app.use("*", serveStatic({ root: clientDir }));
 			app.get("*", serveStatic({
@@ -17792,7 +18259,14 @@ function resolveClientDir() {
 	return join(projectRoot(), "dist", "client");
 }
 function hasClientBuild() {
-	return existsSync(join(resolveClientDir(), "index.html"));
+	return isSea() || existsSync(join(resolveClientDir(), "index.html"));
+}
+const embedded = isSea() ? new Set(getAssetKeys()) : /* @__PURE__ */ new Set();
+function serveEmbedded(c) {
+	const path = c.req.path.slice(1);
+	const key = embedded.has(path) ? path : "index.html";
+	const type = getMimeType(key) ?? "application/octet-stream";
+	return c.body(new Uint8Array(getRawAsset(key)), 200, { "content-type": type });
 }
 //#endregion
 //#region src/server/github/pulls.ts
@@ -18296,6 +18770,102 @@ function describe(skipped) {
 	for (const s of skipped) counts.set(s.reason, (counts.get(s.reason) ?? 0) + 1);
 	return [...counts].map(([reason, n]) => `${n} ${reason}`).join(", ");
 }
+const FileSchema = object({
+	version: literal(1),
+	ranges: record(string(), IterationSchema.array())
+});
+/**
+* The iterations of one range, under its comment key in `<gitDir>/diffle/iterations.json`.
+* Like the comment store, nothing is cached: every mutation is a read-modify-write of fresh
+* disk state under the file lock, so two servers on one repository keep each other's records.
+* Each iteration's commits are pinned under `refs/diffle/iterations/<key hash>/<n>/{old,new}`.
+*/
+var IterationStore = class {
+	repo;
+	key;
+	file;
+	refs;
+	constructor(repo, key) {
+		this.repo = repo;
+		this.key = key;
+		this.file = join(repo.gitDir, "diffle", "iterations.json");
+		this.refs = `refs/diffle/iterations/${createHash("sha1").update(key).digest("hex").slice(0, 16)}`;
+	}
+	/** Oldest first. */
+	async list() {
+		return (await read(this.file)).ranges[this.key] ?? [];
+	}
+	/** The iteration numbered `n`, or null. */
+	async get(n) {
+		return (await this.list()).find((it) => it.n === n) ?? null;
+	}
+	/**
+	* Records the endpoints as the next iteration, unless the latest already has them. Returns
+	* the list afterwards. Pins the commits first, so a recorded iteration is always reachable.
+	*/
+	async record(oldSha, newSha) {
+		return withFileLock(this.file, async () => {
+			const all = await read(this.file);
+			const list = all.ranges[this.key] ?? [];
+			const last = list.at(-1);
+			if (last && last.oldSha === oldSha && last.newSha === newSha) return list;
+			const n = (last?.n ?? 0) + 1;
+			const next = [...list, {
+				n,
+				oldSha,
+				newSha,
+				recordedAt: Date.now()
+			}];
+			const dropped = next.splice(0, Math.max(0, next.length - 50));
+			await this.repo.pin({
+				[`${this.refs}/${n}/old`]: oldSha,
+				[`${this.refs}/${n}/new`]: newSha,
+				...Object.fromEntries(dropped.flatMap((it) => [[`${this.refs}/${it.n}/old`, null], [`${this.refs}/${it.n}/new`, null]]))
+			});
+			all.ranges[this.key] = next;
+			await writeFileAtomic(this.file, JSON.stringify(all, null, 2) + "\n");
+			return next;
+		});
+	}
+	/** Forgets the iteration numbered `n`, if recorded, and unpins its commits. The rest keep their numbers. */
+	async remove(n) {
+		return withFileLock(this.file, async () => {
+			const all = await read(this.file);
+			const list = all.ranges[this.key] ?? [];
+			if (!list.some((it) => it.n === n)) return list;
+			await this.repo.pin({
+				[`${this.refs}/${n}/old`]: null,
+				[`${this.refs}/${n}/new`]: null
+			});
+			const next = list.filter((it) => it.n !== n);
+			if (next.length) all.ranges[this.key] = next;
+			else delete all.ranges[this.key];
+			await writeFileAtomic(this.file, JSON.stringify(all, null, 2) + "\n");
+			return next;
+		});
+	}
+	/** Forgets every iteration of this range and unpins their commits. */
+	async clear() {
+		await withFileLock(this.file, async () => {
+			const all = await read(this.file);
+			const list = all.ranges[this.key] ?? [];
+			await this.repo.pin(Object.fromEntries(list.flatMap((it) => [[`${this.refs}/${it.n}/old`, null], [`${this.refs}/${it.n}/new`, null]])));
+			delete all.ranges[this.key];
+			await writeFileAtomic(this.file, JSON.stringify(all, null, 2) + "\n");
+		});
+	}
+};
+async function read(file) {
+	try {
+		return FileSchema.parse(JSON.parse(await readFile(file, "utf8")));
+	} catch (e) {
+		if (e.code === "ENOENT") return {
+			version: 1,
+			ranges: {}
+		};
+		throw e;
+	}
+}
 //#endregion
 //#region src/server/mode.ts
 /**
@@ -18307,36 +18877,43 @@ function describe(skipped) {
 *   A--B--C  main
 *       \--D--E  HEAD
 *
-*   old       new       mergeBase   oldSha      newSha     live
-*   main      HEAD      false       C           E          refs
-*   main      HEAD      true        B           E          refs
-*   HEAD      worktree  false       E           worktree   worktree
-*   worktree  HEAD      false       worktree    E          worktree
-*   main      worktree  true        B           worktree   worktree
-*   <C hash>  <E hash>  false       C           E          none
+*   old       new       base        oldSha      newSha     live
+*   main      HEAD      direct      C           E          refs
+*   main      HEAD      merge-base  B           E          refs
+*   HEAD      worktree  direct      E           worktree   worktree
+*   worktree  HEAD      direct      worktree    E          worktree
+*   main      worktree  merge-base  B           worktree   worktree
+*   <C hash>  <E hash>  direct      C           E          none
+*   <E hash>  <E hash>  parent      D           E          none
 *
-* mergeBase replaces only the old endpoint with the common ancestor, using
-* HEAD for any worktree input. live is "worktree" if either input is worktree,
-* "none" if both inputs are pinned hashes, and "refs" otherwise.
+* merge-base replaces only the old endpoint with the common ancestor, using
+* HEAD for any worktree input; parent replaces it with new's first parent, or
+* the empty tree for a root commit. live is "worktree" if either input is
+* worktree, "none" if both inputs are pinned hashes, and "refs" otherwise.
 *
 * In an unborn repository, HEAD compared directly with worktree resolves to
 * the empty tree. Invalid revisions or missing merge bases throw RevspecError.
 */
 async function resolveComparison(repo, comparison) {
+	if (comparison.interdiff && comparison.base !== "parent") return {
+		oldSha: comparison.old,
+		newSha: comparison.new,
+		live: "none"
+	};
 	const endpoints = [comparison.old, comparison.new];
 	const resolve = async (rev) => {
 		if (rev === "worktree") return rev;
 		try {
 			return await repo.resolve(rev);
 		} catch (e) {
-			if (!comparison.mergeBase && rev === "HEAD" && endpoints.includes("worktree") && e instanceof GitError && e.code === 1) return repo.emptyTree();
+			if (comparison.base === "direct" && rev === "HEAD" && endpoints.includes("worktree") && e instanceof GitError && e.code === 1) return repo.emptyTree();
 			if (e instanceof GitError) throw new RevspecError(`unknown revision: ${rev}`);
 			throw e;
 		}
 	};
 	const [old, next] = await Promise.all([resolve(comparison.old), resolve(comparison.new)]);
 	let oldSha = old;
-	if (comparison.mergeBase) {
+	if (comparison.base === "merge-base") {
 		const [a, b] = await Promise.all([old === "worktree" ? resolve("HEAD") : old, next === "worktree" ? resolve("HEAD") : next]);
 		try {
 			oldSha = await repo.mergeBase(a, b);
@@ -18345,6 +18922,13 @@ async function resolveComparison(repo, comparison) {
 			throw e;
 		}
 	}
+	if (comparison.base === "parent") {
+		if (next === "worktree") throw new RevspecError("the worktree is not a commit");
+		oldSha = await repo.resolve(`${next}^`).catch((e) => {
+			if (e instanceof GitError && e.code === 1) return repo.emptyTree();
+			throw e;
+		});
+	}
 	const pinned = (rev, sha) => rev.length >= 7 && sha.startsWith(rev.toLowerCase());
 	return {
 		oldSha,
@@ -18352,14 +18936,29 @@ async function resolveComparison(repo, comparison) {
 		live: endpoints.includes("worktree") ? "worktree" : pinned(comparison.old, old) && pinned(comparison.new, next) ? "none" : "refs"
 	};
 }
+/** Whether either endpoint names a local or remote branch, HEAD on one included. */
+async function namesBranch(repo, comparison) {
+	const [old, next] = await Promise.all([repo.branchRef(comparison.old), repo.branchRef(comparison.new)]);
+	return old != null || next != null;
+}
 /** Resolves an input command into a comparison and optional explicit PR identity. */
 async function resolveReview(req, repo, github) {
 	if (req.kind === "pr") return resolvePr(req, repo, github);
 	const parsed = req.kind === "working" ? {
 		old: "HEAD",
 		new: "worktree",
-		mergeBase: false
+		base: "direct"
 	} : parseRevspec(req.args);
+	if (parsed.base === "parent") {
+		const { newSha: sha } = await resolveComparison(repo, parsed);
+		return { mode: {
+			old: sha,
+			new: sha,
+			base: "parent",
+			live: "none",
+			commentKey: `commit:${sha}`
+		} };
+	}
 	const { oldSha, newSha, live } = await resolveComparison(repo, parsed);
 	return { mode: {
 		...parsed,
@@ -18369,19 +18968,21 @@ async function resolveReview(req, repo, github) {
 }
 /**
 * Branch identities keep review state stable across pushes and local branch aliases.
+* Keys read like the comparison, with ... for a merge base and .. otherwise.
 * For origin = github.com/o/r and HEAD on feat tracking origin/feat:
-*   origin/main...HEAD → branches:["o/r:main","o/r:feat",true]
-*   origin/main..HEAD  → branches:["o/r:main","o/r:feat",false]
+*   origin/main...HEAD → range:o/r:main...o/r:feat
+*   origin/main..HEAD  → range:o/r:main..o/r:feat
 * The matching explicit PR uses the first key too. If feat tracks a fork,
 * its identity becomes e.g. "contributor/r:feat", keeping forks distinct.
 *
 * Without a GitHub upstream, branches use full refs:
-*   main...feat → branches:["refs/heads/main","refs/heads/feat",true]
+*   main...feat → range:refs/heads/main...refs/heads/feat
 * Non-branch endpoints use their resolved hash or literal "worktree":
-*   main..worktree → branches:["refs/heads/main","worktree",false]
-* If neither endpoint is a branch, the key is revspec:<oldSha>..<newSha>.
+*   main..worktree → range:refs/heads/main..worktree
+*   <C>..<E>       → range:<C hash>..<E hash>
 * Hash placeholders denote full resolved hashes, with oldSha already adjusted
-* for mergeBase. The working command bypasses this helper and uses "working".
+* for the merge base. The working command bypasses this helper and uses
+* "working"; a single commit uses "commit:<hash>".
 */
 async function commentKey(repo, comparison, oldSha, newSha) {
 	const remotes = await repo.remotes();
@@ -18395,14 +18996,10 @@ async function commentKey(repo, comparison, oldSha, newSha) {
 		return repo.branchRef(rev);
 	};
 	const [old, next] = await Promise.all([identity(comparison.old), identity(comparison.new)]);
-	return old || next ? branchKey(old ?? oldSha, next ?? newSha, comparison.mergeBase) : `revspec:${oldSha}..${newSha}`;
+	return rangeKey(old ?? oldSha, next ?? newSha, comparison.base === "merge-base");
 }
-function branchKey(old, next, mergeBase) {
-	return `branches:${JSON.stringify([
-		old,
-		next,
-		mergeBase
-	])}`;
+function rangeKey(old, next, mergeBase) {
+	return `range:${old}${mergeBase ? "..." : ".."}${next}`;
 }
 /**
 * A GitHub pull request, as GitHub shows it: merge-base(base tip, head) vs head.
@@ -18421,16 +19018,16 @@ async function resolvePr(req, repo, github) {
 	await resolveComparison(repo, {
 		old: base,
 		new: head,
-		mergeBase: true
+		base: "merge-base"
 	});
 	return {
 		prUrl: pr.url,
 		mode: {
 			old: base,
 			new: head,
-			mergeBase: true,
+			base: "merge-base",
 			live: "none",
-			commentKey: branchKey(`${pr.repository.toLowerCase()}:${pr.baseRefName}`, `${pr.headRepository?.toLowerCase() ?? `deleted:${pr.url}`}:${pr.headRefName}`, true)
+			commentKey: rangeKey(`${pr.repository.toLowerCase()}:${pr.baseRefName}`, `${pr.headRepository?.toLowerCase() ?? `deleted:${pr.url}`}:${pr.headRefName}`, true)
 		}
 	};
 }
@@ -18504,16 +19101,18 @@ var Snapshotter = class {
 	mode;
 	version;
 	context;
+	iterations;
 	cache = null;
 	patches = /* @__PURE__ */ new Map();
 	all = null;
 	/** Content-sniff verdict by blob sha. A blob is immutable, so a refresh re-reads only new content. */
 	sniffed = /* @__PURE__ */ new Map();
-	constructor(repo, mode, version, context) {
+	constructor(repo, mode, version, context, iterations = null) {
 		this.repo = repo;
 		this.mode = mode;
 		this.version = version;
 		this.context = context;
+		this.iterations = iterations;
 	}
 	/** Change context lines: drops cached patches; the next snapshot carries the new value. */
 	setContext(context, version) {
@@ -18579,8 +19178,13 @@ var Snapshotter = class {
 	}
 	async compute(version) {
 		const [{ oldSha, newSha }, headSha] = await Promise.all([resolveComparison(this.repo, this.mode), this.repo.resolve("HEAD").catch(() => "")]);
-		const [tracked, changed] = await Promise.all([newSha === "worktree" ? Promise.all([this.repo.lsFiles(), this.repo.untracked()]).then((lists) => lists.flat().filter((p) => !p.endsWith("/"))) : this.repo.lsTree(newSha), this.repo.numstat(oldSha, newSha)]);
-		await this.fillGenerated(changed, newSha);
+		const [tracked, changed, commit, commits] = await Promise.all([
+			newSha === "worktree" ? Promise.all([this.repo.lsFiles(), this.repo.untracked()]).then((lists) => lists.flat().filter((p) => !p.endsWith("/"))) : this.repo.lsTree(newSha),
+			this.repo.numstat(oldSha, newSha),
+			this.mode.base === "parent" ? this.reviewedCommit(newSha) : null,
+			this.rangeCommits(oldSha, newSha, headSha)
+		]);
+		const [iterations] = await Promise.all([this.recordIteration(commits), this.fillGenerated(changed, newSha)]);
 		const tree = new Set(tracked);
 		for (const f of changed) {
 			if (f.status === "D") tree.delete(f.path);
@@ -18596,11 +19200,49 @@ var Snapshotter = class {
 			headSha,
 			context: this.context,
 			changed,
-			tree: [...tree].sort()
+			tree: [...tree].sort(),
+			commit,
+			commits,
+			iterations
 		};
 		for (const f of changed.slice(0, PREWARM)) this.patchFor(snap, f).catch(() => {});
 		return snap;
 	}
+	/** The snapshot taken is the range's current iteration; the worktree has no commit to record. */
+	async recordIteration(commits) {
+		if (!this.iterations || commits.oldSha === "worktree" || commits.newSha === "worktree") return [];
+		return this.iterations.record(commits.oldSha, commits.newSha);
+	}
+	async reviewedCommit(sha) {
+		const [info, neighbours] = await Promise.all([this.repo.commitInfo(sha), this.repo.commitNeighbours(sha)]);
+		return info && {
+			...info,
+			...neighbours
+		};
+	}
+	async rangeCommits(oldSha, newSha, headSha) {
+		if (this.mode.within) {
+			const range = await resolveComparison(this.repo, this.mode.within);
+			return this.spanned(range.oldSha, range.newSha, headSha);
+		}
+		if (this.mode.base === "parent") return {
+			...await this.repo.rangeCommits(`${newSha}^!`, 250),
+			oldSha,
+			newSha
+		};
+		return this.spanned(oldSha, newSha, headSha);
+	}
+	async spanned(oldSha, newSha, headSha) {
+		const [from, to] = [oldSha, newSha].map((sha) => sha === "worktree" ? headSha : sha);
+		return {
+			...!from || !to || from === to ? {
+				list: [],
+				total: 0
+			} : await this.repo.rangeCommits(`${from}..${to}`, 250),
+			oldSha,
+			newSha
+		};
+	}
 	/**
 	* Sets `generated` on each non-binary changed file. A `linguist-generated`
 	* gitattribute on the new side decides outright, as on GitHub; otherwise a
@@ -18649,6 +19291,10 @@ var Snapshotter = class {
 * while its task holds the queue, so published versions are monotonic and the
 * active snapshotter always carries the session's context. Requests that arrive
 * before the first mode resolves await `ready()`.
+*
+* A worktree-live comparison recomputes on every change. A refs-live one only
+* announces that its refs moved (`moved`) and recomputes on `reload()`, so a
+* push or rebase does not swap the review out from under the reviewer.
 */
 var Session = class {
 	repo;
@@ -18663,6 +19309,8 @@ var Session = class {
 	queue = Promise.resolve();
 	/** The refresh waiting for the queue, if any. Later requests join it. */
 	queuedRefresh = null;
+	/** The refs check waiting for the queue, if any. Later signals join it. */
+	queuedCheck = null;
 	readable = /* @__PURE__ */ new WeakMap();
 	snapshotListeners = /* @__PURE__ */ new Set();
 	constructor(repo, hub, opts) {
@@ -18684,6 +19332,24 @@ var Session = class {
 	get snapshotter() {
 		return this.require().snapshotter;
 	}
+	/** The pending reload of a refs-live comparison, for a client that connects after the push. */
+	get moved() {
+		return this.require().moved;
+	}
+	/** Whether moved refs recompute the review, as worktree edits always do, or only announce themselves. */
+	get follows() {
+		const a = this.require();
+		if (a.mode.live === "worktree") return true;
+		switch (this.opts.followRefs) {
+			case "on": return true;
+			case "off": return false;
+			case "auto": return !a.branches;
+		}
+	}
+	/** Change the user's choice for the running session; a pending notice stands until a reload picks the refs up. */
+	setFollowRefs(followRefs) {
+		this.opts.followRefs = followRefs;
+	}
 	/** Cached independently of snapshot construction; callers never hold the transition queue. */
 	github(snap) {
 		const active = this.require();
@@ -18771,7 +19437,7 @@ var Session = class {
 	}
 	/** Switch modes at runtime. Broadcasts a snapshot bump on success. */
 	async switchMode(req) {
-		const snap = await this.run(async () => this.activate(await resolveReview(req, this.repo, this.opts.github)));
+		const snap = await this.run(async () => this.activate(req.kind === "focus" ? await this.focus(req.commit) : req.kind === "interdiff" ? await this.interdiff(req.from, req.to) : req.kind === "pair" ? await this.pair(req.commit) : await resolveReview(req, this.repo, this.opts.github)));
 		this.hub.broadcast({
 			type: "snapshot",
 			version: snap.version
@@ -18779,6 +19445,150 @@ var Session = class {
 		return snap;
 	}
 	/**
+	* Focuses `commit`, by hash or short hash, of the active range's listed commits, or with null returns to
+	* the range. A focused commit keeps its own comments, as when entered alone, and the range's PR identity.
+	*/
+	async focus(commit) {
+		const a = this.require();
+		const { within, ...self } = a.mode;
+		if (!within && self.base === "parent") throw new RevspecError("a single commit has no commits to focus");
+		const range = within ?? self;
+		if (commit === null) return {
+			mode: range,
+			prUrl: a.prUrl
+		};
+		const sha = (await a.snapshotter.current()).commits.list.find((c) => c.sha === commit || c.short === commit)?.sha;
+		if (!sha) throw new RevspecError(`not a listed commit of ${comparisonLabel(range)}: ${commit}`);
+		return {
+			prUrl: a.prUrl,
+			mode: {
+				old: sha,
+				new: sha,
+				base: "parent",
+				live: range.live === "none" ? "none" : "refs",
+				commentKey: `commit:${sha}`,
+				within: range
+			}
+		};
+	}
+	/**
+	* Compares two recorded iterations of the active range: `from`'s head replayed onto `to`'s base
+	* against `to`'s head, so only what the branch itself changed in between shows. The interdiff
+	* keeps its own comments and the range's PR identity; its refs keep being watched.
+	*/
+	async interdiff(from, to) {
+		const a = this.require();
+		const range = a.mode.within ?? a.mode;
+		if (range.base === "parent") throw new RevspecError("a single commit has no iterations");
+		if (from >= to) throw new RevspecError("compare an older iteration with a newer one");
+		const store = new IterationStore(this.repo, range.commentKey);
+		const [older, newer] = await Promise.all([store.get(from), store.get(to)]);
+		if (!older || !newer) throw new RevspecError(`no iteration #${older ? to : from} of ${comparisonLabel(range)}`);
+		const [{ tree, conflicts }, pairs] = await Promise.all([older.oldSha === newer.oldSha ? this.repo.tree(older.newSha).then((tree) => ({
+			tree,
+			conflicts: []
+		})) : this.repo.replay(older.oldSha, newer.oldSha, older.newSha), this.pairs(older, newer)]);
+		return {
+			prUrl: a.prUrl,
+			mode: {
+				old: tree,
+				new: newer.newSha,
+				base: "direct",
+				live: range.live === "none" ? "none" : "refs",
+				commentKey: `${range.commentKey}:interdiff:${from}-${to}`,
+				within: range,
+				interdiff: {
+					from: older,
+					to: newer,
+					conflicts,
+					pairs
+				}
+			}
+		};
+	}
+	/**
+	* Pairs the two iterations' commits as `git range-diff` does and tells a pair whose patch is
+	* the same (a reworded commit) from an amended one by patch id.
+	*/
+	async pairs(older, newer) {
+		const oldRange = `${older.oldSha}..${older.newSha}`;
+		const newRange = `${newer.oldSha}..${newer.newSha}`;
+		const [rows, oldCommits, newCommits] = await Promise.all([
+			this.repo.rangeDiff(oldRange, newRange),
+			this.repo.rangeCommits(oldRange, 250),
+			this.repo.rangeCommits(newRange, 250)
+		]);
+		const find = async (list, abbrev) => {
+			if (abbrev === null) return null;
+			return list.find((c) => c.sha.startsWith(abbrev)) ?? (await this.repo.rangeCommits(`${abbrev}^!`, 1)).list[0] ?? null;
+		};
+		const paired = await Promise.all(rows.map(async (row) => ({
+			old: await find(oldCommits.list, row.old),
+			new: await find(newCommits.list, row.new),
+			marker: row.marker
+		})));
+		const changed = paired.filter((p) => p.marker === "!" && p.old && p.new);
+		const ids = await this.repo.patchIds(changed.flatMap((p) => [p.old.sha, p.new.sha]));
+		return paired.map(({ old, new: next, marker }) => ({
+			old,
+			new: next,
+			status: marker === "=" ? "identical" : marker === "<" ? "dropped" : marker === ">" ? "added" : old && next && ids.get(old.sha) !== void 0 && ids.get(old.sha) === ids.get(next.sha) ? "message" : "changed"
+		}));
+	}
+	/**
+	* Shows one pair of the active interdiff by its new-side commit: an added commit against its
+	* parent, an amended or reworded one against its old self replayed onto its parent. With null,
+	* the whole interdiff again. Identical pairs have nothing to show; dropped ones have no new side.
+	*/
+	async pair(commit) {
+		const a = this.require();
+		const { interdiff, within: range } = a.mode;
+		if (!interdiff || !range) throw new RevspecError("no interdiff to pick a pair from");
+		if (commit === null) return this.interdiff(interdiff.from.n, interdiff.to.n);
+		const found = interdiff.pairs.find((p) => p.new && (p.new.sha === commit || p.new.short === commit));
+		if (!found?.new) throw new RevspecError(`not a commit of ${comparisonLabel(a.mode)}: ${commit}`);
+		if (found.status === "identical") throw new RevspecError(`${found.new.short} is identical in both iterations`);
+		const base = {
+			live: range.live === "none" ? "none" : "refs",
+			within: range,
+			interdiff
+		};
+		if (!found.old) {
+			const sha = found.new.sha;
+			return {
+				prUrl: a.prUrl,
+				mode: {
+					...base,
+					old: sha,
+					new: sha,
+					base: "parent",
+					commentKey: `commit:${sha}`,
+					pair: {
+						old: null,
+						new: sha,
+						conflicts: []
+					}
+				}
+			};
+		}
+		const { tree, conflicts } = await this.repo.replay(`${found.old.sha}^`, `${found.new.sha}^`, found.old.sha);
+		return {
+			prUrl: a.prUrl,
+			mode: {
+				...base,
+				old: tree,
+				new: found.new.sha,
+				base: "direct",
+				commentKey: `${range.commentKey}:pair:${found.old.sha}-${found.new.sha}`,
+				pair: {
+					old: found.old.sha,
+					new: found.new.sha,
+					conflicts
+				}
+			}
+		};
+	}
+	/**
 	* Runs `fn` after every earlier mutation settled. The only way to touch
 	* `active`, `version` or `opts.context`.
 	*/
@@ -18788,14 +19598,22 @@ var Session = class {
 		return r;
 	}
 	async activate({ mode, prUrl }) {
-		const snapshotter = new Snapshotter(this.repo, mode, ++this.version, this.opts.context);
-		const [comments, snap] = await Promise.all([CommentStore.open(this.repo.gitDir, mode.commentKey), snapshotter.current()]);
+		const range = mode.within ?? mode;
+		const followed = range.base !== "parent" && (range.live === "refs" || prUrl != null);
+		const snapshotter = new Snapshotter(this.repo, mode, ++this.version, this.opts.context, followed ? new IterationStore(this.repo, range.commentKey) : null);
+		const [comments, snap, branches] = await Promise.all([
+			CommentStore.open(this.repo.gitDir, mode.commentKey),
+			snapshotter.current(),
+			range.live === "refs" && namesBranch(this.repo, range)
+		]);
 		const next = {
 			mode,
 			prUrl,
 			snapshotter,
 			comments,
-			watcher: null
+			watcher: null,
+			moved: null,
+			branches
 		};
 		await this.relocateComments(next, snap);
 		if (this.opts.watch && mode.live !== "none") next.watcher = await this.startWatcher(next);
@@ -18825,13 +19643,61 @@ var Session = class {
 		if (this.queuedRefresh) return this.queuedRefresh;
 		const r = this.run(async () => {
 			this.queuedRefresh = null;
-			const a = this.require();
-			a.snapshotter.invalidate(++this.version);
-			await this.publish(a);
+			await this.recompute();
 		}).catch((e) => console.error("[diffle] refresh failed:", e));
 		this.queuedRefresh = r;
 		return r;
 	}
+	/** The reviewer asks for the moved refs: recompute now. Unlike `refresh`, a failure is the caller's. */
+	reload() {
+		return this.run(async () => {
+			const a = this.require();
+			if (!a.mode.interdiff || !a.mode.within) return this.recompute();
+			return this.leaveInterdiff(a);
+		});
+	}
+	/** Forgets the range's recorded iterations and unpins their commits; its current state is recorded anew as #1. */
+	clearIterations() {
+		return this.run(async () => {
+			const a = this.require();
+			const range = a.mode.within ?? a.mode;
+			await new IterationStore(this.repo, range.commentKey).clear();
+			return a.mode.interdiff ? this.leaveInterdiff(a) : this.recompute();
+		});
+	}
+	/**
+	* Forgets one recorded iteration and unpins its commits. The latest stays: it is the range's
+	* current state and would be recorded again at once.
+	*/
+	deleteIteration(n) {
+		return this.run(async () => {
+			const a = this.require();
+			const range = a.mode.within ?? a.mode;
+			const store = new IterationStore(this.repo, range.commentKey);
+			const list = await store.list();
+			if (!list.some((it) => it.n === n)) throw new RevspecError(`no iteration #${n}`);
+			if (list.at(-1).n === n) throw new RevspecError(`#${n} is the latest iteration, the range's current state`);
+			await store.remove(n);
+			const inter = a.mode.interdiff;
+			return inter && (inter.from.n === n || inter.to.n === n) ? this.leaveInterdiff(a) : this.recompute();
+		});
+	}
+	async leaveInterdiff(a) {
+		const snap = await this.activate({
+			mode: a.mode.within,
+			prUrl: a.prUrl
+		});
+		this.hub.broadcast({
+			type: "snapshot",
+			version: snap.version
+		});
+		return snap;
+	}
+	recompute() {
+		const a = this.require();
+		a.snapshotter.invalidate(++this.version);
+		return this.publish(a);
+	}
 	/**
 	* Computes `a`'s current snapshot, re-anchors its threads (hunks may have
 	* grown, shrunk or moved), then broadcasts and announces it.
@@ -18839,11 +19705,40 @@ var Session = class {
 	async publish(a) {
 		const snap = await a.snapshotter.current();
 		await this.relocateComments(a, snap);
+		a.moved = null;
 		this.hub.broadcast({
 			type: "snapshot",
 			version: snap.version
 		});
 		this.announce(snap);
+		return snap;
+	}
+	/**
+	* Resolves the refs the live comparison follows and tells clients when they
+	* left the snapshot behind, or came back to it. At most one check waits
+	* behind the running one, as with `refresh`.
+	*/
+	checkMoved(a) {
+		if (this.queuedCheck) return this.queuedCheck;
+		const r = this.run(async () => {
+			this.queuedCheck = null;
+			if (this.active !== a) return;
+			const snap = await a.snapshotter.current();
+			const { oldSha, newSha } = await resolveComparison(this.repo, a.mode.within ?? a.mode);
+			const moved = oldSha === snap.commits.oldSha && newSha === snap.commits.newSha ? null : {
+				version: snap.version,
+				oldSha,
+				newSha
+			};
+			if (moved?.oldSha === a.moved?.oldSha && moved?.newSha === a.moved?.newSha) return;
+			a.moved = moved;
+			this.hub.broadcast({
+				type: "moved",
+				moved
+			});
+		}).catch((e) => console.error("[diffle] refs check failed:", e));
+		this.queuedCheck = r;
+		return r;
 	}
 	/**
 	* Re-anchors threads against what `snap` shows. A changed file shows its
@@ -18907,6 +19802,7 @@ var Session = class {
 	* review. Goes through `readSide`, so the allowlist applies.
 	*/
 	anchorSource() {
+		if (this.mode.interdiff) throw new RevspecError("comments are off while comparing iterations");
 		return {
 			quote: async (path, side, startLine, endLine) => {
 				const snap = await this.snapshotter.current();
@@ -18947,6 +19843,10 @@ var Session = class {
 		});
 		watcher.on("dirty", () => {
 			if (this.active !== a) return;
+			if (!this.follows) {
+				this.checkMoved(a);
+				return;
+			}
 			this.refresh();
 			this.run(async () => {
 				if (this.active === a && a.mode.live === "worktree") await refreshIgnored();
@@ -19037,6 +19937,7 @@ function normalize(c) {
 	return {
 		autoViewed: Array.isArray(c.autoViewed) ? c.autoViewed.filter((p) => typeof p === "string").map((p) => p.trim()).filter(Boolean) : DEFAULT_USER_CONFIG.autoViewed,
 		contextLines: typeof c.contextLines === "number" && Number.isFinite(c.contextLines) ? Math.max(0, Math.min(1e4, Math.floor(c.contextLines))) : DEFAULT_USER_CONFIG.contextLines,
+		followRefs: FollowRefsSchema.safeParse(c.followRefs).data ?? DEFAULT_USER_CONFIG.followRefs,
 		lspCommands: lspCommands(c)
 	};
 }
@@ -22744,6 +23645,12 @@ function parseLspOverride(raw) {
 function collectLspOverride(raw, prev) {
 	return [...Array.isArray(prev) ? prev : [], parseLspOverride(raw)];
 }
+/** A `set-follow-refs` value. */
+function parseFollowRefs(value) {
+	const parsed = FollowRefsSchema.safeParse(value);
+	if (!parsed.success) throw new InvalidArgumentError("expected on, auto or off");
+	return parsed.data;
+}
 //#endregion
 //#region src/cli/browserLifetime.ts
 /**
@@ -22895,6 +23802,7 @@ Shorthands (in place of <revs>):
   working                  same as HEAD..worktree: uncommitted changes, staged and untracked included
   pr [number|url]          a GitHub pull request: its base...head, fetched if needed
                            (without an argument: the pull request for this branch)
+  show [rev]               same as <rev>^!: one commit against its first parent, pinned (default: HEAD)
 
 Revisions follow git diff, except that a lone one compares from the merge base:
   diffle main              same as main...HEAD: what this branch added since it left main
@@ -22902,6 +23810,7 @@ Revisions follow git diff, except that a lone one compares from the merge base:
   diffle main..feat        main vs feat
   diffle main...feat       what feat added since it left main
   diffle main..worktree    main vs the uncommitted tree ("worktree" works on either side)
+  diffle a1b2c3d^!         the commit a1b2c3d alone, like git show
 
 Without revisions, diffle compares HEAD..worktree.
 
@@ -22914,6 +23823,10 @@ Ctrl+C always stops it.`).action(async (revs, _o, cmd) => {
 	}, cmd.optsWithGlobals());
 });
 program.command("working", { hidden: true }).summary("same as HEAD..worktree").description("Same as `diffle HEAD..worktree`: uncommitted changes, staged and untracked files included.").action(async (_o, cmd) => run({ kind: "working" }, cmd.optsWithGlobals()));
+program.command("show", { hidden: true }).argument("[rev]", "the commit to review", "HEAD").summary("one commit").description("Same as `diffle <rev>^!`: one commit against its first parent, as git show shows it.").action(async (rev, _o, cmd) => run({
+	kind: "revspec",
+	args: [`${rev}^!`]
+}, cmd.optsWithGlobals()));
 program.command("pr", { hidden: true }).argument("[pr]", "pull request number or url; default: the pull request for this branch").summary("a GitHub pull request").description("A GitHub pull request, as GitHub shows it: merge-base(base, head) vs head.").action(async (pr, _o, cmd) => run({
 	kind: "pr",
 	pr
@@ -22934,6 +23847,11 @@ config.command("set-context").description("set context lines around changes").ar
 	await store.set({ contextLines: n });
 	console.log(store.get().contextLines);
 });
+config.command("set-follow-refs").description("follow moved refs: on, auto (not branches), off").argument("<mode>", "on: reload at once; auto: so unless a branch is compared; off: offer a Reload button", parseFollowRefs).action(async (followRefs) => {
+	const store = await UserConfigStore.open();
+	await store.set({ followRefs });
+	console.log(store.get().followRefs);
+});
 config.command("set-lsp").description("set the language-server command for one language").addArgument(languageArgument("<language>", `one of: ${LANGUAGE_IDS.join(", ")}`).argParser(parseLanguage)).argument("<command>", "shell command that starts a stdio language server, e.g. \"pyrefly lsp\"; \"\" to turn it off").action(async (language, command) => {
 	const store = await UserConfigStore.open();
 	await store.set({ lspCommands: {
@@ -23009,6 +23927,7 @@ async function serve(req, opts, repo, closeRepo, config, github, timing) {
 	const session = new Session(repo, hub, {
 		watch: opts.watch,
 		context: opts.context ?? config.get().contextLines,
+		followRefs: config.get().followRefs,
 		github: github.client ?? void 0
 	});
 	const named = Array.isArray(opts.lsp) ? opts.lsp : [];
@@ -23071,7 +23990,7 @@ async function serve(req, opts, repo, closeRepo, config, github, timing) {
 		console.error(`🔍 ${c.dim("comparing")} ${c.bold(comparisonLabel(snap.mode))}`);
 		if (n === 0) console.error(`${c.yellow("!")} No differences. Open any file from the tree to comment on it.`);
 		else console.error(`📝 ${n} changed file${n === 1 ? "" : "s"}  ${c.green(`+${adds}`)} ${c.red(`−${dels}`)}`);
-		if (snap.mode.live !== "none") console.error(`👀 ${c.dim(snap.mode.live === "worktree" ? "watching the worktree" : "watching refs")}${opts.watch ? "" : c.dim(" (disabled with --no-watch)")}`);
+		if (snap.mode.live !== "none") console.error(`👀 ${c.dim(snap.mode.live === "worktree" ? "watching the worktree" : session.follows ? "watching refs" : "watching refs; moved refs show a Reload button")}${opts.watch ? "" : c.dim(" (disabled with --no-watch)")}`);
 		if (lsp) {
 			const { servers, missing } = lsp.status();
 			const names = servers.map((s) => `${s.name} ${c.dim(`(${s.languages.join(", ")})`)}`).join(", ");