pi-hashline-edit-pro 4.1.0 → 4.2.1

package/src/config-ui.ts

@@ -2,22 +2,27 @@ import { Key, matchesKey, visibleWidth } from "@earendil-works/pi-tui";
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import { readConfig, type Config } from "./config";
 
-export type ConfigToggleKey = "autoRead" | "anchorGrepEnabled" | "requirePath" | "strictInput" | "boundaryDedupEnabled";
+export type ConfigToggleKey = "autoRead" | "anchorGrepEnabled" | "requirePath" | "strictInput" | "boundaryDedupMode" | "diffContextLines";
 
 export interface ConfigRow {
   key: ConfigToggleKey;
   label: string;
   hint: string;
   enabled: boolean;
+  mode?: string;
+  cycle?: string[];
+  value?: number;
+  disabled?: boolean;
 }
 
 export function configRows(config: Config): ConfigRow[] {
   return [
     { key: "autoRead", label: "Auto-read", hint: "Anchors after write + post-edit diffs", enabled: config.autoRead !== false },
+    { key: "diffContextLines", label: "Diff context", hint: "Surrounding lines in post-edit diffs (needs Auto-read)", enabled: config.autoRead !== false, value: config.diffContextLines ?? 1, disabled: config.autoRead === false },
     { key: "anchorGrepEnabled", label: "Anchor grep", hint: "anchor_grep tool (builtin grep off while on)", enabled: config.anchorGrepEnabled === true },
     { key: "requirePath", label: "Require path", hint: "replace + insert need path (RPC visibility)", enabled: config.requirePath === true },
     { key: "strictInput", label: "Strict input", hint: "Reject auto-fixable slips instead of warnings", enabled: config.strictInput === true },
-    { key: "boundaryDedupEnabled", label: "Boundary dedup", hint: "Strip re-included edge lines (off = literal)", enabled: config.boundaryDedupEnabled !== false },
+    { key: "boundaryDedupMode", label: "Boundary dedup", hint: "Strip edge lines: on, strict (reject), off (literal)", enabled: (config.boundaryDedupMode ?? "on") !== "off", mode: config.boundaryDedupMode ?? "on", cycle: ["on", "strict", "off"] },
   ];
 }
 
@@ -26,11 +31,22 @@ function padRow(theme: Theme, innerWidth: number, content: string): string {
   return theme.fg("border", "│") + padded + theme.fg("border", "│");
 }
 
+function modeBox(theme: Theme, mode: string): string {
+  if (mode === "off") return theme.fg("dim", `[${mode}]`);
+  if (mode === "strict") return theme.fg("accent", `[${mode}]`);
+  return theme.fg("success", `[${mode}]`);
+}
+
+function numberBox(theme: Theme, value: number, disabled?: boolean): string {
+  if (disabled) return theme.fg("dim", `[${value}]`);
+  return theme.fg("accent", `[${value}]`);
+}
+
 export class HashlineConfigOverlay {
   private rows: ConfigRow[];
   private selected = 0;
 
-  constructor(private readonly opts: { tui: { requestRender(force?: boolean): void }; theme: Theme; done: () => void; onToggle: (key: ConfigToggleKey) => Promise<void> }) {
+  constructor(private readonly opts: { tui: { requestRender(force?: boolean): void }; theme: Theme; done: () => void; onToggle: (key: ConfigToggleKey, delta?: number) => Promise<void> }) {
     this.rows = [];
   }
 
@@ -38,12 +54,9 @@ export class HashlineConfigOverlay {
     this.rows = configRows(await readConfig());
   }
 
-  private toggleSelected(): void {
-    const row = this.rows[this.selected];
-    if (!row) return;
-    row.enabled = !row.enabled;
+  private runToggle(row: ConfigRow, delta?: number): void {
     this.opts.tui.requestRender(true);
-    void this.opts.onToggle(row.key).then(async () => {
+    void this.opts.onToggle(row.key, delta).then(async () => {
       this.rows = configRows(await readConfig());
       this.opts.tui.requestRender(true);
     }).catch((error: unknown) => {
@@ -51,6 +64,32 @@ export class HashlineConfigOverlay {
     });
   }
 
+  private toggleSelected(): void {
+    const row = this.rows[this.selected];
+    if (!row || row.disabled) return;
+    if (row.value !== undefined) {
+      row.value += 1;
+      this.runToggle(row, 1);
+      return;
+    }
+    if (row.cycle && row.mode !== undefined) {
+      const next = row.cycle[(row.cycle.indexOf(row.mode) + 1) % row.cycle.length] ?? row.cycle[0];
+      if (next === undefined) return;
+      row.mode = next;
+      row.enabled = next !== "off";
+    } else {
+      row.enabled = !row.enabled;
+    }
+    this.runToggle(row);
+  }
+
+  private adjustSelected(delta: number): void {
+    const row = this.rows[this.selected];
+    if (!row || row.disabled || row.value === undefined) return;
+    row.value += delta;
+    this.runToggle(row, delta);
+  }
+
   handleInput(data: string): void {
     if (matchesKey(data, Key.up) || data === "k") {
       this.selected = (this.selected + this.rows.length - 1) % this.rows.length;
@@ -60,6 +99,14 @@ export class HashlineConfigOverlay {
       this.selected = (this.selected + 1) % this.rows.length;
       return;
     }
+    if (matchesKey(data, Key.right) || data === "+" || data === "=") {
+      this.adjustSelected(1);
+      return;
+    }
+    if (matchesKey(data, Key.left) || data === "-" || data === "_") {
+      this.adjustSelected(-1);
+      return;
+    }
     if (matchesKey(data, Key.space) || matchesKey(data, Key.enter) || data === " " || data === "\r" || data === "\n") {
       this.toggleSelected();
       return;
@@ -81,12 +128,12 @@ export class HashlineConfigOverlay {
     lines.push(theme.fg("border", `├${"─".repeat(innerWidth)}┤`));
     this.rows.forEach((row, index) => {
       const cursor = index === this.selected ? theme.fg("accent", "> ") : "  ";
-      const box = row.enabled ? theme.fg("success", "[x]") : theme.fg("dim", "[ ]");
-      const label = index === this.selected ? theme.fg("accent", theme.bold(row.label)) : row.label;
+      const box = row.value !== undefined ? numberBox(theme, row.value, row.disabled) : row.mode !== undefined ? modeBox(theme, row.mode) : row.enabled ? theme.fg("success", "[x]") : theme.fg("dim", "[ ]");
+      const label = row.disabled ? theme.fg("dim", row.label) : index === this.selected ? theme.fg("accent", theme.bold(row.label)) : row.label;
       lines.push(padRow(theme, innerWidth, `${cursor}${box} ${label} ${theme.fg("dim", `— ${row.hint}`)}`));
     });
     lines.push(theme.fg("border", `├${"─".repeat(innerWidth)}┤`));
-    lines.push(padRow(theme, innerWidth, theme.fg("dim", " ↑↓ navigate · space toggle · q close")));
+    lines.push(padRow(theme, innerWidth, theme.fg("dim", " ↑↓ navigate · space toggle · ←/→ or -/+ adjust · q close")));
     lines.push(theme.fg("border", `╰${"─".repeat(innerWidth)}╯`));
     return lines;
   }

package/src/config.ts

@@ -3,12 +3,19 @@ import { configPath } from "./paths";
 import { errCode, isRec } from "./utils";
 import { writeAtomic } from "./fs-write";
 
+export type BoundaryDedupMode = "on" | "off" | "strict";
+
+export const DEFAULT_DIFF_CONTEXT_LINES = 1;
+export const MIN_DIFF_CONTEXT_LINES = 0;
+export const MAX_DIFF_CONTEXT_LINES = 10;
+
 export interface Config {
   autoRead: boolean;
   anchorGrepEnabled: boolean;
   requirePath?: boolean;
   strictInput?: boolean;
-  boundaryDedupEnabled?: boolean;
+  boundaryDedupMode?: BoundaryDedupMode;
+  diffContextLines?: number;
 }
 
 const DEFAULT_CONFIG: Config = {
@@ -16,9 +23,27 @@ const DEFAULT_CONFIG: Config = {
   anchorGrepEnabled: true,
   requirePath: false,
   strictInput: false,
-  boundaryDedupEnabled: true
+  boundaryDedupMode: "on",
+  diffContextLines: DEFAULT_DIFF_CONTEXT_LINES
 };
 
+const BOUNDARY_DEDUP_MODES: BoundaryDedupMode[] = ["on", "strict", "off"];
+
+function parseBoundaryDedupMode(mode: unknown, legacy: unknown): BoundaryDedupMode {
+  if (mode === "on" || mode === "strict" || mode === "off") return mode;
+  if (legacy === true) return "on";
+  if (legacy === false) return "off";
+  return DEFAULT_CONFIG.boundaryDedupMode ?? "on";
+}
+
+export function normalizeDiffContextLines(value: unknown): number {
+  if (typeof value !== "number" || !Number.isFinite(value)) return DEFAULT_DIFF_CONTEXT_LINES;
+  const floored = Math.floor(value);
+  if (floored < MIN_DIFF_CONTEXT_LINES) return MIN_DIFF_CONTEXT_LINES;
+  if (floored > MAX_DIFF_CONTEXT_LINES) return MAX_DIFF_CONTEXT_LINES;
+  return floored;
+}
+
 function parseConfig(content: string): Config {
   const parsed = JSON.parse(content) as unknown;
   const autoRead = isRec(parsed) ? parsed.autoRead : undefined;
@@ -28,13 +53,16 @@ function parseConfig(content: string): Config {
   const anchorGrepEnabled = isRec(parsed) ? parsed.anchorGrepEnabled : undefined;
   const requirePath = isRec(parsed) ? parsed.requirePath : undefined;
   const strictInput = isRec(parsed) ? parsed.strictInput : undefined;
-  const boundaryDedupEnabled = isRec(parsed) ? parsed.boundaryDedupEnabled : undefined;
+  const boundaryDedupMode = isRec(parsed) ? parsed.boundaryDedupMode : undefined;
+  const legacyBoundaryDedup = isRec(parsed) ? parsed.boundaryDedupEnabled : undefined;
+  const diffContextLines = isRec(parsed) ? parsed.diffContextLines : undefined;
   return {
     autoRead,
     anchorGrepEnabled: typeof anchorGrepEnabled === "boolean" ? anchorGrepEnabled : DEFAULT_CONFIG.anchorGrepEnabled,
     requirePath: typeof requirePath === "boolean" ? requirePath : DEFAULT_CONFIG.requirePath,
     strictInput: typeof strictInput === "boolean" ? strictInput : DEFAULT_CONFIG.strictInput,
-    boundaryDedupEnabled: typeof boundaryDedupEnabled === "boolean" ? boundaryDedupEnabled : DEFAULT_CONFIG.boundaryDedupEnabled,
+    boundaryDedupMode: parseBoundaryDedupMode(boundaryDedupMode, legacyBoundaryDedup),
+    diffContextLines: normalizeDiffContextLines(diffContextLines),
   };
 }
 
@@ -83,10 +111,23 @@ export async function toggleStrictInput(): Promise<boolean> {
   return config.strictInput === true;
 }
 
-export async function toggleBoundaryDedup(): Promise<boolean> {
+export async function cycleBoundaryDedupMode(): Promise<BoundaryDedupMode> {
+  const config = await readConfig();
+  const current = config.boundaryDedupMode ?? "on";
+  const next = BOUNDARY_DEDUP_MODES[(BOUNDARY_DEDUP_MODES.indexOf(current) + 1) % BOUNDARY_DEDUP_MODES.length] ?? "on";
+  config.boundaryDedupMode = next;
+  await writeConfig(config);
+  return next;
+}
+
+export async function getDiffContextLines(): Promise<number> {
+  return normalizeDiffContextLines((await readConfig()).diffContextLines);
+}
+
+export async function adjustDiffContextLines(delta: number): Promise<number> {
   const config = await readConfig();
-  const enabled = config.boundaryDedupEnabled !== false;
-  config.boundaryDedupEnabled = !enabled;
+  const next = normalizeDiffContextLines(normalizeDiffContextLines(config.diffContextLines) + delta);
+  config.diffContextLines = next;
   await writeConfig(config);
-  return !enabled;
+  return next;
 }

package/src/edit-common.ts

@@ -3,7 +3,7 @@ import { resolveInCwd } from "./fs-write";
 import { abortIf, makePrepareArguments } from "./utils";
 import { ownerOf } from "./anchor-registry";
 import { parseHashRef, stripAnchorRow } from "./hashline";
-import { readConfig } from "./config";
+import { readConfig, type BoundaryDedupMode } from "./config";
 import { makeRenderCall, renderEditResult, type RPreview, type FgT } from "./replace-render";
 import type { ReplaceDetails } from "./replace";
 export const editPrepare = makePrepareArguments();
@@ -11,14 +11,14 @@ export const editPrepare = makePrepareArguments();
 export interface EditToolFlags {
   requirePath: boolean;
   strictInput: boolean;
-  boundaryDedupEnabled: boolean;
+  boundaryDedupMode: BoundaryDedupMode;
   autoRead: boolean;
 }
 
 export const DEFAULT_EDIT_FLAGS: EditToolFlags = {
   requirePath: false,
   strictInput: false,
-  boundaryDedupEnabled: true,
+  boundaryDedupMode: "on",
   autoRead: true
 };
 
@@ -27,7 +27,7 @@ export async function currentEditFlags(): Promise<EditToolFlags> {
   return {
     requirePath: config.requirePath === true,
     strictInput: config.strictInput === true,
-    boundaryDedupEnabled: config.boundaryDedupEnabled !== false,
+    boundaryDedupMode: config.boundaryDedupMode ?? "on",
     autoRead: config.autoRead !== false
   };
 }
@@ -38,7 +38,7 @@ export function withReplacePrompts(base: { description: string; snippet: string;
   let guidelines = [...base.guidelines];
   if (!flags.autoRead) {
     description = description.replace(" Anchor follow-up edits on the `+anchor│` and ` anchor│` rows of the post-edit diff instead of re-reading.", "");
-    guidelines = guidelines.map((guideline) => guideline.includes("post-edit diff") ? "`replace`: one edit per turn; verify each result before the next edit on that file." : guideline);
+    guidelines = guidelines.map((guideline) => guideline.includes("post-edit diff") ? "`replace`: one batch per file per turn; verify each result before the next edit on that file." : guideline);
   }
   const descriptionParts = [description];
   if (flags.requirePath) {
@@ -50,9 +50,12 @@ export function withReplacePrompts(base: { description: string; snippet: string;
     descriptionParts.push("Strict-input mode is on: auto-fixable slips are rejected instead of fixed with warnings.");
     guidelines.push("`replace`: strict-input is on: auto-fixable slips are rejected instead of fixed.");
   }
-  if (!flags.boundaryDedupEnabled) {
+  if (flags.boundaryDedupMode === "off") {
     descriptionParts.push("Boundary dedup is off: edits apply literally.");
     guidelines.push("`replace`: boundary dedup is off: edits apply literally.");
+  } else if (flags.boundaryDedupMode === "strict") {
+    descriptionParts.push("Boundary dedup is strict: edits that re-include edge lines are rejected instead of stripped.");
+    guidelines.push("`replace`: boundary dedup is strict: edits that re-include edge lines are rejected instead of stripped.");
   }
   return { description: descriptionParts.join(" "), snippet: snippetParts.join(""), guidelines };
 }
@@ -116,10 +119,10 @@ export interface PathRequirementInput {
 export async function resolveEditTargetWithRequirement(input: PathRequirementInput): Promise<string> {
   const { requirePath } = await readConfig();
   if (!requirePath && input.providedPath !== undefined) {
-    throw new Error("[E_BAD_SHAPE] Edit request contains unknown or unsupported fields: path. Path resolution is anchor-only; enable require-path in /hashline-config to require it.");
+    throw new Error("[E_BAD_SHAPE] Edit request contains unknown or unsupported fields: path. Path resolution is anchor-only; retry without `path`.");
   }
   if (requirePath && (typeof input.providedPath !== "string" || input.providedPath.length === 0)) {
-    throw new Error('[E_BAD_SHAPE] Edit request requires a non-empty "path" string when require-path mode is on (disable it in /hashline-config).');
+    throw new Error('[E_BAD_SHAPE] Edit request requires a non-empty "path" string when require-path mode is on. Provide `path` matching the file the anchors were served for.');
   }
   const anchorTarget = typeof input.anchor === "string"
     ? resolveEditTarget(input.anchor)
@@ -138,13 +141,12 @@ export async function throwIfStrictInput(warnings: string[]): Promise<void> {
   if (fixes.length === 0) return;
   const { strictInput } = await readConfig();
   if (strictInput === true) {
-    throw new Error(`[E_BAD_SHAPE] Strict-input mode rejects auto-fixable input (disable it in /hashline-config):\n${fixes.join("\n")}`);
+    throw new Error(`[E_BAD_SHAPE] Strict-input mode rejects auto-fixable input:\n${fixes.join("\n")}`);
   }
 }
 
-export async function isBoundaryDedupEnabled(): Promise<boolean> {
-  const { boundaryDedupEnabled } = await readConfig();
-  return boundaryDedupEnabled !== false;
+export async function getBoundaryDedupMode(): Promise<BoundaryDedupMode> {
+  return (await readConfig()).boundaryDedupMode ?? "on";
 }
 
 export function editRenderCallWrapper(

package/src/grep.ts

@@ -677,7 +677,7 @@ export function regGrep(pi: ExtensionAPI): void {
       if (rowTruncated) notes.push(`[grep: output truncated at ${DEFAULT_MAX_LINES} rows or ${formatSize(DEFAULT_MAX_BYTES)}; refine the pattern to see more.]`);
       if (limitTruncated) notes.push(`[grep: showing first ${limit} matches; increase limit to see more.]`);
       if (linesReplaced > 0) notes.push(`[grep: ${linesReplaced} line(s) exceed ${formatSize(MAX_GREP_LINE_BYTES)} and are shown as truncated fragments; use read to see the full lines.]`);
-      if (poolSkipped > 0) notes.push(`[grep: ${poolSkipped} file(s) skipped because the session's anchor pool is exhausted; free anchors with /clear-anchors or narrow the search.]`);
+      if (poolSkipped > 0) notes.push(`[grep: ${poolSkipped} file(s) skipped because the session's anchor pool is exhausted; narrow the search.]`);
       const truncated = limitTruncated || rowTruncated;
       const truncation: TruncationResult | undefined = rowTruncated
         ? {

package/src/hashline/apply.ts

@@ -1,4 +1,4 @@
-import { abortIf, splitLines } from "../utils";
+import { abortIf, clipLine, splitLines } from "../utils";
 import { _lineHashesPure } from "./hash";
 import {
 	valEdit,
@@ -52,7 +52,7 @@ type NoopSpan = {
 	loc: string;
 	currentContent: string;
 };
-function assertNotEmpty(originalContent: string, result: string): void {
+export function assertNotEmpty(originalContent: string, result: string): void {
 	if (originalContent.length > 0 && result.length === 0) {
 		throw new Error(
 			"[E_WOULD_EMPTY] A replace cannot empty a non-empty file. Use `write` to clear the file."
@@ -148,6 +148,122 @@ function assemble(
 	return content.slice(0, span.start) + span.replacement + content.slice(span.end);
 }
 
+export interface PlannedEdit {
+  resolved: RHEdit;
+  warnings: string[];
+  autoFixes?: AutoFix[];
+}
+
+
+function throwStrictBoundaryDedup(edit: HEdit, boundaryDups: BDup[], resolved: RHEdit): never {
+  const startLine = resolved.hash_bounds[0].line;
+  const endLine = resolved.hash_bounds[1].line;
+  const range = startLine === endLine ? `line ${startLine}` : `lines ${startLine}-${endLine}`;
+  const seen = new Set<number>();
+  for (const dup of boundaryDups) seen.add(dup.replacementLineIndex);
+  const removed = [...seen].sort((a, b) => a - b).map((index) => `replacement_lines line ${index + 1}: ${clipLine(edit.content_lines[index] ?? "")}`);
+  throw new Error(`[E_BOUNDARY_STRICT] Strict boundary dedup rejects this edit: ${seen.size} replacement line(s) re-include edge lines (${range}). ${removed.join("; ")}. Resend without those lines.`);
+}
+export function planEdit(
+  content: string,
+  edit: HEdit,
+  precomputedHashes: string[],
+  options?: {
+    filePath?: string;
+    servedHashes?: ReadonlyMap<string, string>;
+    skipBoundaryDedup?: boolean;
+    strictBoundaryDedup?: boolean;
+    signal?: AbortSignal;
+  },
+): PlannedEdit {
+  const signal = options?.signal;
+  abortIf(signal);
+  const lineIndex = buildIdx(content);
+  const fileHashes = precomputedHashes;
+  const warnings: string[] = [];
+
+  const rangeFixed = swapReversedRanges(edit, fileHashes, warnings);
+  const prefixFixed = stripDiffPrefixes(
+    stripBarePrefixes(rangeFixed, fileHashes, warnings),
+    warnings,
+  );
+
+  const { resolved: initialResolved, mismatches, boundaryDups } = valEdit(
+    prefixFixed,
+    lineIndex.fileLines,
+    fileHashes,
+    warnings,
+    signal,
+  );
+  if (mismatches.length || !initialResolved) {
+    const feedback = fmtMismatchWithHashes(
+      mismatches,
+      lineIndex.fileLines,
+      fileHashes,
+      options?.filePath,
+    );
+    throw new AnchorMismatchError(feedback.text, feedback.hashes, feedback.servedMap);
+  }
+
+  warnUnicodeEsc(prefixFixed, warnings);
+
+  if (options?.strictBoundaryDedup === true && boundaryDups.length > 0) {
+    throwStrictBoundaryDedup(prefixFixed, boundaryDups, initialResolved);
+  }
+  let resolved = initialResolved;
+  let autoFixes: AutoFix[] | undefined;
+  if (boundaryDups.length > 0 && !(options?.skipBoundaryDedup === true)) {
+    autoFixes = [];
+    const correctedEdit: HEdit = {
+      ...prefixFixed,
+      content_lines: [...prefixFixed.content_lines],
+    };
+    const seen = new Set<number>();
+    const uniqueDups: BDup[] = [];
+    for (const dup of boundaryDups) {
+      if (seen.has(dup.replacementLineIndex)) continue;
+      seen.add(dup.replacementLineIndex);
+      uniqueDups.push(dup);
+    }
+    const dupsByIndex = uniqueDups.sort(
+      (a, b) => b.replacementLineIndex - a.replacementLineIndex,
+    );
+    for (const dup of dupsByIndex) {
+      const idx = dup.replacementLineIndex;
+      if (idx < 0 || idx >= correctedEdit.content_lines.length) continue;
+      const removed = correctedEdit.content_lines.splice(idx, 1)[0];
+      autoFixes.push({ kind: dup.kind, removedLine: removed, removedLineIndex: idx });
+    }
+    const correctedResult = valEdit(
+      correctedEdit,
+      lineIndex.fileLines,
+      fileHashes,
+      warnings,
+      signal,
+    );
+    if (correctedResult.mismatches.length || !correctedResult.resolved) {
+      const feedback = fmtMismatchWithHashes(
+        correctedResult.mismatches,
+        lineIndex.fileLines,
+        fileHashes,
+        options?.filePath,
+      );
+      throw new AnchorMismatchError(feedback.text, feedback.hashes, feedback.servedMap);
+    }
+    resolved = correctedResult.resolved;
+  }
+
+  if (options?.servedHashes) {
+    abortIf(signal);
+    assertRangeServed(resolved, lineIndex.fileLines, fileHashes, options.servedHashes, options?.filePath);
+  }
+
+  return {
+    resolved,
+    warnings,
+    ...(autoFixes ? { autoFixes } : {}),
+  };
+}
 export function applyEdit(
 	content: string,
 	edit: HEdit,
@@ -156,6 +272,7 @@ export function applyEdit(
 	filePath?: string,
 	servedHashes?: ReadonlyMap<string, string>,
 	skipBoundaryDedup?: boolean,
+	strictBoundaryDedup?: boolean,
 	): {
 	content: string;
 	firstChangedLine: number | undefined;
@@ -164,88 +281,15 @@ export function applyEdit(
 	noopEdit?: NEdit;
 	autoFixes?: AutoFix[];
 } {
-	abortIf(signal);
-
-	const lineIndex = buildIdx(content);
-	if (precomputedHashes === undefined) {
-		throw new Error("[E_BAD_SHAPE] applyEdit requires the file's allocated anchors; derive them via lineHashes(content, path) first.");
-	}
-	const fileHashes = precomputedHashes;
-	const warnings: string[] = [];
-
-	const rangeFixed = swapReversedRanges(edit, fileHashes, warnings);
-	const prefixFixed = stripDiffPrefixes(
-		stripBarePrefixes(rangeFixed, fileHashes, warnings),
-		warnings,
-	);
-
-	const { resolved: initialResolved, mismatches, boundaryDups } = valEdit(
-		prefixFixed,
-		lineIndex.fileLines,
-		fileHashes,
-		warnings,
-		signal,
-	);
-	if (mismatches.length || !initialResolved) {
-		const feedback = fmtMismatchWithHashes(
-			mismatches,
-			lineIndex.fileLines,
-			fileHashes,
-			filePath,
-		);
-		throw new AnchorMismatchError(feedback.text, feedback.hashes, feedback.servedMap);
-	}
-
-	warnUnicodeEsc(prefixFixed, warnings);
-
-	let resolved = initialResolved;
-	let autoFixes: AutoFix[] | undefined;
-	if (boundaryDups.length > 0 && !skipBoundaryDedup) {
-		autoFixes = [];
-		const correctedEdit: HEdit = {
-			...prefixFixed,
-			content_lines: [...prefixFixed.content_lines],
-		};
-		const seen = new Set<number>();
-		const uniqueDups: BDup[] = [];
-		for (const dup of boundaryDups) {
-			if (seen.has(dup.replacementLineIndex)) continue;
-			seen.add(dup.replacementLineIndex);
-			uniqueDups.push(dup);
-		}
-		const dupsByIndex = uniqueDups.sort(
-			(a, b) => b.replacementLineIndex - a.replacementLineIndex,
-		);
-		for (const dup of dupsByIndex) {
-			const idx = dup.replacementLineIndex;
-			if (idx < 0 || idx >= correctedEdit.content_lines.length) continue;
-			const removed = correctedEdit.content_lines.splice(idx, 1)[0];
-			autoFixes.push({ kind: dup.kind, removedLine: removed, removedLineIndex: idx });
-		}
-		const correctedResult = valEdit(
-			correctedEdit,
-			lineIndex.fileLines,
-			fileHashes,
-			warnings,
-			signal,
-		);
-		if (correctedResult.mismatches.length || !correctedResult.resolved) {
-			const feedback = fmtMismatchWithHashes(
-				correctedResult.mismatches,
-				lineIndex.fileLines,
-				fileHashes,
-				filePath,
-			);
-			throw new AnchorMismatchError(feedback.text, feedback.hashes, feedback.servedMap);
-		}
-		resolved = correctedResult.resolved;
-	}
-
-	if (servedHashes) {
-		abortIf(signal);
-		assertRangeServed(resolved, lineIndex.fileLines, fileHashes, servedHashes, filePath);
-	}
-
+  abortIf(signal);
+  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, skipBoundaryDedup, strictBoundaryDedup, signal });
+  const lineIndex = buildIdx(content);
+  const warnings = planned.warnings;
+  const resolved = planned.resolved;
+  const autoFixes = planned.autoFixes;
 	const spanResult = resToSpan(resolved, content, lineIndex);
 	if (spanResult.kind === "noop") {
 		return {

package/src/hashline/index.ts

@@ -43,7 +43,10 @@ export {
 export {
 	buildIdx,
 	applyEdit,
+	planEdit,
+	type PlannedEdit,
 	fmtRegion,
 	fmtRow,
 	changedRange,
+	assertNotEmpty,
 } from "./apply";