@prometheus-ai/hashline 0.5.4 → 0.5.8

package/src/apply.ts

@@ -7,7 +7,7 @@
  * which absorbs common model mistakes where a payload restates unchanged range
  * boundaries or duplicates/drops structural closers.
  */
-import { UNRESOLVED_BLOCK_INTERNAL } from "./messages";
+import { afterInsertLandingShiftWarning, blockInsertLandingShiftWarning, UNRESOLVED_BLOCK_INTERNAL } from "./messages";
 import { cloneCursor } from "./tokenizer";
 import type { Anchor, ApplyResult, Cursor, Edit } from "./types";
 
@@ -35,11 +35,26 @@ function getEditAnchors(edit: AppliedEdit): Anchor[] {
 	return getCursorAnchors(edit.cursor);
 }
 
+function trailingPhantomLine(fileLines: readonly string[]): number {
+	// `split("\n")` on a newline-terminated file yields a trailing "" sentinel.
+	// It is addressable for inserts (append-past-end), but it is not real
+	// content. Deleting it only strips the file's final newline, so ignore delete
+	// edits that land there; inclusive ranges ending at EOF then do the intended
+	// thing and delete through the last concrete line.
+	return fileLines.length > 1 && fileLines[fileLines.length - 1] === "" ? fileLines.length : 0;
+}
+
+function dropTrailingPhantomDeletes(edits: AppliedEdit[], fileLines: readonly string[]): AppliedEdit[] {
+	const phantomLine = trailingPhantomLine(fileLines);
+	if (phantomLine === 0) return edits;
+	return edits.filter(edit => edit.kind !== "delete" || edit.anchor.line !== phantomLine);
+}
+
 /**
  * Verify every anchored edit points at an existing line. File-version binding is
  * checked once per section via the header hash before this function runs.
  */
-function validateLineBounds(edits: AppliedEdit[], fileLines: string[]): void {
+function validateLineBounds(edits: readonly AppliedEdit[], fileLines: readonly string[]): void {
 	for (const edit of edits) {
 		for (const anchor of getEditAnchors(edit)) {
 			if (anchor.line < 1 || anchor.line > fileLines.length) {
@@ -113,7 +128,7 @@ function bucketAnchorEditsByLine(edits: IndexedEdit[]): Map<number, IndexedEdit[
 // wrapper" mistake.
 
 /** A line that is nothing but closing delimiters: `}`, `)`, `];`, `})`, `},`. */
-const STRUCTURAL_CLOSER_RE = /^\s*[)\]}]+[;,]?\s*$/;
+export const STRUCTURAL_CLOSER_RE = /^\s*[)\]}]+[;,]?\s*$/;
 
 interface DelimiterBalance {
 	paren: number;
@@ -303,11 +318,22 @@ function findDuplicatePrefix(group: ReplacementGroup, fileLines: readonly string
 	return 0;
 }
 
+function payloadEndsWithDeletedSuffix(group: ReplacementGroup, fileLines: readonly string[], count: number): boolean {
+	if (group.payload.length < count) return false;
+	const deletedStart = group.endLine - count;
+	const payloadStart = group.payload.length - count;
+	for (let offset = 0; offset < count; offset++) {
+		if (group.payload[payloadStart + offset] !== fileLines[deletedStart + offset]) return false;
+	}
+	return true;
+}
+
 /**
  * Smallest `m` such that the range's last `m` deleted lines are all pure
- * structural closers and sparing them (keeping instead of deleting) zeroes
- * `delta`. The mirror mistake: a range that swallows a closing delimiter the
- * payload never restates.
+ * structural closers, the payload does not already restate those same suffix
+ * lines, and sparing them (keeping instead of deleting) zeroes `delta`. The
+ * mirror mistake: a range that swallows a closing delimiter the payload never
+ * restates.
  */
 function findDroppedSuffixClosers(
 	group: ReplacementGroup,
@@ -318,6 +344,7 @@ function findDroppedSuffixClosers(
 	const maxM = group.deleteIndices.length;
 	for (let m = 1; m <= maxM; m++) {
 		if (!STRUCTURAL_CLOSER_RE.test(fileLines[group.endLine - m] ?? "")) break;
+		if (payloadEndsWithDeletedSuffix(group, fileLines, m)) continue;
 		if (balanceEqual(computeDelimiterBalance(fileLines.slice(group.endLine - m, group.endLine)), wanted)) return m;
 	}
 	return 0;
@@ -383,6 +410,21 @@ function findBoundaryEcho(group: ReplacementGroup, fileLines: readonly string[])
 	// repair would strip explicit replacement content with no signal that the
 	// payload was a mistake rather than an intentional duplication.
 	if (leadingMax + trailingMax >= group.payload.length) return undefined;
+	// Balance-neutrality guard (see header comment): the dropped echo lines must
+	// either be delimiter-neutral on their own or exactly cancel the payload/range
+	// balance delta. In brace-heavy code where bare closer lines repeat, an
+	// "echo" that shifts delimiter balance is structural content the payload
+	// placed intentionally — stripping it would corrupt the result.
+	const leadingBalance = computeDelimiterBalance(group.payload.slice(0, leadingMax));
+	const trailingBalance = computeDelimiterBalance(group.payload.slice(group.payload.length - trailingMax));
+	const droppedBalance = balanceDelta(leadingBalance, balanceNegate(trailingBalance));
+	if (!balanceIsZero(droppedBalance)) {
+		const delta = balanceDelta(
+			computeDelimiterBalance(group.payload),
+			computeDelimiterBalance(fileLines.slice(group.startLine - 1, group.endLine)),
+		);
+		if (!balanceEqual(droppedBalance, delta)) return undefined;
+	}
 	return { leading: leadingMax, trailing: trailingMax };
 }
 
@@ -481,6 +523,217 @@ function repairReplacementBoundaries(
 	return { edits: out, warnings };
 }
 
+// ═══════════════════════════════════════════════════════════════════════════
+// After-insert landing correction
+//
+// The body rows of an `insert after N:` hunk carry an implicit depth claim:
+// their leading indentation says how deep the author expects the new lines
+// to sit. Two corrections share that claim, in opposite directions:
+//
+// Outward (any after-insert): when the depth is shallower than line N itself,
+// the hunk is inserting a sibling of some enclosing construct while anchored
+// inside it — the common shape is anchoring on the last statement of a block
+// and writing the body at the parent's depth. Sliding the landing point
+// forward across the structural closer lines that follow (and nothing else —
+// content lines are never crossed) places the body at the depth its
+// indentation names.
+//
+// Inward (block-lowered inserts only): `insert after block N:` anchors on the
+// resolved block's closing line, but a body indented deeper than that closer
+// claims a depth inside the block — the common misreading of the op as
+// "append at the end of block N's body". Sliding the landing point backward
+// across the block's trailing closer lines places the body inside, at its
+// claimed depth. Scoped to block-lowered inserts because there the author
+// named the opener and never saw the closer; a plain `insert after M:` on a
+// closer line stays literal (the escape hatch for genuinely-after content
+// such as method-chain continuations).
+//
+// Both shifts are deliberately conservative: they fire only when the body
+// and anchor indentation are comparable (one is a prefix of the other),
+// cross only pure closing-delimiter lines, stop as soon as depth matches the
+// body's claim, and are abandoned when any other edit in the patch targets a
+// crossed line. Every shift is reported as a warning so the author can
+// re-issue when the original landing was intended.
+
+/** Leading run of tabs and spaces. */
+function leadingIndent(line: string): string {
+	let end = 0;
+	while (end < line.length) {
+		const code = line.charCodeAt(end);
+		if (code !== 9 && code !== 32) break;
+		end++;
+	}
+	return line.slice(0, end);
+}
+
+/** `deeper` strictly extends `shallower` (same indent style, more depth). */
+function isIndentDeeper(deeper: string, shallower: string): boolean {
+	return deeper.length > shallower.length && deeper.startsWith(shallower);
+}
+
+interface AfterInsertGroup {
+	/** Anchor line shared by every insert row of the hunk. */
+	anchor: number;
+	/** Indices into the edit list, in patch order. */
+	members: number[];
+	/** First line of the resolved block when lowered from `insert after block N:`. */
+	blockStart?: number;
+}
+
+/**
+ * Depth of an after-insert hunk's body: the shallowest indentation across its
+ * non-blank rows. Returns `undefined` when no depth claim can be made — an
+ * all-blank or all-closer body, or rows whose indentation styles are not
+ * mutually comparable (tabs vs spaces).
+ */
+function bodyTargetIndent(rows: readonly string[]): string | undefined {
+	const nonBlank = rows.filter(hasNonWhitespace);
+	if (nonBlank.length === 0) return undefined;
+	// A body of pure closers re-balances delimiters; it claims no depth.
+	if (nonBlank.every(row => STRUCTURAL_CLOSER_RE.test(row))) return undefined;
+	let target = leadingIndent(nonBlank[0] ?? "");
+	for (const row of nonBlank) {
+		const indent = leadingIndent(row);
+		if (indent.startsWith(target)) continue;
+		if (target.startsWith(indent)) target = indent;
+		else return undefined;
+	}
+	return target;
+}
+
+/**
+ * Resolve where an after-insert hunk anchored on `group.anchor` should land
+ * given its body depth `target`: the last structural closer line in the run
+ * directly below the anchor whose indentation still covers `target`. Returns
+ * `undefined` when the landing stays put.
+ */
+function resolveShiftedLanding(
+	group: AfterInsertGroup,
+	target: string,
+	fileLines: readonly string[],
+	targetedLines: ReadonlySet<number>,
+): { line: number; crossed: number } | undefined {
+	const anchorText = fileLines[group.anchor - 1];
+	if (anchorText === undefined || !hasNonWhitespace(anchorText)) return undefined;
+	if (!isIndentDeeper(leadingIndent(anchorText), target)) return undefined;
+
+	let landing = group.anchor;
+	let crossed = 0;
+	for (let line = group.anchor + 1; line <= fileLines.length; line++) {
+		const text = fileLines[line - 1] ?? "";
+		if (!hasNonWhitespace(text)) continue; // look past blanks, never land on them
+		if (!STRUCTURAL_CLOSER_RE.test(text)) break; // content is never crossed
+		const indent = leadingIndent(text);
+		if (!indent.startsWith(target)) break; // shallower than the body — crossing would over-escape
+		if (targetedLines.has(line)) return undefined; // another hunk owns this closer
+		landing = line;
+		crossed++;
+		if (indent.length === target.length) break; // depth returned to the body's level
+	}
+	return landing === group.anchor ? undefined : { line: landing, crossed };
+}
+
+/**
+ * Resolve where a block-lowered after-insert anchored on the block's closing
+ * line should land given a body depth `target` deeper than that closer: just
+ * above the block's trailing run of closer lines, bounded below by
+ * `blockStart` (an empty block lands the body right after its opener).
+ * Returns `undefined` when the landing stays put.
+ */
+function resolveInwardLanding(
+	group: AfterInsertGroup,
+	target: string,
+	blockStart: number,
+	fileLines: readonly string[],
+	targetedLines: ReadonlySet<number>,
+): number | undefined {
+	const anchorText = fileLines[group.anchor - 1];
+	if (anchorText === undefined || !hasNonWhitespace(anchorText)) return undefined;
+	// Fires only when the block ends in a pure closer the body out-indents.
+	// Blocks ending in content (indentation-only languages) already land the
+	// body inside the block — nothing to correct.
+	if (!STRUCTURAL_CLOSER_RE.test(anchorText)) return undefined;
+	if (!isIndentDeeper(target, leadingIndent(anchorText))) return undefined;
+
+	let landing = group.anchor;
+	for (let line = group.anchor; line > blockStart; line--) {
+		const text = fileLines[line - 1] ?? "";
+		if (!hasNonWhitespace(text)) {
+			landing = line - 1; // look past trailing blanks, never land after one
+			continue;
+		}
+		if (!STRUCTURAL_CLOSER_RE.test(text)) break; // content reached — land right after it
+		const indent = leadingIndent(text);
+		if (!isIndentDeeper(target, indent)) break; // closer at the body's depth — land after it
+		// Another hunk owns this closer (the group's own rows put the anchor
+		// itself in `targetedLines`; that one is ours to cross).
+		if (line !== group.anchor && targetedLines.has(line)) return undefined;
+		landing = line - 1;
+	}
+	return landing === group.anchor ? undefined : landing;
+}
+
+/**
+ * Slide mis-anchored after-insert hunks to the depth their body indentation
+ * claims: outward past the structural closer lines that follow the anchor
+ * when the body is shallower, or — for `insert after block N:` lowerings —
+ * inward across the block's trailing closers when the body is deeper than
+ * the block's closing line. Returns the corrected edit list plus one warning
+ * per shifted hunk.
+ */
+function repairAfterInsertLandings(
+	edits: readonly AppliedEdit[],
+	fileLines: readonly string[],
+): { edits: readonly AppliedEdit[]; warnings: string[] } {
+	// Group plain (non-replacement) after-anchor inserts per authored hunk:
+	// rows of one hunk share the anchor line and the patch header line.
+	const groups = new Map<string, AfterInsertGroup>();
+	edits.forEach((edit, idx) => {
+		if (edit.kind !== "insert" || edit.mode === "replacement") return;
+		if (edit.cursor.kind !== "after_anchor") return;
+		const key = `${edit.cursor.anchor.line}:${edit.lineNum}`;
+		const group = groups.get(key);
+		if (group === undefined)
+			groups.set(key, { anchor: edit.cursor.anchor.line, members: [idx], blockStart: edit.blockStart });
+		else group.members.push(idx);
+	});
+	if (groups.size === 0) return { edits, warnings: [] };
+
+	// Lines explicitly targeted by any edit; a shift never crosses them.
+	const targetedLines = new Set<number>();
+	for (const edit of edits) {
+		if (edit.kind === "delete") targetedLines.add(edit.anchor.line);
+		else if (edit.cursor.kind === "before_anchor" || edit.cursor.kind === "after_anchor")
+			targetedLines.add(edit.cursor.anchor.line);
+	}
+
+	let out: AppliedEdit[] | undefined;
+	const warnings: string[] = [];
+	const retarget = (group: AfterInsertGroup, line: number): void => {
+		out ??= [...edits];
+		for (const idx of group.members) {
+			const edit = out[idx] as InsertEdit;
+			out[idx] = { ...edit, cursor: { kind: "after_anchor", anchor: { line } } };
+		}
+	};
+	for (const group of groups.values()) {
+		const target = bodyTargetIndent(group.members.map(idx => (edits[idx] as InsertEdit).text));
+		if (target === undefined) continue;
+		const outward = resolveShiftedLanding(group, target, fileLines, targetedLines);
+		if (outward !== undefined) {
+			retarget(group, outward.line);
+			warnings.push(afterInsertLandingShiftWarning(group.anchor, outward.line, outward.crossed));
+			continue;
+		}
+		if (group.blockStart === undefined) continue;
+		const inward = resolveInwardLanding(group, target, group.blockStart, fileLines, targetedLines);
+		if (inward === undefined) continue;
+		retarget(group, inward);
+		warnings.push(blockInsertLandingShiftWarning(group.blockStart, group.anchor, inward));
+	}
+	return { edits: out ?? edits, warnings };
+}
+
 /**
  * Apply a parsed list of edits to a text body. Pure function — no I/O.
  *
@@ -506,15 +759,20 @@ export function applyEdits(text: string, edits: readonly Edit[]): ApplyResult {
 		if (firstChangedLine === undefined || line < firstChangedLine) firstChangedLine = line;
 	};
 
-	const targetEdits = appliedEdits.map((edit, index) => cloneAppliedEdit(edit, index));
+	const targetEdits = dropTrailingPhantomDeletes(
+		appliedEdits.map((edit, index) => cloneAppliedEdit(edit, index)),
+		fileLines,
+	);
 	validateLineBounds(targetEdits, fileLines);
-	const { edits: repaired, warnings } = repairReplacementBoundaries(targetEdits, fileLines);
+	const { edits: repaired, warnings: boundaryWarnings } = repairReplacementBoundaries(targetEdits, fileLines);
+	const { edits: landed, warnings: landingWarnings } = repairAfterInsertLandings(repaired, fileLines);
+	const warnings = [...boundaryWarnings, ...landingWarnings];
 
 	// Partition edits into bof, eof, and anchor-targeted buckets.
 	const bofLines: string[] = [];
 	const eofLines: string[] = [];
 	const anchorEdits: IndexedEdit[] = [];
-	repaired.forEach((edit, idx) => {
+	landed.forEach((edit, idx) => {
 		if (edit.kind === "insert" && edit.cursor.kind === "bof") {
 			bofLines.push(edit.text);
 		} else if (edit.kind === "insert" && edit.cursor.kind === "eof") {

package/src/block.ts

@@ -1,36 +1,60 @@
 /**
- * Expand deferred `replace block N:` edits into concrete inserts + deletes.
+ * Expand deferred block edits (`replace block N:` / `delete block N` /
+ * `insert after block N:`) into concrete inserts + deletes.
  *
  * The hashline parser cannot expand a block edit on its own — the line span is
  * unknown until file text + path (→ language) are available. This transform
  * runs at every apply/preview boundary that has text: it calls the injected
  * {@link BlockResolver} to resolve each block's `[start, end]` span, then emits
- * the exact same `before_anchor` replacement inserts + range deletes that
- * `replace start..end:` produces in the parser. After it runs, no `block` edits
- * remain, so {@link applyEdits} (and recovery) only ever see resolved edits.
+ * the exact same edits the concrete form produces in the parser: `replace
+ * start..end:` inserts + deletes for a replace, a pure range delete for a
+ * delete, and plain `after_anchor` inserts at `end` for an insert-after. After
+ * it runs, no `block` edits remain, so {@link applyEdits} (and recovery) only
+ * ever see resolved edits.
  */
-import { BLOCK_RESOLVER_UNAVAILABLE, blockUnresolvedMessage } from "./messages";
-import type { BlockResolver, Cursor, Edit } from "./types";
+import { STRUCTURAL_CLOSER_RE } from "./apply";
+import {
+	BLOCK_RESOLVER_UNAVAILABLE,
+	blockUnresolvedMessage,
+	insertAfterBlockCloserLoweredWarning,
+	insertAfterBlockUnresolvedLoweredWarning,
+} from "./messages";
+import type { BlockResolution, BlockResolver, Cursor, Edit } from "./types";
 
 export interface ResolveBlockEditsOptions {
 	/**
-	 * How to handle a block edit that cannot be resolved (missing resolver or a
-	 * `null` span). `"throw"` (default) raises a `blockUnresolvedMessage` error —
-	 * used by the authoritative apply + final preview paths. `"drop"` silently
-	 * skips the edit — used by the streaming preview, where a half-written file
-	 * or transient parse error must not throw.
+	 * How to handle a replace/delete block edit that cannot be resolved
+	 * (missing resolver or a `null` span). `"throw"` (default) raises a
+	 * `blockUnresolvedMessage` error — used by the authoritative apply + final
+	 * preview paths. `"drop"` silently skips the edit — used by the streaming
+	 * preview, where a half-written file or transient parse error must not
+	 * throw. Unresolvable `insert after block N:` edits never reach this: they
+	 * are lowered to plain `insert after N:` with a warning.
 	 */
 	onUnresolved?: "throw" | "drop";
+	/**
+	 * Invoked once per successfully resolved block edit, in patch order, with
+	 * the anchor line and the concrete span it resolved to. Lets the host echo
+	 * the resolution back to the caller. Never fired for dropped/unresolvable
+	 * edits.
+	 */
+	onResolved?: (resolution: BlockResolution) => void;
+	/**
+	 * Invoked once per diagnostic produced while resolving — currently the
+	 * `insert after block N:` lowerings (closer anchor or unresolvable block).
+	 * Hosts should surface these on the apply result's `warnings`.
+	 */
+	onWarning?: (message: string) => void;
 }
 
-/** True when at least one edit is an unresolved `replace block N:` edit. */
+/** True when at least one edit is an unresolved deferred block edit. */
 export function hasBlockEdit(edits: readonly Edit[]): boolean {
 	return edits.some(edit => edit.kind === "block");
 }
 
 /**
- * Resolve every `replace block N:` edit in `edits` against `text` (parsed as
- * the language inferred from `path`). Non-block edits pass through untouched.
+ * Resolve every deferred block edit in `edits` against `text` (parsed as the
+ * language inferred from `path`). Non-block edits pass through untouched.
  * Returns a fresh edit list with no `block` variants. The fast path returns the
  * input unchanged when there is nothing to resolve.
  *
@@ -54,13 +78,63 @@ export function resolveBlockEdits(
 			resolved.push(edit);
 			continue;
 		}
+		const op = edit.mode === "insert_after" ? "insert_after" : edit.payloads.length === 0 ? "delete" : "replace";
 		const span = resolver ? resolver({ path, text, line: edit.anchor.line }) : null;
 		if (span === null) {
+			// `insert after block N:` never fails the patch — lower it to plain
+			// `insert after N:` with a warning instead. Two flavors:
+			// - anchored on a pure closing-delimiter line: no block begins
+			//   there, but line N IS the end of one, and "after the end of the
+			//   block" is exactly the plain form — warn with the opener rule.
+			// - otherwise (unsupported language, blank line, unparsable block,
+			//   or no resolver wired): "after the block at N" degrades to
+			//   "after line N" — warn to verify the landing line.
+			if (op === "insert_after") {
+				const anchorText = text.split("\n")[edit.anchor.line - 1];
+				const isCloser = anchorText !== undefined && STRUCTURAL_CLOSER_RE.test(anchorText);
+				options.onWarning?.(
+					isCloser
+						? insertAfterBlockCloserLoweredWarning(edit.anchor.line)
+						: insertAfterBlockUnresolvedLoweredWarning(edit.anchor.line),
+				);
+				for (const payload of edit.payloads) {
+					const cursor: Cursor = { kind: "after_anchor", anchor: { line: edit.anchor.line } };
+					resolved.push({ kind: "insert", cursor, text: payload, lineNum: edit.lineNum, index: synthIndex++ });
+				}
+				continue;
+			}
 			if (onUnresolved === "drop") continue;
 			throw new Error(
-				`line ${edit.lineNum}: ${resolver ? blockUnresolvedMessage(edit.anchor.line) : BLOCK_RESOLVER_UNAVAILABLE}`,
+				`line ${edit.lineNum}: ${
+					resolver ? blockUnresolvedMessage(edit.anchor.line, op, text.split("\n")) : BLOCK_RESOLVER_UNAVAILABLE
+				}`,
 			);
 		}
+		options.onResolved?.({
+			anchorLine: edit.anchor.line,
+			start: span.start,
+			end: span.end,
+			op,
+		});
+		if (op === "insert_after") {
+			// Mirror the parser's `insert after N:` lowering: one `after_anchor`
+			// insert per payload row, anchored on the block's last line. The
+			// `blockStart` tag lets the applier's landing correction slide a
+			// body that claims a depth inside the block back across the block's
+			// trailing closer lines.
+			for (const payload of edit.payloads) {
+				const cursor: Cursor = { kind: "after_anchor", anchor: { line: span.end } };
+				resolved.push({
+					kind: "insert",
+					cursor,
+					text: payload,
+					lineNum: edit.lineNum,
+					index: synthIndex++,
+					blockStart: span.start,
+				});
+			}
+			continue;
+		}
 		// Mirror the parser's `replace start..end:` expansion exactly: one
 		// `before_anchor` replacement insert per payload row at `span.start`,
 		// then one delete per line across `[span.start, span.end]`. An empty

package/src/diff-preview.ts

@@ -1,49 +1,124 @@
 /**
  * Re-number a unified diff that uses the `+<lineNum>|content` /
  * `-<lineNum>|content` / ` <lineNum>|content` line format into a compact
- * preview that anchors every line to its post-edit position. Added lines,
- * removed lines, and context lines all end up with a hashline-style anchor
- * so a follow-up edit can reuse them directly.
+ * current-file preview. Removed lines are counted for stats and post-edit
+ * offset tracking, but omitted from the preview. Added and context lines are
+ * anchored to their post-edit positions so a follow-up edit can reuse visible
+ * concrete lines directly. Long contiguous added runs are summarized with a
+ * `…` marker instead of echoing every inserted line.
  *
  * This is intentionally decoupled from the diff producer: anything that
  * emits the `<sign><lineNum>|<content>` shape works.
  */
 import type { CompactDiffOptions, CompactDiffPreview } from "./types";
 
-export function buildCompactDiffPreview(diff: string, _options: CompactDiffOptions = {}): CompactDiffPreview {
+const DEFAULT_ADDED_RUN_CONTEXT_LINES = 2;
+
+const PREVIEW_ELISION_MARKER = "…";
+/** Blank row separating non-contiguous regions of a numbered diff. */
+const PREVIEW_GAP_ROW = "";
+const RAW_ELISION_MARKERS = new Set(["...", PREVIEW_ELISION_MARKER, `+${PREVIEW_ELISION_MARKER}`]);
+
+function isPreviewSeparator(line: string | undefined): boolean {
+	return line === PREVIEW_ELISION_MARKER || line === PREVIEW_GAP_ROW;
+}
+
+function appendPreviewLine(output: string[], line: string): void {
+	const normalized = RAW_ELISION_MARKERS.has(line) ? PREVIEW_ELISION_MARKER : line;
+	// Separators (elision markers, blank gap rows) never stack: omitted
+	// removed lines between two separators would otherwise leave them
+	// adjacent. A leading separator is dropped outright.
+	if (isPreviewSeparator(normalized) && (output.length === 0 || isPreviewSeparator(output[output.length - 1]))) {
+		return;
+	}
+	output.push(normalized);
+}
+
+interface ParsedDiffLine {
+	kind: "+" | "-" | " ";
+	lineNumber: number;
+	content: string;
+}
+
+function normalizeAddedRunContext(value: number | undefined): number {
+	if (value === undefined || !Number.isFinite(value)) return DEFAULT_ADDED_RUN_CONTEXT_LINES;
+	return Math.max(1, Math.trunc(value));
+}
+
+function parseNumberedDiffLine(line: string): ParsedDiffLine | undefined {
+	const kind = line[0];
+	if (kind !== "+" && kind !== "-" && kind !== " ") return undefined;
+
+	const body = line.slice(1);
+	const sep = body.indexOf("|");
+	if (sep === -1) return undefined;
+
+	const lineNumber = Number.parseInt(body.slice(0, sep), 10);
+	if (!Number.isFinite(lineNumber)) return undefined;
+
+	return { kind, lineNumber, content: body.slice(sep + 1) };
+}
+
+function appendAddedRun(output: string[], run: string[], edgeLines: number): void {
+	if (run.length === 0) return;
+
+	const collapseThreshold = edgeLines * 2 + 1;
+	if (run.length <= collapseThreshold) {
+		for (const text of run) appendPreviewLine(output, text);
+		return;
+	}
+
+	for (let i = 0; i < edgeLines; i++) appendPreviewLine(output, run[i]);
+	appendPreviewLine(output, PREVIEW_ELISION_MARKER);
+	for (let i = run.length - edgeLines; i < run.length; i++) appendPreviewLine(output, run[i]);
+}
+
+export function buildCompactDiffPreview(diff: string, options: CompactDiffOptions = {}): CompactDiffPreview {
 	const lines = diff.length === 0 ? [] : diff.split("\n");
+	const addedRunContext = normalizeAddedRunContext(options.maxAddedRunContext ?? options.maxUnchangedRun);
 	let addedLines = 0;
 	let removedLines = 0;
+	const formatted: string[] = [];
+	const addedRun: string[] = [];
+
+	const flushAddedRun = (): void => {
+		appendAddedRun(formatted, addedRun, addedRunContext);
+		addedRun.length = 0;
+	};
 
 	// External diff producers number `+` lines with the post-edit line number,
 	// `-` lines with the pre-edit line number, and context lines with the
 	// pre-edit line number. To emit fresh line numbers usable for follow-up
 	// edits, convert context-line numbers to post-edit positions by tracking
 	// the running offset (added so far - removed so far) as we walk the diff.
-	const formatted = lines.map(line => {
-		const kind = line[0];
-		if (kind !== "+" && kind !== "-" && kind !== " ") return line;
-
-		const body = line.slice(1);
-		const sep = body.indexOf("|");
-		if (sep === -1) return line;
-
-		const lineNumber = Number.parseInt(body.slice(0, sep), 10);
-		const content = body.slice(sep + 1);
+	for (const line of lines) {
+		const parsed = parseNumberedDiffLine(line);
+		if (!parsed) {
+			flushAddedRun();
+			appendPreviewLine(formatted, line);
+			continue;
+		}
 
-		switch (kind) {
-			case "+":
+		switch (parsed.kind) {
+			case "+": {
 				addedLines++;
-				return `+${lineNumber}:${content}`;
+				addedRun.push(`${parsed.lineNumber}:${parsed.content}`);
+				break;
+			}
 			case "-":
+				flushAddedRun();
 				removedLines++;
-				return `-${lineNumber}:${content}`;
+				break;
 			default: {
-				const newLineNumber = lineNumber + addedLines - removedLines;
-				return ` ${newLineNumber}:${content}`;
+				flushAddedRun();
+				const newLineNumber = parsed.lineNumber + addedLines - removedLines;
+				appendPreviewLine(formatted, `${newLineNumber}:${parsed.content}`);
+				break;
 			}
 		}
-	});
+	}
+	flushAddedRun();
+	while (formatted.length > 0 && isPreviewSeparator(formatted[formatted.length - 1])) formatted.pop();
 
 	return { preview: formatted.join("\n"), addedLines, removedLines };
 }

package/src/grammar.lark

@@ -7,15 +7,17 @@ file_header: "[" filename "#" file_hash "]" LF
 file_hash: /[0-9A-F]{4}/
 filename: /[^#\r\n]+/
 
-hunk: replace_hunk | replace_block_hunk | insert_hunk | delete_hunk | delete_block_hunk
+hunk: replace_hunk | replace_block_hunk | insert_hunk | insert_block_hunk | delete_hunk | delete_block_hunk
 replace_hunk: replace_anchor LF emit_op*
 replace_block_hunk: replace_block_anchor LF emit_op+
 insert_hunk: insert_anchor LF emit_op+
+insert_block_hunk: insert_block_anchor LF emit_op+
 delete_hunk: "delete " header_range LF
 delete_block_hunk: "delete block " LID LF
 replace_anchor: "replace " header_range ":"
 replace_block_anchor: "replace block " LID ":"
 insert_anchor:  "insert " insert_pos ":"
+insert_block_anchor: "insert after block " LID ":"
 insert_pos: "before " LID | "after " LID | "head" | "tail"
 emit_op: "+" /(.*)/ LF