@oh-my-pi/pi-coding-agent 15.5.3 → 15.5.4

package/src/hashline/executor.ts

@@ -1,347 +0,0 @@
-import {
-	ABORT_WARNING,
-	IMPLICIT_CONTINUATION_WARNING,
-	INLINE_PAYLOAD_ACCEPTED_WARNING,
-	PAYLOAD_LINE_PREFIX_DEMOTED_WARNING,
-	REPLACE_PAIR_COALESCED_WARNING,
-} from "./constants";
-import {
-	HL_OP_CHARS,
-	HL_OP_DELETE,
-	HL_OP_INSERT_AFTER,
-	HL_OP_INSERT_BEFORE,
-	HL_OP_REPLACE,
-	HL_PAYLOAD_PREFIX,
-} from "./hash";
-import {
-	cloneCursor,
-	type HashlineToken,
-	HashlineTokenizer,
-	isDeleteOpWithPayload,
-	type ParsedRange,
-} from "./tokenizer";
-import type { Anchor, HashlineCursor, HashlineEdit } from "./types";
-
-function validateRangeOrder(range: ParsedRange, lineNum: number): void {
-	if (range.end.line < range.start.line) {
-		throw new Error(`line ${lineNum}: range ${range.start.line}-${range.end.line} ends before it starts.`);
-	}
-}
-
-function rangesEqual(a: ParsedRange, b: ParsedRange): boolean {
-	return a.start.line === b.start.line && a.end.line === b.end.line;
-}
-
-function rangeContains(outer: ParsedRange, inner: ParsedRange): boolean {
-	return outer.start.line <= inner.start.line && inner.end.line <= outer.end.line;
-}
-
-function expandRange(range: ParsedRange): Anchor[] {
-	const anchors: Anchor[] = [];
-	for (let line = range.start.line; line <= range.end.line; line++) {
-		anchors.push({ line });
-	}
-	return anchors;
-}
-
-type PendingOp =
-	| { kind: "insert"; cursor: HashlineCursor; lineNum: number }
-	| { kind: "replace"; range: ParsedRange; lineNum: number };
-
-interface Pending {
-	op: PendingOp;
-	payload: string[];
-}
-
-/**
- * Token-driven state machine that turns a stream of {@link HashlineToken}s
- * into the flat list of {@link HashlineEdit}s applied downstream by the
- * apply/diff layers.
- *
- * The executor owns:
- *   - the running edit index (kept monotonic across pending flushes),
- *   - the pending-payload buffer (lines accumulated for the most recently
- *     opened insert/replace op),
- *   - all parse-time diagnostics (range order, "delete with payload",
- *     orphan payload, unrecognized op),
- *   - the {@link terminated} flag set by `envelope-end`/`abort`.
- *
- * Tokens are dispatched in the order they arrive; the matching tokenizer
- * supplies the line numbers carried inside each token so diagnostics line
- * up with the source.
- */
-export class HashlineExecutor {
-	#edits: HashlineEdit[] = [];
-	#warnings: string[] = [];
-	#editIndex = 0;
-	#pending: Pending | undefined;
-	#terminated = false;
-
-	/** True once an `envelope-end` or `abort` token has been observed. */
-	get terminated(): boolean {
-		return this.#terminated;
-	}
-
-	/**
-	 * Consume one token. After `terminated` flips true subsequent feeds
-	 * are silently ignored so callers can keep draining their tokenizer
-	 * without explicit early-exit guards.
-	 */
-	feed(token: HashlineToken): void {
-		if (this.#terminated) return;
-
-		switch (token.kind) {
-			case "envelope-begin":
-				return;
-			case "envelope-end":
-				this.#terminated = true;
-				return;
-			case "abort":
-				this.#warnings.push(ABORT_WARNING);
-				this.#terminated = true;
-				return;
-			case "header":
-				this.#flushPending();
-				return;
-			case "blank":
-				return;
-			case "payload":
-				this.#handlePayload(token.text, token.lineNum);
-				return;
-			case "raw":
-				this.#handleRaw(token.text, token.lineNum);
-				return;
-			case "op-delete":
-				this.#flushPending();
-				if (token.trailingPayload) {
-					throw new Error(
-						`line ${token.lineNum}: ${HL_OP_DELETE} deletes only. Payload is forbidden after ${HL_OP_DELETE}; use ${HL_OP_REPLACE} to replace.`,
-					);
-				}
-				validateRangeOrder(token.range, token.lineNum);
-				for (const anchor of expandRange(token.range)) {
-					this.#edits.push({ kind: "delete", anchor, lineNum: token.lineNum, index: this.#editIndex++ });
-				}
-				return;
-			case "op-insert":
-				this.#flushPending();
-				this.#pending = {
-					op: { kind: "insert", cursor: token.cursor, lineNum: token.lineNum },
-					payload: [],
-				};
-				if (token.inlineBody !== undefined) {
-					this.#pending.payload.push(token.inlineBody);
-					if (!this.#warnings.includes(INLINE_PAYLOAD_ACCEPTED_WARNING)) {
-						this.#warnings.push(INLINE_PAYLOAD_ACCEPTED_WARNING);
-					}
-				}
-				return;
-			case "op-replace":
-				validateRangeOrder(token.range, token.lineNum);
-				if (this.#pending !== undefined && this.#pending.op.kind === "replace") {
-					const outer = this.#pending.op.range;
-					const inner = token.range;
-					if (rangesEqual(outer, inner)) {
-						// Identical-range before/after pair. Drop the "before" payload
-						// silently; the second op proceeds as the lone winner. Other
-						// overlap shapes (different ranges, replace+delete, delete+delete)
-						// still hit the post-hoc validator.
-						this.#pending = undefined;
-						if (!this.#warnings.includes(REPLACE_PAIR_COALESCED_WARNING)) {
-							this.#warnings.push(REPLACE_PAIR_COALESCED_WARNING);
-						}
-					} else if (rangeContains(outer, inner)) {
-						// Model wrote a payload line in read-output `LINE:TEXT` format
-						// (or `A-B:TEXT` for a sub-range) inside an outer `A-B:` block.
-						// The tokenizer can't tell payload from op when the anchor and
-						// sigil shape are identical, so demote: append the op's inline
-						// body to the pending payload, strip the `LINE:` prefix, and
-						// keep accumulating. Without this the inner anchors would each
-						// register as their own delete and clash with the outer range.
-						this.#pending.payload.push(token.inlineBody ?? "");
-						if (!this.#warnings.includes(PAYLOAD_LINE_PREFIX_DEMOTED_WARNING)) {
-							this.#warnings.push(PAYLOAD_LINE_PREFIX_DEMOTED_WARNING);
-						}
-						return;
-					}
-				}
-				this.#flushPending();
-				this.#pending = {
-					op: { kind: "replace", range: token.range, lineNum: token.lineNum },
-					payload: [],
-				};
-				if (token.inlineBody !== undefined) {
-					this.#pending.payload.push(token.inlineBody);
-					if (!this.#warnings.includes(INLINE_PAYLOAD_ACCEPTED_WARNING)) {
-						this.#warnings.push(INLINE_PAYLOAD_ACCEPTED_WARNING);
-					}
-				}
-				return;
-		}
-	}
-
-	/**
-	 * Flush any open pending op (with its full accumulated payload, including
-	 * explicit `+` blank lines) and return the accumulated edits and warnings.
-	 * The executor is single-use; reset() is required for reuse.
-	 * Throws if two replace/delete ops target the same line with non-identical
-	 * shapes (different ranges, replace+delete, delete+delete). Identical-range
-	 * `A-B:` pairs in the same hunk are coalesced last-wins by `feed()` with a
-	 * warning, so they never reach the validator.
-	 */
-	end(): { edits: HashlineEdit[]; warnings: string[] } {
-		this.#flushPending();
-		this.#validateNoOverlappingDeletes();
-		return { edits: this.#edits, warnings: this.#warnings };
-	}
-
-	/** Reset to a fresh state so the same instance can drive another parse. */
-	reset(): void {
-		this.#edits = [];
-		this.#warnings = [];
-		this.#editIndex = 0;
-		this.#pending = undefined;
-		this.#terminated = false;
-	}
-
-	/**
-	 * Each `:` / `!` op contributes a delete edit per line in its range; if
-	 * any line ends up targeted by deletes originating from two different
-	 * source ops (distinguished by their `lineNum`), the patch is internally
-	 * inconsistent. Identical-range `A-B:` pairs are already collapsed by
-	 * `feed()`; remaining shapes here are an `A-B:` that overlaps a later
-	 * `N!`/`N:` with a different range, or two `!` deletes on the same line.
-	 * The applier would run both literally and the file would end up with two
-	 * copies of the line, not a chosen winner.
-	 */
-	#validateNoOverlappingDeletes(): void {
-		const sourceLinesByAnchor = new Map<number, number[]>();
-		for (const edit of this.#edits) {
-			if (edit.kind !== "delete") continue;
-			let sourceLines = sourceLinesByAnchor.get(edit.anchor.line);
-			if (sourceLines === undefined) {
-				sourceLines = [];
-				sourceLinesByAnchor.set(edit.anchor.line, sourceLines);
-			}
-			if (!sourceLines.includes(edit.lineNum)) sourceLines.push(edit.lineNum);
-		}
-		for (const [anchorLine, sourceLines] of sourceLinesByAnchor) {
-			if (sourceLines.length < 2) continue;
-			const [firstOp, secondOp] = [...sourceLines].sort((a, b) => a - b);
-			throw new Error(
-				`line ${secondOp}: anchor line ${anchorLine} is already targeted by the ${HL_OP_REPLACE}/${HL_OP_DELETE} op on line ${firstOp}. ` +
-					`Issue ONE op per range; payload is only the final desired content, never a before/after pair.`,
-			);
-		}
-	}
-
-	#handlePayload(text: string, lineNum: number): void {
-		if (this.#pending) {
-			this.#pending.payload.push(text);
-			return;
-		}
-
-		throw new Error(
-			`line ${lineNum}: payload line has no preceding ${HL_OP_INSERT_BEFORE}, ${HL_OP_INSERT_AFTER}, ${HL_OP_REPLACE}, or ${HL_OP_DELETE} operation. ` +
-				`Got ${JSON.stringify(`${HL_PAYLOAD_PREFIX}${text}`)}.`,
-		);
-	}
-
-	#handleRaw(text: string, lineNum: number): void {
-		if (this.#pending) {
-			if (text.trim().length === 0) return;
-			// Lenient legacy fallback: the tokenizer routes a line to `raw` only
-			// when it does not parse as an op, header, payload, or envelope
-			// marker. A `raw` token while a pending op exists is therefore an
-			// unambiguous continuation row that the model authored without the
-			// `+` prefix. Accept it as payload and warn so the canonical
-			// `+`-prefixed form remains preferred.
-			this.#pending.payload.push(text);
-			if (!this.#warnings.includes(IMPLICIT_CONTINUATION_WARNING)) {
-				this.#warnings.push(IMPLICIT_CONTINUATION_WARNING);
-			}
-			return;
-		}
-
-		// Whitespace-only raw lines outside any pending op are silently dropped;
-		// fully empty lines arrive as `blank` tokens.
-		if (text.trim().length === 0) return;
-		// Orphan raw text outside any pending op: pick the most specific
-		// diagnostic so the model sees the actionable hint.
-		if (isDeleteOpWithPayload(text)) {
-			throw new Error(
-				`line ${lineNum}: ${HL_OP_DELETE} deletes only. Payload is forbidden after ${HL_OP_DELETE}; use ${HL_OP_REPLACE} to replace.`,
-			);
-		}
-
-		const firstChar = text[0];
-		const startsWithOp = firstChar !== undefined && HL_OP_CHARS.includes(firstChar);
-		if (startsWithOp || firstChar === "-" || firstChar === "@" || firstChar === "«" || firstChar === "»") {
-			throw new Error(
-				`line ${lineNum}: unrecognized op. Use LINE${HL_OP_INSERT_BEFORE} (insert before), LINE${HL_OP_INSERT_AFTER} (insert after), LINE${HL_OP_REPLACE} / A-B${HL_OP_REPLACE} (replace), or LINE${HL_OP_DELETE} / A-B${HL_OP_DELETE} (delete). ` +
-					`Got ${JSON.stringify(text)}.`,
-			);
-		}
-
-		throw new Error(
-			`line ${lineNum}: payload line has no preceding ${HL_OP_INSERT_BEFORE}, ${HL_OP_INSERT_AFTER}, ${HL_OP_REPLACE}, or ${HL_OP_DELETE} operation. ` +
-				`Got ${JSON.stringify(text)}.`,
-		);
-	}
-
-	#flushPending(): void {
-		const pending = this.#pending;
-		if (!pending) return;
-
-		const { op, payload } = pending;
-		const linesToInsert = payload.length === 0 ? [""] : payload;
-
-		if (op.kind === "insert") {
-			for (const text of linesToInsert) {
-				this.#edits.push({
-					kind: "insert",
-					cursor: cloneCursor(op.cursor),
-					text,
-					lineNum: op.lineNum,
-					index: this.#editIndex++,
-				});
-			}
-		} else {
-			for (const text of linesToInsert) {
-				this.#edits.push({
-					kind: "insert",
-					cursor: { kind: "before_anchor", anchor: { ...op.range.start } },
-					text,
-					lineNum: op.lineNum,
-					index: this.#editIndex++,
-				});
-			}
-			for (const anchor of expandRange(op.range)) {
-				this.#edits.push({ kind: "delete", anchor, lineNum: op.lineNum, index: this.#editIndex++ });
-			}
-		}
-
-		this.#pending = undefined;
-	}
-}
-
-/**
- * Drive a full hashline diff through the tokenizer + executor pipeline and
- * return the resulting edits plus any parse-time warnings. This is the
- * convenience entry point most callers want; reach for {@link
- * HashlineTokenizer}/{@link HashlineExecutor} directly only when you need
- * streaming feeds, cross-section state, or custom token handling.
- */
-export function parseHashline(diff: string): { edits: HashlineEdit[]; warnings: string[] } {
-	const tokenizer = new HashlineTokenizer();
-	const executor = new HashlineExecutor();
-	const drain = (tokens: HashlineToken[]): void => {
-		for (const token of tokens) {
-			if (executor.terminated) return;
-			executor.feed(token);
-		}
-	};
-	drain(tokenizer.feed(diff));
-	drain(tokenizer.end());
-	return executor.end();
-}

package/src/hashline/grammar.lark

@@ -1,22 +0,0 @@
-start: begin_patch hunk+ end_patch
-begin_patch: "*** Begin Patch" LF
-end_patch: "*** End Patch" LF?
-
-hunk: update_hunk
-update_hunk: "$HFILE$" filename ("#" file_hash)? LF line_op*
-
-filename: /([^\s#]+)/
-file_hash: /[0-9a-f]{4}/
-
-line_op: insert_before | insert_after | replace | delete
-insert_before: anchor "$HOP_INSERT_BEFORE$" LF payload*
-insert_after: anchor "$HOP_INSERT_AFTER$" LF payload*
-replace: range "$HOP_REPLACE$" LF payload*
-delete: range "$HOP_DELETE$" LF
-payload: "+" /[^\n]*/ LF
-
-anchor: LID | "EOF" | "BOF"
-range: LID ("-" LID)?
-LID: /[1-9]\d*/
-
-%import common.LF

package/src/hashline/hash.ts

@@ -1,131 +0,0 @@
-/**
- * Core hash utilities shared by hashline edit mode, read/search output,
- * and prompt helpers.
- */
-
-const regexEscape = (str: string): string => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-
-/**
- * Decoration prefix that may precede a line number in tool output:
- * `>` (context line in grep), `-` (removed line), `*` (match line).
- * Any combination, in any order, surrounded by optional
- * whitespace. Output formatters emit at most one decoration per line; the
- * parser stays liberal because it accepts whatever the model echoes back.
- */
-export const HL_ANCHOR_DECORATION_RE_RAW = `\\s*[>\\-*]*\\s*`;
-
-/** Capture-group regex source for a decorated bare line-number anchor. */
-export const HL_ANCHOR_RE_RAW = `${HL_ANCHOR_DECORATION_RE_RAW}(\\d+)`;
-
-/** Bare positive line-number Lid (no decorations, no captures, no anchors). */
-export const HL_LINE_RE_RAW = `[1-9]\\d*`;
-
-/** Capture-group form of {@link HL_LINE_RE_RAW}. */
-export const HL_LINE_CAPTURE_RE_RAW = `([1-9]\\d*)`;
-
-/** Four-hex-character file hash carried by a hashline section header. */
-export const HL_FILE_HASH_RE_RAW = `[0-9a-f]{4}`;
-
-/** Capture-group form of {@link HL_FILE_HASH_RE_RAW}. */
-export const HL_FILE_HASH_CAPTURE_RE_RAW = `(${HL_FILE_HASH_RE_RAW})`;
-
-/** Separator between a hashline file path and its file hash. */
-export const HL_FILE_HASH_SEP = "#";
-
-/** Separator between a line number and displayed line content in hashline mode. */
-export const HL_LINE_BODY_SEP = ":";
-
-/** Regex-escaped form of {@link HL_LINE_BODY_SEP}, safe for embedding inside a regex. */
-export const HL_LINE_BODY_SEP_RE_RAW = regexEscape(HL_LINE_BODY_SEP);
-
-/**
- * Representative file hashes for use in user-facing error messages and prompt
- * examples.
- */
-export const HL_FILE_HASH_EXAMPLES = ["1a2b", "3c4d", "9f3e"] as const;
-
-/**
- * Format a comma-separated list of example anchors with an optional line-number
- * prefix, quoted for inclusion in error messages: `"160", "42", "7"`.
- */
-export function describeAnchorExamples(linePrefix = ""): string {
-	const examples = linePrefix ? [linePrefix, `${linePrefix.slice(0, -1) || "4"}2`, "7"] : ["160", "42", "7"];
-	return examples.map(e => `"${e}"`).join(", ");
-}
-
-/**
- * Substitute every grammar placeholder with the value derived from its
- * TypeScript counterpart. Grammars that don't reference these placeholders
- * pass through unchanged.
- */
-export function resolveHashlineGrammarPlaceholders(grammar: string): string {
-	return grammar
-		.replaceAll("$HFMT$", "")
-		.replaceAll("$HFILE_HASH$", HL_FILE_HASH_RE_RAW)
-		.replaceAll("$HFILE_HASH_SEP$", HL_FILE_HASH_SEP)
-		.replaceAll("$HOP_INSERT_BEFORE$", HL_OP_INSERT_BEFORE)
-		.replaceAll("$HOP_INSERT_AFTER$", HL_OP_INSERT_AFTER)
-		.replaceAll("$HOP_REPLACE$", HL_OP_REPLACE)
-		.replaceAll("$HOP_DELETE$", HL_OP_DELETE)
-		.replaceAll("$HOP_CHARS$", HL_OP_CHARS)
-		.replaceAll("$HFILE$", HL_FILE_PREFIX);
-}
-
-/**
- * op lines have an `ANCHOR<SIGIL>[INLINE_PAYLOAD]` shape, where SIGIL is one of
- * {@link HL_OP_INSERT_BEFORE}, {@link HL_OP_INSERT_AFTER}, {@link HL_OP_REPLACE},
- * or {@link HL_OP_DELETE}. Multi-line payloads follow on subsequent lines
- * prefixed with {@link HL_PAYLOAD_PREFIX}; that prefix is stripped before the
- * payload is written.
- *
- * These constants are the single source of truth for the edit parser, grammar,
- * renderer, and prompt.
- */
-export const HL_OP_INSERT_BEFORE = "↑";
-export const HL_OP_INSERT_AFTER = "↓";
-export const HL_OP_REPLACE = ":";
-export const HL_OP_DELETE = "!";
-
-/** Prefix for payload continuation lines. The prefix itself is not written. */
-export const HL_PAYLOAD_PREFIX = "+";
-
-/** All hashline edit op sigils, concatenated for fast membership tests. */
-export const HL_OP_CHARS = `${HL_OP_INSERT_BEFORE}${HL_OP_INSERT_AFTER}${HL_OP_REPLACE}${HL_OP_DELETE}`;
-
-/** Hashline edit file section header marker. */
-export const HL_FILE_PREFIX = "¶";
-
-function normalizeFileHashText(text: string): string {
-	return text
-		.replace(/\r/g, "")
-		.split("\n")
-		.map(line => line.trimEnd())
-		.join("\n");
-}
-
-/**
- * Compute the 4-hex-character hash carried by a hashline section header.
- * The hash normalizes CR characters and trailing whitespace before hashing so
- * platform line endings and display-trimmed lines do not invalidate anchors.
- */
-export function computeFileHash(text: string): string {
-	const normalized = normalizeFileHashText(text);
-	const low16 = Bun.hash.xxHash32(normalized, 0) & 0xffff;
-	return low16.toString(16).padStart(4, "0");
-}
-
-/** Format a hashline section header for a file path and file hash. */
-export function formatHashlineHeader(filePath: string, fileHash: string): string {
-	return `${HL_FILE_PREFIX}${filePath}${HL_FILE_HASH_SEP}${fileHash}`;
-}
-
-/** Formats a single numbered line as `LINE:TEXT`. */
-export function formatNumberedLine(lineNumber: number, line: string): string {
-	return `${lineNumber}${HL_LINE_BODY_SEP}${line}`;
-}
-
-/** Format file text with hashline-mode line-number prefixes for display. */
-export function formatNumberedLines(text: string, startLine = 1): string {
-	const lines = text.split("\n");
-	return lines.map((line, i) => formatNumberedLine(startLine + i, line)).join("\n");
-}

package/src/hashline/index.ts

@@ -1,14 +0,0 @@
-export * from "./anchors";
-export * from "./apply";
-export * from "./constants";
-export * from "./diff";
-export * from "./diff-preview";
-export * from "./execute";
-export * from "./executor";
-export * from "./hash";
-export * from "./input";
-export * from "./prefixes";
-export * from "./recovery";
-export * from "./stream";
-export * from "./tokenizer";
-export * from "./types";

package/src/hashline/input.ts

@@ -1,137 +0,0 @@
-import * as path from "node:path";
-import { HL_FILE_HASH_SEP, HL_FILE_PREFIX } from "./hash";
-import { HashlineTokenizer } from "./tokenizer";
-import type { HashlineInputSection, SplitHashlineOptions } from "./types";
-
-// Pure classification — single shared tokenizer is safe.
-const TOKENIZER = new HashlineTokenizer();
-
-function unquoteHashlinePath(pathText: string): string {
-	if (pathText.length < 2) return pathText;
-	const first = pathText[0];
-	const last = pathText[pathText.length - 1];
-	if ((first === '"' || first === "'") && first === last) return pathText.slice(1, -1);
-	return pathText;
-}
-
-function normalizeHashlinePath(rawPath: string, cwd?: string): string {
-	const unquoted = unquoteHashlinePath(rawPath.trim());
-	if (!cwd || !path.isAbsolute(unquoted)) return unquoted;
-	const relative = path.relative(path.resolve(cwd), path.resolve(unquoted));
-	const isWithinCwd = relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
-	return isWithinCwd ? relative || "." : unquoted;
-}
-
-/**
- * Parse a `¶PATH[#hash]` header line. Returns `null` for lines that do not
- * begin with the `¶` prefix; throws the existing "Input header must be …"
- * error when a `¶`-prefixed line fails the strict shape (so malformed paths
- * surface immediately instead of being silently re-classified as payload).
- */
-function parseHashlineHeaderLine(line: string, cwd?: string): HashlineInputSection | null {
-	const trimmed = line.trimEnd();
-	if (!trimmed.startsWith(HL_FILE_PREFIX)) return null;
-
-	const token = TOKENIZER.tokenize(trimmed);
-	if (token.kind !== "header") {
-		throw new Error(
-			`Input header must be ${HL_FILE_PREFIX}PATH or ${HL_FILE_PREFIX}PATH${HL_FILE_HASH_SEP}HASH with a 4-hex file hash; got ${JSON.stringify(trimmed)}.`,
-		);
-	}
-
-	const parsedPath = normalizeHashlinePath(token.path, cwd);
-	if (parsedPath.length === 0) {
-		throw new Error(`Input header "${HL_FILE_PREFIX}" is empty; provide a file path.`);
-	}
-	return token.fileHash !== undefined
-		? { path: parsedPath, fileHash: token.fileHash, diff: "" }
-		: { path: parsedPath, diff: "" };
-}
-
-function stripLeadingBlankLines(input: string): string {
-	const stripped = input.startsWith("\uFEFF") ? input.slice(1) : input;
-	const lines = stripped.split("\n");
-	while (lines.length > 0) {
-		const head = lines[0].replace(/\r$/, "");
-		if (head.trim().length === 0 || TOKENIZER.tokenize(head).kind === "envelope-begin") {
-			lines.shift();
-			continue;
-		}
-		break;
-	}
-	return lines.join("\n");
-}
-
-export function containsRecognizableHashlineOperations(input: string): boolean {
-	for (const line of input.split(/\r?\n/)) {
-		if (TOKENIZER.isOp(line)) return true;
-	}
-	return false;
-}
-
-function normalizeFallbackInput(input: string, options: SplitHashlineOptions): string {
-	const stripped = input.startsWith("\uFEFF") ? input.slice(1) : input;
-	const hasExplicitHeader = stripped
-		.split(/\r?\n/)
-		.some(rawLine => parseHashlineHeaderLine(rawLine, options.cwd) !== null);
-	if (hasExplicitHeader) return input;
-
-	if (!options.path || !containsRecognizableHashlineOperations(input)) return input;
-	const fallbackPath = normalizeHashlinePath(options.path, options.cwd);
-	if (fallbackPath.length === 0) return input;
-	return `${HL_FILE_PREFIX}${fallbackPath}\n${input}`;
-}
-
-export function splitHashlineInput(input: string, options: SplitHashlineOptions = {}): HashlineInputSection {
-	const [section] = splitHashlineInputs(input, options);
-	return section;
-}
-
-export function splitHashlineInputs(input: string, options: SplitHashlineOptions = {}): HashlineInputSection[] {
-	const stripped = stripLeadingBlankLines(normalizeFallbackInput(input, options));
-	const lines = stripped.split(/\r?\n/);
-	const firstLine = lines[0] ?? "";
-
-	if (parseHashlineHeaderLine(firstLine, options.cwd) === null) {
-		const preview = JSON.stringify(firstLine.slice(0, 120));
-		throw new Error(
-			`input must begin with "${HL_FILE_PREFIX}PATH${HL_FILE_HASH_SEP}HASH" on the first non-blank line for anchored edits; got: ${preview}. ` +
-				`Example: "${HL_FILE_PREFIX}src/foo.ts${HL_FILE_HASH_SEP}1a2b" then edit ops.`,
-		);
-	}
-
-	const sections: HashlineInputSection[] = [];
-	let current: HashlineInputSection | undefined;
-	let currentLines: string[] = [];
-
-	const flush = () => {
-		if (!current) return;
-		const hasOps = currentLines.some(line => line.trim().length > 0);
-		if (hasOps) sections.push({ ...current, diff: currentLines.join("\n") });
-		currentLines = [];
-	};
-
-	for (const line of lines) {
-		const trimmed = line.trimEnd();
-		const token = TOKENIZER.tokenize(line);
-		if (token.kind === "envelope-end" || token.kind === "abort") break;
-		if (token.kind === "envelope-begin") continue;
-
-		// Route every `¶`-prefixed line through parseHashlineHeaderLine so
-		// malformed headers still raise the strict "Input header must be …"
-		// diagnostic (the tokenizer alone would silently classify them as
-		// payload).
-		if (trimmed.startsWith(HL_FILE_PREFIX)) {
-			const header = parseHashlineHeaderLine(line, options.cwd);
-			if (header !== null) {
-				flush();
-				current = header;
-				currentLines = [];
-				continue;
-			}
-		}
-		currentLines.push(line);
-	}
-	flush();
-	return sections;
-}