@d3ara1n/pi-hashline-edit 0.1.1 → 0.2.0

package/src/core/apply.ts

@@ -1,22 +1,37 @@
 /**
- * Pure-function applicator: applies edits to the file backing a snapshot.
+ * Pure-function applicator: applies edits to a file's current text.
  *
- * Strict semantics:
- * - Requires the current `text === snapshot.text` (stale check); drift is
- *   handled by the `transforms/relocate` middleware before calling apply — pure
- *   apply does not guess.
- * - Each anchor's hash must match its corresponding line in the snapshot
- *   (guards against the model misremembering line numbers / hashes).
+ * Verification is live and surgical: each anchor's hash is recomputed from the
+ * CURRENT line content at the cited line number and compared to the cited hash.
+ * No snapshot, no global stale check — a line that changed (or was
+ * misremembered) fails its own anchor; unchanged lines elsewhere never block
+ * the edit.
+ *
+ * Shifted-anchor recovery: when a cited anchor no longer matches, we rescan
+ * ±radius lines for the original content, holding the ORIGINAL line number fixed
+ * and re-hashing each candidate's content. On a unique hit the new anchor (with
+ * its freshly computed hash) is returned so the caller can retry without a
+ * re-read; on several hits they are reported as ambiguous; on none the live
+ * content at the cited line is returned to steer a re-read.
+ *
+ * Batch semantics: all ops are verified against the same current snapshot. If
+ * ANY anchor fails, EVERY failure (with recovery) is collected and returned
+ * together — nothing is written. This keeps the rescue report and the on-disk
+ * file in sync: a partial write would shift lines and invalidate the very
+ * recovery info we just returned. Range issues among the surviving ops are
+ * deferred until anchors are corrected.
+ *
+ * Other strict semantics:
  * - Operation ranges must not overlap (including the same insertion point).
- * - body byte-identical to the target → `noop` error (guides the model to
- *   investigate the bug rather than blindly retry).
+ * - body byte-identical to the whole-file result → `noop` error (guides the
+ *   model to investigate rather than blindly retry).
  *
  * @module pi-hashline-edit/core
  */
 
-import { buildDiff } from "./diff.ts";
-import { createSnapshot, joinLines, splitLines } from "./snapshot.ts";
-import type { ApplyResult, Edit, FileSnapshot, PatchError } from "./types.ts";
+import { computeLineHash } from "./hash.ts";
+import { detectLineEnding, joinLines, splitLines } from "./lines.ts";
+import type { Anchor, AnchorFailure, AnchorRecovery, ApplyResult, Edit } from "./types.ts";
 
 /** Line-level operation: replace the raw lines in the `[lo, hi)` range (0-based, hi exclusive) with newLines. */
 interface SpanOp {
@@ -25,40 +40,94 @@ interface SpanOp {
 	newLines: string[];
 }
 
-/** Verify the anchor matches the snapshot (pure apply: text already equals snapshot.text, so this only guards against misremembering). */
-function checkAnchor(snapshot: FileSnapshot, line: number, hash: string): PatchError | null {
-	if (line < 1 || line > snapshot.lineHashes.length) {
-		return {
-			kind: "anchor",
-			message: `line ${line} does not exist (file has ${snapshot.lineHashes.length} lines)`,
-		};
+/** Default ±line radius for shifted-anchor recovery. */
+const DEFAULT_SHIFT_RADIUS = 15;
+
+/**
+ * Verify an anchor against the live content; on mismatch, attempt shifted
+ * recovery. Returns null when the anchor matches, otherwise an
+ * {@link AnchorFailure} carrying the recovery outcome and the cited line's
+ * current snapshot.
+ *
+ * Recovery holds the ORIGINAL line number fixed and re-hashes each candidate's
+ * content: `computeLineHash(citedLine, candidateContent) === citedHash` holds
+ * iff the candidate IS the original content (modulo negligible hash collision).
+ * A returned candidate's anchor uses the candidate's real line number with a
+ * hash computed for that line, so it verifies on retry.
+ */
+function verifyAnchor(
+	lines: readonly string[],
+	cited: Anchor,
+	which: "anchor" | "end",
+	opIndex: number,
+	op: Edit["op"],
+	hashLen: number,
+	radius: number,
+): AnchorFailure | null {
+	const { line, hash } = cited;
+	if (line >= 1 && line <= lines.length && computeLineHash(line, lines[line - 1], hashLen) === hash) {
+		return null;
 	}
-	if (snapshot.lineHashes[line - 1] !== hash) {
-		return {
-			kind: "anchor",
-			message: `hash mismatch at line ${line}: file has #${snapshot.lineHashes[line - 1]}, edit says #${hash}`,
-		};
+
+	// Shifted recovery: scan ±radius (excluding the already-failed cited line).
+	const candidates: { line: number; hash: string }[] = [];
+	const lo = Math.max(1, line - radius);
+	const hi = Math.min(lines.length, line + radius);
+	for (let c = lo; c <= hi; c++) {
+		if (c === line) continue;
+		if (computeLineHash(line, lines[c - 1], hashLen) === hash) {
+			candidates.push({ line: c, hash: computeLineHash(c, lines[c - 1], hashLen) });
+		}
+	}
+
+	let recovery: AnchorRecovery;
+	if (candidates.length === 1) {
+		recovery = { kind: "found", newLine: candidates[0].line, newHash: candidates[0].hash };
+	} else if (candidates.length > 1) {
+		recovery = { kind: "ambiguous", candidates };
+	} else {
+		recovery = { kind: "none" };
 	}
-	return null;
+
+	const current =
+		line >= 1 && line <= lines.length
+			? { hash: computeLineHash(line, lines[line - 1], hashLen), content: lines[line - 1] }
+			: null;
+
+	return { opIndex, which, op, cited, recovery, current };
 }
 
-/** Translate an Edit into a SpanOp, while verifying anchors and ranges. */
-function translateEdit(edit: Edit, snapshot: FileSnapshot): { op: SpanOp } | { error: PatchError } {
+type TranslateResult =
+	| { readonly ok: true; readonly op: SpanOp }
+	| { readonly ok: false; readonly anchorFailures: AnchorFailure[] }
+	| { readonly ok: false; readonly rangeError: string };
+
+/** Translate an Edit into a SpanOp, verifying anchors and ranges against the current lines. */
+function translateEdit(
+	edit: Edit,
+	opIndex: number,
+	lines: readonly string[],
+	hashLen: number,
+	radius: number,
+): TranslateResult {
 	switch (edit.op) {
 		case "replace":
 		case "delete": {
-			const startErr = checkAnchor(snapshot, edit.start.line, edit.start.hash);
-			if (startErr) return { error: startErr };
+			const failures: AnchorFailure[] = [];
+			const startF = verifyAnchor(lines, edit.start, "anchor", opIndex, edit.op, hashLen, radius);
+			if (startF) failures.push(startF);
 			let endLine = edit.start.line;
 			if (edit.end) {
-				const endErr = checkAnchor(snapshot, edit.end.line, edit.end.hash);
-				if (endErr) return { error: endErr };
+				const endF = verifyAnchor(lines, edit.end, "end", opIndex, edit.op, hashLen, radius);
+				if (endF) failures.push(endF);
 				endLine = edit.end.line;
 			}
+			if (failures.length > 0) return { ok: false, anchorFailures: failures };
 			if (endLine < edit.start.line) {
-				return { error: { kind: "range", message: `range ${edit.start.line}..${endLine} ends before it starts` } };
+				return { ok: false, rangeError: `range ${edit.start.line}..${endLine} ends before it starts` };
 			}
 			return {
+				ok: true,
 				op: {
 					lo: edit.start.line - 1,
 					hi: endLine,
@@ -67,20 +136,20 @@ function translateEdit(edit: Edit, snapshot: FileSnapshot): { op: SpanOp } | { e
 			};
 		}
 		case "insert_after": {
-			const err = checkAnchor(snapshot, edit.anchor.line, edit.anchor.hash);
-			if (err) return { error: err };
-			return { op: { lo: edit.anchor.line, hi: edit.anchor.line, newLines: edit.body } };
+			const f = verifyAnchor(lines, edit.anchor, "anchor", opIndex, edit.op, hashLen, radius);
+			if (f) return { ok: false, anchorFailures: [f] };
+			return { ok: true, op: { lo: edit.anchor.line, hi: edit.anchor.line, newLines: edit.body } };
 		}
 		case "insert_before": {
-			const err = checkAnchor(snapshot, edit.anchor.line, edit.anchor.hash);
-			if (err) return { error: err };
-			return { op: { lo: edit.anchor.line - 1, hi: edit.anchor.line - 1, newLines: edit.body } };
+			const f = verifyAnchor(lines, edit.anchor, "anchor", opIndex, edit.op, hashLen, radius);
+			if (f) return { ok: false, anchorFailures: [f] };
+			return { ok: true, op: { lo: edit.anchor.line - 1, hi: edit.anchor.line - 1, newLines: edit.body } };
 		}
 		case "append": {
-			return { op: { lo: snapshot.lineHashes.length, hi: snapshot.lineHashes.length, newLines: edit.body } };
+			return { ok: true, op: { lo: lines.length, hi: lines.length, newLines: edit.body } };
 		}
 		case "prepend": {
-			return { op: { lo: 0, hi: 0, newLines: edit.body } };
+			return { ok: true, op: { lo: 0, hi: 0, newLines: edit.body } };
 		}
 	}
 }
@@ -91,28 +160,42 @@ function maxAffected(op: SpanOp): number {
 }
 
 /**
- * Apply edits to the file backing a snapshot.
+ * Apply edits to `text`. Anchors are verified against the current content; on
+ * success `touchedLines` gives the 0-based indices of the new-file lines this
+ * edit produced. On any anchor mismatch, all failures (with shifted recovery)
+ * are collected and returned together — nothing is written.
  *
- * @param text     current full file text
- * @param edits    parsed edit operations
- * @param snapshot snapshot recorded at read time (text must equal current text)
- * @returns apply result; on failure returns a structured error
+ * @param text        current full file text
+ * @param edits       parsed edit operations
+ * @param hashLen     hash length used to verify anchors (default 4)
+ * @param shiftRadius ±line radius for shifted-anchor recovery (default 15; 0 disables rescue)
  */
-export function applyEdits(text: string, edits: Edit[], snapshot: FileSnapshot): ApplyResult {
-	if (text !== snapshot.text) {
-		return {
-			ok: false,
-			error: { kind: "stale", message: "file changed since last read; re-read before editing" },
-		};
-	}
-
+export function applyEdits(text: string, edits: Edit[], hashLen = 4, shiftRadius = DEFAULT_SHIFT_RADIUS): ApplyResult {
 	const lines = splitLines(text);
+	const ending = detectLineEnding(text);
 
 	const ops: SpanOp[] = [];
-	for (const edit of edits) {
-		const t = translateEdit(edit, snapshot);
-		if ("error" in t) return { ok: false, error: t.error };
-		ops.push(t.op);
+	const anchorFailures: AnchorFailure[] = [];
+	let rangeError: string | null = null;
+
+	for (let i = 0; i < edits.length; i++) {
+		const t = translateEdit(edits[i], i, lines, hashLen, shiftRadius);
+		if (t.ok) {
+			ops.push(t.op);
+		} else if ("anchorFailures" in t) {
+			anchorFailures.push(...t.anchorFailures);
+		} else if (rangeError === null) {
+			rangeError = t.rangeError;
+		}
+	}
+
+	// Anchor failures take priority: the model must fix anchors first; range
+	// issues among surviving ops are premature until anchors are corrected.
+	if (anchorFailures.length > 0) {
+		return { ok: false, failure: { kind: "anchor", failures: anchorFailures } };
+	}
+	if (rangeError !== null) {
+		return { ok: false, failure: { kind: "range", message: rangeError } };
 	}
 
 	// Overlap check: sort ascending by lo; the next op's start must not fall inside the previous op's affected range
@@ -121,7 +204,7 @@ export function applyEdits(text: string, edits: Edit[], snapshot: FileSnapshot):
 		if (sorted[k].lo <= maxAffected(sorted[k - 1])) {
 			return {
 				ok: false,
-				error: {
+				failure: {
 					kind: "range",
 					message: `overlapping edits near line ${sorted[k].lo + 1}; issue one edit per range`,
 				},
@@ -129,25 +212,37 @@ export function applyEdits(text: string, edits: Edit[], snapshot: FileSnapshot):
 		}
 	}
 
-	// Apply back-to-front (lo descending) to avoid line-number shifts
+	// Apply back-to-front (lo descending) so original lo/hi stay valid
 	let result = [...lines];
 	for (const op of [...sorted].sort((a, b) => b.lo - a.lo)) {
 		result = [...result.slice(0, op.lo), ...op.newLines, ...result.slice(op.hi)];
 	}
 
-	const newText = joinLines(result, snapshot.lineEnding);
+	const newText = joinLines(result, ending);
 	if (newText === text) {
 		return {
 			ok: false,
-			error: {
+			failure: {
 				kind: "noop",
-				message:
-					"edit parsed and applied cleanly but produced no change; body is byte-identical to the target — the bug is elsewhere, re-read first",
+				message: "edit parsed and applied cleanly but produced no change; body is byte-identical — the bug is elsewhere, re-read first",
 			},
 		};
 	}
 
-	const newSnapshot = createSnapshot(snapshot.path, newText, snapshot.hashLen);
-	const diff = buildDiff(snapshot.path, lines, sorted);
-	return { ok: true, text: newText, newSnapshot, changed: true, diff };
+	// touchedLines: new-file indices worth re-anchoring — each produced line,
+	// and for a pure delete the line that shifted into the gap (so the model
+	// gets a fresh anchor for the shifted region).
+	const touched: number[] = [];
+	let delta = 0;
+	for (const op of sorted) {
+		const newLo = op.lo + delta;
+		if (op.newLines.length > 0) {
+			for (let i = 0; i < op.newLines.length; i++) touched.push(newLo + i);
+		} else if (newLo < result.length) {
+			touched.push(newLo);
+		}
+		delta += op.newLines.length - (op.hi - op.lo);
+	}
+
+	return { ok: true, text: newText, changed: true, touchedLines: touched };
 }

package/src/core/hash.test.ts

@@ -5,26 +5,29 @@ import { computeLineHash, hashFileLines } from "./hash.ts";
 const ALLOWED = new Set("0123456789ABCDEFGHJKMNPQRSTVWXYZ");
 
 test("computeLineHash is stable and base32", () => {
-	const a = computeLineHash("p", "c", "n", 4);
-	const b = computeLineHash("p", "c", "n", 4);
+	const a = computeLineHash(3, "code", 4);
+	const b = computeLineHash(3, "code", 4);
 	assert.equal(a, b);
 	assert.equal(a.length, 4);
 	for (const ch of a) assert.ok(ALLOWED.has(ch), `bad char ${ch}`);
 });
 
-test("context-aware: same line, different neighbors → different hash", () => {
-	const h1 = computeLineHash("a", "x", "b");
-	const h2 = computeLineHash("c", "x", "d");
-	assert.notEqual(h1, h2);
+test("different line number → different hash (even for identical content)", () => {
+	assert.notEqual(computeLineHash(2, ""), computeLineHash(5, ""));
+	assert.notEqual(computeLineHash(1, "}"), computeLineHash(2, "}"));
 });
 
-test("context-aware: same triple → same hash", () => {
-	assert.equal(computeLineHash("a", "x", "b"), computeLineHash("a", "x", "b"));
+test("different content → different hash", () => {
+	assert.notEqual(computeLineHash(1, "a"), computeLineHash(1, "b"));
+});
+
+test("same (line, content) → same hash", () => {
+	assert.equal(computeLineHash(7, "x"), computeLineHash(7, "x"));
 });
 
 test("base32 alphabet (without I/L/O/U) in bulk", () => {
 	for (let i = 0; i < 2000; i++) {
-		const h = computeLineHash("", `line ${i}`, "", 4);
+		const h = computeLineHash(i + 1, `line ${i}`, 4);
 		for (const ch of h) assert.ok(ALLOWED.has(ch), `bad char ${ch} in ${h}`);
 	}
 });
@@ -37,10 +40,12 @@ test("hashFileLines empty file", () => {
 	assert.deepEqual(hashFileLines([]), []);
 });
 
-test("hashFileLines has no in-file collisions (many duplicate lines)", () => {
+test("hashFileLines: identical content lines get distinct hashes (no collision, no length bloat)", () => {
+	// runs of identical lines — the case neighbor-aware hashing explodes on
 	const lines = ["", "", "", "", "", "}", "}", "}", "return", "return", ",", ","];
 	const hashes = hashFileLines(lines);
-	assert.equal(new Set(hashes).size, hashes.length, "collision not resolved");
+	assert.equal(new Set(hashes).size, hashes.length, "duplicate hashes");
+	for (const h of hashes) assert.equal(h.length, 4, `hash ${h} is not 4 chars`);
 });
 
 test("hashFileLines respects the length parameter", () => {

package/src/core/hash.ts

@@ -1,11 +1,22 @@
 /**
- * Per-line context-aware hash.
+ * Per-line content hash.
  *
- * Each line's hash is computed by concatenating "previous line + this line +
- * next line", so identical content lines (blank lines, `}`, `return`) get
- * different hashes due to different neighbors, making in-file collisions
- * effectively zero. Residual collisions are resolved by {@link hashFileLines}
- * via automatic length extension (per-file zero-collision guarantee).
+ * The hash mixes the 1-based line number into the line content, so every line
+ * gets a unique hash by construction — line numbers are unique, therefore no
+ * in-file collision is possible, and no length extension / fallback is ever
+ * needed.
+ *
+ * Why line + content (not content alone, not content + neighbors):
+ *
+ * - The line number is the address; the hash is a checksum that the line at
+ *   that address is still what was read. Mixing the number in makes the hash a
+ *   pure fingerprint of (position, content): it changes only when the line's
+ *   own content changes, never when a neighbor changes. (A neighbor-aware hash
+ *   would change an unchanged line's hash when an adjacent line is edited — a
+ *   spurious dependency with no benefit under this design's position-fixed
+ *   apply.)
+ * - Content alone would leave identical lines (blank lines, `}`) sharing a
+ *   hash; mixing the line number disambiguates them for free.
  *
  * @module pi-hashline-edit/core
  */
@@ -38,62 +49,20 @@ function toBase32(n: number, len: number): string {
 }
 
 /**
- * Compute the context-aware hash of a single line.
+ * Compute the hash of a single line from its 1-based line number and content.
  *
- * @param prev previous line content (`""` for the first line)
- * @param cur  this line's content
- * @param next next line content (`""` for the last line)
- * @param len  hash length (default 4, 20 bits ≈ 1M values)
+ * @param line    1-based line number
+ * @param content the line's content (no line terminator)
+ * @param len     hash length (default 4, 20 bits ≈ 1M values)
  */
-export function computeLineHash(prev: string, cur: string, next: string, len = 4): string {
-	const h = fnv1a32(`${prev}\n${cur}\n${next}`);
-	return toBase32(h, len);
-}
-
-/** Compute raw per-line hashes (no collision handling). */
-function rawHashes(lines: readonly string[], len: number): string[] {
-	return lines.map((line, i) =>
-		computeLineHash(lines[i - 1] ?? "", line, lines[i + 1] ?? "", len),
-	);
-}
-
-/** Find hash values that appear more than once. */
-function duplicatedHashes(hashes: readonly string[]): Set<string> {
-	const counts = new Map<string, number>();
-	for (const h of hashes) counts.set(h, (counts.get(h) ?? 0) + 1);
-	return new Set([...counts.entries()].filter(([, c]) => c > 1).map(([h]) => h));
-}
-
-/** Fallback: force uniqueness with an index suffix (theoretically unreachable under context-aware hashing). */
-function forceUnique(hashes: string[]): string[] {
-	const seen = new Map<string, number>();
-	return hashes.map((h) => {
-		const c = seen.get(h) ?? 0;
-		seen.set(h, c + 1);
-		return c === 0 ? h : `${h}${c}`;
-	});
+export function computeLineHash(line: number, content: string, len = 4): string {
+	return toBase32(fnv1a32(`${line}\n${content}`), len);
 }
 
 /**
- * Compute per-line hashes for the whole file and resolve in-file collisions:
- * colliding lines are recomputed with a longer len until unique within the file
- * (per-file zero-collision guarantee).
- *
- * Design rationale: context-aware hashing already drives the collision
- * probability near zero; this extension is a defensive fallback guaranteeing
- * apply never mislocates due to hash ambiguity.
+ * Compute per-line hashes for a file. Unique by construction — the 1-based line
+ * number is part of each hash, so two identical content lines always differ.
  */
 export function hashFileLines(lines: readonly string[], len = 4): string[] {
-	if (lines.length === 0) return [];
-	let hashes = rawHashes(lines, len);
-	for (let curLen = len; curLen <= len + 4; curLen++) {
-		const dups = duplicatedHashes(hashes);
-		if (dups.size === 0) return hashes;
-		hashes = hashes.map((h, i) =>
-			dups.has(h)
-				? computeLineHash(lines[i - 1] ?? "", lines[i] ?? "", lines[i + 1] ?? "", curLen + 1)
-				: h,
-		);
-	}
-	return forceUnique(hashes);
+	return lines.map((content, i) => computeLineHash(i + 1, content, len));
 }

package/src/core/index.ts

@@ -9,9 +9,5 @@
 
 export * from "./types.ts";
 export { computeLineHash, hashFileLines } from "./hash.ts";
-export { splitLines, joinLines, createSnapshot, verifyAnchor } from "./snapshot.ts";
-export type { AnchorVerifyResult } from "./snapshot.ts";
-export { parsePatch } from "./parse.ts";
-export type { ParseResult } from "./parse.ts";
+export { splitLines, joinLines, detectLineEnding } from "./lines.ts";
 export { applyEdits } from "./apply.ts";
-export { buildDiff } from "./diff.ts";

package/src/core/lines.test.ts

@@ -0,0 +1,30 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { splitLines, joinLines, detectLineEnding } from "./lines.ts";
+
+test("splitLines edge cases", () => {
+	assert.deepEqual(splitLines(""), []);
+	assert.deepEqual(splitLines("a"), ["a"]);
+	assert.deepEqual(splitLines("a\nb"), ["a", "b"]);
+	assert.deepEqual(splitLines("a\nb\n"), ["a", "b"]);
+	assert.deepEqual(splitLines("a\n\n"), ["a", ""]);
+	assert.deepEqual(splitLines("\n"), [""]);
+});
+
+test("splitLines strips CRLF \\r", () => {
+	assert.deepEqual(splitLines("a\r\nb\r\n"), ["a", "b"]);
+	assert.deepEqual(splitLines("a\r\nb"), ["a", "b"]);
+});
+
+test("joinLines restores line endings", () => {
+	assert.equal(joinLines(["a", "b"]), "a\nb\n");
+	assert.equal(joinLines([]), "");
+	assert.equal(joinLines(["a", "b"], "crlf"), "a\r\nb\r\n");
+	assert.equal(joinLines(["a", "b"], "lf"), "a\nb\n");
+});
+
+test("detectLineEnding", () => {
+	assert.equal(detectLineEnding("a\nb\n"), "lf");
+	assert.equal(detectLineEnding("a\r\nb\r\n"), "crlf");
+	assert.equal(detectLineEnding("a\nb\r\nc\n"), "crlf");
+});

package/src/core/lines.ts

@@ -0,0 +1,42 @@
+/**
+ * Line text helpers: split/join with CRLF normalization and line-ending
+ * detection.
+ *
+ * CRLF: splitLines strips the trailing `\r` from each line (hashes are based on
+ * clean lines, matching the `\r`-free content the model copies from the
+ * display); detectLineEnding records the original ending so joinLines can
+ * restore it — guaranteeing a CRLF file keeps its endings after edit.
+ *
+ * @module pi-hashline-edit/core
+ */
+
+import type { LineEnding } from "./types.ts";
+
+/**
+ * Split text into lines, stripping the trailing `\r` of each line (CRLF
+ * normalization, so hashes are based on clean lines).
+ *
+ * Convention: a trailing newline is treated as the terminator of the last line,
+ * not as producing an extra empty trailing line.
+ * - `"a\nb\n"` → `["a", "b"]`
+ * - `"a\r\nb\r\n"` → `["a", "b"]` (`\r` stripped)
+ * - `"a\n\n"` → `["a", ""]`
+ * - `""` → `[]`
+ */
+export function splitLines(text: string): string[] {
+	if (text === "") return [];
+	const normalized = text.endsWith("\n") ? text.slice(0, -1) : text;
+	return normalized.split("\n").map((l) => (l.endsWith("\r") ? l.slice(0, -1) : l));
+}
+
+/** Detect the dominant line ending of the text (any `\r\n` counts as CRLF). */
+export function detectLineEnding(text: string): LineEnding {
+	return text.includes("\r\n") ? "crlf" : "lf";
+}
+
+/** Join a line array back into text, restoring the given line ending (default LF). Non-empty files end with a newline. */
+export function joinLines(lines: readonly string[], ending: LineEnding = "lf"): string {
+	if (lines.length === 0) return "";
+	const sep = ending === "crlf" ? "\r\n" : "\n";
+	return lines.join(sep) + sep;
+}