pi-hashline-edit-pro 4.2.10 → 4.3.0

package/src/replace-render.ts

@@ -1,6 +1,7 @@
 import { Markdown, Text } from "@earendil-works/pi-tui";
 import { keyHint, type Theme } from "@earendil-works/pi-coding-agent";
 import type { ReplaceDetails } from "./replace";
+import { abortedBatchMessageFor } from "./batch";
 import { withLineNumbers } from "./utils";
 import { isDedupRow } from "./replace-response";
 import { getPreviewInput } from "./payload-contract";
@@ -66,6 +67,21 @@ export function fmtResult(diff: string, theme: FgT): string {
 	return colorLines(diff.split("\n"), theme).join("\n");
 }
 
+export function highlightBatchRefs(text: string, theme: FgT): string {
+	const pattern = /\b([Bb]atch \d+)\b/g;
+	const sections: string[] = [];
+	let cursor = 0;
+	for (;;) {
+		const match = pattern.exec(text);
+		if (!match) break;
+		if (match.index > cursor) sections.push(theme.fg("error", text.slice(cursor, match.index)));
+		sections.push(theme.fg("warning", match[0]));
+		cursor = match.index + match[0].length;
+	}
+	if (cursor < text.length) sections.push(theme.fg("error", text.slice(cursor)));
+	return sections.join("");
+}
+
 export function fmtCall(
   args: { path?: string; remove_from?: string; remove_to?: string; anchor?: string } | undefined,
   state: RRState,
@@ -144,6 +160,14 @@ function extractSummary(text: string | undefined): string | undefined {
 	return summary.length > 0 ? summary : undefined;
 }
 
+const BATCH_HEADER_RE = /^batch \d+:\n/;
+
+function splitBatchHeader(diff: string, lineNumbers: (number | undefined)[] | undefined): { header: string | undefined; body: string; lineNumbers: (number | undefined)[] | undefined } {
+	const match = diff.match(BATCH_HEADER_RE);
+	if (!match) return { header: undefined, body: diff, lineNumbers };
+	return { header: match[0]!.slice(0, -1), body: diff.slice(match[0].length), lineNumbers: lineNumbers?.slice(1) };
+}
+
 export function buildAppliedText(
 	text: string | undefined,
 	details: ReplaceDetails | undefined,
@@ -154,8 +178,9 @@ export function buildAppliedText(
 	const summary = extractSummary(text);
 	if (summary) sections.push(summary);
 	if (details?.diff) {
-		const rawDiff = details.diffLineNumbers ? toNumberedDiff(details.diff, details.diffLineNumbers) : details.diff;
-		const diffLines = details.diff.split("\n");
+		const { header, body, lineNumbers } = splitBatchHeader(details.diff, details.diffLineNumbers);
+		const rawDiff = lineNumbers ? toNumberedDiff(body, lineNumbers) : body;
+		const diffLines = body.split("\n");
 		const diffSection = expanded
 			? fmtResult(rawDiff, theme)
 			: fmtPreview(rawDiff, false, theme);
@@ -163,7 +188,7 @@ export function buildAppliedText(
 			!expanded && diffLines.length > RESULT_PREVIEW_LINES
 				? ` (${expandHint()})`
 				: "";
-		sections.push(`${diffSection}${hint}`);
+		sections.push(header !== undefined ? `${theme.fg("warning", header)}\n${diffSection}${hint}` : `${diffSection}${hint}`);
 	}
 	const warnings = details?.warnings?.length ? `Warnings:\n${details.warnings.join("\n")}` : extractWarnings(text);
 	if (warnings) sections.push(warnings);
@@ -343,9 +368,17 @@ export function renderEditResult(
 		renderState.preview = undefined;
 		renderState.previewGeneration = (renderState.previewGeneration ?? 0) + 1;
 	}
+	const batch = result.details?.batch;
+	if (batch && batch.last === false) {
+		const abortedMessage = typeof context?.toolCallId === "string" ? abortedBatchMessageFor(context.toolCallId) : undefined;
+		if (abortedMessage !== undefined) {
+			return reuseText(context, `\n${highlightBatchRefs(abortedMessage, theme)}`);
+		}
+		return reuseText(context, theme.fg("warning", `In batch ${batch.id}`));
+	}
 	if (context.isError) {
 		return renderedText
-			? reuseText(context, `\n${theme.fg("error", renderedText)}`)
+			? reuseText(context, `\n${highlightBatchRefs(renderedText, theme)}`)
 			: new Text("", 0, 0);
 	}
 	if (isApplied(result.details)) {

package/src/replace-response.ts

@@ -2,7 +2,7 @@ import { formatSize, DEFAULT_MAX_BYTES } from "@earendil-works/pi-coding-agent";
 import type { NEdit } from "./hashline";
 import { HASH_SEP } from "./hashline";
 import type { ReplaceDetails } from "./replace";
-import { genDiff, genPatch, type DiffSpan } from "./replace-diff";
+import { genDiff, genPatch, fmtDedupRow, type DiffSpan } from "./replace-diff";
 import { visLines, clipLine } from "./utils";
 import { DEDUP_ANCHOR } from "./constants";
 
@@ -106,7 +106,7 @@ export function buildNoop(input: NoopInput, noopNoun = "Replacement"): TResult {
 		: "The edit produced identical content.";
 	const dedupNote =
 		boundaryRemovedLines !== undefined && boundaryRemovedLines > 0
-			? `\nBoundary dedup removed ${boundaryRemovedLines} line(s); resend the same edit to apply it literally.`
+			? `\nBoundary dedup removed ${boundaryRemovedLines} line(s) that duplicated adjacent lines.`
 			: "";
 
 	const text = `No changes made to ${path}\nClassification: noop\n${noopDetailsText}${dedupNote}${warnBlock(warnings)}`;
@@ -131,13 +131,7 @@ export function buildNoop(input: NoopInput, noopNoun = "Replacement"): TResult {
 		},
 	};
 }
-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.]`;
-}
+export { fmtDedupRow };
 
 export function isDedupRow(line: string): boolean {
   return line.startsWith(`${DEDUP_ANCHOR}${HASH_SEP}`);
@@ -147,9 +141,42 @@ export function isChangeRow(line: string): boolean {
   return line.startsWith("+") || line.startsWith("-");
 }
 
-export function withDedupRows(diff: string, lineNumbers: (number | undefined)[], above: string[] | undefined, below: string[] | undefined): { diff: string; lineNumbers: (number | undefined)[] } {
-  const top = (above ?? []).map(fmtDedupRow);
-  const bottom = (below ?? []).map(fmtDedupRow);
+function capDedupRows(rows: string[], budget: number): { rows: string[]; bytes: number; omitted: number } {
+  const kept: string[] = [];
+  let bytes = 0;
+  for (const row of rows) {
+    const rowBytes = Buffer.byteLength(row, "utf-8") + 1;
+    if (bytes + rowBytes > budget) break;
+    kept.push(row);
+    bytes += rowBytes;
+  }
+  return { rows: kept, bytes, omitted: rows.length - kept.length };
+}
+
+function dedupOmissionNote(omitted: number, maxBytes: number): string {
+  return fmtDedupRow(`[${omitted} line(s) not shown again; output capped at ${formatSize(maxBytes)}.]`);
+}
+
+export function withDedupRows(diff: string, lineNumbers: (number | undefined)[], above: string[] | undefined, below: string[] | undefined, maxBytes = DEFAULT_MAX_BYTES): { diff: string; lineNumbers: (number | undefined)[] } {
+  const topAll = (above ?? []).map(fmtDedupRow);
+  const bottomAll = (below ?? []).map(fmtDedupRow);
+  if (topAll.length === 0 && bottomAll.length === 0) return { diff, lineNumbers };
+  const usedBytes = Buffer.byteLength(diff, "utf-8");
+  const fullBudget = Math.max(0, maxBytes - usedBytes);
+  const initialTop = capDedupRows(topAll, fullBudget);
+  const initialBottom = capDedupRows(bottomAll, Math.max(0, fullBudget - initialTop.bytes));
+  const anyOmitted = initialTop.omitted + initialBottom.omitted > 0;
+  const reserved = anyOmitted ? Buffer.byteLength(dedupOmissionNote(topAll.length + bottomAll.length, maxBytes), "utf-8") + 1 : 0;
+  const budget = Math.max(0, fullBudget - reserved);
+  const topCapped = anyOmitted ? capDedupRows(topAll, budget) : initialTop;
+  const bottomCapped = anyOmitted ? capDedupRows(bottomAll, Math.max(0, budget - topCapped.bytes)) : initialBottom;
+  const top = topCapped.rows;
+  const bottom = [...bottomCapped.rows];
+  const omitted = topCapped.omitted + bottomCapped.omitted;
+  if (omitted > 0) {
+    const note = dedupOmissionNote(omitted, maxBytes);
+    if (usedBytes + topCapped.bytes + bottomCapped.bytes + Buffer.byteLength(note, "utf-8") + 1 <= maxBytes) bottom.push(note);
+  }
   if (top.length === 0 && bottom.length === 0) return { diff, lineNumbers };
   if (diff.length === 0) return { diff: [...top, ...bottom].join("\n"), lineNumbers: [...lineNumbers, ...[...top, ...bottom].map(() => undefined)] };
   const lines = diff.split("\n");
@@ -175,7 +202,9 @@ export function buildChanged(input: SuccessInput, verb = "replaced", diffContext
   const { path, result, warnings, snapshotId, originalNormalized, originalHashes, editMeta, resultHashes, boundaryDedupAbove, boundaryDedupBelow, spans } = input;
   const resultLines = visLines(result);
   const baseDiff = genDiff(originalNormalized, result, diffContextLines, resultHashes, originalHashes, undefined, spans);
-  const diffResult = withDedupRows(baseDiff.diff, baseDiff.lineNumbers, boundaryDedupAbove, boundaryDedupBelow);
+  const diffResult = baseDiff.spanDedupEmitted
+    ? baseDiff
+    : withDedupRows(baseDiff.diff, baseDiff.lineNumbers, boundaryDedupAbove, boundaryDedupBelow);
   const addedLines = editMeta.addedLines;
   const removedLines = editMeta.removedLines;
   const warningsBlock = warnBlock(warnings);

package/src/replace-undo.ts

@@ -4,10 +4,9 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { loadHashStore, persistSnapshot, upsertUndo, getUndoEntry, deleteUndo, type UndoRecord } from "./hash-store";
-import { servedHashesFromDiff, buildServedMap } from "./served";
-import { contentChecksum } from "./hashline/hasher";
-import { hashSource } from "./hashline";
-import { markServed as markServedScoped, freeAnchors, adoptAnchors, withAnchorSession } from "./anchor-registry";
+import { servedHashesFromDiff, serveRows } from "./served";
+import { lineChecksum } from "./hashline";
+import { freeAnchors, adoptAnchors, withAnchorSession } from "./anchor-registry";
 import { resolveInCwd, writeAtomic, type FileIdentity } from "./fs-write";
 import { toLF, stripBOM, restoreEndings, type LineEnding } from "./normalize";
 import { genDiff, genPatch, spansFromHashes } from "./replace-diff";
@@ -172,7 +171,7 @@ export function regUndo(pi: ExtensionAPI): void {
               content: [
                 {
                   type: "text",
-                  text: `[E_UNDO_STALE] Cannot undo last change on ${path}: the file was modified after the edit, so nothing was reverted. The current content already contains your applied edit plus that external change and is most likely the correct state. Do not modify the file to make an undo possible and do not revert your own edit. The undo record is kept. Call read() to verify the current state, then stop.`
+                  text: `[E_UNDO_STALE] Cannot undo last change on ${path}: the file was modified after the edit, so nothing was reverted and the file was left untouched. The undo record is kept. Do not edit the file to force the undo. Call read() to inspect the current state.`
                 },
               ],
               isError: true,
@@ -200,16 +199,17 @@ export function regUndo(pi: ExtensionAPI): void {
           try {
             const store = await loadHashStore();
             const undoLines = splitLines(undo.content);
-            persistSnapshot(store, mutationTargetPath, undo.content, undo.hashes, undoLines.map((line) => contentChecksum(hashSource(line))));
+            persistSnapshot(store, mutationTargetPath, undo.content, undo.hashes, undoLines.map(lineChecksum));
             freeAnchors(mutationTargetPath);
             adoptAnchors(
               mutationTargetPath,
-              new Map(undoLines.map((line, i) => [undo.hashes[i]!, contentChecksum(hashSource(line))])),
+              new Map(undoLines.map((line, i) => [undo.hashes[i]!, lineChecksum(line)])),
             );
-            markServedScoped(
+            serveRows(
               mutationTargetPath,
-              buildServedMap(undo.hashes, undoLines, servedHashesFromDiff(undoDiff)),
-              new Set(undo.hashes),
+              undo.hashes,
+              undoLines,
+              servedHashesFromDiff(undoDiff),
             );
           } catch (error) {
             console.error("Failed to restore hash store snapshot after undo:", error);

package/src/replace.ts

@@ -32,10 +32,9 @@ import { loadHashStore, type HashStore } from "./hash-store";
 import { adoptAnchors, servedForPath, withAnchorSession } from "./anchor-registry";
 import { resolveTarget } from "./fs-write";
 import { toCwd } from "./paths";
-import { noopPayloadKey, markBoundaryNoop, consumeBoundaryBypass, clearBoundaryBypass } from "./boundary-bypass";
 import { queuedEdit, editToolBase, editRenderCallWrapper, editRenderResultWrapper, resolveEditTargetWithRequirement, throwIfStrictInput, getBoundaryDedupMode, withReplacePrompts, DEFAULT_EDIT_FLAGS, type EditToolFlags } from "./edit-common";
-import { commitEdit } from "./commit";
-import { batchMemberFor, executeBatchMember, noteBatchFailure, suffixPoisonCause } from "./batch";
+import { commitEdit, dedupRowsFromFixes } from "./commit";
+import { batchMemberFor, executeBatchMember, noteBatchFailure } from "./batch";
 
 export { editToolSchema, type ReqParams, assertReq };
 
@@ -67,7 +66,6 @@ export interface PipelineResult {
   resultHashes: string[];
   totalAddedLines: number;
   totalRemovedLines: number;
-  hadBoundaryDedup: boolean;
   boundaryRemovedLines: number;
   boundaryRemovedLineTexts: string[];
   boundaryDedupAbove: string[];
@@ -92,7 +90,14 @@ export function hashSpan(hashes: string[], from: string, to: string): [number, n
   if (a < 0 || b < 0) return undefined;
   return [Math.min(a, b), Math.max(a, b)];
 }
-async function noteAnchorError(absolutePath: string, error: unknown, scopeHashes: string[], noPersist?: boolean): Promise<void> {
+
+export function spanForEdit(originalHashes: string[], from: string, to: string, resultContent: string): DiffSpan | undefined {
+  const span = hashSpan(originalHashes, from, to);
+  if (!span) return undefined;
+  const replacementCount = splitLines(resultContent).length - (originalHashes.length - (span[1] - span[0] + 1));
+  return { start: span[0], end: span[1], replacementCount };
+}
+async function noteAnchorError(absolutePath: string, error: unknown, noPersist?: boolean): Promise<void> {
   if (noPersist === true) return;
   if (error instanceof RangeStaleError) {
     adoptAnchors(absolutePath, error.rangeServedMap);
@@ -161,7 +166,7 @@ export async function execPipeline(
       strictBoundaryDedup,
     );
   } catch (error) {
-    await noteAnchorError(absolutePath, error, originalHashes, options?.noPersist);
+    await noteAnchorError(absolutePath, error, options?.noPersist);
     throw error;
   }
 
@@ -180,12 +185,9 @@ export async function execPipeline(
     edit, originalHashes, isNoop, anchorResult.autoFixes?.length ?? 0,
   );
 
-  const sortedFixes = [...(anchorResult.autoFixes ?? [])].sort((a, b) => a.removedLineIndex - b.removedLineIndex);
-  const aboveFixes = sortedFixes.filter((fix) => fix.kind === "leading" || fix.kind === "last-new-before");
-  const belowFixes = sortedFixes.filter((fix) => fix.kind === "trailing" || fix.kind === "first-new-after");
-  const pipeSpan = isNoop ? undefined : hashSpan(originalHashes, edit.hash_bounds[0].hash, edit.hash_bounds[1].hash);
-  const pipeResultCount = splitLines(result).length;
-  const pipeSpans = pipeSpan ? [{ start: pipeSpan[0], end: pipeSpan[1], replacementCount: pipeResultCount - (originalHashes.length - (pipeSpan[1] - pipeSpan[0] + 1)) }] : undefined;
+  const sortedFixes = dedupRowsFromFixes(anchorResult.autoFixes ?? []);
+  const pipeSpan = isNoop ? undefined : spanForEdit(originalHashes, edit.hash_bounds[0].hash, edit.hash_bounds[1].hash, result);
+  const pipeSpans = pipeSpan ? [pipeSpan] : undefined;
   return {
     path: displayPath,
     originalNormalized,
@@ -201,11 +203,10 @@ export async function execPipeline(
     originalHashes,
     totalAddedLines,
     totalRemovedLines,
-    hadBoundaryDedup: (anchorResult.autoFixes?.length ?? 0) > 0,
     boundaryRemovedLines: anchorResult.autoFixes?.length ?? 0,
-    boundaryRemovedLineTexts: sortedFixes.map((fix) => fix.removedLine),
-    boundaryDedupAbove: aboveFixes.map((fix) => fix.removedLine),
-    boundaryDedupBelow: belowFixes.map((fix) => fix.removedLine),
+    boundaryRemovedLineTexts: sortedFixes.removedTexts,
+    boundaryDedupAbove: sortedFixes.above,
+    boundaryDedupBelow: sortedFixes.below,
     identity,
     ...(pipeSpans ? { spans: pipeSpans } : {}),
   };
@@ -287,54 +288,34 @@ export function buildToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): ToolDef
         }).catch((error: unknown) => {
           const member = batchMemberFor(_toolCallId);
           if (member) noteBatchFailure(member, error);
-          else suffixPoisonCause(_toolCallId, error);
           throw error;
         });
         return queuedEdit(targetPath, ctx.cwd, signal, async (absolutePath, mutationTargetPath) => {
           const dedupMode = await getBoundaryDedupMode();
-          const dedupOn = dedupMode !== "off";
-          const noopPayload = noopPayloadKey(mutationTargetPath, normalizedParams.remove_from, normalizedParams.remove_to, normalizedParams.replacement_lines);
-          const boundaryBypass = dedupOn ? consumeBoundaryBypass(mutationTargetPath, noopPayload) : false;
-          const strictBoundaryDedup = dedupMode === "strict" && !boundaryBypass;
+          const strictBoundaryDedup = dedupMode === "strict";
           const member = batchMemberFor(_toolCallId);
           if (!member) {
-            try {
-              const pipe = await execPipeline(
-                targetPath,
-                normalizedParams,
-                ctx.cwd,
-                { accessMode: constants.R_OK | constants.W_OK, signal, skipBoundaryDedup: boundaryBypass },
-              );
-              const appliedWarnings = boundaryBypass
-                ? ["[W_BOUNDARY_BYPASS] Boundary dedup was off for this call and is back on."]
-                : [];
-              return await commitEdit(pipe, {
-                path: pipe.path,
-                absolutePath,
-                mutationTargetPath,
-                editAnchors: [normalizedParams.remove_from, normalizedParams.remove_to],
-                signal,
-                appliedWarnings,
-                onApplied: () => { if (dedupOn) clearBoundaryBypass(mutationTargetPath); },
-                onNoopDedup: dedupOn ? () => markBoundaryNoop(mutationTargetPath, noopPayload) : undefined,
-              });
-            } catch (error) {
-              const detail = error instanceof Error ? error.message : String(error);
-              if (boundaryBypass && !detail.includes("File was written;")) markBoundaryNoop(mutationTargetPath, noopPayload);
-              throw error;
-            }
+            const pipe = await execPipeline(
+              targetPath,
+              normalizedParams,
+              ctx.cwd,
+              { accessMode: constants.R_OK | constants.W_OK, signal },
+            );
+            return await commitEdit(pipe, {
+              path: pipe.path,
+              absolutePath,
+              mutationTargetPath,
+              editAnchors: [normalizedParams.remove_from, normalizedParams.remove_to],
+              signal,
+            });
           }
           let built: { edit: HEdit; warnings: string[] };
           try {
             built = buildReplaceHEdit(normalizedParams);
           } catch (error) {
             noteBatchFailure(member, error);
-            if (boundaryBypass) markBoundaryNoop(mutationTargetPath, noopPayload);
             throw error;
           }
-          const appliedWarnings = boundaryBypass
-            ? ["[W_BOUNDARY_BYPASS] Boundary dedup was off for this call and is back on."]
-            : [];
           return executeBatchMember({
             kind: "replace",
             member,
@@ -343,11 +324,9 @@ export function buildToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): ToolDef
             cwd: ctx.cwd,
             signal,
             hedit: built.edit,
-            extraWarnings: [...built.warnings, ...appliedWarnings],
-            skipBoundaryDedup: boundaryBypass,
+            extraWarnings: built.warnings,
+            skipBoundaryDedup: false,
             strictBoundaryDedup,
-            noopPayload,
-            bypassConsumed: boundaryBypass,
           });
         });
       });

package/src/served.ts

@@ -1,6 +1,6 @@
 import { HASH_CLASS } from "./hashline/alphabet";
-import { hashSource } from "./hashline";
-import { contentChecksum } from "./hashline/hasher";
+import { lineChecksum } from "./hashline/hash";
+import { markServed } from "./anchor-registry";
 
 const SERVED_DIFF_ROW_RE = new RegExp(`^[+ ](${HASH_CLASS})│`);
 
@@ -26,7 +26,11 @@ export function buildServedMap(
   const entries: Array<[string, string]> = [];
   for (const hash of wantedHashes) {
     const idx = index.get(hash);
-    if (idx !== undefined) entries.push([hash, contentChecksum(hashSource(fileLines[idx]!))]);
+    if (idx !== undefined) entries.push([hash, lineChecksum(fileLines[idx]!)]);
   }
   return entries;
 }
+
+export function serveRows(path: string, fileHashes: string[], fileLines: string[], wantedHashes: string[]): void {
+  markServed(path, buildServedMap(fileHashes, fileLines, wantedHashes), new Set(fileHashes));
+}

package/src/utils.ts

@@ -22,14 +22,16 @@ export function normalizeAnchors(record: Record<string, unknown>): void {
   }
 }
 
+export function normalizeRequest(input: unknown): unknown {
+  if (!isRec(input)) return input;
+  const record: Record<string, unknown> = { ...input };
+  normalizeFilePath(record);
+  normalizeAnchors(record);
+  return record;
+}
+
 export function makePrepareArguments(): (args: unknown) => any {
-  return (args) => {
-    if (!isRec(args)) return args;
-    const record = { ...args };
-    normalizeFilePath(record);
-    normalizeAnchors(record);
-    return record;
-  };
+  return normalizeRequest;
 }
 
 export function splitLines(text: string): string[] {
@@ -293,7 +295,6 @@ export function decodeStringArray(value: unknown, warnings?: string[], label = "
 	if (candidate === undefined) return undefined;
 	const decoded = decodeArrayText(candidate);
 	if (decoded !== undefined) {
-		warnings?.push(`[W_BAD_SHAPE] Unwrapped JSON array syntax from a ${label} element.`);
 		return decoded;
 	}
 	if (looksLikeStringArray(candidate)) {

package/src/write-hook.ts

@@ -19,10 +19,6 @@ export function findServedHashEcho(content: string, served: ReadonlyMap<string,
   return searchEcho(splitLines(content), served);
 }
 
-export function findEditHashEcho(lines: string[], served: ReadonlyMap<string, string> | ReadonlySet<string>): { line: number; hash: string } | undefined {
-  return searchEcho(lines, served);
-}
-
 export async function servedHashEchoDenial(rawPath: string, content: string, cwd: string, signal?: AbortSignal): Promise<string | undefined> {
   abortIf(signal);
   const { resolved } = await resolveInCwd(rawPath, cwd);

package/src/boundary-bypass.ts

@@ -1,51 +0,0 @@
-import { parseText } from "./hashline/parse";
-import { ANCHOR_ROW_RE } from "./hashline/resolve";
-import { stripRowPrefix } from "./hashline/hash";
-
-function canonRef(ref: string): string {
-  const trimmed = ref.trim();
-  const match = trimmed.match(ANCHOR_ROW_RE);
-  return match ? match[2]! : trimmed;
-}
-
-function canonLines(lines: string[]): string[] {
-  return parseText(lines).map((line) => stripRowPrefix(line).text);
-}
-
-const boundaryBypassTracker = new Map<string, string>();
-const BOUNDARY_BYPASS_LIMIT = 256;
-
-export function noopPayloadKey(
-  absolutePath: string,
-  removeFrom: string,
-  removeTo: string,
-  replacementLines: string[],
-): string {
-  return JSON.stringify([
-    absolutePath,
-    canonRef(removeFrom),
-    canonRef(removeTo),
-    canonLines(replacementLines),
-  ]);
-}
-
-export function markBoundaryNoop(absolutePath: string, payload: string): void {
-  boundaryBypassTracker.delete(absolutePath);
-  boundaryBypassTracker.set(absolutePath, payload);
-  if (boundaryBypassTracker.size > BOUNDARY_BYPASS_LIMIT) {
-    const oldest = boundaryBypassTracker.keys().next().value;
-    if (oldest !== undefined) boundaryBypassTracker.delete(oldest);
-  }
-}
-
-export function consumeBoundaryBypass(absolutePath: string, payload: string): boolean {
-  if (boundaryBypassTracker.get(absolutePath) === payload) {
-    boundaryBypassTracker.delete(absolutePath);
-    return true;
-  }
-  return false;
-}
-
-export function clearBoundaryBypass(absolutePath: string): void {
-  boundaryBypassTracker.delete(absolutePath);
-}