@moritzwilksch/diffle 0.1.9 → 0.2.1

package/dist/server/main.js

@@ -3952,7 +3952,7 @@ function generateCompletion(program, { shell, executable = program.name() }) {
 }
 //#endregion
 //#region package.json
-var version$1 = "0.1.9";
+var version$1 = "0.2.1";
 //#endregion
 //#region src/server/comments/anchor.ts
 function splitLines(contents) {
@@ -4109,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;
@@ -4185,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");
@@ -4300,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 {
@@ -11890,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",
@@ -12165,9 +12278,35 @@ const ModeRequestSchema = discriminatedUnion("kind", [
 	object({
 		kind: literal("focus"),
 		commit: string().nullable()
+	}),
+	object({
+		kind: literal("interdiff"),
+		from: number().int().positive(),
+		to: number().int().positive()
+	}),
+	object({
+		kind: literal("range-diff"),
+		args: string().array()
+	}),
+	object({
+		kind: literal("pair"),
+		commit: string().nullable()
 	})
 ]);
 /**
+* 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).
 */
@@ -12189,18 +12328,118 @@ const ComparisonSchema = object({
 	/** Fixed when the comparison is entered; discovery never changes comment storage. */
 	commentKey: string()
 });
-const ModeSpecSchema = ComparisonSchema.extend({ 
-/** Set while one commit of a range is focused: the range, whose commits the snapshot keeps listing. */
-within: ComparisonSchema.optional() });
+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
+});
+/**
+* One range of a range-diff, `old..new`: the revisions that named it, so moved refs can be
+* resolved again, and the commits they resolved to. A recorded iteration of the enclosing
+* range carries its number; a range the reviewer named carries null.
+*/
+const RangeSideSchema = object({
+	old: string(),
+	new: string(),
+	oldSha: string(),
+	newSha: string(),
+	iteration: number().nullable()
+});
+/**
+* Two ranges compared: two iterations of one range, or any two the reviewer named. 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: RangeSideSchema,
+	to: RangeSideSchema,
+	/** 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 ranges are compared: the range, whose commits the
+	* snapshot keeps listing. For a range-diff it is the newer range, where the reviewer continues.
+	*/
+	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>^!`, or as `<range> @ <sha>` when focused within a range.
+* `<sha>^!`, as `<range> @ <sha>` when focused within a range, as `<range> #1→#2` for two of its
+* iterations, as `<a>..<b> → <c>..<d>` for two named ranges, and with ` @ <sha>` for one pair of either.
 */
 function comparisonLabel(mode) {
+	if (mode.within && mode.interdiff) {
+		const { from, to } = mode.interdiff;
+		const iterations = shownIterations(mode);
+		const label = iterations ? `${comparisonLabel(mode.within)} #${iterations.from}→#${iterations.to}` : `${rangeLabel(from)} → ${rangeLabel(to)}`;
+		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)}^!`;
-	const name = (rev) => rev.replace(/^refs\/diffle\/[^/]+\/\d+\/(?:base|head)\//, "").replace(/^refs\/(?:heads|remotes)\//, "");
-	return `${name(mode.old)}${mode.base === "merge-base" ? "..." : ".."}${name(mode.new)}`;
+	return `${refName(mode.old)}${mode.base === "merge-base" ? "..." : ".."}${refName(mode.new)}`;
+}
+/** One side of a range-diff as the reviewer named it, `<old>..<new>`, with full hashes abbreviated. */
+function rangeLabel(side) {
+	const short = (rev) => /^[0-9a-f]{40}$/.test(rev) ? rev.slice(0, 7) : refName(rev);
+	return `${short(side.old)}..${short(side.new)}`;
+}
+/** The iteration numbers an interdiff compares, or null when it compares ranges the reviewer named. */
+function shownIterations(mode) {
+	const inter = mode.interdiff;
+	return inter && inter.from.iteration != null && inter.to.iteration != null ? {
+		from: inter.from.iteration,
+		to: inter.to.iteration
+	} : null;
+}
+/** 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(),
@@ -12250,31 +12489,17 @@ 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()
 });
-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()
-});
 /**
 * 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: CommitInfoSchema.extend({
-		author: string(),
-		email: string(),
-		/** Author date, epoch milliseconds. */
-		date: number()
-	}).array(),
-	total: number()
+	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(),
@@ -12293,7 +12518,20 @@ object({
 	tree: string().array(),
 	/** The reviewed commit when the comparison is a single commit against its parent; otherwise null. */
 	commit: ReviewedCommitSchema.nullable(),
-	commits: RangeCommitsSchema
+	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) });
@@ -12425,11 +12663,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`.
@@ -12439,6 +12690,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. */
@@ -12509,6 +12761,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. */
@@ -12531,6 +12795,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") }),
@@ -12624,7 +12892,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() });
@@ -12670,6 +12939,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
@@ -13239,6 +13578,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) },
@@ -13321,7 +13684,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) {
@@ -13333,7 +13696,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
@@ -13352,7 +13715,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
@@ -13466,6 +13829,7 @@ var LspBridge = class LspBridge {
 						definition: { linkSupport: true },
 						typeDefinition: { linkSupport: true },
 						references: {},
+						documentHighlight: {},
 						hover: { contentFormat: ["markdown", "plaintext"] },
 						documentSymbol: { hierarchicalDocumentSymbolSupport: true },
 						semanticTokens: {
@@ -14051,11 +14415,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) {
@@ -14065,7 +14432,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
@@ -14200,6 +14567,53 @@ function parseRevspec(args) {
 		base: "merge-base"
 	};
 }
+/**
+* `git range-diff` style arguments, as two `old..new` ranges:
+*   "a..b" "c..d"  → a..b against c..d
+*   "base" "b" "d" → base..b against base..d
+*   "b...d"        → d..b against b..d: each tip's commits since their divergence
+* A range also takes `<rev>^!`, the one commit. Empty sides default to HEAD; the worktree is
+* not a commit and has no place in a range.
+*/
+function parseRangeDiff(args) {
+	if (args.length === 3) {
+		const [base, b, d] = args;
+		for (const arg of args) if (arg.includes("..") || arg.endsWith("^!")) throw new RevspecError("expected <base> <rev1> <rev2> as three plain revisions");
+		return [range(base, b), range(base, d)];
+	}
+	if (args.length === 2) {
+		const [a, b] = args;
+		return [parseRange(a), parseRange(b)];
+	}
+	if (args.length === 1) {
+		const arg = args[0];
+		const three = arg.indexOf("...");
+		if (three === -1 || arg.endsWith("^!")) throw new RevspecError("expected <range1> <range2>, <rev1>...<rev2> or <base> <rev1> <rev2>");
+		const b = arg.slice(0, three) || "HEAD";
+		const d = arg.slice(three + 3) || "HEAD";
+		if (b.includes("..") || d.includes("..")) throw new RevspecError("cannot combine \"...\" with \"..\"");
+		return [range(d, b), range(b, d)];
+	}
+	throw new RevspecError("expected <range1> <range2>, <rev1>...<rev2> or <base> <rev1> <rev2>");
+}
+function parseRange(arg) {
+	if (arg.endsWith("^!")) {
+		const commit = arg.slice(0, -2) || "HEAD";
+		if (commit.includes("..")) throw new RevspecError("cannot combine \"^!\" with \"..\"");
+		return range(`${commit}^`, commit);
+	}
+	if (arg.includes("...")) throw new RevspecError(`a range of a range-diff is <old>..<new>, not ${arg}`);
+	const two = arg.indexOf("..");
+	if (two === -1) throw new RevspecError(`not a range: ${arg} (expected <old>..<new>)`);
+	return range(arg.slice(0, two) || "HEAD", arg.slice(two + 2) || "HEAD");
+}
+function range(old, next) {
+	for (const rev of [old, next]) if (rev === WORKTREE || rev === `${WORKTREE}^`) throw new RevspecError("the worktree is not a commit");
+	return {
+		old,
+		new: next
+	};
+}
 var RevspecError = class extends Error {};
 //#endregion
 //#region node_modules/@hono/node-server/dist/index.mjs
@@ -17536,6 +17950,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));
@@ -17731,6 +18153,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);
@@ -17743,6 +18171,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;
@@ -18422,6 +18851,163 @@ 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/rangediff.ts
+/**
+* The mode that compares `older` with `newer`: `older`'s head replayed onto `newer`'s base against
+* `newer`'s head, so only what the series itself changed in between shows, with the two ranges'
+* commits paired. `range` is where the reviewer continues afterwards; its refs keep being watched,
+* so the comparison is pinned under them. Comments are off in it: the old side is a tree no
+* revision names.
+*/
+async function compareRanges(repo, range, older, newer) {
+	const commentKey = older.iteration != null && newer.iteration != null ? `${range.commentKey}:interdiff:${older.iteration}-${newer.iteration}` : `range-diff:${older.oldSha}..${older.newSha}:${newer.oldSha}..${newer.newSha}`;
+	const [{ tree, conflicts }, pairs] = await Promise.all([older.oldSha === newer.oldSha ? repo.tree(older.newSha).then((tree) => ({
+		tree,
+		conflicts: []
+	})) : repo.replay(older.oldSha, newer.oldSha, older.newSha), pairRanges(repo, older, newer)]);
+	return {
+		old: tree,
+		new: newer.newSha,
+		base: "direct",
+		live: range.live === "none" ? "none" : "refs",
+		commentKey,
+		within: range,
+		interdiff: {
+			from: older,
+			to: newer,
+			conflicts,
+			pairs
+		}
+	};
+}
+/**
+* Pairs the two ranges' 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. range-diff compares every commit
+* with every other, so a range past MAX_RANGE_COMMITS is refused rather than left running.
+*/
+async function pairRanges(repo, older, newer) {
+	const oldRange = `${older.oldSha}..${older.newSha}`;
+	const newRange = `${newer.oldSha}..${newer.newSha}`;
+	const [oldCommits, newCommits] = await Promise.all([repo.rangeCommits(oldRange, 250), repo.rangeCommits(newRange, 250)]);
+	for (const [side, commits] of [[older, oldCommits], [newer, newCommits]]) if (commits.total > 250) throw new RevspecError(`${comparisonLabel({
+		...side,
+		base: "direct"
+	})} spans ${commits.total} commits; a range-diff takes at most 250`);
+	const rows = await repo.rangeDiff(oldRange, newRange);
+	const find = async (list, abbrev) => {
+		if (abbrev === null) return null;
+		return list.find((c) => c.sha.startsWith(abbrev)) ?? (await 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 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"
+	}));
+}
 //#endregion
 //#region src/server/mode.ts
 /**
@@ -18451,6 +19037,11 @@ function describe(skipped) {
 * 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;
@@ -18487,9 +19078,15 @@ 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);
+	if (req.kind === "range-diff") return rangeDiffReview(repo, parseRangeDiff(req.args));
 	const parsed = req.kind === "working" ? {
 		old: "HEAD",
 		new: "worktree",
@@ -18505,12 +19102,48 @@ async function resolveReview(req, repo, github) {
 			commentKey: `commit:${sha}`
 		} };
 	}
+	return { mode: await resolveRange(repo, parsed, req.kind === "working" ? "working" : void 0) };
+}
+/** A range as a comparison: resolved for its liveness and keyed for its comments, unless `key` names them. */
+async function resolveRange(repo, parsed, key) {
 	const { oldSha, newSha, live } = await resolveComparison(repo, parsed);
-	return { mode: {
+	return {
 		...parsed,
 		live,
-		commentKey: req.kind === "working" ? "working" : await commentKey(repo, parsed, oldSha, newSha)
-	} };
+		commentKey: key ?? await commentKey(repo, parsed, oldSha, newSha)
+	};
+}
+/**
+* Two ranges the reviewer named, compared. Both resolve now and the comparison is pinned; the
+* newer range is where "All changes" leads and whose refs are watched. Resolving again, as a
+* reload does, follows the revisions either range was named by.
+*/
+async function rangeDiffReview(repo, [older, newer], prUrl) {
+	const resolveSide = async (parsed) => {
+		const { oldSha, newSha } = await resolveComparison(repo, {
+			...parsed,
+			base: "direct"
+		});
+		return {
+			old: parsed.old,
+			new: parsed.new,
+			oldSha,
+			newSha,
+			iteration: null
+		};
+	};
+	const [range, from, to] = await Promise.all([
+		resolveRange(repo, {
+			...newer,
+			base: "direct"
+		}),
+		resolveSide(older),
+		resolveSide(newer)
+	]);
+	return {
+		prUrl,
+		mode: await compareRanges(repo, range, from, to)
+	};
 }
 /**
 * Branch identities keep review state stable across pushes and local branch aliases.
@@ -18647,16 +19280,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) {
@@ -18728,7 +19363,7 @@ var Snapshotter = class {
 			this.mode.base === "parent" ? this.reviewedCommit(newSha) : null,
 			this.rangeCommits(oldSha, newSha, headSha)
 		]);
-		await this.fillGenerated(changed, newSha);
+		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);
@@ -18746,11 +19381,17 @@ var Snapshotter = class {
 			changed,
 			tree: [...tree].sort(),
 			commit,
-			commits
+			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 && {
@@ -18763,16 +19404,23 @@ var Snapshotter = class {
 			const range = await resolveComparison(this.repo, this.mode.within);
 			return this.spanned(range.oldSha, range.newSha, headSha);
 		}
-		if (this.mode.base === "parent") return this.repo.rangeCommits(`${newSha}^!`, 250);
+		if (this.mode.base === "parent") return {
+			...await this.repo.rangeCommits(`${newSha}^!`, 250),
+			oldSha,
+			newSha
+		};
 		return this.spanned(oldSha, newSha, headSha);
 	}
-	spanned(oldSha, newSha, headSha) {
+	async spanned(oldSha, newSha, headSha) {
 		const [from, to] = [oldSha, newSha].map((sha) => sha === "worktree" ? headSha : sha);
-		if (!from || !to || from === to) return Promise.resolve({
-			list: [],
-			total: 0
-		});
-		return this.repo.rangeCommits(`${from}..${to}`, 250);
+		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`
@@ -18822,6 +19470,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;
@@ -18836,6 +19488,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) {
@@ -18857,6 +19511,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();
@@ -18944,7 +19616,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(req.kind === "focus" ? await this.focus(req.commit) : 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
@@ -18979,6 +19651,87 @@ var Session = class {
 		};
 	}
 	/**
+	* Compares two recorded iterations of the active range, 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 side = (it) => ({
+			old: it.oldSha,
+			new: it.newSha,
+			oldSha: it.oldSha,
+			newSha: it.newSha,
+			iteration: it.n
+		});
+		return {
+			prUrl: a.prUrl,
+			mode: await compareRanges(this.repo, range, side(older), side(newer))
+		};
+	}
+	/**
+	* 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 {
+			prUrl: a.prUrl,
+			mode: await compareRanges(this.repo, range, interdiff.from, interdiff.to)
+		};
+		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 ranges`);
+		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`.
 	*/
@@ -18988,14 +19741,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);
@@ -19025,13 +19786,71 @@ 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.within && shownIterations(a.mode)) return this.leaveInterdiff(a);
+			return this.recompute();
+		});
+	}
+	/** 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 shownIterations(a.mode) ? 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 shown = shownIterations(a.mode);
+			return shown && (shown.from === n || shown.to === n) ? this.leaveInterdiff(a) : this.recompute();
+		});
+	}
+	leaveInterdiff(a) {
+		return this.enter({
+			mode: a.mode.within,
+			prUrl: a.prUrl
+		});
+	}
+	/** Activates a review in place of the current one, as a switch does, and tells clients. */
+	async enter(review) {
+		const snap = await this.activate(review);
+		this.hub.broadcast({
+			type: "snapshot",
+			version: snap.version
+		});
+		return snap;
+	}
+	/**
+	* Recomputes the active snapshot. A range-diff of two named ranges resolves them again
+	* instead, since its sides are pinned trees: that is how it follows the refs it was named by.
+	*/
+	recompute() {
+		const a = this.require();
+		const inter = a.mode.interdiff;
+		if (inter && !shownIterations(a.mode) && !a.mode.pair) return rangeDiffReview(this.repo, [inter.from, inter.to], a.prUrl).then((review) => this.enter(review));
+		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.
@@ -19039,11 +19858,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
@@ -19107,6 +19955,7 @@ var Session = class {
 	* review. Goes through `readSide`, so the allowlist applies.
 	*/
 	anchorSource() {
+		if (this.mode.interdiff) throw new RevspecError(shownIterations(this.mode) ? "comments are off while comparing iterations" : "comments are off in a range-diff");
 		return {
 			quote: async (path, side, startLine, endLine) => {
 				const snap = await this.snapshotter.current();
@@ -19147,6 +19996,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();
@@ -19237,6 +20090,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)
 	};
 }
@@ -22944,6 +23798,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
 /**
@@ -23089,13 +23949,19 @@ const c = {
 };
 const program = new Command().exitOverride().name("diffle").description("Review a git diff in the browser and export line comments as an agent prompt.").version(version$1, "-v, --version", "print the version and exit").addOption(completionHint(new Option("-C <path>", "run as if started in <path> (any directory inside a git worktree)"), { kind: "directory" })).option("-p, --port <port>", `port to listen on (default: ${DEFAULT_PORT}, or the next free one; 0 = random)`, parsePort).option("-H, --host <host>", "address to bind; use 0.0.0.0 to expose on the network", "127.0.0.1").option("--allowed-origin <origin>", "trusted public HTTP(S) origin behind a reverse proxy (without a path)", parseAllowedOrigin).option("--no-open", "do not open a browser").option("--keep-alive", "keep the server running after all browser tabs close").option("--no-watch", "do not watch for changes").addOption(new Option("--auto-viewed <glob>", "mark matching files viewed for this session (repeatable)").argParser(collect).default([], "none")).option("-U, --context <n>", "context lines around changes for this session (default: config, 5)", parseContext).addOption(new Option("--lsp <language=command>", "language server command for one language, started for this run (repeatable); by default the diff's languages are served by whatever is on PATH").argParser(collectLspOverride).default(true, "the diff's languages, resolved on PATH")).option("--no-lsp", "do not start any language server").option("--timing", "print startup phase timings to stderr").option("--dev", "serve the client through Vite (development)", process.env.DIFFLE_DEV === "1" ? true : void 0).addArgument(completionHint(new Argument("[revs...]", "git-diff style revisions: <rev> | <a>..<b> | <a>...<b> | <a> <b>"), {
 	kind: "choices",
-	values: ["working", "pr"]
+	values: [
+		"working",
+		"pr",
+		"range-diff"
+	]
 })).addHelpText("after", `
 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)
+  range-diff <ranges...>   how one series of commits became another, like git range-diff:
+                           <a>..<b> <c>..<d> | <base> <b> <d> | <b>...<d>
 
 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
@@ -23124,6 +23990,10 @@ program.command("pr", { hidden: true }).argument("[pr]", "pull request number or
 	kind: "pr",
 	pr
 }, cmd.optsWithGlobals()));
+program.command("range-diff", { hidden: true }).argument("<ranges...>", "two ranges: <a>..<b> <c>..<d>, <base> <b> <d>, or <b>...<d>").summary("two series of commits").description("How one series of commits became another, as git range-diff shows it: the older range replayed onto the newer one’s base against the newer range, with the commits paired.").action(async (ranges, _o, cmd) => run({
+	kind: "range-diff",
+	args: ranges
+}, cmd.optsWithGlobals()));
 const config = program.command("config").description("show or edit the user config (same settings as the UI dialog)");
 config.command("show", { isDefault: true }).description("print the config file path and contents").action(async () => {
 	const store = await UserConfigStore.open();
@@ -23140,6 +24010,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: {
@@ -23215,6 +24090,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 : [];
@@ -23277,7 +24153,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(", ");