pi-hashline-edit-pro 4.4.4 → 4.5.0

package/src/edit-common.ts

@@ -96,6 +96,25 @@ export function withUndoPrompts(base: { description: string; snippet: string; gu
   return { description: base.description, snippet: base.snippet, guidelines };
 }
 
+export function withTransferPrompts(base: { description: string; snippet: string; guidelines: string[] }, flags: EditToolFlags, toolName: "copy" | "move"): { description: string; snippet: string; guidelines: string[] } {
+  const descriptionParts = [base.description];
+  const snippetParts = [base.snippet];
+  const guidelines = [...base.guidelines];
+  if (flags.requirePath) {
+    descriptionParts.push("Also give `path` matching the source or destination file the anchors were served for; it is required and must match anchor ownership.");
+    snippetParts.push("; include `path` (required)");
+    guidelines.push(`\`${toolName}\`: include \`path\` matching the source or destination file the anchors were served for; it is required.`);
+  } else {
+    descriptionParts.push("Path resolution is anchor-only; do not pass `path`.");
+    guidelines.push(`\`${toolName}\`: path resolution is anchor-only; don't pass \`path\`.`);
+  }
+  if (flags.strictInput) {
+    descriptionParts.push("Strict-input mode is on: auto-fixable slips are rejected instead of fixed with warnings.");
+    guidelines.push(`\`${toolName}\`: strict-input is on: auto-fixable slips are rejected instead of fixed.`);
+  }
+  return { description: descriptionParts.join(" "), snippet: snippetParts.join(""), guidelines };
+}
+
 function staleAnchorMessage(ref: string, hash: string, owners: Array<OwnedAnchor | undefined>): string {
   const knownPaths = new Set<string>();
   for (const owner of owners) {

package/src/file-reader.ts

@@ -5,6 +5,7 @@ import { loadFileKindAndText, type LFile } from "./file-kind";
 import { resolveTarget, type FileIdentity } from "./fs-write";
 import { toCwd, toDisplayPath } from "./paths";
 import { detectEnding, toLF, stripBOM, type LineEnding } from "./normalize";
+import { splitSeparators } from "./line-endings";
 import { abortIf, errCode, assertLineLimit } from "./utils";
 import { ANCHOR_POOL_EXHAUSTED_PREFIX } from "./constants";
 import { valKind, valAccess } from "./validation";
@@ -14,6 +15,7 @@ export interface NormFile {
   normalized: string;
   bom: string;
   originalEnding: LineEnding;
+  endingSeparators: LineEnding[];
   fileHashes: string[];
   hadUtf8DecodeErrors: boolean;
   identity: FileIdentity;
@@ -91,6 +93,7 @@ export async function readNormFile(
   abortIf(signal);
   const { bom, text: rawContent } = stripBOM(file.text);
   const originalEnding = detectEnding(rawContent);
+  const endingSeparators = splitSeparators(rawContent);
   const normalized = toLF(rawContent);
 
   if (options?.maxLines !== undefined) assertLineLimit(normalized, path, options.maxLines);
@@ -106,6 +109,7 @@ export async function readNormFile(
     normalized,
     bom,
     originalEnding,
+    endingSeparators,
     fileHashes,
     identity,
     hadUtf8DecodeErrors: file.hadUtf8DecodeErrors === true,

package/src/hash-store/validation.ts

@@ -60,3 +60,25 @@ export function isBusyError(error: unknown): boolean {
   }
   return error instanceof Error && /busy|locked/i.test(error.message);
 }
+
+export interface SeparatorParse {
+	ok: boolean;
+	value?: string[];
+}
+
+export function parseSeparators(raw: unknown): SeparatorParse {
+	if (raw === null || raw === undefined || raw === "") return { ok: true };
+	if (typeof raw !== "string") return { ok: false };
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(raw);
+	} catch (error) {
+		console.error("[parseSeparators] failed to parse stored separators JSON:", error);
+		return { ok: false };
+	}
+	if (!Array.isArray(parsed) || !parsed.every((entry) => entry === "\n" || entry === "\r" || entry === "\r\n")) {
+		console.error("[parseSeparators] stored separators did not pass validation:", JSON.stringify(parsed).slice(0, 200));
+		return { ok: false };
+	}
+	return { ok: true, value: parsed as string[] };
+}

package/src/hash-store.ts

@@ -11,6 +11,7 @@ import {
   isValidSnapshot,
   isCorruptionError,
   parseHashList,
+  parseSeparators,
 } from "./hash-store/validation";
 import {
   withBusyRetry,
@@ -18,6 +19,7 @@ import {
   withBusyRetryAsync,
 } from "./hash-store/retry";
 import { snapshotCache, cacheSnapshot, SNAPSHOT_CACHE_LIMIT } from "./hash-store/cache";
+import { countNewlines } from "./line-endings";
 
 export { isValidHashList, parseHashList, parseStoredHashes, isCorruptionError };
 export { SNAPSHOT_CACHE_LIMIT };
@@ -135,8 +137,10 @@ export interface UndoRecord {
   content: string;
   bom: string;
   ending: string;
+  separators?: string[];
   hashes: string[];
   resultContent: string;
+  resultSeparators?: string[];
   mode?: number;
 }
 
@@ -181,8 +185,10 @@ function buildStore(db: RawDb): { db: RawDb; stmts: Prepared } {
       "content TEXT NOT NULL, " +
       "bom TEXT NOT NULL, " +
       "ending TEXT NOT NULL, " +
+      "separators TEXT, " +
       "hashes TEXT NOT NULL, " +
       "result_content TEXT NOT NULL, " +
+      "result_separators TEXT, " +
       "updated_at INTEGER NOT NULL" +
     ")"
   );
@@ -192,6 +198,12 @@ function buildStore(db: RawDb): { db: RawDb; stmts: Prepared } {
   try {
     db.exec("ALTER TABLE undo ADD COLUMN mode INTEGER");
   } catch {}
+  try {
+    db.exec("ALTER TABLE undo ADD COLUMN separators TEXT");
+  } catch {}
+  try {
+    db.exec("ALTER TABLE undo ADD COLUMN result_separators TEXT");
+  } catch {}
   const versionRow = db.prepare("SELECT value FROM meta WHERE key = 'version'").get() as { value?: string } | undefined;
   if (versionRow && versionRow.value !== String(HASH_STORE_VERSION)) {
     db.exec("DELETE FROM snapshots");
@@ -210,11 +222,11 @@ function buildStore(db: RawDb): { db: RawDb; stmts: Prepared } {
     "ON CONFLICT(path) DO UPDATE SET checksum = excluded.checksum, line_count = excluded.line_count, hashes = excluded.hashes, line_checksums = excluded.line_checksums, updated_at = excluded.updated_at"
   );
   const undoUpsertStmt = db.prepare(
-    "INSERT INTO undo (path, content, bom, ending, hashes, result_content, mode, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?) " +
-    "ON CONFLICT(path) DO UPDATE SET content = excluded.content, bom = excluded.bom, ending = excluded.ending, hashes = excluded.hashes, result_content = excluded.result_content, mode = excluded.mode, updated_at = excluded.updated_at"
+    "INSERT INTO undo (path, content, bom, ending, separators, hashes, result_content, result_separators, mode, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?) " +
+    "ON CONFLICT(path) DO UPDATE SET content = excluded.content, bom = excluded.bom, ending = excluded.ending, separators = excluded.separators, hashes = excluded.hashes, result_content = excluded.result_content, result_separators = excluded.result_separators, mode = excluded.mode, updated_at = excluded.updated_at"
   );
   const undoGetStmt = db.prepare(
-    "SELECT content, bom, ending, hashes, result_content, mode FROM undo WHERE path = ?"
+    "SELECT content, bom, ending, separators, hashes, result_content, result_separators, mode FROM undo WHERE path = ?"
   );
   const undoDelStmt = db.prepare("DELETE FROM undo WHERE path = ?");
   const snapshotTimeStmt = db.prepare("SELECT updated_at FROM snapshots WHERE path = ?");
@@ -543,8 +555,10 @@ export function upsertUndo(store: HashStore, path: string, entry: UndoRecord): v
     entry.content,
     entry.bom,
     entry.ending,
+    entry.separators ? JSON.stringify(entry.separators) : null,
     JSON.stringify(entry.hashes),
     entry.resultContent,
+    entry.resultSeparators ? JSON.stringify(entry.resultSeparators) : null,
     typeof entry.mode === "number" ? entry.mode : null,
     Date.now(),
   );
@@ -560,12 +574,26 @@ export function getUndoEntry(store: HashStore, path: string): UndoRecord | undef
     store.stmts.undoDelete(path);
     return undefined;
   }
+  const separators = parseSeparators(row.separators);
+  const resultSeparators = parseSeparators(row.result_separators);
+  const resultContent = row.result_content as string;
+  if (
+    !separators.ok ||
+    !resultSeparators.ok ||
+    (separators.value !== undefined && separators.value.length !== countNewlines(content)) ||
+    (resultSeparators.value !== undefined && resultSeparators.value.length !== countNewlines(resultContent))
+  ) {
+    store.stmts.undoDelete(path);
+    return undefined;
+  }
   return {
     content,
     bom: row.bom as string,
     ending: row.ending as string,
+    ...(separators.value !== undefined ? { separators: separators.value } : {}),
     hashes: parsed,
-    resultContent: row.result_content as string,
+    resultContent,
+    ...(resultSeparators.value !== undefined ? { resultSeparators: resultSeparators.value } : {}),
     ...(typeof row.mode === "number" ? { mode: row.mode } : {}),
   };
 }

package/src/hashline/apply.ts

@@ -11,6 +11,7 @@ import {
 	type RHEdit,
 	type NEdit,
 	type HEdit,
+	type StripWarningLocation,
 } from "./resolve";
 
 type LIdx = {
@@ -160,6 +161,7 @@ export function planEdit(
     servedHashes?: ReadonlyMap<string, string>;
     signal?: AbortSignal;
     baseFileLines?: string[];
+    stripWarning?: StripWarningLocation;
   },
 ): PlannedEdit {
   const signal = options?.signal;
@@ -171,8 +173,9 @@ export function planEdit(
 
   const rangeFixed = swapReversedRanges(edit, fileHashes);
   const prefixFixed = stripDiffPrefixes(
-    stripBarePrefixes(rangeFixed, warnings),
+    stripBarePrefixes(rangeFixed, warnings, options?.stripWarning),
     warnings,
+    options?.stripWarning,
   );
 
   const { resolved: initialResolved, mismatches } = valEdit(
@@ -213,6 +216,8 @@ export function applyEdit(
 	precomputedHashes?: string[],
 	filePath?: string,
 	servedHashes?: ReadonlyMap<string, string>,
+	allowEmpty = false,
+	stripWarning?: StripWarningLocation,
 	): {
 	content: string;
 	firstChangedLine: number | undefined;
@@ -224,7 +229,7 @@ export function applyEdit(
   if (precomputedHashes === undefined) {
     throw new Error("[E_BAD_SHAPE] applyEdit requires the file's allocated anchors; derive them via lineHashes(content, path) first.");
   }
-  const planned = planEdit(content, edit, precomputedHashes, { filePath, servedHashes, signal });
+  const planned = planEdit(content, edit, precomputedHashes, { filePath, servedHashes, signal, stripWarning });
   const lineIndex = buildIdx(content);
   const warnings = planned.warnings;
   const resolved = planned.resolved;
@@ -240,7 +245,7 @@ export function applyEdit(
 	}
 
 	const result = assemble(content, spanResult, signal);
-	assertNotEmpty(content, result);
+	if (!allowEmpty) assertNotEmpty(content, result);
 	const range = changedRange(content, result);
 
 	return {

package/src/hashline/index.ts

@@ -18,7 +18,9 @@ export {
 export {
 	parseHashRef,
 	parseText,
+	parseTextWithSeparators,
 	type Anchor,
+	type ParsedText,
 } from "./parse";
 
 export {
@@ -32,6 +34,7 @@ export {
 	valEdit,
 	stripBarePrefixes,
 	stripDiffPrefixes,
+	type StripWarningLocation,
 	swapReversedRanges,
 	assertRangeServed,
 	RangeStaleError,

package/src/hashline/parse.ts

@@ -4,6 +4,8 @@ import {
 } from "./hash";
 import { ALPH_RE } from "./alphabet";
 import { NEW_CONTENT_NOT_ARRAY_MSG } from "../constants";
+import { splitWithEndings } from "../line-endings";
+import type { LineEnding } from "../normalize";
 
 const HASH_EXTRACT_RE = new RegExp(HASH_CLASS);
 
@@ -68,15 +70,25 @@ function unwrapJsonEnvelope(line: string): string {
   }
 }
 
+export interface ParsedText {
+	lines: string[];
+	separators: (LineEnding | undefined)[];
+}
+
+export function parseTextWithSeparators(edit: string[]): ParsedText {
+	if (!Array.isArray(edit) || edit.some((line) => typeof line !== "string")) {
+		throw new Error(NEW_CONTENT_NOT_ARRAY_MSG);
+	}
+	const lines: string[] = [];
+	const separators: (LineEnding | undefined)[] = [];
+	for (const line of edit) {
+		const parsed = splitWithEndings(unwrapJsonEnvelope(line));
+		lines.push(...parsed.lines);
+		separators.push(...parsed.endings);
+	}
+	return { lines, separators };
+}
+
 export function parseText(edit: string[]): string[] {
-  if (!Array.isArray(edit) || edit.some((line) => typeof line !== "string")) {
-    throw new Error(NEW_CONTENT_NOT_ARRAY_MSG);
-  }
-  const out: string[] = [];
-  for (const line of edit) {
-    const unwrapped = unwrapJsonEnvelope(line);
-    const normalized = unwrapped.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-    out.push(...normalized.split("\n"));
-  }
-  return out;
+	return parseTextWithSeparators(edit).lines;
 }

package/src/hashline/resolve.ts

@@ -1,15 +1,20 @@
 import { abortIf, rejectUnknownFields, clipLine, decodeStringArray, assertNoNul } from "../utils";
-import { parseHashRef, parseText, type Anchor } from "./parse";
+import { parseHashRef, parseTextWithSeparators, type Anchor } from "./parse";
 import { HASH_SEP, stripRowPrefix, lineChecksum, type RowPrefixKind } from "./hash";
 import { HASH_RUN } from "./alphabet";
 import { NEW_CONTENT_NOT_ARRAY_MSG, MAX_RANGE_STALE_LINES } from "../constants";
+import type { LineEnding } from "../normalize";
 
 export type RAnchor = {
 	line: number;
 	hash: string;
 };
 
-export type HEdit = { content_lines: string[]; hash_bounds: [Anchor, Anchor] };
+export type HEdit = {
+	content_lines: string[];
+	hash_bounds: [Anchor, Anchor];
+	content_separators?: (LineEnding | undefined)[];
+};
 export type RHEdit = {
   content_lines: string[];
   hash_bounds: [RAnchor, RAnchor];
@@ -158,7 +163,8 @@ export function stripAnchorRow(
 export function resEdit(edit: HTEdit, warnings?: string[]): HEdit {
   assertItem(edit as Record<string, unknown>);
 
-  const replaceLines = parseText(decodeStringArray(edit.replacement_lines, warnings) ?? edit.replacement_lines);
+  const parsed = parseTextWithSeparators(decodeStringArray(edit.replacement_lines, warnings) ?? edit.replacement_lines);
+  const replaceLines = parsed.lines;
   assertNoNul(replaceLines);
   const bounds = [edit.remove_from, edit.remove_to].map((ref) => {
     return stripAnchorRow(ref.trim(), "remove_from/remove_to entry", warnings);
@@ -166,6 +172,7 @@ export function resEdit(edit: HTEdit, warnings?: string[]): HEdit {
   return {
     content_lines: replaceLines,
     hash_bounds: [parseHashRef(bounds[0]), parseHashRef(bounds[1])],
+    ...(parsed.separators.some((separator) => separator !== undefined) ? { content_separators: parsed.separators } : {}),
   };
 }
 
@@ -180,12 +187,18 @@ function warnUnicodeEsc(
   }
 }
 
+export interface StripWarningLocation {
+	label: string;
+	indexOffset: number;
+}
+
 function stripRowPrefixes(
 	edit: HEdit,
 	warnings: string[],
 	kinds: RowPrefixKind[],
 	code: string,
 	marker: string,
+	location: StripWarningLocation,
 ): HEdit {
 	const stripped: number[] = [];
 	const contentLines = edit.content_lines.map((line, lineIndex) => {
@@ -195,17 +208,19 @@ function stripRowPrefixes(
 		return result.text;
 	});
 	if (stripped.length === 0) return edit;
-	const locations = stripped.map((i) => `replacement_lines line ${i + 1}`).join(", ");
+	const locations = stripped.map((i) => `${location.label} line ${i + 1 + location.indexOffset}`).join(", ");
 	warnings.push(`${code} Stripped ${marker} from ${locations}.`);
 	return { ...edit, content_lines: contentLines };
 }
 
-export function stripBarePrefixes(edit: HEdit, warnings: string[]): HEdit {
-	return stripRowPrefixes(edit, warnings, ["bare"], "[W_BARE_HASH_PREFIX]", '"anchor│" prefix');
+const DEFAULT_STRIP_WARNING_LOCATION: StripWarningLocation = { label: "replacement_lines", indexOffset: 0 };
+
+export function stripBarePrefixes(edit: HEdit, warnings: string[], location: StripWarningLocation = DEFAULT_STRIP_WARNING_LOCATION): HEdit {
+	return stripRowPrefixes(edit, warnings, ["bare"], "[W_BARE_HASH_PREFIX]", '"anchor│" prefix', location);
 }
 
-export function stripDiffPrefixes(edit: HEdit, warnings: string[]): HEdit {
-	return stripRowPrefixes(edit, warnings, ["plus", "minus"], "[W_INVALID_PATCH]", "diff-preview marker");
+export function stripDiffPrefixes(edit: HEdit, warnings: string[], location: StripWarningLocation = DEFAULT_STRIP_WARNING_LOCATION): HEdit {
+	return stripRowPrefixes(edit, warnings, ["plus", "minus"], "[W_INVALID_PATCH]", "diff-preview marker", location);
 }
 
 export function swapReversedRanges(

package/src/insert.ts

@@ -5,12 +5,13 @@ import { execPipeline, type ReqParams, type ReplaceDetails, previewFromPipe, pre
 import { commitEdit } from "./commit";
 import { batchMemberFor, ensureBatchBase, executeBatchMember, noteBatchFailure } from "./batch";
 import { readNormFile, type NormFile } from "./file-reader";
-import { MAX_HASH_LINES, parseHashRef, resEdit, resolveAnchorLine, type Anchor, type HEdit } from "./hashline";
+import { MAX_HASH_LINES, parseHashRef, parseTextWithSeparators, resEdit, resolveAnchorLine, type Anchor, type HEdit, type StripWarningLocation } from "./hashline";
+import type { LineEnding } from "./normalize";
 import { stripAnchorRow } from "./hashline/resolve";
 import { withAnchorSession } from "./anchor-registry";
 import { loadP, loadGuide } from "./prompts";
 import { assertInsertReq, normReq, type InsertReq } from "./payload-contract";
-import { decodeStringArray, isRec, splitLines } from "./utils";
+import { decodeStringArray, isRec, literalEscapeWarning, splitLines } from "./utils";
 import { queuedEdit, editToolBase, editRenderCallWrapper, editRenderResultWrapper, resolveEditTargetWithRequirement, throwIfStrictInput, withInsertPrompts, DEFAULT_EDIT_FLAGS, type EditToolFlags } from "./edit-common";
 import type { RPreview, RRState } from "./replace-render";
 export { assertInsertReq, type InsertReq };
@@ -27,7 +28,7 @@ const insertDirectionSchema = Type.Union(
 
 const insertLinesSchema = Type.Array(
   Type.String({
-    description: "One line to insert; never embed \\n inside an element.",
+    description: "One line to insert. A real line break (\\n, \\r\\n, or \\r) splits it into lines and sets their endings; escape sequences are not decoded.",
   }),
   {
     description: 'One string per line; [""] is a blank line; never include the anchor line.',
@@ -73,7 +74,8 @@ export function buildInsertEdit(
   preload: NormFile,
   ref: Anchor,
   path: string,
-): { editParams: ReqParams; anchorLine: string | undefined } {
+): { editParams: ReqParams; anchorLine: string | undefined; contentSeparators: (LineEnding | undefined)[] } {
+  const parsed = parseTextWithSeparators(req.lines);
   const fileLines = splitLines(preload.normalized);
   const line = resolveAnchorLine(ref, fileLines, preload.fileHashes, path);
   const anchorLine = preload.normalized.length === 0 ? undefined : fileLines[line - 1];
@@ -82,12 +84,21 @@ export function buildInsertEdit(
     remove_to: ref.hash,
     replacement_lines:
       anchorLine === undefined
-        ? [...req.lines]
+        ? [...parsed.lines]
         : req.direction === "after"
-          ? [anchorLine, ...req.lines]
-          : [...req.lines, anchorLine],
+          ? [anchorLine, ...parsed.lines]
+          : [...parsed.lines, anchorLine],
   };
-  return { editParams, anchorLine };
+  const contentSeparators = anchorLine === undefined
+    ? parsed.separators
+    : req.direction === "after"
+      ? [undefined, ...parsed.separators]
+      : [...parsed.separators, undefined];
+  return { editParams, anchorLine, contentSeparators };
+}
+
+function insertStripWarning(anchorLine: string | undefined, direction: "before" | "after"): StripWarningLocation {
+  return { label: "lines", indexOffset: anchorLine !== undefined && direction === "after" ? -1 : 0 };
 }
 
 export async function insertPreview(request: unknown, cwd: string, signal?: AbortSignal): Promise<RPreview> {
@@ -114,12 +125,13 @@ export async function insertPreview(request: unknown, cwd: string, signal?: Abor
       allocation: "shadow",
       signal,
     });
-    const { editParams } = buildInsertEdit(normalized, preload, ref, targetPath);
+    const { editParams, anchorLine } = buildInsertEdit(normalized, preload, ref, targetPath);
     const pipe = await execPipeline(targetPath, editParams, cwd, {
       accessMode: constants.R_OK,
       noPersist: true,
       preloadedNorm: preload,
       signal,
+      stripWarning: insertStripWarning(anchorLine, normalized.direction),
     });
     return previewFromPipe(pipe);
   } catch (error: unknown) {
@@ -180,6 +192,8 @@ export function buildInsertToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): I
         }
         assertInsertReq(canonical);
         const req = canonical;
+        const literalEscape = literalEscapeWarning(req.lines, "lines");
+        if (literalEscape !== undefined) insertWarnings.push(literalEscape);
         const targetPath = await resolveEditTargetWithRequirement({
           anchor: req.anchor,
           providedPath: req.path,
@@ -224,6 +238,8 @@ export function buildInsertToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): I
               hedit,
               extraWarnings: [...anchorWarnings, ...insertWarnings, ...resWarnings],
               foldedLines: built.anchorLine === undefined ? 0 : 1,
+              stripWarning: insertStripWarning(built.anchorLine, req.direction),
+              contentSeparators: built.contentSeparators,
             });
           }
           const preload = await readNormFile(targetPath, ctx.cwd, {
@@ -231,11 +247,12 @@ export function buildInsertToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): I
             accessMode: constants.R_OK | constants.W_OK,
             maxLines: MAX_HASH_LINES,
           });
-          const { editParams, anchorLine } = buildInsertEdit(req, preload, ref, targetPath);
+          const { editParams, anchorLine, contentSeparators } = buildInsertEdit(req, preload, ref, targetPath);
           const pipe = await execPipeline(targetPath, editParams, ctx.cwd, {
             accessMode: constants.R_OK | constants.W_OK,
             signal,
             preloadedNorm: preload,
+            stripWarning: insertStripWarning(anchorLine, req.direction),
           });
           return commitEdit(pipe, {
             path: pipe.path,
@@ -250,6 +267,7 @@ export function buildInsertToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): I
             noopNoun: "Insertion",
             foldedAnchorLines: anchorLine === undefined ? 0 : 1,
             prefixWarnings: [...anchorWarnings, ...insertWarnings],
+            endingOverrides: contentSeparators,
           });
         });
       });

package/src/line-endings.ts

@@ -0,0 +1,151 @@
+import type { LineEnding } from "./normalize";
+
+export interface EndingSpan {
+	start: number;
+	end: number;
+	replacementCount: number;
+}
+
+export function countNewlines(content: string): number {
+	let count = 0;
+	for (let index = 0; index < content.length; index++) {
+		if (content.charCodeAt(index) === 10) count += 1;
+	}
+	return count;
+}
+
+export function splitSeparators(raw: string): LineEnding[] {
+	const separators: LineEnding[] = [];
+	for (let index = 0; index < raw.length; index++) {
+		const char = raw[index]!;
+		if (char === "\r") {
+			if (raw[index + 1] === "\n") {
+				separators.push("\r\n");
+				index += 1;
+			} else {
+				separators.push("\r");
+			}
+		} else if (char === "\n") {
+			separators.push("\n");
+		}
+	}
+	return separators;
+}
+
+export function joinSeparators(content: string, separators: readonly LineEnding[]): string {
+	let out = "";
+	let separatorIndex = 0;
+	for (const char of content) {
+		if (char === "\n") {
+			out += separators[separatorIndex] ?? "\n";
+			separatorIndex += 1;
+		} else {
+			out += char;
+		}
+	}
+	return out;
+}
+
+function sourceLineMap(baseLineCount: number, spans: readonly EndingSpan[]): number[] {
+	const sorted = [...spans].sort((left, right) => left.start - right.start);
+	const map: number[] = [];
+	let baseLine = 0;
+	for (const span of sorted) {
+		while (baseLine < span.start && baseLine < baseLineCount) {
+			map.push(baseLine);
+			baseLine += 1;
+		}
+		const spanLength = span.end >= span.start ? span.end - span.start + 1 : 0;
+		for (let offset = 0; offset < span.replacementCount; offset++) {
+			if (offset < spanLength) map.push(span.start + offset);
+			else map.push(spanLength > 0 ? span.end : span.start - 1);
+		}
+		baseLine = span.end >= span.start ? span.end + 1 : span.start;
+	}
+	while (baseLine < baseLineCount) {
+		map.push(baseLine);
+		baseLine += 1;
+	}
+	return map;
+}
+
+export function separatorsForSpans(
+	baseSeparators: readonly LineEnding[],
+	baseLineCount: number,
+	spans: readonly EndingSpan[],
+	resultContent: string,
+	fallback: LineEnding,
+): LineEnding[] {
+	const mapped = sourceLineMap(baseLineCount, spans).map((source) =>
+		source >= 0 && source < baseSeparators.length ? baseSeparators[source]! : "",
+	);
+	const needed = countNewlines(resultContent);
+	const result: LineEnding[] = [];
+	for (let index = 0; index < needed; index++) {
+		const candidate = mapped[index];
+		if (candidate !== undefined && candidate !== "") result.push(candidate);
+		else result.push(result[index - 1] ?? fallback);
+	}
+	return result;
+}
+
+export function endingsForRange(separators: readonly LineEnding[], startLine: number, endLine: number): (LineEnding | undefined)[] {
+	const endings: (LineEnding | undefined)[] = [];
+	for (let line = startLine; line <= endLine; line += 1) {
+		endings.push(separators[line - 1]);
+	}
+	return endings;
+}
+
+export function splitWithEndings(text: string): { lines: string[]; endings: (LineEnding | undefined)[] } {
+	const lines: string[] = [];
+	const endings: (LineEnding | undefined)[] = [];
+	let current = "";
+	for (let index = 0; index < text.length; index += 1) {
+		const char = text[index]!;
+		if (char === "\r") {
+			const crlf = text[index + 1] === "\n";
+			endings.push(crlf ? "\r\n" : "\r");
+			lines.push(current);
+			current = "";
+			if (crlf) index += 1;
+			continue;
+		}
+		if (char === "\n") {
+			endings.push("\n");
+			lines.push(current);
+			current = "";
+			continue;
+		}
+		current += char;
+	}
+	lines.push(current);
+	endings.push(undefined);
+	return { lines, endings };
+}
+
+export function applyEndingOverrides(separators: LineEnding[], spanStart: number, endings: readonly (LineEnding | undefined)[] | undefined): void {
+	if (endings === undefined) return;
+	for (let index = 0; index < endings.length; index += 1) {
+		const ending = endings[index];
+		if (ending === undefined) continue;
+		const target = spanStart + index;
+		if (target >= 0 && target < separators.length) separators[target] = ending;
+	}
+}
+
+export function applySpanEndings(separators: LineEnding[], spans: readonly { start: number; end: number; replacementCount: number; endings?: (LineEnding | undefined)[] }[]): void {
+	const sorted = [...spans].sort((left, right) => left.start - right.start);
+	let offset = 0;
+	for (const span of sorted) {
+		if (span.endings !== undefined) {
+			for (let index = 0; index < span.endings.length; index += 1) {
+				const ending = span.endings[index];
+				if (ending === undefined) continue;
+				const target = span.start + offset + index;
+				if (target >= 0 && target < separators.length) separators[target] = ending;
+			}
+		}
+		offset += span.replacementCount - (span.end - span.start + 1);
+	}
+}