@mrsf/cli 0.4.3 → 0.6.0

package/dist/lib/fuzzy.js

@@ -110,37 +110,6 @@ export function normalizedMatch(lines, needle) {
 function tokenize(text) {
     return text.split(/\s+/).filter((t) => t.length > 0);
 }
-/**
- * Build a frequency map for a token array. Used for fast multiset
- * intersection during the fuzzySearch prefilter.
- */
-function buildTokenFreq(tokens) {
-    const freq = new Map();
-    for (const tok of tokens) {
-        freq.set(tok, (freq.get(tok) ?? 0) + 1);
-    }
-    return freq;
-}
-/**
- * Multiset intersection size: sum over needle tokens of
- * min(needleFreq[token], windowFreq[token]). This is an upper bound on
- * the longest common subsequence length, so it lets us cheaply skip
- * windows that cannot possibly reach the score threshold.
- */
-function multisetIntersection(needleFreq, windowFreq) {
-    let common = 0;
-    // Iterate the smaller map for speed.
-    const [smaller, larger] = needleFreq.size <= windowFreq.size
-        ? [needleFreq, windowFreq]
-        : [windowFreq, needleFreq];
-    for (const [tok, cnt] of smaller) {
-        const other = larger.get(tok);
-        if (other !== undefined) {
-            common += cnt < other ? cnt : other;
-        }
-    }
-    return common;
-}
 /**
  * Longest Common Subsequence length of two token arrays.
  */
@@ -230,144 +199,38 @@ export function fuzzySearch(lines, needle, threshold = 0.6, hintLine) {
     const needleLines = needle.split("\n");
     const needleLineCount = needleLines.length;
     const candidates = [];
-    // Pre-tokenize: do this once per call instead of per window. Per-line
-    // tokenization gives identical results to tokenize(lines.join("\n")) since
-    // tokenize splits on /\s+/ and filters empties.
-    const lineTokens = new Array(lines.length);
-    const lineTokenLengths = new Array(lines.length);
-    for (let i = 0; i < lines.length; i++) {
-        const toks = lines[i] ? tokenize(lines[i]) : [];
-        lineTokens[i] = toks;
-        lineTokenLengths[i] = toks.length;
-    }
-    const needleTokens = tokenize(needle);
-    const needleTokenCount = needleTokens.length;
-    const needleFreq = buildTokenFreq(needleTokens);
-    // The combined score is 0.6 * tScore + 0.4 * lScore. Since lScore <= 1.0,
-    // a window can only reach `threshold` if tScore >= (threshold - 0.4) / 0.6.
-    // Use this as a hard prefilter before doing the expensive LCS / Levenshtein.
-    const minTScore = Math.max(0, (threshold - 0.4) / 0.6);
     // Window sizes: ±30% of original line count, minimum 1
     const minWindow = Math.max(1, Math.floor(needleLineCount * 0.7));
     const maxWindow = Math.min(lines.length - 1, Math.ceil(needleLineCount * 1.3) + 1);
-    // Track total token count per window using a rolling sum so we don't
-    // re-walk the line-token arrays for every (winSize, startLine) pair.
     for (let winSize = minWindow; winSize <= maxWindow; winSize++) {
-        if (winSize < 1)
-            continue;
-        if (winSize > lines.length - 1)
-            continue;
-        // Initial window token sum for startLine = 1.
-        let runningTokenCount = 0;
-        for (let i = 1; i < 1 + winSize && i < lines.length; i++) {
-            runningTokenCount += lineTokenLengths[i];
-        }
         for (let startLine = 1; startLine + winSize - 1 < lines.length; startLine++) {
-            const endLineExclusive = startLine + winSize;
-            const M = runningTokenCount;
-            // Cheap skip: empty windows or empty needle can't fuzzy-match.
-            if (needleTokenCount > 0 && M > 0) {
-                // Build a frequency map for the window tokens. Cheaper than LCS:
-                // O(M) instead of O(M * needleTokenCount). We allocate a fresh map
-                // per window; tried a rolling map and the bookkeeping was a wash
-                // with realistic windowSize but if profiling demands it can be
-                // converted.
-                const windowFreq = new Map();
-                for (let li = startLine; li < endLineExclusive; li++) {
-                    const arr = lineTokens[li];
-                    for (let ti = 0; ti < arr.length; ti++) {
-                        const tok = arr[ti];
-                        windowFreq.set(tok, (windowFreq.get(tok) ?? 0) + 1);
-                    }
-                }
-                // Multiset intersection is an upper bound on LCS length. If we
-                // can't reach minTScore even with a perfect LCS, skip the window.
-                const common = multisetIntersection(needleFreq, windowFreq);
-                const tScoreUpperBound = common / Math.max(needleTokenCount, M);
-                if (tScoreUpperBound >= minTScore) {
-                    // Build the flat window token array only when we actually need
-                    // to compute LCS.
-                    const windowTokens = new Array(M);
-                    let wi = 0;
-                    for (let li = startLine; li < endLineExclusive; li++) {
-                        const arr = lineTokens[li];
-                        for (let ti = 0; ti < arr.length; ti++) {
-                            windowTokens[wi++] = arr[ti];
-                        }
-                    }
-                    const lcs = lcsLength(needleTokens, windowTokens);
-                    const tScore = lcs / Math.max(needleTokenCount, M);
-                    if (tScore >= minTScore) {
-                        // Defer expensive string join + Levenshtein until we know the
-                        // tScore could plausibly reach threshold.
-                        const windowLines = lines.slice(startLine, endLineExclusive);
-                        const windowText = windowLines.join("\n");
-                        let lScore;
-                        if (needle.length < 500 && windowText.length < 500) {
-                            lScore = levenshteinScore(needle, windowText);
-                        }
-                        else {
-                            lScore = tScore; // fall back to token score only
-                        }
-                        const score = tScore * 0.6 + lScore * 0.4;
-                        if (score >= threshold) {
-                            candidates.push({
-                                text: windowText,
-                                line: startLine,
-                                endLine: startLine + winSize - 1,
-                                startColumn: 0,
-                                endColumn: windowLines[windowLines.length - 1].length,
-                                score,
-                            });
-                        }
-                    }
-                }
-            }
-            // Slide window by one: drop startLine token count, add endLine token count.
-            const nextStart = startLine + 1;
-            const nextEndExclusive = nextStart + winSize;
-            if (nextEndExclusive <= lines.length) {
-                runningTokenCount += lineTokenLengths[endLineExclusive] - lineTokenLengths[startLine];
+            const windowLines = lines.slice(startLine, startLine + winSize);
+            const windowText = windowLines.join("\n");
+            const score = combinedScore(needle, windowText);
+            if (score >= threshold) {
+                candidates.push({
+                    text: windowText,
+                    line: startLine,
+                    endLine: startLine + winSize - 1,
+                    startColumn: 0,
+                    endColumn: windowLines[windowLines.length - 1].length,
+                    score,
+                });
             }
         }
     }
-    // For single-line needles, also try substring matching within each line.
-    // Prefilter each line by token overlap before running the inner sliding
-    // window — long lines without enough needle-token coverage are skipped
-    // wholesale, since no substring of such a line can exceed its parent
-    // line's token-overlap with the needle.
+    // For single-line needles, also try substring matching within each line
     if (needleLineCount === 1 && needle.length < 200) {
-        // The minimum number of needle tokens that must appear in a line for any
-        // substring of that line to plausibly reach minTScore. tScore =
-        // lcs / max(needleN, subN), so lcs >= minTScore * needleN is required,
-        // and lcs <= number of common tokens.
-        const requiredLineCommon = Math.max(0, Math.ceil(needleTokenCount * minTScore));
         for (let lineNum = 1; lineNum < lines.length; lineNum++) {
             const line = lines[lineNum];
             if (!line)
                 continue;
-            if (needleTokenCount > 0 && requiredLineCommon > 0) {
-                const lineFreq = buildTokenFreq(lineTokens[lineNum]);
-                const lineCommon = multisetIntersection(needleFreq, lineFreq);
-                if (lineCommon < requiredLineCommon)
-                    continue;
-            }
-            // Sliding window within line. Step by 1 by default for accuracy, but
-            // for very long lines and long needles, we coarsen the column step to
-            // avoid quadratic-in-line-length behaviour. The natural `len = winLen`
-            // is always swept densely so we don't miss the most likely match.
+            // Sliding window within line
             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++) {
-                // Coarsen the column step proportionally to needle length once the
-                // sub-window is no longer the natural needle length. This trades a
-                // tiny bit of recall for an order-of-magnitude speedup on long
-                // lines with many candidate offsets.
-                const colStep = len === winLen
-                    ? 1
-                    : Math.max(1, Math.floor(winLen / 16));
-                for (let col = 0; col + len <= line.length; col += colStep) {
+                for (let col = 0; col + len <= line.length; col++) {
                     const sub = line.substring(col, col + len);
                     const score = combinedScore(needle, sub);
                     if (score >= threshold) {

package/dist/lib/identity.d.ts

@@ -0,0 +1,12 @@
+export interface ParsedAuthor {
+    name: string;
+    handle?: string;
+}
+export declare function formatAuthor(name: string, handle?: string): string;
+export declare function parseAuthor(author: string): ParsedAuthor;
+/**
+ * Create a collision-resistant MRSF comment id.
+ * ULID is also permitted by the spec; UUIDv4 is the default for this package.
+ */
+export declare function newCommentId(): string;
+//# sourceMappingURL=identity.d.ts.map

package/dist/lib/identity.js

@@ -0,0 +1,23 @@
+import { v4 as uuidv4 } from "uuid";
+export function formatAuthor(name, handle) {
+    const trimmedName = name.trim();
+    const trimmedHandle = handle?.trim();
+    return trimmedHandle ? `${trimmedName} (${trimmedHandle})` : trimmedName;
+}
+export function parseAuthor(author) {
+    const trimmed = author.trim();
+    const match = /^(.*?)\s*\(([^()]*)\)\s*$/.exec(trimmed);
+    if (!match)
+        return { name: trimmed };
+    const name = match[1].trim();
+    const handle = match[2].trim();
+    return handle ? { name, handle } : { name };
+}
+/**
+ * Create a collision-resistant MRSF comment id.
+ * ULID is also permitted by the spec; UUIDv4 is the default for this package.
+ */
+export function newCommentId() {
+    return uuidv4();
+}
+//# sourceMappingURL=identity.js.map

package/dist/lib/parser.d.ts

@@ -1,25 +1,14 @@
 /**
  * MRSF Parser — load and parse MRSF sidecar files (YAML or JSON).
  */
-import type { MrsfDocument, Comment } from "./types.js";
-/** Result from a lenient (non-throwing) parse attempt. */
-export interface LenientParseResult {
-    /** Fully parsed document, or null if parsing failed entirely. */
-    doc: MrsfDocument | null;
-    /** If parsing failed or produced warnings, the error message. */
-    error?: string;
-    /** Comments that could be salvaged from a partially-corrupted sidecar. */
-    partialComments?: Comment[];
-}
+import type { MrsfDocument } from "./types.js";
+import { type LenientParseResult } from "./serialize.js";
+export { parseSidecarContent, parseSidecarContentLenient, } from "./serialize.js";
+export type { LenientParseResult } from "./serialize.js";
 /**
  * Parse an MRSF sidecar file from disk.
  */
 export declare function parseSidecar(filePath: string): Promise<MrsfDocument>;
-/**
- * Parse MRSF sidecar content from a string.
- * Detects JSON vs YAML based on content or optional filename hint.
- */
-export declare function parseSidecarContent(content: string, filenameHint?: string): MrsfDocument;
 /**
  * Lenient parse: attempts to parse a sidecar file from disk without
  * throwing.  On complete failure, returns `{ doc: null, error }`.
@@ -28,10 +17,6 @@ export declare function parseSidecarContent(content: string, filenameHint?: stri
  * salvage individual well-formed comments.
  */
 export declare function parseSidecarLenient(filePath: string): Promise<LenientParseResult>;
-/**
- * Lenient parse from string content.
- */
-export declare function parseSidecarContentLenient(content: string, filenameHint?: string): LenientParseResult;
 /**
  * Read a Markdown document from disk and return its lines.
  * Lines are 1-indexed in the returned array (index 0 is unused).

package/dist/lib/parser.js

@@ -3,7 +3,10 @@
  */
 import { readFile } from "node:fs/promises";
 import path from "node:path";
-import yaml from "js-yaml";
+import { parseSidecarContent, parseSidecarContentLenient, } from "./serialize.js";
+// Re-exported from the Node-free serialize module so existing
+// `@mrsf/cli` import paths keep working.
+export { parseSidecarContent, parseSidecarContentLenient, } from "./serialize.js";
 /**
  * Parse an MRSF sidecar file from disk.
  */
@@ -12,37 +15,6 @@ export async function parseSidecar(filePath) {
     const content = await readFile(abs, "utf-8");
     return parseSidecarContent(content, abs);
 }
-/**
- * Parse MRSF sidecar content from a string.
- * Detects JSON vs YAML based on content or optional filename hint.
- */
-export function parseSidecarContent(content, filenameHint) {
-    const trimmed = content.trim();
-    let parsed;
-    // Detect JSON by content or filename
-    const isJson = trimmed.startsWith("{") ||
-        (filenameHint && filenameHint.endsWith(".review.json"));
-    if (isJson) {
-        try {
-            parsed = JSON.parse(trimmed);
-        }
-        catch (e) {
-            throw new Error(`Failed to parse JSON: ${e.message}`);
-        }
-    }
-    else {
-        try {
-            parsed = yaml.load(trimmed, { schema: yaml.JSON_SCHEMA });
-        }
-        catch (e) {
-            throw new Error(`Failed to parse YAML: ${e.message}`);
-        }
-    }
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-        throw new Error("MRSF sidecar must be a YAML/JSON object");
-    }
-    return parsed;
-}
 /**
  * Lenient parse: attempts to parse a sidecar file from disk without
  * throwing.  On complete failure, returns `{ doc: null, error }`.
@@ -61,114 +33,6 @@ export async function parseSidecarLenient(filePath) {
     }
     return parseSidecarContentLenient(content, abs);
 }
-/**
- * Lenient parse from string content.
- */
-export function parseSidecarContentLenient(content, filenameHint) {
-    const trimmed = content.trim();
-    if (!trimmed) {
-        return { doc: null, error: "File is empty" };
-    }
-    const isJson = trimmed.startsWith("{") ||
-        (filenameHint && filenameHint.endsWith(".review.json"));
-    // First, try a normal parse
-    let parsed;
-    try {
-        parsed = isJson ? JSON.parse(trimmed) : yaml.load(trimmed, { schema: yaml.JSON_SCHEMA });
-    }
-    catch (e) {
-        // Total parse failure — try to salvage what we can from YAML
-        if (!isJson) {
-            return salvageYaml(trimmed);
-        }
-        return { doc: null, error: `Failed to parse JSON: ${e.message}` };
-    }
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-        return { doc: null, error: "MRSF sidecar must be a YAML/JSON object" };
-    }
-    const obj = parsed;
-    const doc = {
-        mrsf_version: typeof obj.mrsf_version === "string" ? obj.mrsf_version : "1.0",
-        document: typeof obj.document === "string" ? obj.document : "unknown",
-        comments: [],
-    };
-    if (!Array.isArray(obj.comments)) {
-        return {
-            doc,
-            error: "comments field is not an array — file may be corrupted",
-        };
-    }
-    // Validate each comment individually
-    const good = [];
-    const bad = [];
-    for (let i = 0; i < obj.comments.length; i++) {
-        const c = obj.comments[i];
-        if (c && typeof c === "object" && !Array.isArray(c) && typeof c.id === "string") {
-            good.push(c);
-        }
-        else {
-            bad.push(i);
-        }
-    }
-    doc.comments = good;
-    if (bad.length > 0) {
-        return {
-            doc,
-            error: `${bad.length} comment(s) at indices [${bad.join(", ")}] were malformed and skipped`,
-            partialComments: good,
-        };
-    }
-    return { doc };
-}
-/**
- * Attempt to extract individual comment blocks from corrupted YAML by
- * splitting on `- id:` patterns and parsing each block independently.
- */
-function salvageYaml(content) {
-    const salvaged = [];
-    let mrsf_version = "1.0";
-    let document = "unknown";
-    // Try to extract top-level fields from the beginning
-    const versionMatch = content.match(/^mrsf_version:\s*["']?([^"'\n]+)/m);
-    if (versionMatch)
-        mrsf_version = versionMatch[1].trim();
-    const docMatch = content.match(/^document:\s*["']?([^"'\n]+)/m);
-    if (docMatch)
-        document = docMatch[1].trim();
-    // Split on comment block boundaries (- id: ...)
-    const blocks = content.split(/(?=^  - id:\s)/m);
-    for (const block of blocks) {
-        const trimmed = block.trim();
-        if (!trimmed.startsWith("- id:"))
-            continue;
-        // Wrap in a minimal YAML array context and try to parse
-        try {
-            const parsed = yaml.load(trimmed, { schema: yaml.JSON_SCHEMA });
-            if (Array.isArray(parsed) && parsed.length > 0) {
-                const c = parsed[0];
-                if (c && typeof c === "object" && typeof c.id === "string") {
-                    salvaged.push(c);
-                }
-            }
-            else if (parsed && typeof parsed === "object" && typeof parsed.id === "string") {
-                salvaged.push(parsed);
-            }
-        }
-        catch {
-            // This block is unparseable — skip
-        }
-    }
-    const doc = {
-        mrsf_version,
-        document,
-        comments: salvaged,
-    };
-    return {
-        doc: salvaged.length > 0 ? doc : null,
-        error: `YAML parse failed. Salvaged ${salvaged.length} comment(s) from raw content.`,
-        partialComments: salvaged.length > 0 ? salvaged : undefined,
-    };
-}
 /**
  * Read a Markdown document from disk and return its lines.
  * Lines are 1-indexed in the returned array (index 0 is unused).

package/dist/lib/reanchor-core.d.ts

@@ -1,18 +1,34 @@
-import type { Comment, DiffHunk, MrsfDocument, ReanchorResult } from "./types.js";
+import type { AnchorPosition, Comment, DiffHunk, MrsfDocument, ReanchorResult } from "./types.js";
 export declare const HIGH_THRESHOLD = 0.8;
 export declare const DEFAULT_THRESHOLD = 0.6;
+/**
+ * Default proximity window (in lines) for the §7.4 step 1a relocation guard.
+ *
+ * A lone exact match of `selected_text` that lands farther than this many
+ * lines from the comment's original `line` — while the text at the original
+ * position has changed — is treated as an in-place edit rather than a
+ * confident relocation. See {@link isImplausibleExactRelocation}.
+ */
+export declare const DEFAULT_PROXIMITY_WINDOW = 5;
 export declare function toReanchorLines(documentText: string): string[];
 export declare function reanchorComment(comment: Comment, documentLines: string[], opts?: {
     diffHunks?: DiffHunk[];
     threshold?: number;
     commitIsStale?: boolean;
+    proximityWindow?: number;
 }): ReanchorResult;
 export declare function reanchorDocumentLines(doc: MrsfDocument, documentLines: string[], opts?: {
     threshold?: number;
+    proximityWindow?: number;
 }): ReanchorResult[];
 export declare function reanchorDocumentText(doc: MrsfDocument, documentText: string, opts?: {
     threshold?: number;
+    proximityWindow?: number;
 }): ReanchorResult[];
+export declare function resolveAnchor(comment: Comment, documentText: string, opts?: {
+    threshold?: number;
+    proximityWindow?: number;
+}): AnchorPosition;
 export declare function applyReanchorResults(doc: MrsfDocument, results: ReanchorResult[], opts?: {
     updateText?: boolean;
     force?: boolean;

package/dist/lib/reanchor-core.js

@@ -1,11 +1,21 @@
 import { exactMatch, fuzzySearch, normalizedMatch, } from "./fuzzy.js";
 export const HIGH_THRESHOLD = 0.8;
 export const DEFAULT_THRESHOLD = 0.6;
+/**
+ * Default proximity window (in lines) for the §7.4 step 1a relocation guard.
+ *
+ * A lone exact match of `selected_text` that lands farther than this many
+ * lines from the comment's original `line` — while the text at the original
+ * position has changed — is treated as an in-place edit rather than a
+ * confident relocation. See {@link isImplausibleExactRelocation}.
+ */
+export const DEFAULT_PROXIMITY_WINDOW = 5;
 export function toReanchorLines(documentText) {
     return ["", ...documentText.replace(/\r\n/g, "\n").split("\n")];
 }
 export function reanchorComment(comment, documentLines, opts = {}) {
     const threshold = opts.threshold ?? DEFAULT_THRESHOLD;
+    const proximityWindow = opts.proximityWindow ?? DEFAULT_PROXIMITY_WINDOW;
     const commentId = comment.id;
     const selectedText = comment.selected_text;
     if (!selectedText && comment.line == null) {
@@ -54,30 +64,51 @@ export function reanchorComment(comment, documentLines, opts = {}) {
     }
     if (selectedText) {
         const exactCandidates = exactMatch(documentLines, selectedText);
+        // Pick the best exact candidate: the only one, or — when several remain —
+        // the one nearest to the original line (§7.4 step 1b).
+        let chosen;
+        let chosenReason = "";
         if (exactCandidates.length === 1) {
-            const candidate = exactCandidates[0];
-            return {
-                commentId,
-                status: "anchored",
-                score: 1.0,
-                newLine: candidate.line,
-                newEndLine: candidate.endLine,
-                newStartColumn: candidate.startColumn,
-                newEndColumn: candidate.endColumn,
-                reason: "Exact text match (unique).",
-            };
+            chosen = exactCandidates[0];
+            chosenReason = "Exact text match (unique).";
+        }
+        else if (exactCandidates.length > 1 && comment.line != null) {
+            chosen = closestToLine(exactCandidates, comment.line);
+            chosenReason = `Exact text match (${exactCandidates.length} occurrences; chose nearest to original line ${comment.line}).`;
         }
-        if (exactCandidates.length > 1 && comment.line != null) {
-            const best = closestToLine(exactCandidates, comment.line);
+        if (chosen) {
+            // §7.4 step 1a proximity guard: a lone/closest exact match that lands far
+            // from the original position — while the text at the original position no
+            // longer equals selected_text — most likely indicates an in-place edit of
+            // the anchored text, not a genuine relocation. Keep the comment at its
+            // original position and flag it for re-anchoring instead of teleporting it
+            // onto an unrelated identical token with full confidence.
+            if (isImplausibleExactRelocation(comment, chosen, documentLines, proximityWindow)) {
+                const textAtOrigin = extractText(documentLines, comment.line, comment.end_line, comment.start_column, comment.end_column);
+                return {
+                    commentId,
+                    status: "fuzzy",
+                    score: 0.5,
+                    newLine: comment.line,
+                    newEndLine: comment.end_line,
+                    newStartColumn: comment.start_column,
+                    newEndColumn: comment.end_column,
+                    anchoredText: textAtOrigin ?? undefined,
+                    previousSelectedText: selectedText,
+                    reason: `Lone exact match at line ${chosen.line} is beyond the proximity window ` +
+                        `(±${proximityWindow}) of original line ${comment.line} and the text at the ` +
+                        `original position changed; kept at original position, needs re-anchoring.`,
+                };
+            }
             return {
                 commentId,
                 status: "anchored",
                 score: 1.0,
-                newLine: best.line,
-                newEndLine: best.endLine,
-                newStartColumn: best.startColumn,
-                newEndColumn: best.endColumn,
-                reason: `Exact text match (${exactCandidates.length} occurrences; chose nearest to original line ${comment.line}).`,
+                newLine: chosen.line,
+                newEndLine: chosen.endLine,
+                newStartColumn: chosen.startColumn,
+                newEndColumn: chosen.endColumn,
+                reason: chosenReason,
             };
         }
         const normCandidates = normalizedMatch(documentLines, selectedText);
@@ -192,6 +223,68 @@ export function reanchorDocumentLines(doc, documentLines, opts = {}) {
 export function reanchorDocumentText(doc, documentText, opts = {}) {
     return reanchorDocumentLines(doc, toReanchorLines(documentText), opts);
 }
+export function resolveAnchor(comment, documentText, opts = {}) {
+    const normalizedText = documentText.replace(/\r\n/g, "\n");
+    const documentLines = toReanchorLines(documentText);
+    const result = reanchorComment(comment, documentLines, opts);
+    if (result.status === "orphaned") {
+        return {
+            status: "orphaned",
+            score: result.score,
+            reason: result.reason,
+        };
+    }
+    const line = result.newLine ?? comment.line;
+    if (line == null) {
+        return {
+            status: result.status,
+            score: result.score,
+            reason: result.reason,
+        };
+    }
+    const rawLines = normalizedText.split("\n");
+    const lineStarts = computeLineStarts(rawLines);
+    const endLine = result.newEndLine ?? comment.end_line ?? line;
+    const startColumn = result.newStartColumn ?? comment.start_column ?? 0;
+    const endColumn = result.newEndColumn ?? comment.end_column;
+    const from = offsetFor(lineStarts, rawLines, line, startColumn);
+    const selectedText = comment.selected_text?.replace(/\r\n/g, "\n");
+    const to = endColumn != null
+        ? offsetFor(lineStarts, rawLines, endLine, endColumn)
+        : selectedText
+            ? from + selectedText.length
+            : offsetFor(lineStarts, rawLines, endLine, rawLines[endLine - 1]?.length ?? 0);
+    return {
+        status: result.status,
+        score: result.score,
+        from,
+        to,
+        line,
+        endLine,
+        startColumn,
+        endColumn: endColumn ?? columnForOffset(lineStarts, rawLines, endLine, to),
+        reason: result.reason,
+    };
+}
+function computeLineStarts(lines) {
+    const starts = [0];
+    let offset = 0;
+    for (const line of lines) {
+        starts.push(offset);
+        offset += line.length + 1;
+    }
+    return starts;
+}
+function offsetFor(lineStarts, lines, line, column) {
+    const start = lineStarts[line] ?? 0;
+    const maxColumn = lines[line - 1]?.length ?? 0;
+    return start + Math.max(0, Math.min(column, maxColumn));
+}
+function columnForOffset(lineStarts, lines, line, offset) {
+    const start = lineStarts[line] ?? 0;
+    const maxColumn = lines[line - 1]?.length ?? 0;
+    return Math.max(0, Math.min(offset - start, maxColumn));
+}
 export function applyReanchorResults(doc, results, opts = {}) {
     let changed = 0;
     const resultMap = new Map(results.map((result) => [result.commentId, result]));
@@ -280,6 +373,36 @@ function extractText(lines, line, endLine, startColumn, endColumn) {
 function closestToLine(candidates, targetLine) {
     return candidates.reduce((best, candidate) => Math.abs(candidate.line - targetLine) < Math.abs(best.line - targetLine) ? candidate : best);
 }
+/**
+ * §7.4 step 1a relocation guard.
+ *
+ * Returns true when a chosen exact-match candidate is an *implausible*
+ * full-confidence relocation: the original `line` still exists in the document,
+ * the candidate is farther than `proximityWindow` lines away, and the text now
+ * at the original position no longer equals `selected_text`. This is the
+ * signature of an in-place edit of the anchored text (which removed the
+ * original occurrence) rather than a genuine move of the selection.
+ *
+ * When the original line no longer exists (the document shrank or the section
+ * was removed) or no positional anchor is available, relocation is treated as a
+ * legitimate §7.4 step 3 contextual re-anchor and this returns false.
+ */
+function isImplausibleExactRelocation(comment, candidate, lines, proximityWindow) {
+    if (comment.line == null)
+        return false;
+    // Original position must still exist to be a viable fallback anchor.
+    if (comment.line <= 0 || comment.line >= lines.length)
+        return false;
+    // A nearby match is plausibly the same (or an adjacent) edit region.
+    if (Math.abs(candidate.line - comment.line) <= proximityWindow)
+        return false;
+    // If the text at the original position still equals selected_text, the
+    // original occurrence is intact and relocation is not a teleport.
+    const textAtOrigin = extractText(lines, comment.line, comment.end_line, comment.start_column, comment.end_column);
+    if (textAtOrigin === comment.selected_text)
+        return false;
+    return true;
+}
 function getLineShift(diffHunks, line) {
     let shift = 0;
     let modified = false;