@mrsf/cli 0.5.0 → 0.6.0

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,20 +1,33 @@
 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;

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);
@@ -342,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;

package/dist/lib/reanchor.js

@@ -31,6 +31,7 @@ export { applyReanchorResults, DEFAULT_THRESHOLD, HIGH_THRESHOLD, reanchorCommen
 export async function reanchorDocument(doc, documentLines, opts = {}) {
     const results = [];
     const threshold = opts.threshold ?? DEFAULT_THRESHOLD;
+    const proximityWindow = opts.proximityWindow;
     // Determine git context
     let diffHunks;
     let commitIsStale = false;
@@ -51,17 +52,18 @@ export async function reanchorDocument(doc, documentLines, opts = {}) {
                         diffHunks: hunks,
                         threshold,
                         commitIsStale: true,
+                        proximityWindow,
                     });
                     results.push(result);
                     continue;
                 }
                 // non-stale or no commit
-                results.push(reanchorComment(comment, documentLines, { threshold, commitIsStale: false }));
+                results.push(reanchorComment(comment, documentLines, { threshold, commitIsStale: false, proximityWindow }));
             }
             return results;
         }
     }
-    return reanchorDocumentLines(doc, documentLines, { threshold });
+    return reanchorDocumentLines(doc, documentLines, { threshold, proximityWindow });
 }
 /**
  * High-level re-anchor for a single sidecar file path.

package/dist/lib/serialize.d.ts

@@ -0,0 +1,37 @@
+/**
+ * MRSF string (de)serialization — pure, dependency-light helpers that parse and
+ * serialize MRSF sidecar content to/from strings.
+ *
+ * This module intentionally has **no Node-only imports** (no `node:fs`,
+ * `node:path`, `node:crypto`, …) so it can be consumed from browser/host
+ * adapters via the slim `@mrsf/cli/browser` entry point. Filesystem-bound
+ * helpers (read/discover/write a file) live in `parser.ts` / `writer.ts`.
+ */
+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[];
+}
+/**
+ * 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 from string content.
+ */
+export declare function parseSidecarContentLenient(content: string, filenameHint?: string): LenientParseResult;
+/**
+ * Serialize an MrsfDocument to YAML (for new files / non-round-trip use).
+ */
+export declare function toYaml(doc: MrsfDocument): string;
+/**
+ * Serialize an MrsfDocument to JSON.
+ */
+export declare function toJson(doc: MrsfDocument): string;
+//# sourceMappingURL=serialize.d.ts.map

package/dist/lib/serialize.js

@@ -0,0 +1,170 @@
+/**
+ * MRSF string (de)serialization — pure, dependency-light helpers that parse and
+ * serialize MRSF sidecar content to/from strings.
+ *
+ * This module intentionally has **no Node-only imports** (no `node:fs`,
+ * `node:path`, `node:crypto`, …) so it can be consumed from browser/host
+ * adapters via the slim `@mrsf/cli/browser` entry point. Filesystem-bound
+ * helpers (read/discover/write a file) live in `parser.ts` / `writer.ts`.
+ */
+import yaml from "js-yaml";
+import { Document } from "yaml";
+// ---------------------------------------------------------------------------
+// Parsing (string → document)
+// ---------------------------------------------------------------------------
+/**
+ * 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 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,
+    };
+}
+// ---------------------------------------------------------------------------
+// Serialization (document → string)
+// ---------------------------------------------------------------------------
+/**
+ * Serialize an MrsfDocument to YAML (for new files / non-round-trip use).
+ */
+export function toYaml(doc) {
+    const yamlDoc = new Document(doc);
+    return yamlDoc.toString({ lineWidth: 0 });
+}
+/**
+ * Serialize an MrsfDocument to JSON.
+ */
+export function toJson(doc) {
+    return JSON.stringify(doc, null, 2) + "\n";
+}
+//# sourceMappingURL=serialize.js.map

package/dist/lib/types.d.ts

@@ -172,6 +172,13 @@ export interface ReanchorOptions extends BaseOptions {
     fromCommit?: string;
     /** Update selected_text to match anchored_text (opt-in per §6.2). */
     updateText?: boolean;
+    /**
+     * Proximity window (in lines) for the §7.4 step 1a relocation guard.
+     * A lone exact match farther than this from the original line, when the
+     * original position's text has changed, is kept in place and flagged for
+     * re-anchoring rather than relocated with full confidence. Default 5.
+     */
+    proximityWindow?: number;
     /** Force-anchor: update commit to HEAD and clear audit fields for high-confidence results. */
     force?: boolean;
 }

package/dist/lib/writer.d.ts

@@ -21,14 +21,7 @@ export declare function computeHash(text: string): string;
  * If selected_text is absent, removes the hash.
  */
 export declare function syncHash(comment: Comment): Comment;
-/**
- * Serialize an MrsfDocument to YAML (for new files / non-round-trip use).
- */
-export declare function toYaml(doc: MrsfDocument): string;
-/**
- * Serialize an MrsfDocument to JSON.
- */
-export declare function toJson(doc: MrsfDocument): string;
+export { toYaml, toJson } from "./serialize.js";
 /**
  * Write an MrsfDocument to disk.
  *

package/dist/lib/writer.js

@@ -14,7 +14,8 @@ import { readFile, writeFile, rename, unlink } from "node:fs/promises";
 import { existsSync } from "node:fs";
 import { createHash, randomBytes } from "node:crypto";
 import path from "node:path";
-import { Document, Parser, CST, parse as yamlParse } from "yaml";
+import { Parser, CST, parse as yamlParse } from "yaml";
+import { toYaml, toJson } from "./serialize.js";
 /* ------------------------------------------------------------------ */
 /*  Per-file write serialization                                       */
 /* ------------------------------------------------------------------ */
@@ -327,19 +328,9 @@ function deepEqual(a, b) {
 /* ------------------------------------------------------------------ */
 /*  Public API                                                         */
 /* ------------------------------------------------------------------ */
-/**
- * Serialize an MrsfDocument to YAML (for new files / non-round-trip use).
- */
-export function toYaml(doc) {
-    const yamlDoc = new Document(doc);
-    return yamlDoc.toString({ lineWidth: 0 });
-}
-/**
- * Serialize an MrsfDocument to JSON.
- */
-export function toJson(doc) {
-    return JSON.stringify(doc, null, 2) + "\n";
-}
+// `toYaml` / `toJson` now live in the Node-free serialize module; re-exported
+// here so existing `@mrsf/cli` import paths keep working.
+export { toYaml, toJson } from "./serialize.js";
 /**
  * Write an MrsfDocument to disk.
  *