@oh-my-pi/hashline 17.1.7 → 17.2.0

package/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 ## [Unreleased]
 
+## [17.2.0] - 2026-07-30
+
+### Breaking Changes
+
+- Removed `DEL`, `DEL.BLK`, `COPY`, and `COPY.BLK` from the patch language. Use `CUT` / `CUT.BLK` for deletion; a cut does not require a following `PASTE` and leaves the removed content available to later pastes.
+
+### Added
+
+- Added clipboard ops: `CUT N.=M` captures lines into a register (and deletes them), `CUT.BLK N` captures tree-sitter blocks, and `PASTE.PRE|POST N` / `PASTE.HEAD|TAIL` / `PASTE.BLK.POST N` insert the captured lines without retyping. The register flows top-to-bottom across sections, so content moves between files in one patch; `PASTE` does not consume it and the last capture wins.
+- Added `PatcherOptions.clipboard` for a host-owned register that persists across `Patcher.apply` batches. Batches work on a fork (`forkClipboard`) published per landed section (`commitClipboard`), so failed batches never poison the register and a mid-batch write failure still preserves content already cut from disk.
+- Added clipboard safety guards: a `PASTE` with an empty register, a capture overwriting un-pasted `CUT` content, and clipboard ops in same-path sections interleaved across another file's section are all rejected with targeted diagnostics. `CUT` ranges participate in overlap validation, the seen-lines guard, and drift recovery (every captured line must remap).
+
+### Changed
+
+- Simplified `grammar.lark` around shared target and position shapes, collapsing the concrete and block `CUT` forms plus the `INS` / `PASTE` position variants into their common grammar rules.
+
+### Fixed
+
+- Prevented CPU and memory exhaustion in streaming previews by rejecting line anchors above Number.MAX_SAFE_INTEGER and ranges spanning more than 100,000 lines.
+- Fixed an issue where recorded snapshot tags desynced from disk when the filesystem transformed content on write (e.g., auto-formatting on save), which previously caused subsequent edits to incorrectly reformat unrelated parts of the file. `Patcher.commit` now correctly keys the returned file hash and snapshot on the actual content written to disk and issues a warning when a drift is detected.
+
 ## [17.1.5] - 2026-07-27
 
 ### Changed

package/README.md

@@ -49,9 +49,10 @@ session-aware recovery on mismatch.
 Inside a section:
 - `SWAP A.=B:` — replace lines A.=B with following `+TEXT` body rows.
 - `SWAP.BLK A:` — replace the syntactic block beginning on line A.
-- `DEL A.=B` / `DEL.BLK A` — delete concrete lines or a resolved block.
+- `CUT A.=B` / `CUT.BLK A` — delete concrete lines or a resolved block and capture them for `PASTE`.
 - `INS.PRE A:` / `INS.POST A:` / `INS.HEAD:` / `INS.TAIL:` — insert following body rows.
 - `INS.BLK.POST A:` — insert following body rows after the resolved block's last line.
+- `PASTE.PRE A` / `PASTE.POST A` / `PASTE.HEAD` / `PASTE.TAIL` / `PASTE.BLK.POST A` — insert the clipboard; no body rows. The register flows top-to-bottom across sections (cross-file moves) and can be host-persisted across batches via `PatcherOptions.clipboard`.
 - `REM` — delete the whole file named by the section header.
 - `MV DEST` — move/rename the section file to `DEST` (optionally after line edits).
 - `+TEXT` — literal body row (use `+` alone for a blank line).

package/dist/types/apply.d.ts

@@ -1,10 +1,30 @@
-import type { ApplyResult, Edit } from "./types.js";
+/**
+ * Apply a parsed list of {@link Edit}s to a text body and return the
+ * post-edit lines plus any diagnostic warnings. Pure function: no FS, no
+ * mutation of the input.
+ *
+ * Replacement groups are first normalized by {@link repairReplacementBoundaries},
+ * which absorbs common model mistakes where a payload restates unchanged range
+ * boundaries or duplicates/drops structural closers.
+ */
+import type { ApplyResult, Clipboard, Edit } from "./types.js";
 /** A line that is nothing but closing delimiters: `}`, `)`, `];`, `})`, `},`. */
 export declare const STRUCTURAL_CLOSER_RE: RegExp;
+/** 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 declare function applyEdits(text: string, edits: readonly Edit[]): ApplyResult;
+export declare function applyEdits(text: string, edits: readonly Edit[], options?: ApplyEditsOptions): ApplyResult;

package/dist/types/block.d.ts

@@ -1,13 +1,10 @@
 import type { BlockResolution, BlockResolver, Edit } from "./types.js";
+/** 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";
     /**

package/dist/types/clipboard.d.ts

@@ -0,0 +1,22 @@
+import type { Clipboard, Edit } from "./types.js";
+/** True when at least one edit reads or writes the clipboard register. */
+export declare function hasClipboardEdit(edits: readonly Edit[]): boolean;
+/** 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 declare function resolveClipboardEdits(edits: readonly Edit[], fileLines: readonly string[], clipboard: Clipboard, options?: ResolveClipboardEditsOptions): readonly Edit[];
+/** Create a transactional working copy of a clipboard register. */
+export declare function forkClipboard(source?: Clipboard): Clipboard;
+/** Publish a clipboard fork back to its source register. */
+export declare function commitClipboard(fork: Clipboard, target: Clipboard): void;
+/**
+ * Validate that every paste has a preceding or persisted capture without
+ * mutating the register or reading file content.
+ */
+export declare function validateClipboardSequence(edits: readonly Edit[], clipboard: Clipboard): void;

package/dist/types/format.d.ts

@@ -11,8 +11,6 @@ export declare const HL_FILE_SUFFIX = "]";
 export declare const HL_PAYLOAD_REPLACE = "+";
 /** Hunk-header keyword for concrete line replacement. */
 export declare const HL_REPLACE_KEYWORD = "SWAP";
-/** Hunk-header keyword for concrete line deletion. */
-export declare const HL_DELETE_KEYWORD = "DEL";
 /** Hunk-header keyword for insertion operations. */
 export declare const HL_INSERT_KEYWORD = "INS";
 /** Insert position keyword for inserting before a concrete line. */
@@ -25,10 +23,16 @@ export declare const HL_INSERT_HEAD = "HEAD";
 export declare const HL_INSERT_TAIL = "TAIL";
 /** Hunk-header keyword: `SWAP.BLK N:` resolves N to a tree-sitter block range and replaces its span. */
 export declare 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 declare 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 declare 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 declare const HL_CUT_KEYWORD = "CUT";
+/** Hunk-header keyword: `CUT.BLK N` captures the tree-sitter block at N and deletes its span. */
+export declare const HL_CUT_BLOCK_KEYWORD = "CUT.BLK";
+/** Hunk-header keyword prefix: `PASTE.PRE|POST N` / `PASTE.HEAD|TAIL` inserts the clipboard. */
+export declare const HL_PASTE_KEYWORD = "PASTE";
+/** Hunk-header keyword: `PASTE.BLK.POST N` inserts the clipboard after the tree-sitter block at N. */
+export declare const HL_PASTE_AFTER_BLOCK_KEYWORD = "PASTE.BLK.POST";
 /** File-level keyword: `REM` deletes the whole file named by the section header. */
 export declare const HL_REM_KEYWORD = "REM";
 /** File-level keyword: `MV DEST` renames/moves the section file to `DEST`. */
@@ -46,8 +50,8 @@ export declare const HL_LINE_RE_RAW = "[1-9]\\d*";
 export declare const HL_LINE_CAPTURE_RE_RAW = "([1-9]\\d*)";
 /** Format a concrete replacement hunk header. */
 export declare function formatReplaceHeader(start: number, end: number): string;
-/** Format a concrete deletion hunk header. */
-export declare function formatDeleteHeader(start: number, end?: number): string;
+/** Format a concrete cut hunk header. */
+export declare function formatCutHeader(start: number, end?: number): string;
 /** Format an insertion hunk header for a cursor position. */
 export declare function formatInsertHeader(cursor: Cursor): string;
 /** Number of hex characters in a content-derived file-hash tag. */

package/dist/types/index.d.ts

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

package/dist/types/input.d.ts

@@ -1,8 +1,16 @@
-import type { ApplyResult, BlockResolver, Edit, FileOp, SplitOptions } from "./types.js";
+import type { ApplyResult, BlockResolver, Clipboard, Edit, FileOp, SplitOptions } from "./types.js";
 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;
 }
 /**
  * Returns true when the input contains at least one line that the tokenizer
@@ -55,8 +63,11 @@ export declare 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;
     /**
      * Streaming-tolerant counterpart to {@link applyTo}. Uses
      * {@link parsePatchStreaming} so a trailing in-flight op (no payload yet,
@@ -66,9 +77,9 @@ export declare 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;
     /**
      * A copy of this section rebound to a different target `path`, preserving
      * the snapshot tag, diff body, and any cached parse result. Used by the

package/dist/types/messages.d.ts

@@ -9,7 +9,7 @@ export declare const MISMATCH_CONTEXT = 2;
  */
 export declare function formatAnchoredContext(anchorLines: readonly number[], fileLines: readonly string[]): string[];
 /** Concrete range operation rejected because its absolute end precedes its start. */
-export type AbsoluteRangeOp = "replace" | "delete";
+export type AbsoluteRangeOp = "replace" | "cut";
 /** Explain absolute range endpoints and provide safe, non-applying retry forms. */
 export declare function invalidAbsoluteRangeMessage(patchLine: number, start: number, end: number, op: AbsoluteRangeOp, block?: BlockSpan): string;
 /** Optional patch envelope start marker; silently consumed. */
@@ -34,9 +34,9 @@ export declare const MINUS_BULLET_AUTO_PIPED_WARNING = "Auto-prefixed bare `- `
 /** Unified-diff-style `-` row in a hunk body. */
 export declare const MINUS_ROW_REJECTED = "`-` rows are not valid; the range already names the lines being changed. For Markdown bullets or other literal `-` lines, prefix the literal row with `+`: `+- item`.";
 /** Replace hunk with no body. */
-export declare const EMPTY_REPLACE = "`SWAP N.=M:` needs at least one `+TEXT` body row. To delete lines, use `DEL N.=M`.";
-/** `replace_block N:` hunk with no body. */
-export declare const EMPTY_BLOCK = "`SWAP.BLK N:` needs at least one `+TEXT` body row. To delete a block, use `DEL.BLK N`.";
+export declare const EMPTY_REPLACE = "`SWAP N.=M:` needs at least one `+TEXT` body row. To delete lines, use `CUT N.=M`.";
+/** `SWAP.BLK N:` hunk with no body. */
+export declare const EMPTY_BLOCK = "`SWAP.BLK N:` needs at least one `+TEXT` body row. To delete a block, use `CUT.BLK N`.";
 /** Optional source-aware suggestions appended to block-anchor diagnostics. */
 export interface BlockDiagnosticSuggestions {
     /** Closest following multi-line block that begins after the authored anchor. */
@@ -45,28 +45,21 @@ export interface BlockDiagnosticSuggestions {
     enclosingBlock?: BlockSpan;
 }
 /**
- * Block-anchored replace/delete could not resolve to a syntactic block
- * (unsupported language, blank/out-of-range line, no node beginning on N, or
- * parse error). Appends a {@link formatAnchoredContext} preview when
- * `fileLines` is given. `insert_after_block N:` never reaches this — it is
- * lowered to plain `insert after N:` instead (see
- * {@link insertAfterBlockUnresolvedLoweredWarning}).
- */
-export declare function blockUnresolvedMessage(line: number, op?: "replace" | "delete", fileLines?: readonly string[], suggestions?: BlockDiagnosticSuggestions): string;
-/** Block-anchored edit reached a path with no {@link BlockResolver} wired in — a host-configuration bug. */
-export declare const BLOCK_RESOLVER_UNAVAILABLE = "`SWAP.BLK`/`DEL.BLK`/`INS.BLK.POST` are not available here (no block resolver configured). Use a concrete line range.";
-/**
- * `insert_after_block N:` anchored on a closing-delimiter line, lowered to
- * plain `insert after N:` — the closer ends a block, and inserting after it
- * is exactly what the plain form does.
+ * A block-anchored replace/cut could not resolve to a syntactic block.
+ * Appends a {@link formatAnchoredContext} preview when `fileLines` is given.
+ * `INS.BLK.POST N:` never reaches this path; it lowers to `INS.POST N:`.
  */
+export declare function blockUnresolvedMessage(line: number, op?: AbsoluteRangeOp, fileLines?: readonly string[], suggestions?: BlockDiagnosticSuggestions): string;
+/** Block-anchored edit reached a path with no {@link BlockResolver} wired in. */
+export declare const BLOCK_RESOLVER_UNAVAILABLE = "Block ops (`SWAP.BLK`, `INS.BLK.POST`, `CUT.BLK`, `PASTE.BLK.POST`) are not available here (no block resolver configured). Use a concrete line range.";
+/** `INS.BLK.POST N:` anchored on a closing-delimiter line; applied as `INS.POST N:`. */
 export declare function insertAfterBlockCloserLoweredWarning(line: number): string;
-/**
- * `insert_after_block N:` anchor unresolvable (unsupported language, blank
- * line, parse error, or no resolver), lowered to plain `insert after N:` —
- * applying with a warning beats failing the patch.
- */
+/** `INS.BLK.POST N:` anchor unresolvable; applied as `INS.POST N:`. */
 export declare function insertAfterBlockUnresolvedLoweredWarning(line: number): string;
+/** `PASTE.BLK.POST N` anchored on a closing-delimiter line; applied as `PASTE.POST N`. */
+export declare function pasteAfterBlockCloserLoweredWarning(line: number): string;
+/** `PASTE.BLK.POST N` anchor unresolvable; applied as `PASTE.POST N`. */
+export declare function pasteAfterBlockUnresolvedLoweredWarning(line: number): string;
 /**
  * A one-sided boundary echo whose payload is too short to be the widened
  * range's full content: dropping the echo deletes range line(s) the payload
@@ -85,18 +78,26 @@ export declare function ambiguousBoundaryEchoMessage(startLine: number, endLine:
  */
 export declare function ambiguousCloserSpareMessage(startLine: number, endLine: number, closerLine: number, count: number): string;
 /**
- * Internal invariant: `applyEdits` received an unresolved `replace_block N:`
- * edit; `resolveBlockEdits` must run first. Wiring bug, not authored input.
+ * Internal invariant: `applyEdits` received an unresolved block edit;
+ * `resolveBlockEdits` must run first.
  */
-export declare const UNRESOLVED_BLOCK_INTERNAL = "internal error: unresolved `SWAP.BLK` edit reached the applier (resolveBlockEdits was not run).";
-/** Delete hunk received a body row. */
-export declare const DELETE_TAKES_NO_BODY = "`DEL N.=M` does not take body rows. Remove the body, or use `SWAP N.=M:`.";
+export declare const UNRESOLVED_BLOCK_INTERNAL = "internal error: unresolved block edit reached the applier (resolveBlockEdits was not run).";
 /** `REM` received a body row or coexists with line edits. */
 export declare const REM_TAKES_NO_BODY = "`REM` deletes the whole file and takes no body rows or line ops. Issue it alone under the header.";
 /** `MV` received a body row. */
 export declare const MOVE_TAKES_NO_BODY = "`MV DEST` does not take body rows. Put line edits above the `MV` row; the destination path follows `MV` on the same line.";
-/** `delete_block N` hunk received a body row. */
-export declare const DELETE_BLOCK_TAKES_NO_BODY = "`DEL.BLK N` does not take body rows. Remove the body, or use `SWAP.BLK N:`.";
+/** `CUT N.=M` hunk received a body row. */
+export declare const CUT_TAKES_NO_BODY = "`CUT N.=M` captures + deletes lines and takes no body rows. To replace lines with new content, use `SWAP N.=M:`.";
+/** `PASTE` hunk received a body row. */
+export declare const PASTE_TAKES_NO_BODY = "`PASTE` inserts the clipboard content and takes no `+` body rows. To insert literal text, use `INS`.";
+/** `PASTE` ran with an empty clipboard register. */
+export declare const EMPTY_PASTE = "`PASTE` found nothing in the clipboard. Ops run top-to-bottom across the whole patch (sections included): put `CUT N.=M` or `CUT.BLK N` above the `PASTE`.";
+/**
+ * Clipboard ops inside a same-path section that was merged across another
+ * file's section. Same-path sections coalesce into their first occurrence, so
+ * an interleaved layout would silently reorder the register sequence.
+ */
+export declare const CLIPBOARD_INTERLEAVED_SECTIONS = "`CUT`/`PASTE` cannot be used in a file whose sections are interleaved with another file's: same-path sections merge into the first occurrence, which would reorder the clipboard sequence. Keep each file's ops under ONE `[path#TAG]` header.";
 /** Insert hunk with no body. */
 export declare const EMPTY_INSERT = "`INS` needs at least one `+TEXT` body row.";
 /**
@@ -123,6 +124,15 @@ export declare const RECOVERY_LINE_REMAP_WARNING = "Recovered by remapping stale
  * onto live content and warn instead of hard-failing.
  */
 export declare const HEADTAIL_DRIFT_WARNING = "Applied the `INS.HEAD:`/`INS.TAIL:` edit despite a stale snapshot tag (file changed since your read) \u2014 head/tail position is content-independent. Re-read if the drift was unexpected.";
+/**
+ * The `Filesystem` reported that what actually landed on disk differs from
+ * what was written (see `WriteResult.text`) — most commonly an ACP-connected
+ * editor reformatting the buffer on save (e.g. `format_on_save` with tab/space
+ * settings that don't match the file). The recorded snapshot is re-keyed on
+ * the real, post-write content so the next edit's tag validation matches
+ * reality instead of silently drifting.
+ */
+export declare function writeDriftWarning(path: string): string;
 /**
  * Section omitted the mandatory snapshot tag. Shared by the apply
  * ({@link Patcher.prepare}) and preview/diff paths so both stay in lockstep.
@@ -164,12 +174,10 @@ export interface UnseenLinesReveal {
  */
 export declare function unseenLinesMessage(sectionPath: string, unseenLines: readonly number[], tag: string, reveal?: UnseenLinesReveal): string;
 /** Op kind of a deferred block edit, for {@link blockSingleLineMessage}. */
-export type BlockOp = "replace" | "delete" | "insert_after";
+export type BlockOp = "replace" | "insert_after" | "cut" | "paste_after";
 /**
- * A `replace_block`/`delete_block`/`insert_after_block` anchor resolved to a
- * single line — almost always a bare statement the model mis-anchored, not a
- * multi-line construct. The plain op is unambiguous for one line; the block
- * form only earns its keep when it spares counting a closing line you cannot
- * see. Reject and point at both fixes.
+ * A block-op anchor resolved to a single line: line N is a bare statement,
+ * not the opening line of a multi-line construct. The plain op is exact for
+ * one line, so reject and point at it.
  */
 export declare function blockSingleLineMessage(line: number, op: BlockOp, enclosingBlock?: BlockSpan): string;

package/dist/types/patcher.d.ts

@@ -3,7 +3,7 @@ import type { Patch, PatchSection } from "./input.js";
 import { type LineEnding } from "./normalize.js";
 import { Recovery } from "./recovery.js";
 import type { SnapshotStore } from "./snapshots.js";
-import type { ApplyResult, BlockResolution, BlockResolver, FileOp } from "./types.js";
+import type { ApplyResult, BlockResolution, BlockResolver, Clipboard, FileOp } from "./types.js";
 export interface PatcherOptions {
     /** Storage backend used for all reads and writes. */
     fs: Filesystem;
@@ -21,6 +21,12 @@ export interface PatcherOptions {
      * validate on content hash alone and any anchor into the tagged content applies.
      */
     enforceSeenLines?: boolean;
+    /**
+     * Host-owned clipboard register shared across batches, so `CUT` content
+     * can be `PASTE`d by a later {@link Patcher.apply} call. Each batch works
+     * on a fork and publishes it back only after writes land.
+     */
+    clipboard?: Clipboard;
 }
 /** Per-section result returned by {@link Patcher.apply} / {@link Patcher.commit}. */
 export interface PatchSectionResult {
@@ -38,7 +44,13 @@ export interface PatchSectionResult {
     persisted: string;
     /** Final text that the {@link Filesystem} actually wrote (may differ if the FS transformed it). */
     written: string;
-    /** 4-hex content-hash tag for `after`. Use to anchor follow-up edits. */
+    /**
+     * 4-hex content-hash tag. Hashes the content the {@link Filesystem}
+     * reports actually landed on disk (see `written`), which normally equals
+     * `after` but can diverge when the write path transforms content (e.g. an
+     * ACP-bridge write reformatted by the client's format-on-save). Use to
+     * anchor follow-up edits.
+     */
     fileHash: string;
     /** Hashline section header (`[path#tag]`) of the post-edit content. */
     header: string;
@@ -49,9 +61,8 @@ export interface PatchSectionResult {
     /** Destination path when this section includes `MV DEST`. */
     moveDest?: string;
     /**
-     * Resolved spans for any `replace_block`/`delete_block` ops, present when the
-     * apply matched the tagged content. Undefined for patches with no block ops
-     * (and for resolutions routed through drift recovery, where numbers shift).
+     * Resolved spans for block ops, present when the apply matched the tagged
+     * content. Undefined for patches with no block ops and for drift recovery.
      */
     blockResolutions?: BlockResolution[];
 }
@@ -91,6 +102,7 @@ export declare class Patcher {
     readonly snapshots: SnapshotStore;
     readonly recovery: Recovery;
     readonly blockResolver: BlockResolver | undefined;
+    readonly clipboard: Clipboard | undefined;
     constructor(options: PatcherOptions);
     /**
      * Apply every section in `patch`. `prepare` runs the full apply for each
@@ -110,10 +122,13 @@ export declare class Patcher {
      * {@link PreparedSection} which can be fed to {@link commit} to land
      * the result on the filesystem.
      *
+     * `clipboard` is the register shared by `CUT`/`PASTE` ops. Pass the batch
+     * register when preparing several sections so content can move across files.
+     *
      * Throws on parse error, missing-file-for-anchored-edit, or unrecovered
      * tag mismatch ({@link MismatchError}).
      */
-    prepare(section: PatchSection): Promise<PreparedSection>;
+    prepare(section: PatchSection, clipboard?: Clipboard): Promise<PreparedSection>;
     /**
      * Commit a previously {@link prepare}d section to the filesystem.
      * Restores line endings and BOM, writes via the {@link Filesystem}, and

package/dist/types/recovery.d.ts

@@ -1,10 +1,12 @@
 import type { SnapshotStore } from "./snapshots.js";
-import type { Edit } from "./types.js";
+import type { Clipboard, Edit } from "./types.js";
 export interface RecoveryArgs {
     path: string;
     currentText: string;
     fileHash: string;
     edits: readonly Edit[];
+    /** Shared clipboard register for `cut`/`paste` edits, threaded into the replay apply. */
+    clipboard?: Clipboard;
 }
 export interface RecoveryResult {
     /** Post-recovery text. */

package/dist/types/tokenizer.d.ts

@@ -9,12 +9,6 @@ export type BlockTarget = {
 } | {
     kind: "block";
     anchor: Anchor;
-} | {
-    kind: "delete";
-    range: ParsedRange;
-} | {
-    kind: "delete_block";
-    anchor: Anchor;
 } | {
     kind: "insert_before";
     anchor: Anchor;
@@ -24,6 +18,18 @@ export type BlockTarget = {
 } | {
     kind: "insert_after_block";
     anchor: Anchor;
+} | {
+    kind: "cut";
+    range: ParsedRange;
+} | {
+    kind: "cut_block";
+    anchor: Anchor;
+} | {
+    kind: "paste";
+    cursor: Cursor;
+} | {
+    kind: "paste_after_block";
+    anchor: Anchor;
 } | {
     kind: "rem";
 } | {

package/dist/types/types.d.ts

@@ -48,21 +48,44 @@ export type Edit = {
     oldAssertion?: string;
 } | {
     /**
-     * Deferred block edit (`replace_block N:` / `delete_block N` /
-     * `insert_after_block N:`). The exact line span is unknown at parse
-     * time — it is computed by {@link resolveBlockEdits} once file text +
-     * path (→ language) are available, then expanded into concrete edits:
-     * a non-empty `payloads` without `mode` (from `replace_block`) becomes
-     * the same `replacement` inserts + deletes that `replace start.=end:`
-     * produces; an empty `payloads` (from `delete_block`) becomes a pure
-     * range deletion; `mode: "insert_after"` becomes plain `after_anchor`
-     * inserts at the block's last line. `applyEdits` never sees this
-     * variant.
+     * Clipboard cut (`CUT N.=M`, or the resolved form of `CUT.BLK N`).
+     * Captures the range's current lines into the {@link Clipboard}
+     * register during the applier's clipboard pre-pass and lowers to one
+     * `delete` per range line at parse/resolve time.
+     */
+    kind: "cut";
+    range: ParsedRange;
+    lineNum: number;
+    index: number;
+} | {
+    /**
+     * Clipboard insertion (`PASTE.PRE N` / `PASTE.POST N` / `PASTE.HEAD` /
+     * `PASTE.TAIL`, or the resolved form of `PASTE.BLK.POST N`). Expanded
+     * by the clipboard pre-pass into one plain insert per captured line.
+     * `blockStart` mirrors the insert variant's field for block-lowered
+     * pastes so landing correction can slide the body across trailing
+     * closer lines.
+     */
+    kind: "paste";
+    cursor: Cursor;
+    lineNum: number;
+    index: number;
+    blockStart?: number;
+} | {
+    /**
+     * Deferred block edit (`SWAP.BLK N:`, `INS.BLK.POST N:`,
+     * `CUT.BLK N`, or `PASTE.BLK.POST N`). The exact line span is
+     * unknown at parse time; {@link resolveBlockEdits} computes it once
+     * file text and language are available, then expands it into
+     * concrete edits. `mode: "insert_after"` becomes plain
+     * `after_anchor` inserts, `"cut"` becomes a clipboard cut plus
+     * per-line deletes, and `"paste_after"` becomes a paste after the
+     * resolved block. No mode denotes a block replacement.
      */
     kind: "block";
     anchor: Anchor;
     payloads: string[];
-    mode?: "insert_after";
+    mode?: "insert_after" | "cut" | "paste_after";
     lineNum: number;
     index: number;
 };
@@ -82,10 +105,9 @@ export interface ApplyResult {
     /** Diagnostic warnings collected by the parser, patcher, or recovery. */
     warnings?: string[];
     /**
-     * Resolved spans for each `replace_block`/`delete_block` op in this apply,
-     * in patch order. Present only when the apply matched the tagged content
-     * (the common no-drift path), so the line numbers line up with what the
-     * caller read. Absent when there were no block ops.
+     * Resolved spans for each block op in this apply, in patch order. Present
+     * only when the apply matched the tagged content, so the line numbers match
+     * what the caller read. Absent when there were no block ops.
      */
     blockResolutions?: BlockResolution[];
 }
@@ -127,9 +149,7 @@ export interface CompactDiffOptions {
     /** Back-compat alias for {@link maxAddedRunContext}. */
     maxUnchangedRun?: number;
 }
-/**
- * Resolved 1-indexed inclusive line span of a `replace_block N:` target.
- */
+/** Resolved 1-indexed inclusive line span of a block target. */
 export interface BlockSpan {
     /** First line of the block (1-indexed, inclusive). */
     start: number;
@@ -137,11 +157,9 @@ export interface BlockSpan {
     end: number;
 }
 /**
- * One `replace_block N:` / `delete_block N` / `insert_after_block N:` anchor
- * resolved to its concrete line span. Surfaced on {@link ApplyResult} so the
- * host can echo "block N → lines start.=end" and let the model catch a wrong
- * opener — e.g. a decorator or doc-comment that sits in a separate node
- * outside the resolved block.
+ * One block-op anchor resolved to its concrete line span. Surfaced on
+ * {@link ApplyResult} so the host can echo the resolved range and let the
+ * model catch an anchor on the wrong opener.
  */
 export interface BlockResolution {
     /** The 1-indexed line the block op was anchored on (the `N`). */
@@ -151,9 +169,9 @@ export interface BlockResolution {
     /** Last line of the resolved span (1-indexed, inclusive). */
     end: number;
     /** Which block op produced this resolution. */
-    op: "replace" | "delete" | "insert_after";
+    op: "replace" | "insert_after" | "cut" | "paste_after";
 }
-/** Request handed to a {@link BlockResolver} to resolve one `replace_block N:` anchor. */
+/** Request handed to a {@link BlockResolver} to resolve one block-op anchor. */
 export interface BlockResolverRequest {
     /** Target file path (used to infer language by extension). */
     path: string;
@@ -163,10 +181,19 @@ export interface BlockResolverRequest {
     line: number;
 }
 /**
- * Resolves a `replace_block N:` anchor to the line span of the syntactic block
- * that begins on line N. Returns `null` when no block can be resolved
- * (unrecognized language, blank/out-of-range line, no node begins there, or the
- * resolved subtree has a syntax error). Pure seam: the hashline core declares
- * the contract; the host injects a tree-sitter-backed implementation.
+ * Resolves a block-op anchor to the line span of the syntactic block beginning
+ * on that line. Returns `null` for an unsupported language, invalid line, absent
+ * opener, or syntax error. The host injects the tree-sitter-backed implementation.
  */
 export type BlockResolver = (request: BlockResolverRequest) => BlockSpan | null;
+/**
+ * Mutable clipboard register threaded through one patch application. Filled
+ * by `CUT` edits and read by `PASTE` edits in patch source order, across
+ * sections, so content can move between files. Create one per batch (`{}`)
+ * and hand it to every {@link Patcher.prepare} / `applyTo` call in that batch;
+ * callers that omit it get a private per-call register.
+ */
+export interface Clipboard {
+    /** Lines captured by the most recent `CUT`, or unset. */
+    lines?: readonly string[];
+}

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/hashline",
-	"version": "17.1.7",
+	"version": "17.2.0",
 	"description": "Hashline: a compact, line-anchored patch language and applier. Pluggable FS/IO so it works over disk, in-memory, or any custom backend.",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -33,7 +33,7 @@
 		"fmt": "biome format --write ."
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-natives": "17.1.7",
+		"@oh-my-pi/pi-natives": "17.2.0",
 		"lru-cache": "11.5.2"
 	},
 	"devDependencies": {