pi-hashline-edit-pro 4.2.10 → 4.3.0

package/src/hashline/resolve.ts

@@ -1,10 +1,8 @@
 import { abortIf, rejectUnknownFields, firstNonEmptyIndex, lastNonEmptyIndex, clipLine, getCached, decodeStringArray, assertNoNul } from "../utils";
 import { parseHashRef, parseText, type Anchor } from "./parse";
-import { HASH_SEP, stripRowPrefix, canon } from "./hash";
+import { HASH_SEP, stripRowPrefix, canon, lineChecksum, type RowPrefixKind } from "./hash";
 import { HASH_RUN } from "./alphabet";
 import { NEW_CONTENT_NOT_ARRAY_MSG, MAX_RANGE_STALE_LINES } from "../constants";
-import { contentChecksum } from "./hasher";
-import { hashSource } from "./hash";
 
 export type RAnchor = {
 	line: number;
@@ -110,7 +108,7 @@ export function fmtMismatchWithHashes(
         const h = fileHashes[ln - 1]!;
         const c = fileLines[ln - 1] ?? "";
         hashes.push(h);
-        servedMap.set(h, contentChecksum(hashSource(c)));
+        servedMap.set(h, lineChecksum(c));
         rows.push(`    ${ln}: ${h}│${clipLine(c)}`);
       }
       out.push("");
@@ -171,7 +169,7 @@ 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, warnings);
+  const replaceLines = parseText(decodeStringArray(edit.replacement_lines, warnings) ?? edit.replacement_lines);
   assertNoNul(replaceLines);
   const bounds = [edit.remove_from, edit.remove_to].map((ref) => {
     return stripAnchorRow(ref.trim(), "remove_from/remove_to entry", warnings);
@@ -193,52 +191,37 @@ function warnUnicodeEsc(
   }
 }
 
-export function stripBarePrefixes(
-	edit: HEdit,
-	fileHashes: string[],
-	warnings: string[],
-): HEdit {
-	const fileHashSet = new Set(fileHashes);
-	const stripped: { lineIndex: number; matched: boolean }[] = [];
-	const contentLines = edit.content_lines.map((line, lineIndex) => {
-		const result = stripRowPrefix(line);
-		if (result.kind !== "bare") return line;
-		stripped.push({ lineIndex, matched: fileHashSet.has(result.hash ?? "") });
-		return result.text;
-	});
-	if (stripped.length === 0) return edit;
-	const locations = stripped
-		.map((s) => `replacement_lines line ${s.lineIndex + 1}`)
-		.join(", ");
-	warnings.push(
-    `[W_BARE_HASH_PREFIX] Stripped "anchor│" prefix from ${locations}.`
-	);
-	return { ...edit, content_lines: contentLines };
-}
-
-export function stripDiffPrefixes(
+function stripRowPrefixes(
 	edit: HEdit,
 	warnings: string[],
+	kinds: RowPrefixKind[],
+	code: string,
+	marker: string,
 ): HEdit {
 	const stripped: number[] = [];
 	const contentLines = edit.content_lines.map((line, lineIndex) => {
 		const result = stripRowPrefix(line);
-		if (result.kind !== "plus" && result.kind !== "minus") return line;
+		if (result.kind === null || !kinds.includes(result.kind)) return line;
 		stripped.push(lineIndex);
 		return result.text;
 	});
 	if (stripped.length === 0) return edit;
 	const locations = stripped.map((i) => `replacement_lines line ${i + 1}`).join(", ");
-	warnings.push(
-    `[W_INVALID_PATCH] Stripped diff-preview marker from ${locations}.`
-	);
+	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');
+}
+
+export function stripDiffPrefixes(edit: HEdit, warnings: string[]): HEdit {
+	return stripRowPrefixes(edit, warnings, ["plus", "minus"], "[W_INVALID_PATCH]", "diff-preview marker");
+}
+
 export function swapReversedRanges(
 	edit: HEdit,
 	fileHashes: string[],
-	warnings: string[],
 ): HEdit {
 	const lineByHash = new Map<string, number>();
 	for (let i = 0; i < fileHashes.length; i++) {
@@ -254,9 +237,6 @@ export function swapReversedRanges(
 	) {
 		return edit;
 	}
-	warnings.push(
-    `[W_BAD_OP] Swapped reversed remove_from/remove_to.`
-	);
 	return { ...edit, hash_bounds: [endRef, startRef] as [Anchor, Anchor] };
 }
 
@@ -515,7 +495,7 @@ export function assertRangeServed(
     const hash = fileHashes[line - 1]!;
     const content = fileLines[line - 1]!;
     const servedContent = served?.get(hash);
-    if (servedContent === undefined || servedContent !== contentChecksum(hashSource(content))) mismatchLines.push(line);
+    if (servedContent === undefined || servedContent !== lineChecksum(content)) mismatchLines.push(line);
   }
   if (mismatchLines.length === 0) return;
   const rangeLength = endLine - startLine + 1;
@@ -527,7 +507,7 @@ export function assertRangeServed(
     const hash = fileHashes[line - 1]!;
     const content = fileLines[line - 1]!;
     shownHashes.push(hash);
-    shownMap.set(hash, contentChecksum(hashSource(content)));
+    shownMap.set(hash, lineChecksum(content));
     rows.push(fmtRow(hash, clipLine(content)));
   }
   const location = filePath ? ` in ${filePath}` : "";

package/src/insert.ts

@@ -3,7 +3,7 @@ import { Type } from "typebox";
 import { constants } from "node:fs";
 import { execPipeline, type ReqParams, type ReplaceDetails, previewFromPipe, previewError } from "./replace";
 import { commitEdit } from "./commit";
-import { batchMemberFor, ensureBatchBase, executeBatchMember, noteBatchFailure, suffixPoisonCause } from "./batch";
+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 { stripAnchorRow } from "./hashline/resolve";
@@ -11,7 +11,6 @@ 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 { clearBoundaryBypass } from "./boundary-bypass";
 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 };
@@ -189,7 +188,6 @@ export function buildInsertToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): I
         }).catch((error: unknown) => {
           const member = batchMemberFor(_toolCallId);
           if (member) noteBatchFailure(member, error);
-          else suffixPoisonCause(_toolCallId, error);
           throw error;
         });
         let ref: Anchor;
@@ -218,6 +216,7 @@ export function buildInsertToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): I
             }
             return executeBatchMember({
               kind: "insert",
+              direction: req.direction,
               member,
               targetPath,
               mutationTargetPath,
@@ -251,7 +250,6 @@ export function buildInsertToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): I
             noopNoun: "Insertion",
             foldedAnchorLines: anchorLine === undefined ? 0 : 1,
             prefixWarnings: [...anchorWarnings, ...insertWarnings],
-            onApplied: () => clearBoundaryBypass(mutationTargetPath),
           });
         });
       });

package/src/payload-contract.ts

@@ -1,5 +1,5 @@
 import { Type } from "typebox";
-import { isRec, normalizeAnchors, normalizeFilePath, rejectUnknownFields, assertNoNul } from "./utils";
+import { isRec, normalizeRequest, rejectUnknownFields, assertNoNul } from "./utils";
 
 const replacementLinesSchema = Type.Array(
   Type.String({
@@ -77,20 +77,12 @@ export function assertReq(request: unknown): asserts request is ReqParams {
   assertNoNul(request.replacement_lines);
 }
 
-export function normReq(input: unknown): unknown {
-  if (!isRec(input)) {
-    return input;
-  }
-  const record: Record<string, unknown> = { ...input };
-  normalizeFilePath(record);
-  normalizeAnchors(record);
-  return record;
-}
+export { normalizeRequest as normReq } from "./utils";
 
 export function getPreviewInput(args: unknown): { path?: string; remove_from: string; remove_to: string; replacement_lines: string[] } | null {
   let normalized: unknown;
   try {
-    normalized = normReq(args);
+    normalized = normalizeRequest(args);
   } catch {
     return null;
   }

package/src/read.ts

@@ -17,8 +17,8 @@ import { abortIf, makePrepareArguments, numberedRead, visLines, splitLines } fro
 import { loadP, loadGuide } from "./prompts";
 import { withReadPrompts, DEFAULT_EDIT_FLAGS, type EditToolFlags } from "./edit-common";
 import { valAccess } from "./validation";
-import { markServed as markServedScoped, withAnchorSession } from "./anchor-registry";
-import { buildServedMap } from "./served";
+import { withAnchorSession } from "./anchor-registry";
+import { serveRows } from "./served";
 import { Text } from "@earendil-works/pi-tui";
 const R_DESC = loadP("../prompts/read.md");
 const R_SNIPPET = loadP("../prompts/read-snippet.md");
@@ -237,7 +237,7 @@ export function regRead(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FL
 					fileHashes,
 					resolvedPath,
 				);
-				markServedScoped(resolvedPath, buildServedMap(fileHashes, fileLines, preview.servedHashes), new Set(fileHashes));
+				serveRows(resolvedPath, fileHashes, fileLines, preview.servedHashes);
 				const snapshotId = await safeSnapId(absolutePath, "read");
 				const previewText =
 					hadUtf8DecodeErrors

package/src/replace-diff.ts

@@ -6,7 +6,7 @@ import {
   HASH_SEP,
   changedRange,
 } from "./hashline";
-import { MAX_DIFF_INPUT_BYTES } from "./constants";
+import { MAX_DIFF_INPUT_BYTES, DEDUP_ANCHOR } from "./constants";
 import { splitLines } from "./utils";
 import {
   detectEnding,
@@ -22,6 +22,8 @@ export interface DiffSpan {
   start: number;
   end: number;
   replacementCount: number;
+  dedupAbove?: string[];
+  dedupBelow?: string[];
 }
 
 interface PlacedSpan {
@@ -29,6 +31,16 @@ interface PlacedSpan {
   oldEnd: number;
   newStart: number;
   newEnd: number;
+  dedupAbove?: string[];
+  dedupBelow?: string[];
+}
+
+export function fmtDedupRow(line: string): string {
+  const row = `${DEDUP_ANCHOR}${HASH_SEP}${line}`;
+  if (Buffer.byteLength(row, "utf-8") <= DEFAULT_MAX_BYTES) return row;
+  const size = formatSize(Buffer.byteLength(row, "utf-8"));
+  const limit = formatSize(DEFAULT_MAX_BYTES);
+  return `${DEDUP_ANCHOR}${HASH_SEP}[Row is ${size}, exceeds ${limit}; content not shown. Use read to see the full line.]`;
 }
 
 function fmtDiffLine(
@@ -155,7 +167,7 @@ function placeSpans(
     if (span.replacementCount === 0) {
       if (newEnd !== newStart - 1) return undefined;
     } else if (newEnd >= newLen) return undefined;
-    placed.push({ oldStart: span.start, oldEnd: span.end, newStart, newEnd });
+    placed.push({ oldStart: span.start, oldEnd: span.end, newStart, newEnd, dedupAbove: span.dedupAbove, dedupBelow: span.dedupBelow });
     offset += span.replacementCount - spanLen;
     removedSum += spanLen;
     addedSum += span.replacementCount;
@@ -184,53 +196,32 @@ function trimPlacedSpans(
       newEnd -= 1;
     }
     if (oldStart > oldEnd && newStart > newEnd) continue;
-    out.push({ oldStart, oldEnd, newStart, newEnd });
+    out.push({ oldStart, oldEnd, newStart, newEnd, dedupAbove: span.dedupAbove, dedupBelow: span.dedupBelow });
   }
   return out;
 }
 
-function genSpanDiff(
-  oldContent: string,
-  newContent: string,
-  contextLines: number,
-  newHashes: string[],
-  oldHashes: string[],
+function createRowEmitter(
+  output: string[],
+  lineNumbers: (number | undefined)[],
   maxLineBytes: number,
   maxBytes: number,
-  spans: DiffSpan[],
-): { diff: string; firstChangedLine: number | undefined; lineNumbers: (number | undefined)[] } | undefined {
-  const oldLines = splitLines(oldContent);
-  const newLines = splitLines(newContent);
-  if (oldHashes.length !== oldLines.length || newHashes.length !== newLines.length) return undefined;
-  const placed = placeSpans(oldLines.length, newLines.length, spans);
-  if (!placed) return undefined;
-  const trimmed = trimPlacedSpans(placed, oldLines, newLines);
-  const ordered = [...trimmed].sort((a, b) => a.oldStart - b.oldStart || a.newStart - b.newStart);
-  let oldPos = 0;
-  let newPos = 0;
-  for (const span of ordered) {
-    if (span.oldStart < oldPos || span.newStart < newPos) return undefined;
-    const gapOld = span.oldStart - oldPos;
-    const gapNew = span.newStart - newPos;
-    if (gapOld !== gapNew || gapOld < 0) return undefined;
-    oldPos = span.oldEnd + 1;
-    newPos = span.newEnd + 1;
-  }
-  if (oldLines.length - ordered.reduce((sum, span) => sum + Math.max(0, span.oldEnd - span.oldStart + 1), 0) + ordered.reduce((sum, span) => sum + Math.max(0, span.newEnd - span.newStart + 1), 0) !== newLines.length) {
-    return undefined;
-  }
-  const output: string[] = [];
-  const lineNumbers: (number | undefined)[] = [];
-  let firstChangedLine: number | undefined;
+): {
+  readonly stopped: boolean;
+  readonly truncated: boolean;
+  emitPlain(line: string, num?: number): void;
+  emitRow(prefix: " " | "+" | "-", line: string, hash: string | undefined, num?: number): void;
+  emitDedup(line: string): boolean;
+} {
   let outBytes = 0;
   let stopped = false;
-  let diffTruncated = false;
+  let truncated = false;
   const emitPlain = (line: string, num?: number): void => {
     if (stopped) return;
     const lineBytes = Buffer.byteLength(line, "utf-8") + 1;
     if (outBytes + lineBytes > maxBytes) {
       stopped = true;
-      diffTruncated = true;
+      truncated = true;
       return;
     }
     outBytes += lineBytes;
@@ -248,24 +239,82 @@ function genSpanDiff(
     }
     if (outBytes + rowBytes + 1 > maxBytes) {
       stopped = true;
-      diffTruncated = true;
+      truncated = true;
       return;
     }
     outBytes += rowBytes + 1;
     output.push(full);
     lineNumbers.push(num);
   };
+  const emitDedup = (line: string): boolean => {
+    if (stopped) return false;
+    const row = fmtDedupRow(line);
+    const rowBytes = Buffer.byteLength(row, "utf-8") + 1;
+    if (outBytes + rowBytes > maxBytes) {
+      stopped = true;
+      truncated = true;
+      return false;
+    }
+    outBytes += rowBytes;
+    output.push(row);
+    lineNumbers.push(undefined);
+    return true;
+  };
+  return {
+    get stopped() { return stopped; },
+    get truncated() { return truncated; },
+    emitPlain,
+    emitRow,
+    emitDedup,
+  };
+}
+
+function genSpanDiff(
+  oldContent: string,
+  newContent: string,
+  contextLines: number,
+  newHashes: string[],
+  oldHashes: string[],
+  maxLineBytes: number,
+  maxBytes: number,
+  spans: DiffSpan[],
+): { diff: string; firstChangedLine: number | undefined; lineNumbers: (number | undefined)[]; dedupEmitted: boolean } | undefined {
+  const oldLines = splitLines(oldContent);
+  const newLines = splitLines(newContent);
+  if (oldHashes.length !== oldLines.length || newHashes.length !== newLines.length) return undefined;
+  const placed = placeSpans(oldLines.length, newLines.length, spans);
+  if (!placed) return undefined;
+  const trimmed = trimPlacedSpans(placed, oldLines, newLines);
+  const ordered = [...trimmed].sort((a, b) => a.oldStart - b.oldStart || a.newStart - b.newStart);
+  let oldPos = 0;
+  let newPos = 0;
+  for (const span of ordered) {
+    if (span.oldStart < oldPos || span.newStart < newPos) return undefined;
+    const gapOld = span.oldStart - oldPos;
+    const gapNew = span.newStart - newPos;
+    if (gapOld !== gapNew || gapOld < 0) return undefined;
+    oldPos = span.oldEnd + 1;
+    newPos = span.newEnd + 1;
+  }
+  if (oldLines.length - ordered.reduce((sum, span) => sum + Math.max(0, span.oldEnd - span.oldStart + 1), 0) + ordered.reduce((sum, span) => sum + Math.max(0, span.newEnd - span.newStart + 1), 0) !== newLines.length) {
+    return undefined;
+  }
+  const output: string[] = [];
+  let dedupEmitted = false;
+  const lineNumbers: (number | undefined)[] = [];
+  let firstChangedLine: number | undefined;
+  const em = createRowEmitter(output, lineNumbers, maxLineBytes, maxBytes);
   const emitGap = (gapStartNew: number, gapLen: number, position: "leading" | "middle" | "trailing"): void => {
-    if (stopped || gapLen <= 0) return;
+    if (em.stopped || gapLen <= 0) return;
     if (position === "leading") {
       let count = contextLines;
       if (contextLines > 0 && gapLen > count && isBlankLine(newLines[gapStartNew + gapLen - 1]!)) count += 1;
       count = Math.min(count, gapLen);
       const skipStart = gapLen - count;
-      if (skipStart > 0) emitPlain(" ...", undefined);
-      for (let k = gapLen - count; k < gapLen && !stopped; k++) {
+      if (skipStart > 0) em.emitPlain(" ...", undefined);
+      for (let k = gapLen - count; k < gapLen && !em.stopped; k++) {
         const newIdx = gapStartNew + k;
-        emitRow(" ", newLines[newIdx]!, newHashes[newIdx], newIdx + 1);
+        em.emitRow(" ", newLines[newIdx]!, newHashes[newIdx], newIdx + 1);
       }
       return;
     }
@@ -273,11 +322,11 @@ function genSpanDiff(
       let count = contextLines;
       if (contextLines > 0 && gapLen > count && isBlankLine(newLines[gapStartNew]!)) count += 1;
       count = Math.min(count, gapLen);
-      for (let k = 0; k < count && !stopped; k++) {
+      for (let k = 0; k < count && !em.stopped; k++) {
         const newIdx = gapStartNew + k;
-        emitRow(" ", newLines[newIdx]!, newHashes[newIdx], newIdx + 1);
+        em.emitRow(" ", newLines[newIdx]!, newHashes[newIdx], newIdx + 1);
       }
-      if (gapLen > count) emitPlain(" ...", undefined);
+      if (gapLen > count) em.emitPlain(" ...", undefined);
       return;
     }
     let headCount = contextLines;
@@ -286,50 +335,58 @@ function genSpanDiff(
     if (contextLines > 0 && gapLen - tailCount > headCount && isBlankLine(newLines[gapStartNew + gapLen - tailCount]!)) tailCount += 1;
     const middleLen = gapLen - headCount - tailCount;
     if (middleLen <= 0) {
-      for (let k = 0; k < gapLen && !stopped; k++) {
+      for (let k = 0; k < gapLen && !em.stopped; k++) {
         const newIdx = gapStartNew + k;
-        emitRow(" ", newLines[newIdx]!, newHashes[newIdx], newIdx + 1);
+        em.emitRow(" ", newLines[newIdx]!, newHashes[newIdx], newIdx + 1);
       }
       return;
     }
-    for (let k = 0; k < headCount && !stopped; k++) {
+    for (let k = 0; k < headCount && !em.stopped; k++) {
       const newIdx = gapStartNew + k;
-      emitRow(" ", newLines[newIdx]!, newHashes[newIdx], newIdx + 1);
+      em.emitRow(" ", newLines[newIdx]!, newHashes[newIdx], newIdx + 1);
     }
-    if (!stopped) emitPlain(" ...", undefined);
-    for (let k = gapLen - tailCount; k < gapLen && !stopped; k++) {
+    if (!em.stopped) em.emitPlain(" ...", undefined);
+    for (let k = gapLen - tailCount; k < gapLen && !em.stopped; k++) {
       const newIdx = gapStartNew + k;
-      emitRow(" ", newLines[newIdx]!, newHashes[newIdx], newIdx + 1);
+      em.emitRow(" ", newLines[newIdx]!, newHashes[newIdx], newIdx + 1);
     }
   };
   oldPos = 0;
   newPos = 0;
-  for (let spanIdx = 0; spanIdx < ordered.length && !stopped; spanIdx++) {
+  for (let spanIdx = 0; spanIdx < ordered.length && !em.stopped; spanIdx++) {
     const span = ordered[spanIdx]!;
     const gapLen = span.oldStart - oldPos;
     emitGap(newPos, gapLen, spanIdx === 0 ? "leading" : "middle");
-    if (stopped) break;
+    if (em.stopped) break;
     if (firstChangedLine === undefined) firstChangedLine = span.newStart + 1;
-    for (let oldIdx = span.oldStart; oldIdx <= span.oldEnd && !stopped; oldIdx++) {
-      emitRow("-", oldLines[oldIdx]!, oldHashes[oldIdx], oldIdx + 1);
+    for (const dedup of span.dedupAbove ?? []) {
+      if (em.stopped) break;
+      if (em.emitDedup(dedup)) dedupEmitted = true;
     }
-    for (let newIdx = span.newStart; newIdx <= span.newEnd && !stopped; newIdx++) {
-      emitRow("+", newLines[newIdx]!, newHashes[newIdx], newIdx + 1);
+    for (let oldIdx = span.oldStart; oldIdx <= span.oldEnd && !em.stopped; oldIdx++) {
+      em.emitRow("-", oldLines[oldIdx]!, oldHashes[oldIdx], oldIdx + 1);
+    }
+    for (let newIdx = span.newStart; newIdx <= span.newEnd && !em.stopped; newIdx++) {
+      em.emitRow("+", newLines[newIdx]!, newHashes[newIdx], newIdx + 1);
+    }
+    for (const dedup of span.dedupBelow ?? []) {
+      if (em.stopped) break;
+      if (em.emitDedup(dedup)) dedupEmitted = true;
     }
     oldPos = span.oldEnd + 1;
     newPos = span.newEnd + 1;
   }
-  if (!stopped) {
+  if (!em.stopped) {
     const trailingLen = oldLines.length - oldPos;
     emitGap(newPos, trailingLen, "trailing");
   }
-  if (diffTruncated) {
+  if (em.truncated) {
     output.push(" ...");
     lineNumbers.push(undefined);
     output.push(`[diff truncated at ${formatSize(maxBytes)}; use read to see the rest.]`);
     lineNumbers.push(undefined);
   }
-  return { diff: output.join("\n"), firstChangedLine, lineNumbers };
+  return { diff: output.join("\n"), firstChangedLine, lineNumbers, dedupEmitted };
 }
 
 function overDiffInputLimit(oldContent: string, newContent: string): boolean {
@@ -344,14 +401,14 @@ export function genDiff(
   oldContentHashes?: string[],
   limits?: DiffLimits,
   spans?: DiffSpan[],
-): { diff: string; firstChangedLine: number | undefined; lineNumbers: (number|undefined)[] } {
+): { diff: string; firstChangedLine: number | undefined; lineNumbers: (number|undefined)[]; spanDedupEmitted?: boolean } {
   const maxLineBytes = limits?.unlimited ? Number.POSITIVE_INFINITY : (limits?.maxLineBytes ?? DEFAULT_MAX_BYTES);
   const maxBytes = limits?.unlimited ? Number.POSITIVE_INFINITY : (limits?.maxBytes ?? DEFAULT_MAX_BYTES);
   if (spans && newContentHashes && oldContentHashes) {
     const anchored = genSpanDiff(oldContent, newContent, contextLines, newContentHashes, oldContentHashes, maxLineBytes, maxBytes, spans);
     if (anchored) {
       const diff = disambiguateDuplicateAnchors(anchored.diff);
-      return { diff, firstChangedLine: anchored.firstChangedLine, lineNumbers: anchored.lineNumbers };
+      return { diff, firstChangedLine: anchored.firstChangedLine, lineNumbers: anchored.lineNumbers, ...(anchored.dedupEmitted ? { spanDedupEmitted: true as const } : {}) };
     }
   }
   if (!limits?.unlimited && overDiffInputLimit(oldContent, newContent)) {
@@ -416,45 +473,12 @@ export function genDiff(
   let oldLineNum = 1;
   let lastWasChange = false;
   let firstChangedLine: number | undefined;
-  let outBytes = 0;
-  let stopped = false;
-  let diffTruncated = false;
   const lineNumbers: (number|undefined)[] = [];
 
-  const emitPlain = (line: string, num?: number): void => {
-    if (stopped) return;
-    const lineBytes = Buffer.byteLength(line, "utf-8") + 1;
-    if (outBytes + lineBytes > maxBytes) {
-      stopped = true;
-      diffTruncated = true;
-      return;
-    }
-    outBytes += lineBytes;
-    output.push(line);
-    lineNumbers.push(num);
-  };
-
-  const emitRow = (prefix: " " | "+" | "-", line: string, hash: string | undefined, num?: number): void => {
-    if (stopped) return;
-    const full = fmtDiffLine(prefix, line, hash);
-    const rowBytes = Buffer.byteLength(full, "utf-8");
-    if (rowBytes > maxLineBytes) {
-      const marker = `[Row is ${formatSize(rowBytes)}, exceeds ${formatSize(maxLineBytes)}; content not shown. Use read to see the full line.]`;
-      emitPlain(fmtDiffLine(prefix, marker, hash), num);
-      return;
-    }
-    if (outBytes + rowBytes + 1 > maxBytes) {
-      stopped = true;
-      diffTruncated = true;
-      return;
-    }
-    outBytes += rowBytes + 1;
-    output.push(full);
-    lineNumbers.push(num);
-  };
+  const em = createRowEmitter(output, lineNumbers, maxLineBytes, maxBytes);
 
   for (let i = 0; i < parts.length; i++) {
-    if (stopped) break;
+    if (em.stopped) break;
     const part = parts[i]!;
     const raw = part.value.split("\n");
     if (raw[raw.length - 1] === "") raw.pop();
@@ -463,18 +487,18 @@ export function genDiff(
     if (part.added || part.removed) {
       if (firstChangedLine === undefined) firstChangedLine = newLineNum;
       for (let k = 0; k < displayLines.length; k++) {
-        if (stopped) break;
+        if (em.stopped) break;
         if (part.added) {
           const hash = effectiveNewHashes[newLineNum - 1];
-          emitRow("+", displayLines[k]!, hash, newLineNum);
+          em.emitRow("+", displayLines[k]!, hash, newLineNum);
           newLineNum++;
         } else {
           const hash = oldContentHashes?.[oldLineNum - 1];
-          emitRow("-", displayLines[k]!, hash, oldLineNum);
+          em.emitRow("-", displayLines[k]!, hash, oldLineNum);
           oldLineNum++;
         }
       }
-      if (stopped) break;
+      if (em.stopped) break;
       lastWasChange = true;
       continue;
     }
@@ -537,25 +561,25 @@ export function genDiff(
       }
 
       if (skipStart > 0) {
-        emitPlain(" ...", undefined);
+        em.emitPlain(" ...", undefined);
         newLineNum += skipStart;
         oldLineNum += skipStart;
       }
       for (const line of linesToShow) {
-        if (stopped) break;
+        if (em.stopped) break;
         if (isEllipsisMarker(line)) {
-          emitPlain(" ...", undefined);
+          em.emitPlain(" ...", undefined);
           newLineNum += skipMiddle;
           oldLineNum += skipMiddle;
           continue;
         }
         const hash = effectiveNewHashes[newLineNum - 1];
-        emitRow(" ", line, hash, newLineNum);
+        em.emitRow(" ", line, hash, newLineNum);
         newLineNum++;
         oldLineNum++;
       }
       if (skipTail > 0) {
-        emitPlain(" ...", undefined);
+        em.emitPlain(" ...", undefined);
       }
     } else {
       newLineNum += displayLines.length;
@@ -564,7 +588,7 @@ export function genDiff(
     lastWasChange = false;
   }
 
-  if (diffTruncated) {
+  if (em.truncated) {
     output.push(" ...");
     lineNumbers.push(undefined);
     output.push(`[diff truncated at ${formatSize(maxBytes)}; use read to see the rest.]`);