@mrsf/cli 0.6.0 → 0.7.1

package/dist/browser.cjs

@@ -33,7 +33,10 @@ __export(browser_exports, {
   DEFAULT_THRESHOLD: () => DEFAULT_THRESHOLD2,
   HIGH_THRESHOLD: () => HIGH_THRESHOLD2,
   applyReanchorResults: () => applyReanchorResults2,
+  calibrateAnchorEvidence: () => calibrateAnchorEvidence2,
   combinedScore: () => combinedScore2,
+  createAnchorContextIndex: () => createAnchorContextIndex2,
+  createRevisionProjection: () => createRevisionProjection2,
   exactMatch: () => exactMatch2,
   formatAuthor: () => formatAuthor2,
   fuzzySearch: () => fuzzySearch2,
@@ -47,6 +50,7 @@ __export(browser_exports, {
   reanchorComment: () => reanchorComment2,
   reanchorDocumentLines: () => reanchorDocumentLines2,
   reanchorDocumentText: () => reanchorDocumentText2,
+  reconcileCommentAnchors: () => reconcileCommentAnchors2,
   resolveAnchor: () => resolveAnchor2,
   toJson: () => toJson2,
   toReanchorLines: () => toReanchorLines2,
@@ -58,6 +62,16 @@ module.exports = __toCommonJS(browser_exports);
 
 // src/lib/fuzzy.ts
 var import_fastest_levenshtein = require("fastest-levenshtein");
+var MAX_FUZZY_CANDIDATE_LINES = 64;
+function createFuzzySearchIndex(lines) {
+  const tokenPostings = /* @__PURE__ */ new Map();
+  const trigramPostings = /* @__PURE__ */ new Map();
+  for (let line = 1; line < lines.length; line += 1) {
+    addPostingSignals(tokenPostings, lexicalTokens(lines[line]), line);
+    addPostingSignals(trigramPostings, characterTrigrams(lines[line]), line);
+  }
+  return { lines, tokenPostings, trigramPostings };
+}
 function exactMatch(lines, needle) {
   if (!needle) return [];
   const results = [];
@@ -180,22 +194,48 @@ function combinedScore(needle, candidate) {
   }
   return tScore * 0.6 + lScore * 0.4;
 }
-function fuzzySearch(lines, needle, threshold = 0.6, hintLine) {
-  if (!needle) return [];
+function fuzzySearch(lines, needle, threshold = 0.6, hintLine, index) {
+  return fuzzySearchThresholds(
+    lines,
+    needle,
+    [threshold],
+    hintLine,
+    index
+  ).get(threshold) ?? [];
+}
+function fuzzySearchThresholds(lines, needle, thresholds, hintLine, index = createFuzzySearchIndex(lines)) {
+  const uniqueThresholds = [...new Set(thresholds)];
+  const results = /* @__PURE__ */ new Map();
+  if (uniqueThresholds.length === 0) return results;
+  if (!needle) {
+    for (const threshold of uniqueThresholds) results.set(threshold, []);
+    return results;
+  }
   const needleLines = needle.split("\n");
   const needleLineCount = needleLines.length;
   const candidates = [];
+  const minimumThreshold = Math.min(...uniqueThresholds);
+  const candidateLines = retrieveCandidateLines(index, needle, hintLine);
   const minWindow = Math.max(1, Math.floor(needleLineCount * 0.7));
   const maxWindow = Math.min(
     lines.length - 1,
     Math.ceil(needleLineCount * 1.3) + 1
   );
   for (let winSize = minWindow; winSize <= maxWindow; winSize++) {
-    for (let startLine = 1; startLine + winSize - 1 < lines.length; startLine++) {
+    const startLines = /* @__PURE__ */ new Set();
+    for (const candidateLine of candidateLines) {
+      for (let offset = 0; offset < winSize; offset += 1) {
+        const startLine = candidateLine - offset;
+        if (startLine >= 1 && startLine + winSize - 1 < lines.length) {
+          startLines.add(startLine);
+        }
+      }
+    }
+    for (const startLine of startLines) {
       const windowLines = lines.slice(startLine, startLine + winSize);
       const windowText = windowLines.join("\n");
       const score = combinedScore(needle, windowText);
-      if (score >= threshold) {
+      if (score >= minimumThreshold) {
         candidates.push({
           text: windowText,
           line: startLine,
@@ -208,17 +248,18 @@ function fuzzySearch(lines, needle, threshold = 0.6, hintLine) {
     }
   }
   if (needleLineCount === 1 && needle.length < 200) {
-    for (let lineNum = 1; lineNum < lines.length; lineNum++) {
+    for (const lineNum of candidateLines) {
       const line = lines[lineNum];
       if (!line) continue;
       const winLen = needle.length;
       const minWinLen = Math.max(3, Math.floor(winLen * 0.7));
       const maxWinLen = Math.min(line.length, Math.ceil(winLen * 1.3));
-      for (let len = minWinLen; len <= maxWinLen; len++) {
+      const lengths = evenlySpacedIntegers(minWinLen, maxWinLen, 7);
+      for (const len of lengths) {
         for (let col = 0; col + len <= line.length; col++) {
           const sub = line.substring(col, col + len);
           const score = combinedScore(needle, sub);
-          if (score >= threshold) {
+          if (score >= minimumThreshold) {
             candidates.push({
               text: sub,
               line: lineNum,
@@ -232,15 +273,83 @@ function fuzzySearch(lines, needle, threshold = 0.6, hintLine) {
       }
     }
   }
-  let deduped = deduplicateCandidates(candidates);
+  const deduped = deduplicateCandidates(candidates);
+  const scored = deduped.map((candidate) => ({
+    baseScore: candidate.score,
+    candidate: applyProximityBonus(candidate, hintLine)
+  }));
+  for (const threshold of uniqueThresholds) {
+    results.set(
+      threshold,
+      scored.filter((item) => item.baseScore >= threshold).map((item) => item.candidate).sort((left, right) => right.score - left.score)
+    );
+  }
+  return results;
+}
+function retrieveCandidateLines(index, needle, hintLine) {
+  const votes = /* @__PURE__ */ new Map();
+  const lineCount = Math.max(0, index.lines.length - 1);
+  const signals = [
+    ...postingSignals(index.tokenPostings, lexicalTokens(needle), 2),
+    ...postingSignals(index.trigramPostings, characterTrigrams(needle), 1)
+  ].sort((left, right) => left.postings.length - right.postings.length).slice(0, 16);
+  for (const signal of signals) {
+    const rarity = Math.log1p(lineCount / signal.postings.length);
+    for (const line of signal.postings) {
+      votes.set(line, (votes.get(line) ?? 0) + signal.weight * rarity);
+    }
+  }
   if (hintLine != null) {
-    deduped = deduped.map((c) => {
-      const dist = Math.abs(c.line - hintLine);
-      const proximityBonus = 0.1 * Math.max(0, 1 - dist / 50);
-      return { ...c, score: Math.min(1, c.score + proximityBonus) };
-    });
+    for (let offset = -4; offset <= 4; offset += 1) {
+      const line = hintLine + offset;
+      if (line >= 1 && line <= lineCount) {
+        votes.set(line, (votes.get(line) ?? 0) + 0.25);
+      }
+    }
+  }
+  if (votes.size === 0) {
+    return Array.from({ length: lineCount }, (_, index2) => index2 + 1);
   }
-  return deduped.sort((a, b) => b.score - a.score);
+  return [...votes.entries()].sort(
+    (left, right) => right[1] - left[1] || distanceFromHint(left[0], hintLine) - distanceFromHint(right[0], hintLine) || left[0] - right[0]
+  ).slice(0, MAX_FUZZY_CANDIDATE_LINES).map(([line]) => line);
+}
+function postingSignals(postings, values, weight) {
+  return [...new Set(values)].map((value) => ({ postings: postings.get(value) ?? [], weight })).filter((signal) => signal.postings.length > 0);
+}
+function addPostingSignals(postings, values, line) {
+  for (const value of new Set(values)) {
+    const lines = postings.get(value);
+    if (lines) {
+      lines.push(line);
+    } else {
+      postings.set(value, [line]);
+    }
+  }
+}
+function lexicalTokens(text) {
+  return text.toLowerCase().match(/[\p{L}\p{N}_-]+/gu) ?? [];
+}
+function characterTrigrams(text) {
+  const normalized = text.toLowerCase().replace(/\s+/g, " ").trim();
+  const characters = [...normalized];
+  if (characters.length < 3) return normalized ? [normalized] : [];
+  const trigrams = [];
+  for (let index = 0; index <= characters.length - 3; index += 1) {
+    trigrams.push(characters.slice(index, index + 3).join(""));
+  }
+  return trigrams;
+}
+function evenlySpacedIntegers(minimum, maximum, count) {
+  if (maximum <= minimum) return [minimum];
+  const values = /* @__PURE__ */ new Set();
+  for (let index = 0; index < count; index += 1) {
+    values.add(Math.round(minimum + (maximum - minimum) * index / (count - 1)));
+  }
+  return [...values];
+}
+function distanceFromHint(line, hintLine) {
+  return hintLine == null ? 0 : Math.abs(line - hintLine);
 }
 function deduplicateCandidates(candidates) {
   const seen = /* @__PURE__ */ new Map();
@@ -253,6 +362,15 @@ function deduplicateCandidates(candidates) {
   }
   return Array.from(seen.values());
 }
+function applyProximityBonus(candidate, hintLine) {
+  if (hintLine == null) return candidate;
+  const distance = Math.abs(candidate.line - hintLine);
+  const proximityBonus = 0.1 * Math.max(0, 1 - distance / 50);
+  return {
+    ...candidate,
+    score: Math.min(1, candidate.score + proximityBonus)
+  };
+}
 
 // src/lib/identity.ts
 var import_uuid = require("uuid");
@@ -273,6 +391,783 @@ function newCommentId() {
   return (0, import_uuid.v4)();
 }
 
+// src/lib/revision-projection.ts
+var CONTEXT_RADIUS = 8;
+function createRevisionProjection(sourceLines, targetLines) {
+  const sourceOccurrences = collectLineOccurrences(sourceLines);
+  const targetOccurrences = collectLineOccurrences(targetLines);
+  const lineMap = /* @__PURE__ */ new Map();
+  for (const [text, sourceLineNumbers] of sourceOccurrences) {
+    const targetLineNumbers = targetOccurrences.get(text);
+    if (sourceLineNumbers.length === 1 && targetLineNumbers?.length === 1) {
+      lineMap.set(sourceLineNumbers[0], targetLineNumbers[0]);
+    }
+  }
+  return { sourceLines, targetLines, lineMap };
+}
+function projectCommentAnchor(comment, projection, threshold) {
+  if (comment.line == null || !comment.selected_text) return void 0;
+  const sourceText = extractText(
+    projection.sourceLines,
+    comment.line,
+    comment.end_line,
+    comment.start_column,
+    comment.end_column
+  );
+  if (sourceText !== comment.selected_text) return void 0;
+  const exactCandidates = exactMatch(
+    projection.targetLines,
+    comment.selected_text
+  );
+  if (exactCandidates.length === 1) {
+    const candidate = exactCandidates[0];
+    const contextSupport = countIndependentExactSupport(
+      comment,
+      candidate.line,
+      projection
+    );
+    if (contextSupport >= 2) {
+      return {
+        line: candidate.line,
+        endLine: candidate.endLine,
+        startColumn: candidate.startColumn,
+        endColumn: candidate.endColumn,
+        text: candidate.text,
+        score: 1,
+        exact: true,
+        contextSupport,
+        contextMargin: 1,
+        reason: "Source revision and neighboring line evidence confirm exact relocation."
+      };
+    }
+  }
+  if (exactCandidates.length > 0) return void 0;
+  const projected = projectLineFromContext(comment, projection);
+  if (projected == null) return void 0;
+  const projectedLine = projected.line;
+  const lineSpan = (comment.end_line ?? comment.line) - comment.line;
+  const projectedEndLine = projectedLine + lineSpan;
+  if (projectedLine < 1 || projectedEndLine >= projection.targetLines.length) {
+    return void 0;
+  }
+  const columns = projectColumns(comment, projection, projectedLine);
+  const targetText = extractText(
+    projection.targetLines,
+    projectedLine,
+    projectedEndLine,
+    columns.startColumn,
+    columns.endColumn
+  );
+  if (targetText == null) return void 0;
+  const score = Math.min(
+    1,
+    combinedScore(comment.selected_text, targetText) + 0.1
+  );
+  if (score < threshold) return void 0;
+  return {
+    line: projectedLine,
+    endLine: projectedEndLine,
+    startColumn: columns.startColumn,
+    endColumn: columns.endColumn,
+    text: targetText,
+    score,
+    exact: targetText === comment.selected_text,
+    contextSupport: projected.support,
+    contextMargin: projected.margin,
+    reason: "Source revision context projects the edited anchor range."
+  };
+}
+function collectLineOccurrences(lines) {
+  const occurrences = /* @__PURE__ */ new Map();
+  for (let line = 1; line < lines.length; line += 1) {
+    const text = lines[line];
+    if (!text.trim()) continue;
+    const existing = occurrences.get(text);
+    if (existing) {
+      existing.push(line);
+    } else {
+      occurrences.set(text, [line]);
+    }
+  }
+  return occurrences;
+}
+function countIndependentExactSupport(comment, candidateLine, projection) {
+  const sourceEndLine = comment.end_line ?? comment.line;
+  const expectedShift = candidateLine - comment.line;
+  if (comment.start_column != null || comment.end_column != null) {
+    const mappedContainerLine = projection.lineMap.get(comment.line);
+    if (mappedContainerLine === candidateLine) return 2;
+  }
+  let support = 0;
+  for (let distance = 1; distance <= CONTEXT_RADIUS; distance += 1) {
+    for (const sourceLine of [
+      comment.line - distance,
+      sourceEndLine + distance
+    ]) {
+      if (sourceLine < 1 || sourceLine >= projection.sourceLines.length) {
+        continue;
+      }
+      const targetLine = projection.lineMap.get(sourceLine);
+      if (targetLine != null && targetLine - sourceLine === expectedShift) {
+        support += 1;
+      }
+    }
+  }
+  return support;
+}
+function projectLineFromContext(comment, projection) {
+  const sourceLine = comment.line;
+  const sourceEndLine = comment.end_line ?? sourceLine;
+  const votes = /* @__PURE__ */ new Map();
+  for (let distance = 1; distance <= CONTEXT_RADIUS; distance += 1) {
+    for (const contextLine of [
+      sourceLine - distance,
+      sourceEndLine + distance
+    ]) {
+      if (contextLine < 1 || contextLine >= projection.sourceLines.length) {
+        continue;
+      }
+      const targetLine = projection.lineMap.get(contextLine);
+      if (targetLine == null) continue;
+      const shift = targetLine - contextLine;
+      const vote = votes.get(shift);
+      if (vote) {
+        vote.count += 1;
+        vote.nearest = Math.min(vote.nearest, distance);
+      } else {
+        votes.set(shift, { count: 1, nearest: distance });
+      }
+    }
+  }
+  const ranked = [...votes.entries()].sort(
+    (left, right) => right[1].count - left[1].count || left[1].nearest - right[1].nearest || Math.abs(left[0]) - Math.abs(right[0])
+  );
+  const best = ranked[0];
+  if (!best) return void 0;
+  if (best[1].count < 2 && best[1].nearest > 3) return void 0;
+  if (ranked[1] && ranked[1][1].count === best[1].count && ranked[1][1].nearest === best[1].nearest) {
+    return void 0;
+  }
+  const runnerUpCount = ranked[1]?.[1].count ?? 0;
+  return {
+    line: sourceLine + best[0],
+    support: best[1].count,
+    margin: (best[1].count - runnerUpCount) / best[1].count
+  };
+}
+function projectColumns(comment, projection, targetLine) {
+  if (comment.line == null || comment.end_line != null && comment.end_line !== comment.line || comment.start_column == null || comment.end_column == null) {
+    return {
+      startColumn: comment.start_column,
+      endColumn: comment.end_column
+    };
+  }
+  const sourceLine = projection.sourceLines[comment.line];
+  const targetLineText = projection.targetLines[targetLine];
+  const prefix = sourceLine.slice(0, comment.start_column);
+  const suffix = sourceLine.slice(comment.end_column);
+  const startColumn = targetLineText.startsWith(prefix) ? prefix.length : Math.min(comment.start_column, targetLineText.length);
+  const endColumn = targetLineText.endsWith(suffix) ? targetLineText.length - suffix.length : Math.min(
+    targetLineText.length,
+    startColumn + (comment.end_column - comment.start_column)
+  );
+  return { startColumn, endColumn };
+}
+function extractText(lines, line, endLine, startColumn, endColumn) {
+  const finalLine = endLine ?? line;
+  if (line < 1 || finalLine >= lines.length) return null;
+  if (line === finalLine) {
+    const text = lines[line];
+    return startColumn != null && endColumn != null ? text.slice(startColumn, endColumn) : text;
+  }
+  const result = [];
+  for (let current = line; current <= finalLine; current += 1) {
+    let text = lines[current];
+    if (current === line && startColumn != null) text = text.slice(startColumn);
+    if (current === finalLine && endColumn != null) text = text.slice(0, endColumn);
+    result.push(text);
+  }
+  return result.join("\n");
+}
+
+// src/lib/anchor-context.ts
+var MATCH_THRESHOLD = 0.35;
+var AMBIGUITY_MARGIN = 0.03;
+var MAX_CONTEXT_CANDIDATE_BLOCKS = 64;
+function createAnchorContextIndex(sourceLines, targetLines) {
+  return {
+    source: createDocumentBlockIndex(sourceLines),
+    target: createDocumentBlockIndex(targetLines)
+  };
+}
+function resolveContextAnchor(comment, index) {
+  if (comment.line == null || !comment.selected_text) return void 0;
+  const sourceBlockIndex = index.source.lineToBlock.get(comment.line);
+  if (sourceBlockIndex == null) return void 0;
+  const sourceBlock = index.source.blocks[sourceBlockIndex];
+  const sourceText = extractText2(
+    index.source.lines,
+    comment.line,
+    comment.end_line,
+    comment.start_column,
+    comment.end_column
+  );
+  if (sourceText !== comment.selected_text) return void 0;
+  const textAtCurrentPosition = extractText2(
+    index.target.lines,
+    comment.line,
+    comment.end_line,
+    comment.start_column,
+    comment.end_column
+  );
+  if (textAtCurrentPosition === comment.selected_text) {
+    return {
+      status: "anchored",
+      score: 1,
+      line: comment.line,
+      endLine: comment.end_line ?? comment.line,
+      startColumn: comment.start_column,
+      endColumn: comment.end_column,
+      text: comment.selected_text,
+      candidateMargin: 1,
+      reason: "Source-verified anchor remains exact at its stored position."
+    };
+  }
+  const candidates = findContextAnchorCandidates(comment, index);
+  const best = candidates[0];
+  if (!best) {
+    if (index.target.lines.slice(1).join("\n").includes(comment.selected_text)) {
+      return void 0;
+    }
+    return {
+      status: "orphaned",
+      score: 0,
+      candidateMargin: 1,
+      reason: "Source block has no plausible structural or contextual match."
+    };
+  }
+  if (candidates[1] && best.score - candidates[1].score < AMBIGUITY_MARGIN) {
+    return {
+      status: "ambiguous",
+      score: best.score,
+      line: best.line,
+      endLine: best.endLine,
+      candidateMargin: best.score - candidates[1].score,
+      reason: `Structural candidates are too close (${best.score.toFixed(3)} vs ${candidates[1].score.toFixed(3)}).`
+    };
+  }
+  const repeatedExactText = best.exact && countOccurrences(
+    index.target.lines.slice(1).join("\n"),
+    comment.selected_text
+  ) > 1;
+  return {
+    status: best.exact && !repeatedExactText ? "anchored" : "fuzzy",
+    score: best.exact && !repeatedExactText ? 1 : best.score,
+    line: best.line,
+    endLine: best.endLine,
+    startColumn: best.startColumn,
+    endColumn: best.endColumn,
+    text: best.text,
+    candidateMargin: candidates[1] ? best.score - candidates[1].score : 1,
+    reason: best.exact && !repeatedExactText ? "Markdown structure and bidirectional context disambiguate the exact anchor." : repeatedExactText ? "Markdown context selects one repeated exact anchor tentatively." : "Markdown structure and bidirectional context locate the edited anchor."
+  };
+}
+function findContextAnchorCandidates(comment, index) {
+  if (comment.line == null || !comment.selected_text) return [];
+  const sourceBlockIndex = index.source.lineToBlock.get(comment.line);
+  if (sourceBlockIndex == null) return [];
+  const sourceBlock = index.source.blocks[sourceBlockIndex];
+  const sourceText = extractText2(
+    index.source.lines,
+    comment.line,
+    comment.end_line,
+    comment.start_column,
+    comment.end_column
+  );
+  if (sourceText !== comment.selected_text) return [];
+  return createCandidateWindows(
+    sourceBlock,
+    sourceBlockIndex,
+    comment.line,
+    index
+  ).map((candidate) => ({
+    ...candidate,
+    score: scoreCandidate(
+      sourceBlock,
+      sourceBlockIndex,
+      candidate,
+      index,
+      comment.line
+    )
+  })).filter((candidate) => candidate.score >= MATCH_THRESHOLD).sort(
+    (left, right) => right.score - left.score || Math.abs(left.startLine - comment.line) - Math.abs(right.startLine - comment.line)
+  ).map((candidate) => {
+    const range = resolveCandidateRange(
+      comment,
+      sourceBlock,
+      candidate,
+      index.target
+    );
+    return {
+      score: candidate.score,
+      line: range.line,
+      endLine: range.endLine,
+      startColumn: range.startColumn,
+      endColumn: range.endColumn,
+      text: range.text,
+      exact: range.text === comment.selected_text
+    };
+  });
+}
+function getAnchorContextScope(comment, index) {
+  if (comment.line == null) return void 0;
+  const blockIndex = index.source.lineToBlock.get(comment.line);
+  if (blockIndex == null) return void 0;
+  return index.source.blocks[blockIndex].headingPath.join("");
+}
+function createDocumentBlockIndex(lines) {
+  const blocks = [];
+  const lineToBlock = /* @__PURE__ */ new Map();
+  const headings = [];
+  let line = 1;
+  while (line < lines.length) {
+    if (!lines[line].trim()) {
+      line += 1;
+      continue;
+    }
+    const startLine = line;
+    const marker = classifyLine(lines[line]);
+    if (marker.type === "heading") {
+      while (headings.length > 0 && headings[headings.length - 1].level >= marker.headingLevel) {
+        headings.pop();
+      }
+      const block = makeBlock(
+        lines,
+        startLine,
+        startLine,
+        "heading",
+        headings.map((heading) => heading.title)
+      );
+      blocks.push(block);
+      headings.push({ level: marker.headingLevel, title: marker.headingTitle });
+      line += 1;
+      continue;
+    }
+    if (marker.type === "code") {
+      line += 1;
+      while (line < lines.length && !lines[line].trimStart().startsWith("```")) {
+        line += 1;
+      }
+      if (line < lines.length) line += 1;
+    } else {
+      line += 1;
+      while (line < lines.length && lines[line].trim() && continuesBlock(marker.type, lines[line])) {
+        line += 1;
+      }
+    }
+    blocks.push(makeBlock(
+      lines,
+      startLine,
+      line - 1,
+      marker.type,
+      headings.map((heading) => heading.title)
+    ));
+  }
+  for (const [blockIndex, block] of blocks.entries()) {
+    for (let blockLine = block.startLine; blockLine <= block.endLine; blockLine += 1) {
+      lineToBlock.set(blockLine, blockIndex);
+    }
+  }
+  return {
+    lines,
+    blocks,
+    lineToBlock,
+    tokenPostings: createTokenPostings(blocks)
+  };
+}
+function makeBlock(lines, startLine, endLine, type, headingPath) {
+  return {
+    startLine,
+    endLine,
+    type,
+    text: lines.slice(startLine, endLine + 1).join("\n"),
+    headingPath
+  };
+}
+function classifyLine(line) {
+  const heading = line.match(/^(#{1,6})\s+(.+)$/);
+  if (heading) {
+    return {
+      type: "heading",
+      headingLevel: heading[1].length,
+      headingTitle: heading[2].trim()
+    };
+  }
+  if (line.trimStart().startsWith("```")) {
+    return { type: "code", headingLevel: 0, headingTitle: "" };
+  }
+  if (/^\s*(?:[-*+]|\d+\.)\s+/.test(line)) {
+    return { type: "list", headingLevel: 0, headingTitle: "" };
+  }
+  if (/^\s*\|/.test(line)) {
+    return { type: "table", headingLevel: 0, headingTitle: "" };
+  }
+  if (/^\s*>/.test(line)) {
+    return { type: "blockquote", headingLevel: 0, headingTitle: "" };
+  }
+  return { type: "paragraph", headingLevel: 0, headingTitle: "" };
+}
+function continuesBlock(type, line) {
+  if (type === "list") return /^\s*(?:[-*+]|\d+\.)\s+/.test(line);
+  if (type === "table") return /^\s*\|/.test(line);
+  if (type === "blockquote") return /^\s*>/.test(line);
+  if (type === "paragraph") {
+    const next = classifyLine(line);
+    return next.type === "paragraph";
+  }
+  return false;
+}
+function createCandidateWindows(sourceBlock, sourceBlockIndex, originalLine, index) {
+  const target = index.target;
+  const candidates = [];
+  for (const start of retrieveCandidateBlocks(
+    sourceBlock,
+    sourceBlockIndex,
+    originalLine,
+    index
+  )) {
+    const block = target.blocks[start];
+    candidates.push(toCandidateWindow(target, start, start));
+    if (sourceBlock.type === "paragraph" && block.type === "paragraph" && target.blocks[start + 1]?.type === "paragraph" && samePath(block.headingPath, target.blocks[start + 1].headingPath)) {
+      candidates.push(toCandidateWindow(target, start, start + 1));
+    }
+  }
+  return candidates;
+}
+function createTokenPostings(blocks) {
+  const postings = /* @__PURE__ */ new Map();
+  for (const [blockIndex, block] of blocks.entries()) {
+    for (const token of new Set(tokenize2(block.text))) {
+      const blocksForToken = postings.get(token);
+      if (blocksForToken) {
+        blocksForToken.push(blockIndex);
+      } else {
+        postings.set(token, [blockIndex]);
+      }
+    }
+  }
+  return postings;
+}
+function retrieveCandidateBlocks(sourceBlock, sourceBlockIndex, originalLine, index) {
+  const votes = /* @__PURE__ */ new Map();
+  const targetCount = index.target.blocks.length;
+  const addEvidence = (text, targetOffset, weight) => {
+    if (!text) return;
+    const rankedTokens = [...new Set(tokenize2(text))].map((token) => ({
+      token,
+      postings: index.target.tokenPostings.get(token) ?? []
+    })).filter((item) => item.postings.length > 0).sort((left, right) => left.postings.length - right.postings.length).slice(0, 12);
+    for (const { postings } of rankedTokens) {
+      const rarity = Math.log1p(targetCount / postings.length);
+      for (const posting of postings) {
+        const candidate = posting + targetOffset;
+        if (candidate >= 0 && candidate < targetCount) {
+          votes.set(candidate, (votes.get(candidate) ?? 0) + weight * rarity);
+        }
+      }
+    }
+  };
+  addEvidence(sourceBlock.text, 0, 1);
+  addEvidence(index.source.blocks[sourceBlockIndex - 1]?.text, 1, 0.7);
+  addEvidence(index.source.blocks[sourceBlockIndex + 1]?.text, -1, 0.7);
+  const nearbyBlock = closestBlockToLine(index.target.blocks, originalLine);
+  if (nearbyBlock != null) {
+    for (let offset = -2; offset <= 2; offset += 1) {
+      const candidate = nearbyBlock + offset;
+      if (candidate >= 0 && candidate < targetCount) {
+        votes.set(candidate, (votes.get(candidate) ?? 0) + 0.25);
+      }
+    }
+  }
+  return [...votes.entries()].sort(
+    (left, right) => right[1] - left[1] || Math.abs(index.target.blocks[left[0]].startLine - originalLine) - Math.abs(index.target.blocks[right[0]].startLine - originalLine) || left[0] - right[0]
+  ).slice(0, MAX_CONTEXT_CANDIDATE_BLOCKS).map(([blockIndex]) => blockIndex);
+}
+function closestBlockToLine(blocks, line) {
+  if (blocks.length === 0) return void 0;
+  let low = 0;
+  let high = blocks.length - 1;
+  while (low <= high) {
+    const middle = Math.floor((low + high) / 2);
+    const block = blocks[middle];
+    if (line < block.startLine) {
+      high = middle - 1;
+    } else if (line > block.endLine) {
+      low = middle + 1;
+    } else {
+      return middle;
+    }
+  }
+  if (low >= blocks.length) return blocks.length - 1;
+  if (high < 0) return 0;
+  return Math.abs(blocks[low].startLine - line) < Math.abs(blocks[high].endLine - line) ? low : high;
+}
+function toCandidateWindow(target, startBlock, endBlock) {
+  const first = target.blocks[startBlock];
+  const last = target.blocks[endBlock];
+  return {
+    startBlock,
+    endBlock,
+    startLine: first.startLine,
+    endLine: last.endLine,
+    type: first.type,
+    text: target.lines.slice(first.startLine, last.endLine + 1).join("\n"),
+    headingPath: first.headingPath,
+    score: 0
+  };
+}
+function scoreCandidate(sourceBlock, sourceBlockIndex, candidate, index, originalLine) {
+  const content = textSimilarity(sourceBlock.text, candidate.text);
+  const type = sourceBlock.type === candidate.type ? 1 : 0;
+  const heading = pathSimilarity(sourceBlock.headingPath, candidate.headingPath);
+  const previous = neighborSimilarity(
+    index.source.blocks[sourceBlockIndex - 1],
+    index.target.blocks[candidate.startBlock - 1]
+  );
+  const next = neighborSimilarity(
+    index.source.blocks[sourceBlockIndex + 1],
+    index.target.blocks[candidate.endBlock + 1]
+  );
+  const proximity = Math.max(
+    0,
+    1 - Math.abs(candidate.startLine - originalLine) / 100
+  );
+  return Math.min(
+    1,
+    content * 0.45 + type * 0.1 + heading * 0.1 + previous * 0.15 + next * 0.15 + proximity * 0.05
+  );
+}
+function neighborSimilarity(source, target) {
+  if (!source || !target) return 0;
+  return textSimilarity(source.text, target.text);
+}
+function textSimilarity(left, right) {
+  return Math.max(
+    tokenDice(left, right),
+    combinedScore(normalizeText(left), normalizeText(right))
+  );
+}
+function pathSimilarity(left, right) {
+  if (left.length === 0 || right.length === 0) return 0;
+  return tokenDice(left.join(" "), right.join(" "));
+}
+function tokenDice(left, right) {
+  const leftTokens = tokenize2(left);
+  const rightTokens = tokenize2(right);
+  if (leftTokens.length === 0 || rightTokens.length === 0) return 0;
+  const remaining = /* @__PURE__ */ new Map();
+  for (const token of rightTokens) {
+    remaining.set(token, (remaining.get(token) ?? 0) + 1);
+  }
+  let overlap = 0;
+  for (const token of leftTokens) {
+    const count = remaining.get(token) ?? 0;
+    if (count > 0) {
+      overlap += 1;
+      remaining.set(token, count - 1);
+    }
+  }
+  return 2 * overlap / (leftTokens.length + rightTokens.length);
+}
+function tokenize2(text) {
+  return normalizeText(text).match(/[\p{L}\p{N}_-]+/gu) ?? [];
+}
+function normalizeText(text) {
+  return text.toLowerCase().replace(/\s+/g, " ").trim();
+}
+function samePath(left, right) {
+  return left.length === right.length && left.every((item, index) => item === right[index]);
+}
+function resolveCandidateRange(comment, sourceBlock, candidate, target) {
+  const exactIndex = candidate.text.indexOf(comment.selected_text);
+  const selectedIsWholeBlock = comment.line === sourceBlock.startLine && (comment.end_line ?? comment.line) === sourceBlock.endLine && comment.start_column == null && comment.end_column == null && comment.selected_text === sourceBlock.text;
+  const sourceOccurrenceIsUnique = countOccurrences(sourceBlock.text, comment.selected_text) === 1;
+  if (exactIndex >= 0 && (selectedIsWholeBlock || sourceOccurrenceIsUnique)) {
+    return exactRange(
+      candidate.startLine,
+      candidate.text,
+      comment.selected_text,
+      exactIndex
+    );
+  }
+  if (selectedIsWholeBlock) {
+    return {
+      line: candidate.startLine,
+      endLine: candidate.endLine,
+      text: candidate.text
+    };
+  }
+  const relativeLine = comment.line - sourceBlock.startLine;
+  const line = Math.min(candidate.endLine, candidate.startLine + relativeLine);
+  const lineSpan = (comment.end_line ?? comment.line) - comment.line;
+  const endLine = Math.min(candidate.endLine, line + lineSpan);
+  const startColumn = comment.start_column;
+  const endColumn = comment.end_column;
+  return {
+    line,
+    endLine,
+    startColumn,
+    endColumn,
+    text: extractText2(
+      target.lines,
+      line,
+      endLine,
+      startColumn,
+      endColumn
+    ) ?? ""
+  };
+}
+function countOccurrences(text, needle) {
+  if (!needle) return 0;
+  let count = 0;
+  let offset = 0;
+  while (offset <= text.length - needle.length) {
+    const index = text.indexOf(needle, offset);
+    if (index < 0) break;
+    count += 1;
+    offset = index + 1;
+  }
+  return count;
+}
+function exactRange(startLine, candidateText, selectedText, index) {
+  const before = candidateText.slice(0, index).split("\n");
+  const selectedLines = selectedText.split("\n");
+  const line = startLine + before.length - 1;
+  const startColumn = before.at(-1)?.length ?? 0;
+  const finalSelectedLineLength = selectedLines.at(-1)?.length ?? 0;
+  return {
+    line,
+    endLine: line + selectedLines.length - 1,
+    startColumn,
+    endColumn: selectedLines.length === 1 ? startColumn + finalSelectedLineLength : finalSelectedLineLength,
+    text: selectedText
+  };
+}
+function extractText2(lines, line, endLine, startColumn, endColumn) {
+  const finalLine = endLine ?? line;
+  if (line < 1 || finalLine >= lines.length) return null;
+  if (line === finalLine) {
+    const text = lines[line];
+    return startColumn != null && endColumn != null ? text.slice(startColumn, endColumn) : text;
+  }
+  const result = [];
+  for (let current = line; current <= finalLine; current += 1) {
+    let text = lines[current];
+    if (current === line && startColumn != null) text = text.slice(startColumn);
+    if (current === finalLine && endColumn != null) text = text.slice(0, endColumn);
+    result.push(text);
+  }
+  return result.join("\n");
+}
+
+// src/lib/confidence-calibration.ts
+function calibrateAnchorEvidence(commentId, selectedText, projected, contextual) {
+  if (projected?.exact) {
+    return {
+      band: "certain",
+      result: projectedResult(commentId, selectedText, projected)
+    };
+  }
+  if (contextual?.status === "anchored") {
+    return {
+      band: "certain",
+      result: contextualResult(commentId, selectedText, contextual)
+    };
+  }
+  if (projected && contextual) {
+    if (sameRange(projected, contextual)) {
+      const result = contextualResult(commentId, selectedText, contextual);
+      result.status = "fuzzy";
+      result.score = combineIndependentScores(projected.score, contextual.score);
+      result.reason = `Probable anchor: revision projection and Markdown context agree (confidence ${result.score.toFixed(3)}).`;
+      return { band: "probable", result };
+    }
+    if (contextual.status === "orphaned" && !isStrongProjection(projected)) {
+      return {
+        band: "orphaned",
+        result: contextualResult(commentId, selectedText, contextual)
+      };
+    }
+    if (contextual.status === "fuzzy" && contextual.candidateMargin >= 0.15 && contextual.score >= projected.score + 0.1) {
+      return {
+        band: "probable",
+        result: contextualResult(commentId, selectedText, contextual)
+      };
+    }
+    return {
+      band: "ambiguous",
+      result: {
+        commentId,
+        status: "ambiguous",
+        score: Math.max(projected.score, contextual.score),
+        reason: `Ambiguous evidence: revision projection points to line ${projected.line}, while Markdown context points to ${contextual.line ?? "no location"}.`
+      }
+    };
+  }
+  if (contextual) {
+    const band = contextual.status === "orphaned" ? "orphaned" : contextual.status === "ambiguous" ? "ambiguous" : "probable";
+    return {
+      band,
+      result: contextualResult(commentId, selectedText, contextual)
+    };
+  }
+  if (projected) {
+    if (!isStrongProjection(projected)) return void 0;
+    return {
+      band: "probable",
+      result: projectedResult(commentId, selectedText, projected)
+    };
+  }
+  return void 0;
+}
+function isStrongProjection(projected) {
+  return projected.contextSupport >= 3 || projected.contextSupport >= 2 && projected.contextMargin >= 0.5;
+}
+function sameRange(projected, contextual) {
+  return projected.line === contextual.line && projected.endLine === contextual.endLine;
+}
+function combineIndependentScores(left, right) {
+  return Math.min(0.95, (left + right) / 2 + 0.05);
+}
+function projectedResult(commentId, selectedText, projected) {
+  return {
+    commentId,
+    status: projected.exact ? "anchored" : "fuzzy",
+    score: projected.score,
+    newLine: projected.line,
+    newEndLine: projected.endLine,
+    newStartColumn: projected.startColumn,
+    newEndColumn: projected.endColumn,
+    anchoredText: projected.exact ? void 0 : projected.text,
+    previousSelectedText: projected.exact ? void 0 : selectedText,
+    reason: projected.reason
+  };
+}
+function contextualResult(commentId, selectedText, contextual) {
+  return {
+    commentId,
+    status: contextual.status,
+    score: contextual.score,
+    newLine: contextual.line,
+    newEndLine: contextual.endLine,
+    newStartColumn: contextual.startColumn,
+    newEndColumn: contextual.endColumn,
+    anchoredText: contextual.status === "fuzzy" ? contextual.text : void 0,
+    previousSelectedText: contextual.status === "fuzzy" ? selectedText : void 0,
+    reason: contextual.reason
+  };
+}
+
 // src/lib/reanchor-core.ts
 var HIGH_THRESHOLD = 0.8;
 var DEFAULT_THRESHOLD = 0.6;
@@ -285,6 +1180,12 @@ function reanchorComment(comment, documentLines, opts = {}) {
   const proximityWindow = opts.proximityWindow ?? DEFAULT_PROXIMITY_WINDOW;
   const commentId = comment.id;
   const selectedText = comment.selected_text;
+  let fuzzyCandidateSets;
+  let fuzzySearchIndex = opts.fuzzySearchIndex;
+  const getFuzzySearchIndex = () => {
+    fuzzySearchIndex ??= opts.getFuzzySearchIndex?.() ?? createFuzzySearchIndex(documentLines);
+    return fuzzySearchIndex;
+  };
   if (!selectedText && comment.line == null) {
     return {
       commentId,
@@ -312,7 +1213,7 @@ function reanchorComment(comment, documentLines, opts = {}) {
       const shiftedLine = comment.line + shift;
       const lineSpan = comment.end_line != null ? comment.end_line - comment.line : 0;
       const shiftedEndLine = comment.end_line != null ? shiftedLine + lineSpan : void 0;
-      const textAtShifted = extractText(
+      const textAtShifted = extractText3(
         documentLines,
         shiftedLine,
         shiftedEndLine,
@@ -331,8 +1232,39 @@ function reanchorComment(comment, documentLines, opts = {}) {
       }
     }
   }
+  const projected = selectedText && opts.revisionProjection ? projectCommentAnchor(
+    comment,
+    opts.revisionProjection,
+    threshold
+  ) : void 0;
+  if (selectedText && projected?.exact) {
+    const exactCalibration = calibrateAnchorEvidence(
+      commentId,
+      selectedText,
+      projected
+    );
+    if (exactCalibration) return exactCalibration.result;
+  }
+  const contextual = selectedText && opts.anchorContext ? resolveContextAnchor(comment, opts.anchorContext) : void 0;
+  if (selectedText && (projected || contextual)) {
+    const calibrated = calibrateAnchorEvidence(
+      commentId,
+      selectedText,
+      projected,
+      contextual
+    );
+    if (calibrated) return calibrated.result;
+  }
   if (selectedText) {
     const exactCandidates = exactMatch(documentLines, selectedText);
+    if (exactCandidates.length > 1 && comment.line == null) {
+      return {
+        commentId,
+        status: "ambiguous",
+        score: 1,
+        reason: `Ambiguous: ${exactCandidates.length} exact matches and no position or source context to disambiguate them.`
+      };
+    }
     let chosen;
     let chosenReason = "";
     if (exactCandidates.length === 1) {
@@ -344,7 +1276,7 @@ function reanchorComment(comment, documentLines, opts = {}) {
     }
     if (chosen) {
       if (isImplausibleExactRelocation(comment, chosen, documentLines, proximityWindow)) {
-        const textAtOrigin = extractText(
+        const textAtOrigin = extractText3(
           documentLines,
           comment.line,
           comment.end_line,
@@ -391,12 +1323,14 @@ function reanchorComment(comment, documentLines, opts = {}) {
         reason: "Normalized whitespace match."
       };
     }
-    const fuzzyCandidates = fuzzySearch(
+    fuzzyCandidateSets = fuzzySearchThresholds(
       documentLines,
       selectedText,
-      HIGH_THRESHOLD,
-      comment.line
+      [HIGH_THRESHOLD, threshold],
+      comment.line,
+      getFuzzySearchIndex()
     );
+    const fuzzyCandidates = fuzzyCandidateSets.get(HIGH_THRESHOLD) ?? [];
     if (fuzzyCandidates.length === 1 || fuzzyCandidates.length > 0 && fuzzyCandidates[0].score >= HIGH_THRESHOLD) {
       const best = fuzzyCandidates.length === 1 ? fuzzyCandidates[0] : closestToLine(fuzzyCandidates, comment.line ?? 1);
       return {
@@ -445,11 +1379,12 @@ function reanchorComment(comment, documentLines, opts = {}) {
     }
   }
   if (selectedText) {
-    const lowCandidates = fuzzySearch(
+    const lowCandidates = fuzzyCandidateSets?.get(threshold) ?? fuzzySearch(
       documentLines,
       selectedText,
       threshold,
-      comment.line
+      comment.line,
+      getFuzzySearchIndex()
     );
     if (lowCandidates.length === 1) {
       const candidate = lowCandidates[0];
@@ -486,7 +1421,14 @@ function reanchorComment(comment, documentLines, opts = {}) {
   };
 }
 function reanchorDocumentLines(doc, documentLines, opts = {}) {
-  return doc.comments.map((comment) => reanchorComment(comment, documentLines, opts));
+  let fuzzySearchIndex;
+  const getFuzzySearchIndex = () => {
+    fuzzySearchIndex ??= createFuzzySearchIndex(documentLines);
+    return fuzzySearchIndex;
+  };
+  return doc.comments.map(
+    (comment) => reanchorComment(comment, documentLines, { ...opts, getFuzzySearchIndex })
+  );
 }
 function reanchorDocumentText(doc, documentText, opts = {}) {
   return reanchorDocumentLines(doc, toReanchorLines(documentText), opts);
@@ -605,7 +1547,7 @@ function applyReanchorResults(doc, results, opts = {}) {
   }
   return changed;
 }
-function extractText(lines, line, endLine, startColumn, endColumn) {
+function extractText3(lines, line, endLine, startColumn, endColumn) {
   const startIdx = line;
   const endIdx = endLine ?? line;
   if (startIdx < 1 || endIdx >= lines.length) return null;
@@ -634,7 +1576,7 @@ function isImplausibleExactRelocation(comment, candidate, lines, proximityWindow
   if (comment.line == null) return false;
   if (comment.line <= 0 || comment.line >= lines.length) return false;
   if (Math.abs(candidate.line - comment.line) <= proximityWindow) return false;
-  const textAtOrigin = extractText(
+  const textAtOrigin = extractText3(
     lines,
     comment.line,
     comment.end_line,
@@ -660,6 +1602,137 @@ function getLineShift(diffHunks, line) {
   return { shift, modified };
 }
 
+// src/lib/global-reconciliation.ts
+var LOCAL_LANDMARK_WINDOW = 30;
+var MIN_LANDMARK_SUPPORT = 0.65;
+var MIN_SUPPORTING_LANDMARKS = 2;
+var MIN_GLOBAL_MARGIN = 0.08;
+var MAX_RECONCILIATION_ROUNDS = 4;
+function reconcileCommentAnchors(comments, results, anchorContext) {
+  const reconciled = results.map((result) => ({ ...result }));
+  if (comments.length < MIN_SUPPORTING_LANDMARKS + 1 || !reconciled.some((result) => result.status === "ambiguous")) {
+    return reconciled;
+  }
+  const resultIndexes = new Map(
+    reconciled.map((result, index) => [result.commentId, index])
+  );
+  const landmarks = collectLandmarks(comments, reconciled, anchorContext);
+  const landmarkCounts = /* @__PURE__ */ new Map();
+  for (const landmark of landmarks) {
+    landmarkCounts.set(
+      landmark.scope,
+      (landmarkCounts.get(landmark.scope) ?? 0) + 1
+    );
+  }
+  for (let round = 0; round < MAX_RECONCILIATION_ROUNDS; round += 1) {
+    let changed = false;
+    for (const comment of comments) {
+      if (comment.line == null || !comment.selected_text) continue;
+      const scope = getAnchorContextScope(comment, anchorContext);
+      if (scope == null) continue;
+      if ((landmarkCounts.get(scope) ?? 0) < MIN_SUPPORTING_LANDMARKS) {
+        continue;
+      }
+      const resultIndex = resultIndexes.get(comment.id);
+      if (resultIndex == null) continue;
+      const result = reconciled[resultIndex];
+      if (result.status !== "ambiguous") continue;
+      const candidates = deduplicateCandidates2(
+        findContextAnchorCandidates(comment, anchorContext)
+      ).slice(0, 8);
+      if (candidates.length < 2) continue;
+      const ranked = candidates.map(
+        (candidate) => scoreWithLandmarks(
+          comment.line,
+          scope,
+          candidate,
+          landmarks
+        )
+      ).sort(
+        (left, right) => right.globalScore - left.globalScore || right.candidate.score - left.candidate.score || left.candidate.line - right.candidate.line
+      );
+      const best = ranked[0];
+      const second = ranked[1];
+      if (!best.candidate.exact || best.supportingLandmarks < MIN_SUPPORTING_LANDMARKS || best.support < MIN_LANDMARK_SUPPORT || best.globalScore - second.globalScore < MIN_GLOBAL_MARGIN) {
+        continue;
+      }
+      reconciled[resultIndex] = {
+        commentId: comment.id,
+        status: "anchored",
+        score: Math.min(0.99, 0.8 + best.support * 0.19),
+        newLine: best.candidate.line,
+        newEndLine: best.candidate.endLine,
+        newStartColumn: best.candidate.startColumn,
+        newEndColumn: best.candidate.endColumn,
+        reason: `Global reconciliation selected this candidate from ${best.supportingLandmarks} nearby landmark(s) (support ${best.support.toFixed(3)}, margin ${(best.globalScore - second.globalScore).toFixed(3)}).`
+      };
+      changed = true;
+      landmarks.push({
+        sourceLine: comment.line,
+        targetLine: best.candidate.line,
+        scope
+      });
+      landmarkCounts.set(scope, (landmarkCounts.get(scope) ?? 0) + 1);
+    }
+    if (!changed) break;
+  }
+  return reconciled;
+}
+function collectLandmarks(comments, results, anchorContext) {
+  const resultMap = new Map(results.map((result) => [result.commentId, result]));
+  return comments.flatMap((comment) => {
+    const result = resultMap.get(comment.id);
+    if (comment.line == null || result?.newLine == null || result.status !== "anchored" && result.status !== "shifted" || result.score < 0.99) {
+      return [];
+    }
+    const scope = getAnchorContextScope(comment, anchorContext);
+    return scope == null ? [] : [{ sourceLine: comment.line, targetLine: result.newLine, scope }];
+  });
+}
+function scoreWithLandmarks(sourceLine, scope, candidate, landmarks) {
+  let weightedSupport = 0;
+  let totalWeight = 0;
+  let supportingLandmarks = 0;
+  const candidateShift = candidate.line - sourceLine;
+  for (const landmark of landmarks) {
+    if (landmark.scope !== scope) continue;
+    const sourceDistance = Math.abs(sourceLine - landmark.sourceLine);
+    if (sourceDistance === 0 || sourceDistance > LOCAL_LANDMARK_WINDOW) continue;
+    const landmarkShift = landmark.targetLine - landmark.sourceLine;
+    const shiftError = Math.abs(candidateShift - landmarkShift);
+    const agreement = Math.max(0, 1 - shiftError / 8);
+    const weight = 1 / (1 + sourceDistance / 4);
+    weightedSupport += agreement * weight;
+    totalWeight += weight;
+    if (agreement >= MIN_LANDMARK_SUPPORT) supportingLandmarks += 1;
+  }
+  const support = totalWeight > 0 ? weightedSupport / totalWeight : 0;
+  return {
+    candidate,
+    globalScore: candidate.score * 0.5 + support * 0.45 + (candidate.exact ? 0.05 : 0),
+    support,
+    supportingLandmarks
+  };
+}
+function deduplicateCandidates2(candidates) {
+  const unique = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    const key = [
+      candidate.line,
+      candidate.endLine,
+      candidate.startColumn ?? "",
+      candidate.endColumn ?? ""
+    ].join(":");
+    const existing = unique.get(key);
+    if (!existing || candidate.score > existing.score) {
+      unique.set(key, candidate);
+    }
+  }
+  return [...unique.values()].sort(
+    (left, right) => right.score - left.score || left.line - right.line
+  );
+}
+
 // src/lib/validate-core.ts
 var import_ajv = __toESM(require("ajv"), 1);
 var import_ajv_formats = __toESM(require("ajv-formats"), 1);
@@ -1039,6 +2112,10 @@ var reanchorDocumentLines2 = reanchorDocumentLines;
 var reanchorDocumentText2 = reanchorDocumentText;
 var resolveAnchor2 = resolveAnchor;
 var toReanchorLines2 = toReanchorLines;
+var createAnchorContextIndex2 = createAnchorContextIndex;
+var reconcileCommentAnchors2 = reconcileCommentAnchors;
+var createRevisionProjection2 = createRevisionProjection;
+var calibrateAnchorEvidence2 = calibrateAnchorEvidence;
 var validateDocument2 = validateDocument;
 var formatAuthor2 = formatAuthor;
 var parseAuthor2 = parseAuthor;