opencode-hashline 1.1.3 → 1.3.0

package/dist/{chunk-I6RACR3D.js → chunk-DOR4YDIS.js}

@@ -56,7 +56,9 @@ var DEFAULT_CONFIG = {
   // 0 = adaptive
   cacheSize: 100,
   prefix: DEFAULT_PREFIX,
-  debug: false
+  debug: false,
+  fileRev: true,
+  safeReapply: false
 };
 function resolveConfig(config, pluginConfig) {
   const merged = {
@@ -72,9 +74,55 @@ function resolveConfig(config, pluginConfig) {
     hashLength: merged.hashLength ?? DEFAULT_CONFIG.hashLength,
     cacheSize: merged.cacheSize ?? DEFAULT_CONFIG.cacheSize,
     prefix: merged.prefix !== void 0 ? merged.prefix : DEFAULT_CONFIG.prefix,
-    debug: merged.debug ?? DEFAULT_CONFIG.debug
+    debug: merged.debug ?? DEFAULT_CONFIG.debug,
+    fileRev: merged.fileRev ?? DEFAULT_CONFIG.fileRev,
+    safeReapply: merged.safeReapply ?? DEFAULT_CONFIG.safeReapply
   };
 }
+var HashlineError = class extends Error {
+  code;
+  expected;
+  actual;
+  candidates;
+  hint;
+  lineNumber;
+  filePath;
+  constructor(opts) {
+    super(opts.message);
+    this.name = "HashlineError";
+    this.code = opts.code;
+    this.expected = opts.expected;
+    this.actual = opts.actual;
+    this.candidates = opts.candidates;
+    this.hint = opts.hint;
+    this.lineNumber = opts.lineNumber;
+    this.filePath = opts.filePath;
+  }
+  toDiagnostic() {
+    const parts = [`[${this.code}] ${this.message}`];
+    if (this.filePath) {
+      parts.push(`  File: ${this.filePath}`);
+    }
+    if (this.lineNumber !== void 0) {
+      parts.push(`  Line: ${this.lineNumber}`);
+    }
+    if (this.expected !== void 0 && this.actual !== void 0) {
+      parts.push(`  Expected hash: ${this.expected}`);
+      parts.push(`  Actual hash:   ${this.actual}`);
+    }
+    if (this.candidates && this.candidates.length > 0) {
+      parts.push(`  Candidates (${this.candidates.length}):`);
+      for (const c of this.candidates) {
+        const preview = c.content.length > 60 ? c.content.slice(0, 60) + "..." : c.content;
+        parts.push(`    - line ${c.lineNumber}: ${preview}`);
+      }
+    }
+    if (this.hint) {
+      parts.push(`  Hint: ${this.hint}`);
+    }
+    return parts.join("\n");
+  }
+};
 function fnv1aHash(str) {
   let hash = 2166136261;
   for (let i = 0; i < str.length; i++) {
@@ -104,7 +152,49 @@ function computeLineHash(idx, line, hashLen = 3) {
   const hash = raw % modulus;
   return hash.toString(16).padStart(hashLen, "0");
 }
-function formatFileWithHashes(content, hashLen, prefix) {
+function computeFileRev(content) {
+  const normalized = content.includes("\r\n") ? content.replace(/\r\n/g, "\n") : content;
+  const hash = fnv1aHash(normalized);
+  return hash.toString(16).padStart(8, "0");
+}
+function extractFileRev(annotatedContent, prefix) {
+  const effectivePrefix = prefix === void 0 ? DEFAULT_PREFIX : prefix === false ? "" : prefix;
+  const escapedPrefix = effectivePrefix.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = new RegExp(`^${escapedPrefix}REV:([0-9a-f]{8})$`);
+  const firstLine = annotatedContent.split("\n")[0];
+  const match = firstLine.match(pattern);
+  return match ? match[1] : null;
+}
+function verifyFileRev(expectedRev, currentContent) {
+  const actualRev = computeFileRev(currentContent);
+  if (actualRev !== expectedRev) {
+    throw new HashlineError({
+      code: "FILE_REV_MISMATCH",
+      message: `File revision mismatch: expected "${expectedRev}", got "${actualRev}". The file has changed since it was last read.`,
+      expected: expectedRev,
+      actual: actualRev,
+      hint: "Re-read the file to get fresh hash references and a new file revision."
+    });
+  }
+}
+function findCandidateLines(originalLineNumber, expectedHash, lines, hashLen) {
+  const effectiveLen = hashLen && hashLen >= 2 ? hashLen : expectedHash.length;
+  const originalIdx = originalLineNumber - 1;
+  const candidates = [];
+  for (let i = 0; i < lines.length; i++) {
+    if (i === originalIdx) continue;
+    const candidateHash = computeLineHash(originalIdx, lines[i], effectiveLen);
+    if (candidateHash === expectedHash) {
+      candidates.push({
+        lineNumber: i + 1,
+        // 1-based
+        content: lines[i]
+      });
+    }
+  }
+  return candidates;
+}
+function formatFileWithHashes(content, hashLen, prefix, includeFileRev) {
   const normalized = content.includes("\r\n") ? content.replace(/\r\n/g, "\n") : content;
   const lines = normalized.split("\n");
   const effectiveLen = hashLen && hashLen >= 3 ? hashLen : getAdaptiveHashLength(lines.length);
@@ -128,9 +218,14 @@ function formatFileWithHashes(content, hashLen, prefix) {
       hashes[idx] = hash;
     }
   }
-  return lines.map((line, idx) => {
+  const annotatedLines = lines.map((line, idx) => {
     return `${effectivePrefix}${idx + 1}:${hashes[idx]}|${line}`;
-  }).join("\n");
+  });
+  if (includeFileRev) {
+    const rev = computeFileRev(content);
+    annotatedLines.unshift(`${effectivePrefix}REV:${rev}`);
+  }
+  return annotatedLines.join("\n");
 }
 var stripRegexCache = /* @__PURE__ */ new Map();
 function stripHashes(content, prefix) {
@@ -141,9 +236,10 @@ function stripHashes(content, prefix) {
     hashLinePattern = new RegExp(`^([+ \\-])?${escapedPrefix}\\d+:[0-9a-f]{2,8}\\|`);
     stripRegexCache.set(escapedPrefix, hashLinePattern);
   }
+  const revPattern = new RegExp(`^${escapedPrefix}REV:[0-9a-f]{8}$`);
   const lineEnding = detectLineEnding(content);
   const normalized = lineEnding === "\r\n" ? content.replace(/\r\n/g, "\n") : content;
-  const result = normalized.split("\n").map((line) => {
+  const result = normalized.split("\n").filter((line) => !revPattern.test(line)).map((line) => {
     const match = line.match(hashLinePattern);
     if (match) {
       const patchMarker = match[1] || "";
@@ -157,7 +253,10 @@ function parseHashRef(ref) {
   const match = ref.match(/^(\d+):([0-9a-f]{2,8})$/);
   if (!match) {
     const display = ref.length > 100 ? `${ref.slice(0, 100)}\u2026` : ref;
-    throw new Error(`Invalid hash reference: "${display}". Expected format: "<line>:<2-8 char hex>"`);
+    throw new HashlineError({
+      code: "INVALID_REF",
+      message: `Invalid hash reference: "${display}". Expected format: "<line>:<2-8 char hex>"`
+    });
   }
   return {
     line: parseInt(match[1], 10),
@@ -175,9 +274,10 @@ function normalizeHashRef(ref) {
     return `${parseInt(annotated[1], 10)}:${annotated[2].toLowerCase()}`;
   }
   const display = ref.length > 100 ? `${ref.slice(0, 100)}\u2026` : ref;
-  throw new Error(
-    `Invalid hash reference: "${display}". Expected "<line>:<hash>" or an annotated line like "#HL <line>:<hash>|..."`
-  );
+  throw new HashlineError({
+    code: "INVALID_REF",
+    message: `Invalid hash reference: "${display}". Expected "<line>:<hash>" or an annotated line like "#HL <line>:<hash>|..."`
+  });
 }
 function buildHashMap(content, hashLen) {
   const lines = content.split("\n");
@@ -190,50 +290,97 @@ function buildHashMap(content, hashLen) {
   }
   return map;
 }
-function verifyHash(lineNumber, hash, currentContent, hashLen, lines) {
+function verifyHash(lineNumber, hash, currentContent, hashLen, lines, safeReapply) {
   const contentLines = lines ?? currentContent.split("\n");
   const effectiveLen = hashLen && hashLen >= 2 ? hashLen : hash.length;
   if (lineNumber < 1 || lineNumber > contentLines.length) {
     return {
       valid: false,
+      code: "TARGET_OUT_OF_RANGE",
       message: `Line ${lineNumber} is out of range (file has ${contentLines.length} lines)`
     };
   }
   const idx = lineNumber - 1;
   const actualHash = computeLineHash(idx, contentLines[idx], effectiveLen);
   if (actualHash !== hash) {
+    const candidates = findCandidateLines(lineNumber, hash, contentLines, effectiveLen);
+    if (safeReapply && candidates.length === 1) {
+      return {
+        valid: true,
+        relocatedLine: candidates[0].lineNumber,
+        candidates
+      };
+    }
+    if (safeReapply && candidates.length > 1) {
+      return {
+        valid: false,
+        code: "AMBIGUOUS_REAPPLY",
+        expected: hash,
+        actual: actualHash,
+        candidates,
+        message: `Hash mismatch at line ${lineNumber}: expected "${hash}", got "${actualHash}". Found ${candidates.length} candidate lines \u2014 ambiguous reapply.`
+      };
+    }
     return {
       valid: false,
+      code: "HASH_MISMATCH",
       expected: hash,
       actual: actualHash,
+      candidates,
       message: `Hash mismatch at line ${lineNumber}: expected "${hash}", got "${actualHash}". The file may have changed since it was read.`
     };
   }
   return { valid: true };
 }
-function resolveRange(startRef, endRef, content, hashLen) {
+function resolveRange(startRef, endRef, content, hashLen, safeReapply) {
   const start = parseHashRef(startRef);
   const end = parseHashRef(endRef);
   if (start.line > end.line) {
-    throw new Error(
-      `Invalid range: start line ${start.line} is after end line ${end.line}`
-    );
+    throw new HashlineError({
+      code: "INVALID_RANGE",
+      message: `Invalid range: start line ${start.line} is after end line ${end.line}`
+    });
   }
   const lineEnding = detectLineEnding(content);
   const normalized = lineEnding === "\r\n" ? content.replace(/\r\n/g, "\n") : content;
   const lines = normalized.split("\n");
-  const startVerify = verifyHash(start.line, start.hash, normalized, hashLen, lines);
+  const startVerify = verifyHash(start.line, start.hash, normalized, hashLen, lines, safeReapply);
   if (!startVerify.valid) {
-    throw new Error(`Start reference invalid: ${startVerify.message}`);
+    throw new HashlineError({
+      code: startVerify.code ?? "HASH_MISMATCH",
+      message: `Start reference invalid: ${startVerify.message}`,
+      expected: startVerify.expected,
+      actual: startVerify.actual,
+      candidates: startVerify.candidates,
+      lineNumber: start.line,
+      hint: startVerify.candidates && startVerify.candidates.length > 0 ? `Content may have moved. Candidates: ${startVerify.candidates.map((c) => `line ${c.lineNumber}`).join(", ")}` : "Re-read the file to get fresh hash references."
+    });
   }
-  const endVerify = verifyHash(end.line, end.hash, normalized, hashLen, lines);
+  const effectiveStartLine = startVerify.relocatedLine ?? start.line;
+  const endVerify = verifyHash(end.line, end.hash, normalized, hashLen, lines, safeReapply);
   if (!endVerify.valid) {
-    throw new Error(`End reference invalid: ${endVerify.message}`);
+    throw new HashlineError({
+      code: endVerify.code ?? "HASH_MISMATCH",
+      message: `End reference invalid: ${endVerify.message}`,
+      expected: endVerify.expected,
+      actual: endVerify.actual,
+      candidates: endVerify.candidates,
+      lineNumber: end.line,
+      hint: endVerify.candidates && endVerify.candidates.length > 0 ? `Content may have moved. Candidates: ${endVerify.candidates.map((c) => `line ${c.lineNumber}`).join(", ")}` : "Re-read the file to get fresh hash references."
+    });
   }
-  const rangeLines = lines.slice(start.line - 1, end.line);
+  const effectiveEndLine = endVerify.relocatedLine ?? end.line;
+  if (effectiveStartLine > effectiveEndLine) {
+    throw new HashlineError({
+      code: "INVALID_RANGE",
+      message: `Invalid effective range after relocation: start line ${effectiveStartLine} is after end line ${effectiveEndLine}`,
+      hint: "The referenced lines may have been reordered. Re-read the file to get fresh references."
+    });
+  }
+  const rangeLines = lines.slice(effectiveStartLine - 1, effectiveEndLine);
   return {
-    startLine: start.line,
-    endLine: end.line,
+    startLine: effectiveStartLine,
+    endLine: effectiveEndLine,
     lines: rangeLines,
     content: rangeLines.join(lineEnding)
   };
@@ -249,22 +396,37 @@ function replaceRange(startRef, endRef, content, replacement, hashLen) {
   const result = [...before, ...replacementLines, ...after].join("\n");
   return lineEnding === "\r\n" ? result.replace(/\n/g, "\r\n") : result;
 }
-function applyHashEdit(input, content, hashLen) {
+function applyHashEdit(input, content, hashLen, safeReapply) {
   const lineEnding = detectLineEnding(content);
   const workContent = lineEnding === "\r\n" ? content.replace(/\r\n/g, "\n") : content;
+  if (input.fileRev) {
+    verifyFileRev(input.fileRev, workContent);
+  }
   const normalizedStart = normalizeHashRef(input.startRef);
   const start = parseHashRef(normalizedStart);
   const lines = workContent.split("\n");
-  const startVerify = verifyHash(start.line, start.hash, workContent, hashLen, lines);
+  const startVerify = verifyHash(start.line, start.hash, workContent, hashLen, lines, safeReapply);
   if (!startVerify.valid) {
-    throw new Error(`Start reference invalid: ${startVerify.message}`);
+    throw new HashlineError({
+      code: startVerify.code ?? "HASH_MISMATCH",
+      message: `Start reference invalid: ${startVerify.message}`,
+      expected: startVerify.expected,
+      actual: startVerify.actual,
+      candidates: startVerify.candidates,
+      lineNumber: start.line,
+      hint: startVerify.candidates && startVerify.candidates.length > 0 ? `Content may have moved. Candidates: ${startVerify.candidates.map((c) => `line ${c.lineNumber}`).join(", ")}` : "Re-read the file to get fresh hash references."
+    });
   }
+  const effectiveStartLine = startVerify.relocatedLine ?? start.line;
   if (input.operation === "insert_before" || input.operation === "insert_after") {
     if (input.replacement === void 0) {
-      throw new Error(`Operation "${input.operation}" requires "replacement" content`);
+      throw new HashlineError({
+        code: "MISSING_REPLACEMENT",
+        message: `Operation "${input.operation}" requires "replacement" content`
+      });
     }
     const insertionLines = input.replacement.split("\n");
-    const insertIndex = input.operation === "insert_before" ? start.line - 1 : start.line;
+    const insertIndex = input.operation === "insert_before" ? effectiveStartLine - 1 : effectiveStartLine;
     const next2 = [
       ...lines.slice(0, insertIndex),
       ...insertionLines,
@@ -272,34 +434,54 @@ function applyHashEdit(input, content, hashLen) {
     ].join("\n");
     return {
       operation: input.operation,
-      startLine: start.line,
-      endLine: start.line,
+      startLine: effectiveStartLine,
+      endLine: effectiveStartLine,
       content: lineEnding === "\r\n" ? next2.replace(/\n/g, "\r\n") : next2
     };
   }
   const normalizedEnd = normalizeHashRef(input.endRef ?? input.startRef);
   const end = parseHashRef(normalizedEnd);
   if (start.line > end.line) {
-    throw new Error(
-      `Invalid range: start line ${start.line} is after end line ${end.line}`
-    );
+    throw new HashlineError({
+      code: "INVALID_RANGE",
+      message: `Invalid range: start line ${start.line} is after end line ${end.line}`
+    });
   }
-  const endVerify = verifyHash(end.line, end.hash, workContent, hashLen, lines);
+  const endVerify = verifyHash(end.line, end.hash, workContent, hashLen, lines, safeReapply);
   if (!endVerify.valid) {
-    throw new Error(`End reference invalid: ${endVerify.message}`);
+    throw new HashlineError({
+      code: endVerify.code ?? "HASH_MISMATCH",
+      message: `End reference invalid: ${endVerify.message}`,
+      expected: endVerify.expected,
+      actual: endVerify.actual,
+      candidates: endVerify.candidates,
+      lineNumber: end.line,
+      hint: endVerify.candidates && endVerify.candidates.length > 0 ? `Content may have moved. Candidates: ${endVerify.candidates.map((c) => `line ${c.lineNumber}`).join(", ")}` : "Re-read the file to get fresh hash references."
+    });
+  }
+  const effectiveEndLine = endVerify.relocatedLine ?? end.line;
+  if (effectiveStartLine > effectiveEndLine) {
+    throw new HashlineError({
+      code: "INVALID_RANGE",
+      message: `Invalid effective range after relocation: start line ${effectiveStartLine} is after end line ${effectiveEndLine}`,
+      hint: "The referenced lines may have been reordered. Re-read the file to get fresh references."
+    });
   }
   const replacement = input.operation === "delete" ? "" : input.replacement;
   if (replacement === void 0) {
-    throw new Error(`Operation "${input.operation}" requires "replacement" content`);
+    throw new HashlineError({
+      code: "MISSING_REPLACEMENT",
+      message: `Operation "${input.operation}" requires "replacement" content`
+    });
   }
-  const before = lines.slice(0, start.line - 1);
-  const after = lines.slice(end.line);
+  const before = lines.slice(0, effectiveStartLine - 1);
+  const after = lines.slice(effectiveEndLine);
   const replacementLines = input.operation === "delete" ? [] : replacement.split("\n");
   const next = [...before, ...replacementLines, ...after].join("\n");
   return {
     operation: input.operation,
-    startLine: start.line,
-    endLine: end.line,
+    startLine: effectiveStartLine,
+    endLine: effectiveEndLine,
     content: lineEnding === "\r\n" ? next.replace(/\n/g, "\r\n") : next
   };
 }
@@ -396,7 +578,7 @@ function createHashline(config) {
         const cached = cache.get(filePath, content);
         if (cached) return cached;
       }
-      const result = formatFileWithHashes(content, hl, pfx);
+      const result = formatFileWithHashes(content, hl, pfx, resolved.fileRev);
       if (filePath) {
         cache.set(filePath, content, result);
       }
@@ -412,16 +594,16 @@ function createHashline(config) {
       return buildHashMap(content, hl);
     },
     verifyHash(lineNumber, hash, currentContent) {
-      return verifyHash(lineNumber, hash, currentContent, hl);
+      return verifyHash(lineNumber, hash, currentContent, hl, void 0, resolved.safeReapply);
     },
     resolveRange(startRef, endRef, content) {
-      return resolveRange(startRef, endRef, content, hl);
+      return resolveRange(startRef, endRef, content, hl, resolved.safeReapply);
     },
     replaceRange(startRef, endRef, content, replacement) {
       return replaceRange(startRef, endRef, content, replacement, hl);
     },
     applyHashEdit(input, content) {
-      return applyHashEdit(input, content, hl);
+      return applyHashEdit(input, content, hl, resolved.safeReapply);
     },
     normalizeHashRef(ref) {
       return normalizeHashRef(ref);
@@ -431,6 +613,18 @@ function createHashline(config) {
     },
     shouldExclude(filePath) {
       return shouldExclude(filePath, resolved.exclude);
+    },
+    computeFileRev(content) {
+      return computeFileRev(content);
+    },
+    verifyFileRev(expectedRev, currentContent) {
+      return verifyFileRev(expectedRev, currentContent);
+    },
+    extractFileRev(annotatedContent) {
+      return extractFileRev(annotatedContent, pfx);
+    },
+    findCandidateLines(originalLineNumber, expectedHash, lines, hashLen) {
+      return findCandidateLines(originalLineNumber, expectedHash, lines, hashLen);
     }
   };
 }
@@ -440,8 +634,13 @@ export {
   DEFAULT_PREFIX,
   DEFAULT_CONFIG,
   resolveConfig,
+  HashlineError,
   getAdaptiveHashLength,
   computeLineHash,
+  computeFileRev,
+  extractFileRev,
+  verifyFileRev,
+  findCandidateLines,
   formatFileWithHashes,
   stripHashes,
   parseHashRef,

package/dist/{hashline-yhMw1Abs.d.ts → hashline-A7k2yn3G.d.cts}

@@ -31,6 +31,10 @@ interface HashlineConfig {
     prefix?: string | false;
     /** Enable debug logging to ~/.config/opencode/hashline-debug.log (default: false) */
     debug?: boolean;
+    /** Include file revision hash in annotations (default: true) */
+    fileRev?: boolean;
+    /** Enable safe reapply — relocate lines by hash when they move (default: false) */
+    safeReapply?: boolean;
 }
 /** Default exclude patterns */
 declare const DEFAULT_EXCLUDE_PATTERNS: string[];
@@ -45,6 +49,31 @@ declare const DEFAULT_CONFIG: Required<HashlineConfig>;
  * @param pluginConfig - optional config from plugin context (e.g. opencode.json)
  */
 declare function resolveConfig(config?: HashlineConfig, pluginConfig?: HashlineConfig): Required<HashlineConfig>;
+type HashlineErrorCode = "HASH_MISMATCH" | "FILE_REV_MISMATCH" | "AMBIGUOUS_REAPPLY" | "TARGET_OUT_OF_RANGE" | "INVALID_REF" | "INVALID_RANGE" | "MISSING_REPLACEMENT";
+interface CandidateLine {
+    lineNumber: number;
+    content: string;
+}
+declare class HashlineError extends Error {
+    readonly code: HashlineErrorCode;
+    readonly expected?: string;
+    readonly actual?: string;
+    readonly candidates?: CandidateLine[];
+    readonly hint?: string;
+    readonly lineNumber?: number;
+    readonly filePath?: string;
+    constructor(opts: {
+        code: HashlineErrorCode;
+        message: string;
+        expected?: string;
+        actual?: string;
+        candidates?: CandidateLine[];
+        hint?: string;
+        lineNumber?: number;
+        filePath?: string;
+    });
+    toDiagnostic(): string;
+}
 /**
  * Determine the appropriate hash length based on the number of lines.
  *
@@ -65,6 +94,34 @@ declare function getAdaptiveHashLength(lineCount: number): number;
  * @returns lowercase hex string of the specified length
  */
 declare function computeLineHash(idx: number, line: string, hashLen?: number): string;
+/**
+ * Compute a file-level revision hash from the entire content.
+ * Uses FNV-1a on CRLF-normalized content, returns 8-char hex (full 32 bits).
+ */
+declare function computeFileRev(content: string): string;
+/**
+ * Extract the file revision from annotated content.
+ * Looks for a line matching `<prefix>REV:<8-hex>` at the start of the content.
+ *
+ * @param annotatedContent - content with hashline annotations
+ * @param prefix - prefix string (default "#HL "), or false for legacy format
+ * @returns the revision hash string, or null if not found
+ */
+declare function extractFileRev(annotatedContent: string, prefix?: string | false): string | null;
+/**
+ * Verify that the file revision matches the current content.
+ * Throws HashlineError with code FILE_REV_MISMATCH if it doesn't match.
+ */
+declare function verifyFileRev(expectedRev: string, currentContent: string): void;
+/**
+ * Find candidate lines that match the expected hash for a given original line index.
+ * Used for safe reapply: if a line moved, find where it went.
+ *
+ * Since computeLineHash uses `${idx}:${trimmed}`, we check each line in the file
+ * computing its hash as if it were at the original index — a match means the content
+ * is the same as what was originally at that position.
+ */
+declare function findCandidateLines(originalLineNumber: number, expectedHash: string, lines: string[], hashLen?: number): CandidateLine[];
 /**
  * Format file content with hashline annotations.
  *
@@ -78,7 +135,7 @@ declare function computeLineHash(idx: number, line: string, hashLen?: number): s
  * @param prefix - prefix string (default "#HL "), or false to disable
  * @returns annotated content with hash prefixes
  */
-declare function formatFileWithHashes(content: string, hashLen?: number, prefix?: string | false): string;
+declare function formatFileWithHashes(content: string, hashLen?: number, prefix?: string | false, includeFileRev?: boolean): string;
 /**
  * Strip hashline prefixes to recover original file content.
  *
@@ -122,6 +179,7 @@ interface HashEditInput {
     startRef: string;
     endRef?: string;
     replacement?: string;
+    fileRev?: string;
 }
 /**
  * Result of applying a hash-aware edit.
@@ -151,6 +209,9 @@ interface VerifyHashResult {
     expected?: string;
     actual?: string;
     message?: string;
+    code?: HashlineErrorCode;
+    candidates?: CandidateLine[];
+    relocatedLine?: number;
 }
 /**
  * Verify that a line's hash matches the current content.
@@ -169,7 +230,7 @@ interface VerifyHashResult {
  * @param lines - optional pre-split lines array to avoid re-splitting
  * @returns verification result
  */
-declare function verifyHash(lineNumber: number, hash: string, currentContent: string, hashLen?: number, lines?: string[]): VerifyHashResult;
+declare function verifyHash(lineNumber: number, hash: string, currentContent: string, hashLen?: number, lines?: string[], safeReapply?: boolean): VerifyHashResult;
 /**
  * Result of a range resolution.
  */
@@ -189,7 +250,7 @@ interface ResolvedRange {
  * @param hashLen - override hash length (0 or undefined = use hash.length from ref)
  * @returns resolved range with line numbers and content
  */
-declare function resolveRange(startRef: string, endRef: string, content: string, hashLen?: number): ResolvedRange;
+declare function resolveRange(startRef: string, endRef: string, content: string, hashLen?: number, safeReapply?: boolean): ResolvedRange;
 /**
  * Replace a range of lines identified by hash references with new content.
  * Splits content once and reuses the lines array.
@@ -208,7 +269,7 @@ declare function replaceRange(startRef: string, endRef: string, content: string,
  * Unlike search/replace tools, this resolves references by line+hash and
  * verifies them before editing, so exact old-string matching is not required.
  */
-declare function applyHashEdit(input: HashEditInput, content: string, hashLen?: number): HashEditResult;
+declare function applyHashEdit(input: HashEditInput, content: string, hashLen?: number, safeReapply?: boolean): HashEditResult;
 /**
  * Simple LRU cache for annotated file content.
  */
@@ -268,6 +329,10 @@ interface HashlineInstance {
         hash: string;
     };
     shouldExclude: (filePath: string) => boolean;
+    computeFileRev: (content: string) => string;
+    verifyFileRev: (expectedRev: string, currentContent: string) => void;
+    extractFileRev: (annotatedContent: string) => string | null;
+    findCandidateLines: (originalLineNumber: number, expectedHash: string, lines: string[], hashLen?: number) => CandidateLine[];
 }
 /**
  * Create a Hashline instance with custom configuration.
@@ -277,4 +342,4 @@ interface HashlineInstance {
  */
 declare function createHashline(config?: HashlineConfig): HashlineInstance;
 
-export { DEFAULT_CONFIG as D, type HashlineConfig as H, type ResolvedRange as R, type VerifyHashResult as V, type HashEditInput as a, type HashEditOperation as b, type HashEditResult as c, type HashlineInstance as d, HashlineCache as e, DEFAULT_EXCLUDE_PATTERNS as f, DEFAULT_PREFIX as g, applyHashEdit as h, buildHashMap as i, computeLineHash as j, createHashline as k, formatFileWithHashes as l, getAdaptiveHashLength as m, getByteLength as n, matchesGlob as o, normalizeHashRef as p, parseHashRef as q, replaceRange as r, resolveConfig as s, resolveRange as t, shouldExclude as u, stripHashes as v, verifyHash as w };
+export { stripHashes as A, verifyFileRev as B, type CandidateLine as C, DEFAULT_CONFIG as D, verifyHash as E, type HashlineConfig as H, type ResolvedRange as R, type VerifyHashResult as V, type HashEditInput as a, type HashEditOperation as b, type HashEditResult as c, type HashlineErrorCode as d, type HashlineInstance as e, HashlineCache as f, DEFAULT_EXCLUDE_PATTERNS as g, DEFAULT_PREFIX as h, HashlineError as i, applyHashEdit as j, buildHashMap as k, computeFileRev as l, computeLineHash as m, createHashline as n, extractFileRev as o, findCandidateLines as p, formatFileWithHashes as q, getAdaptiveHashLength as r, getByteLength as s, matchesGlob as t, normalizeHashRef as u, parseHashRef as v, replaceRange as w, resolveConfig as x, resolveRange as y, shouldExclude as z };