@oh-my-pi/hashline 17.1.7 → 17.2.0

package/src/apply.ts

@@ -7,6 +7,8 @@
  * which absorbs common model mistakes where a payload restates unchanged range
  * boundaries or duplicates/drops structural closers.
  */
+
+import { resolveClipboardEdits } from "./clipboard";
 import {
 	afterInsertLandingShiftWarning,
 	ambiguousBoundaryEchoMessage,
@@ -15,7 +17,7 @@ import {
 	UNRESOLVED_BLOCK_INTERNAL,
 } from "./messages";
 import { cloneCursor } from "./tokenizer";
-import type { Anchor, ApplyResult, Cursor, Edit } from "./types";
+import type { Anchor, ApplyResult, Clipboard, Cursor, Edit } from "./types";
 
 type LineOrigin = "original" | "insert" | "replacement";
 
@@ -1221,24 +1223,43 @@ function repairAfterInsertLandings(
 	return { edits: out ?? edits, warnings };
 }
 
+/** Optional knobs for {@link applyEdits}. */
+export interface ApplyEditsOptions {
+	/**
+	 * Clipboard register filled by `cut` edits and read by `paste` edits.
+	 * Thread one register through every section of a batch to move content
+	 * across files; omitted, the call gets a private register.
+	 */
+	clipboard?: Clipboard;
+	/** `PASTE` with an empty register: `throw` (default) or `drop` (streaming previews). */
+	onEmptyPaste?: "throw" | "drop";
+}
+
 /**
  * Apply a parsed list of edits to a text body. Pure function — no I/O.
  *
  * Returns the post-edit text and the first changed line number (1-indexed).
  * Throws if an anchor is out of bounds.
  */
-export function applyEdits(text: string, edits: readonly Edit[]): ApplyResult {
+export function applyEdits(text: string, edits: readonly Edit[], options: ApplyEditsOptions = {}): ApplyResult {
 	if (edits.length === 0) return { text, firstChangedLine: undefined };
 
+	const fileLines = text.split("\n");
+
+	// Clipboard pre-pass: capture `cut` ranges from the original lines and
+	// expand `paste` edits into plain inserts in authored order.
+	const concrete = resolveClipboardEdits(edits, fileLines, options.clipboard ?? {}, {
+		...(options.onEmptyPaste === undefined ? {} : { onEmptyPaste: options.onEmptyPaste }),
+	});
+
 	// Block edits are deferred until `resolveBlockEdits` expands them into
 	// concrete inserts + deletes. Reaching the applier with one still present
 	// is an internal wiring bug, not authored-input error.
-	for (const edit of edits) {
+	for (const edit of concrete) {
 		if (edit.kind === "block") throw new Error(UNRESOLVED_BLOCK_INTERNAL);
 	}
-	const appliedEdits = edits as readonly AppliedEdit[];
+	const appliedEdits = concrete as readonly AppliedEdit[];
 
-	const fileLines = text.split("\n");
 	const lineOrigins: LineOrigin[] = fileLines.map(() => "original");
 
 	let firstChangedLine: number | undefined;

package/src/block.ts

@@ -1,25 +1,22 @@
 /**
- * Expand deferred block edits (`replace_block N:` / `delete_block N` /
- * `insert_after_block N:`) into concrete inserts + deletes.
+ * Expand deferred block edits into concrete inserts, cuts, pastes, and 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 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.
+ * The parser cannot expand a block edit until file text and language are
+ * available. This transform resolves each anchored span, then emits the same
+ * low-level edits as the corresponding concrete operation. After it runs, no
+ * `block` edits remain, so {@link applyEdits} and recovery see concrete edits.
  */
 import { STRUCTURAL_CLOSER_RE } from "./apply";
 import {
 	BLOCK_RESOLVER_UNAVAILABLE,
 	type BlockDiagnosticSuggestions,
+	type BlockOp,
 	blockSingleLineMessage,
 	blockUnresolvedMessage,
 	insertAfterBlockCloserLoweredWarning,
 	insertAfterBlockUnresolvedLoweredWarning,
+	pasteAfterBlockCloserLoweredWarning,
+	pasteAfterBlockUnresolvedLoweredWarning,
 } from "./messages";
 import type { BlockResolution, BlockResolver, BlockSpan, Cursor, Edit } from "./types";
 
@@ -67,15 +64,12 @@ function findEnclosingBlock(
 	return null;
 }
 
+/** Optional knobs for {@link resolveBlockEdits}. */
 export interface ResolveBlockEditsOptions {
 	/**
-	 * 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.
+	 * How to handle a replace/cut block edit that cannot be resolved. `"throw"`
+	 * (default) raises a block error; `"drop"` skips it for streaming previews.
+	 * Unresolvable after-block edits lower to their plain after-line form.
 	 */
 	onUnresolved?: "throw" | "drop";
 	/**
@@ -124,7 +118,7 @@ export function resolveBlockEdits(
 			resolved.push(edit);
 			continue;
 		}
-		const op = edit.mode === "insert_after" ? "insert_after" : edit.payloads.length === 0 ? "delete" : "replace";
+		const op: BlockOp = edit.mode ?? "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
@@ -135,9 +129,19 @@ export function resolveBlockEdits(
 			// - 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") {
+			if (op === "insert_after" || op === "paste_after") {
 				const anchorText = text.split("\n")[edit.anchor.line - 1];
 				const isCloser = anchorText !== undefined && STRUCTURAL_CLOSER_RE.test(anchorText);
+				if (op === "paste_after") {
+					options.onWarning?.(
+						isCloser
+							? pasteAfterBlockCloserLoweredWarning(edit.anchor.line)
+							: pasteAfterBlockUnresolvedLoweredWarning(edit.anchor.line),
+					);
+					const cursor: Cursor = { kind: "after_anchor", anchor: { line: edit.anchor.line } };
+					resolved.push({ kind: "paste", cursor, lineNum: edit.lineNum, index: synthIndex++ });
+					continue;
+				}
 				options.onWarning?.(
 					isCloser
 						? insertAfterBlockCloserLoweredWarning(edit.anchor.line)
@@ -183,6 +187,32 @@ export function resolveBlockEdits(
 			end: span.end,
 			op,
 		});
+		if (op === "paste_after") {
+			// Mirror the block-lowered insert: paste after the block's last
+			// line, tagging `blockStart` so landing correction can slide a body
+			// claiming a depth inside the block back across its trailing closers.
+			resolved.push({
+				kind: "paste",
+				cursor: { kind: "after_anchor", anchor: { line: span.end } },
+				lineNum: edit.lineNum,
+				index: synthIndex++,
+				blockStart: span.start,
+			});
+			continue;
+		}
+		if (op === "cut") {
+			// Capture the resolved span before deleting it line-by-line.
+			resolved.push({
+				kind: "cut",
+				range: { start: { line: span.start }, end: { line: span.end } },
+				lineNum: edit.lineNum,
+				index: synthIndex++,
+			});
+			for (let line = span.start; line <= span.end; line++) {
+				resolved.push({ kind: "delete", anchor: { line }, lineNum: edit.lineNum, index: synthIndex++ });
+			}
+			continue;
+		}
 		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
@@ -202,10 +232,8 @@ export function resolveBlockEdits(
 			}
 			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
-		// `payloads` (from `delete_block N`) emits no inserts — a pure deletion.
+		// Mirror `SWAP start.=end:`: replacement inserts at `span.start`, then
+		// one delete per line across the resolved span.
 		for (const payload of edit.payloads) {
 			const cursor: Cursor = { kind: "before_anchor", anchor: { line: span.start } };
 			resolved.push({

package/src/clipboard.ts

@@ -0,0 +1,110 @@
+/**
+ * Clipboard register support for `CUT` / `PASTE` ops.
+ *
+ * `CUT` captures its current source lines before ordinary delete edits apply.
+ * `PASTE` expands the latest capture into inserts. One register flows through
+ * patch sections in authored order, so content moves across files; the latest
+ * cut wins and paste does not consume it.
+ */
+import { HL_CUT_KEYWORD, HL_RANGE_SEP } from "./format";
+import { EMPTY_PASTE } from "./messages";
+import { cloneCursor } from "./tokenizer";
+import type { Clipboard, Edit } from "./types";
+
+type CutEdit = Extract<Edit, { kind: "cut" }>;
+
+function describeCutEdit(edit: CutEdit): string {
+	const { start, end } = edit.range;
+	const range = start.line === end.line ? `${start.line}` : `${start.line}${HL_RANGE_SEP}${end.line}`;
+	return `${HL_CUT_KEYWORD} ${range}`;
+}
+
+/** True when at least one edit reads or writes the clipboard register. */
+export function hasClipboardEdit(edits: readonly Edit[]): boolean {
+	return edits.some(
+		edit =>
+			edit.kind === "cut" ||
+			edit.kind === "paste" ||
+			(edit.kind === "block" && (edit.mode === "cut" || edit.mode === "paste_after")),
+	);
+}
+
+/** Optional knobs for {@link resolveClipboardEdits}. */
+export interface ResolveClipboardEditsOptions {
+	/** `PASTE` with an empty register: `throw` (default) or `drop` (streaming previews). */
+	onEmptyPaste?: "throw" | "drop";
+}
+
+/**
+ * Resolve clipboard edits against the original file lines in authored order.
+ * Cuts fill the register and emit nothing; pastes become plain inserts.
+ */
+export function resolveClipboardEdits(
+	edits: readonly Edit[],
+	fileLines: readonly string[],
+	clipboard: Clipboard,
+	options: ResolveClipboardEditsOptions = {},
+): readonly Edit[] {
+	if (!hasClipboardEdit(edits)) return edits;
+	const onEmptyPaste = options.onEmptyPaste ?? "throw";
+	const resolved: Edit[] = [];
+	let synthIndex = 0;
+	for (const edit of edits) {
+		if (edit.kind === "cut") {
+			const { start, end } = edit.range;
+			if (start.line < 1 || end.line > fileLines.length) {
+				throw new Error(
+					`line ${edit.lineNum}: \`${describeCutEdit(edit)}\` is out of range (file has ${fileLines.length} lines).`,
+				);
+			}
+			clipboard.lines = fileLines.slice(start.line - 1, end.line);
+			continue;
+		}
+		if (edit.kind === "paste") {
+			const lines = clipboard.lines;
+			if (lines === undefined) {
+				if (onEmptyPaste === "drop") continue;
+				throw new Error(`line ${edit.lineNum}: ${EMPTY_PASTE}`);
+			}
+			for (const text of lines) {
+				resolved.push({
+					kind: "insert",
+					cursor: cloneCursor(edit.cursor),
+					text,
+					lineNum: edit.lineNum,
+					index: synthIndex++,
+					...(edit.blockStart === undefined ? {} : { blockStart: edit.blockStart }),
+				});
+			}
+			continue;
+		}
+		resolved.push(edit);
+	}
+	return resolved;
+}
+
+/** Create a transactional working copy of a clipboard register. */
+export function forkClipboard(source?: Clipboard): Clipboard {
+	return source === undefined ? {} : { ...source };
+}
+
+/** Publish a clipboard fork back to its source register. */
+export function commitClipboard(fork: Clipboard, target: Clipboard): void {
+	if (fork.lines === undefined) delete target.lines;
+	else target.lines = fork.lines;
+}
+
+/**
+ * Validate that every paste has a preceding or persisted capture without
+ * mutating the register or reading file content.
+ */
+export function validateClipboardSequence(edits: readonly Edit[], clipboard: Clipboard): void {
+	let hasLines = clipboard.lines !== undefined;
+	for (const edit of edits) {
+		if (edit.kind === "cut") {
+			hasLines = true;
+		} else if (edit.kind === "paste" && !hasLines) {
+			throw new Error(`line ${edit.lineNum}: ${EMPTY_PASTE}`);
+		}
+	}
+}

package/src/format.ts

@@ -15,8 +15,6 @@ export const HL_PAYLOAD_REPLACE = "+";
 
 /** Hunk-header keyword for concrete line replacement. */
 export const HL_REPLACE_KEYWORD = "SWAP";
-/** Hunk-header keyword for concrete line deletion. */
-export const HL_DELETE_KEYWORD = "DEL";
 /** Hunk-header keyword for insertion operations. */
 export const HL_INSERT_KEYWORD = "INS";
 /** Insert position keyword for inserting before a concrete line. */
@@ -29,10 +27,16 @@ export const HL_INSERT_HEAD = "HEAD";
 export const HL_INSERT_TAIL = "TAIL";
 /** Hunk-header keyword: `SWAP.BLK N:` resolves N to a tree-sitter block range and replaces its span. */
 export const HL_REPLACE_BLOCK_KEYWORD = "SWAP.BLK";
-/** Hunk-header keyword: `DEL.BLK N` resolves N to a tree-sitter block range and deletes its span. */
-export const HL_DELETE_BLOCK_KEYWORD = "DEL.BLK";
 /** Hunk-header keyword: `INS.BLK.POST N:` inserts after the last line of the tree-sitter block at N. */
 export const HL_INSERT_AFTER_BLOCK_KEYWORD = "INS.BLK.POST";
+/** Hunk-header keyword: `CUT N.=M` captures lines into the clipboard register and deletes them. */
+export const HL_CUT_KEYWORD = "CUT";
+/** Hunk-header keyword: `CUT.BLK N` captures the tree-sitter block at N and deletes its span. */
+export const HL_CUT_BLOCK_KEYWORD = "CUT.BLK";
+/** Hunk-header keyword prefix: `PASTE.PRE|POST N` / `PASTE.HEAD|TAIL` inserts the clipboard. */
+export const HL_PASTE_KEYWORD = "PASTE";
+/** Hunk-header keyword: `PASTE.BLK.POST N` inserts the clipboard after the tree-sitter block at N. */
+export const HL_PASTE_AFTER_BLOCK_KEYWORD = "PASTE.BLK.POST";
 /** File-level keyword: `REM` deletes the whole file named by the section header. */
 export const HL_REM_KEYWORD = "REM";
 /** File-level keyword: `MV DEST` renames/moves the section file to `DEST`. */
@@ -63,9 +67,9 @@ export function formatReplaceHeader(start: number, end: number): string {
 	return `${HL_REPLACE_KEYWORD} ${start}${HL_RANGE_SEP}${end}${HL_HEADER_COLON}`;
 }
 
-/** Format a concrete deletion hunk header. */
-export function formatDeleteHeader(start: number, end = start): string {
-	return start === end ? `${HL_DELETE_KEYWORD} ${start}` : `${HL_DELETE_KEYWORD} ${start}${HL_RANGE_SEP}${end}`;
+/** Format a concrete cut hunk header. */
+export function formatCutHeader(start: number, end = start): string {
+	return start === end ? `${HL_CUT_KEYWORD} ${start}` : `${HL_CUT_KEYWORD} ${start}${HL_RANGE_SEP}${end}`;
 }
 
 /** Format an insertion hunk header for a cursor position. */

package/src/grammar.lark

@@ -7,21 +7,18 @@ file_header: "[" filename "#" file_hash "]" LF
 file_hash: /[0-9A-F]{4}/
 filename: /[^#\r\n]+/
 
-hunk: replace_hunk | replace_block_hunk | insert_hunk | insert_block_hunk | delete_hunk | delete_block_hunk | remove_hunk | move_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: "DEL " header_range LF
-delete_block_hunk: "DEL.BLK " LID LF
-remove_hunk: "REM" LF
-move_hunk: "MV " filename LF emit_op*
-replace_anchor: "SWAP " header_range ":"
-replace_block_anchor: "SWAP.BLK " LID ":"
-insert_anchor:  "INS." insert_pos ":"
-insert_block_anchor: "INS.BLK.POST " LID ":"
-insert_pos: "PRE " LID | "POST " LID | "HEAD" | "TAIL"
-emit_op: "+" /(.*)/ LF
+hunk: swap_hunk | ins_hunk | cut_hunk | paste_hunk | rem_hunk | mv_hunk
+swap_hunk: "SWAP " header_range ":" LF body*
+         | "SWAP.BLK " LID ":" LF body+
+ins_hunk: "INS." pos ":" LF body+
+cut_hunk: "CUT" target LF
+paste_hunk: "PASTE." pos LF
+rem_hunk: "REM" LF
+mv_hunk: "MV " filename LF body*
+
+target: " " header_range | ".BLK " LID
+pos: "PRE " LID | "POST " LID | "BLK.POST " LID | "HEAD" | "TAIL"
+body: "+" /(.*)/ LF
 
 header_range: LID ".=" LID
 LID: /[1-9]\d*/

package/src/index.ts

@@ -1,5 +1,6 @@
 export * from "./apply";
 export * from "./block";
+export * from "./clipboard";
 export * from "./diff-preview";
 export * from "./format";
 export * from "./fs";

package/src/input.ts

@@ -10,10 +10,12 @@
 import * as path from "node:path";
 import { applyEdits } from "./apply";
 import { resolveBlockEdits } from "./block";
+import { hasClipboardEdit } from "./clipboard";
 import { HL_FILE_HASH_EXAMPLES, HL_FILE_HASH_LENGTH, HL_FILE_HASH_SEP, HL_FILE_PREFIX, HL_FILE_SUFFIX } from "./format";
+import { CLIPBOARD_INTERLEAVED_SECTIONS } from "./messages";
 import { parsePatch, parsePatchStreaming } from "./parser";
 import { Tokenizer } from "./tokenizer";
-import type { ApplyResult, BlockResolver, Edit, FileOp, SplitOptions } from "./types";
+import type { ApplyResult, BlockResolver, Clipboard, Edit, FileOp, SplitOptions } from "./types";
 
 // Pure classification — single shared tokenizer is safe.
 const TOKENIZER = new Tokenizer();
@@ -97,6 +99,14 @@ interface RawSection {
 	path: string;
 	fileHash?: string;
 	diff: string;
+	/**
+	 * True when this section coalesced same-path sections that were NOT
+	 * adjacent in the authored input (another file's section sat between
+	 * them). Merging moves the later ops up to the first occurrence, which
+	 * would silently reorder the clipboard register sequence — so clipboard
+	 * ops are rejected in such sections.
+	 */
+	interleaved?: boolean;
 }
 
 /**
@@ -239,10 +249,13 @@ export class PatchSection {
 	readonly diff: string;
 	#parsed: { edits: Edit[]; fileOp?: FileOp; warnings: string[] } | undefined;
 
+	#interleavedMerge: boolean;
+
 	constructor(raw: RawSection) {
 		this.path = raw.path;
 		this.fileHash = raw.fileHash;
 		this.diff = raw.diff;
+		this.#interleavedMerge = raw.interleaved === true;
 	}
 
 	/**
@@ -253,6 +266,12 @@ export class PatchSection {
 	parse(): { edits: Edit[]; fileOp?: FileOp; warnings: readonly string[] } {
 		this.#parsed ??= parsePatch(this.diff);
 		const parsed = this.#parsed;
+		// Same-path sections merge into their first occurrence; when that merge
+		// crossed another file's section, the authored top-to-bottom register
+		// order is gone, so clipboard ops cannot apply deterministically.
+		if (this.#interleavedMerge && hasClipboardEdit(parsed.edits)) {
+			throw new Error(CLIPBOARD_INTERLEAVED_SECTIONS);
+		}
 		const fileOp =
 			parsed.fileOp === undefined
 				? undefined
@@ -289,6 +308,8 @@ export class PatchSection {
 			if (edit.kind === "delete") return true;
 			// A `replace_block N:` edit is anchored to concrete content on line N.
 			if (edit.kind === "block") return true;
+			// A `CUT` range reads concrete content.
+			if (edit.kind === "cut") return true;
 			return edit.cursor.kind === "before_anchor" || edit.cursor.kind === "after_anchor";
 		});
 	}
@@ -305,6 +326,10 @@ export class PatchSection {
 				lines.add(edit.anchor.line);
 				continue;
 			}
+			if (edit.kind === "cut") {
+				for (let line = edit.range.start.line; line <= edit.range.end.line; line++) lines.add(line);
+				continue;
+			}
 			if (edit.cursor.kind === "before_anchor" || edit.cursor.kind === "after_anchor") {
 				lines.add(edit.cursor.anchor.line);
 			}
@@ -321,15 +346,18 @@ export class PatchSection {
 	 *
 	 * `blockResolver` resolves any `replace_block N:` edits against `text`; an
 	 * unresolvable block throws (this is the final, authoritative preview path).
+	 *
+	 * `clipboard` is the register shared by `CUT`/`PASTE` ops. Pass one when
+	 * applying several sections so content can move across files.
 	 */
-	applyTo(text: string, blockResolver?: BlockResolver): ApplyResult {
+	applyTo(text: string, blockResolver?: BlockResolver, clipboard?: Clipboard): ApplyResult {
 		const { edits, warnings } = this.parse();
 		const resolveWarnings: string[] = [];
 		const resolved = resolveBlockEdits(edits, text, this.path, blockResolver, {
 			onUnresolved: "throw",
 			onWarning: warning => resolveWarnings.push(warning),
 		});
-		const result = applyEdits(text, resolved);
+		const result = applyEdits(text, resolved, { clipboard: clipboard ?? {} });
 		// Preserve parse warnings so consumers don't need to call `parse()`
 		// separately.
 		const merged = [...warnings, ...resolveWarnings, ...(result.warnings ?? [])];
@@ -347,16 +375,16 @@ export class PatchSection {
 	 *
 	 * `blockResolver` resolves any `replace_block N:` edits against `text`; an
 	 * unresolvable block is silently dropped so a half-written file does not
-	 * throw mid-stream.
+	 * throw mid-stream. A `PASTE` with an empty register is dropped too.
 	 */
-	applyPartialTo(text: string, blockResolver?: BlockResolver): ApplyResult {
+	applyPartialTo(text: string, blockResolver?: BlockResolver, clipboard?: Clipboard): ApplyResult {
 		const { edits, warnings } = parsePatchStreaming(this.diff);
 		const resolveWarnings: string[] = [];
 		const resolved = resolveBlockEdits(edits, text, this.path, blockResolver, {
 			onUnresolved: "drop",
 			onWarning: warning => resolveWarnings.push(warning),
 		});
-		const result = applyEdits(text, resolved);
+		const result = applyEdits(text, resolved, { clipboard: clipboard ?? {}, onEmptyPaste: "drop" });
 		const merged = [...warnings, ...resolveWarnings, ...(result.warnings ?? [])];
 		return merged.length > 0
 			? { ...result, warnings: merged }
@@ -374,6 +402,7 @@ export class PatchSection {
 			path,
 			...(this.fileHash !== undefined ? { fileHash: this.fileHash } : {}),
 			diff: this.diff,
+			...(this.#interleavedMerge ? { interleaved: true } : {}),
 		});
 		next.#parsed = this.#parsed;
 		return next;
@@ -432,7 +461,8 @@ export class Patch {
  * fails. Path order is preserved by first occurrence.
  */
 function mergeSamePathSections(sections: RawSection[]): RawSection[] {
-	const byPath = new Map<string, { fileHash?: string; diffs: string[] }>();
+	const byPath = new Map<string, { fileHash?: string; diffs: string[]; interleaved: boolean }>();
+	let previousPath: string | undefined;
 	for (const section of sections) {
 		const existing = byPath.get(section.path);
 		if (existing) {
@@ -446,17 +476,24 @@ function mergeSamePathSections(sections: RawSection[]): RawSection[] {
 				);
 			}
 			if (existing.fileHash === undefined && section.fileHash !== undefined) existing.fileHash = section.fileHash;
+			// Merging across another file's section moves these ops up to the
+			// first occurrence; flag it so clipboard ops can refuse the reorder.
+			if (previousPath !== section.path) existing.interleaved = true;
 			existing.diffs.push(section.diff);
+			previousPath = section.path;
 			continue;
 		}
 		byPath.set(section.path, {
 			...(section.fileHash !== undefined ? { fileHash: section.fileHash } : {}),
 			diffs: [section.diff],
+			interleaved: false,
 		});
+		previousPath = section.path;
 	}
 	return Array.from(byPath, ([sectionPath, entry]) => ({
 		path: sectionPath,
 		...(entry.fileHash !== undefined ? { fileHash: entry.fileHash } : {}),
 		diff: entry.diffs.join("\n"),
+		...(entry.interleaved ? { interleaved: true } : {}),
 	}));
 }