@mrsf/cli 0.1.0

package/dist/lib/reanchor.d.ts

@@ -0,0 +1,45 @@
+/**
+ * MRSF Re-anchor Engine — §7.4 Anchoring Resolution Procedure.
+ *
+ * Implements a four-step algorithm to re-locate each comment's
+ * anchor within the current document revision:
+ *
+ *   Step 0  – diff-based shift (git + commit available)
+ *   Step 1  – exact text match
+ *   Step 1.5– fuzzy match ≥ high threshold (0.8)
+ *   Step 2  – line/column fallback (commit-aware staleness)
+ *   Step 3  – lower-threshold fuzzy ≥ configured threshold (0.6)
+ *   Step 4  – orphan
+ */
+import type { Comment, MrsfDocument, ReanchorOptions, ReanchorResult, DiffHunk } from "./types.js";
+/**
+ * Re-anchor a single comment against the current document lines.
+ */
+export declare function reanchorComment(comment: Comment, documentLines: string[], opts?: {
+    diffHunks?: DiffHunk[];
+    threshold?: number;
+    commitIsStale?: boolean;
+}): ReanchorResult;
+/**
+ * Re-anchor all comments in an MRSF document.
+ */
+export declare function reanchorDocument(doc: MrsfDocument, documentLines: string[], opts?: ReanchorOptions & {
+    documentPath?: string;
+    repoRoot?: string;
+}): Promise<ReanchorResult[]>;
+/**
+ * Apply re-anchor results to the document's comments.
+ * Mutates the document in place and returns the number of changed comments.
+ */
+export declare function applyReanchorResults(doc: MrsfDocument, results: ReanchorResult[], opts?: {
+    updateText?: boolean;
+}): number;
+/**
+ * High-level re-anchor for a single sidecar file path.
+ */
+export declare function reanchorFile(sidecarPath: string, opts?: ReanchorOptions): Promise<{
+    results: ReanchorResult[];
+    changed: number;
+    written: boolean;
+}>;
+//# sourceMappingURL=reanchor.d.ts.map

package/dist/lib/reanchor.js

@@ -0,0 +1,389 @@
+/**
+ * MRSF Re-anchor Engine — §7.4 Anchoring Resolution Procedure.
+ *
+ * Implements a four-step algorithm to re-locate each comment's
+ * anchor within the current document revision:
+ *
+ *   Step 0  – diff-based shift (git + commit available)
+ *   Step 1  – exact text match
+ *   Step 1.5– fuzzy match ≥ high threshold (0.8)
+ *   Step 2  – line/column fallback (commit-aware staleness)
+ *   Step 3  – lower-threshold fuzzy ≥ configured threshold (0.6)
+ *   Step 4  – orphan
+ */
+import { findRepoRoot, getCurrentCommit, getDiff, getLineShift, isGitAvailable, } from "./git.js";
+import { exactMatch, fuzzySearch, normalizedMatch, } from "./fuzzy.js";
+import { readDocumentLines } from "./parser.js";
+import { sidecarToDocument } from "./discovery.js";
+import { parseSidecar } from "./parser.js";
+import { writeSidecar } from "./writer.js";
+import path from "node:path";
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const HIGH_THRESHOLD = 0.8;
+const DEFAULT_THRESHOLD = 0.6;
+// ---------------------------------------------------------------------------
+// Single comment re-anchoring
+// ---------------------------------------------------------------------------
+/**
+ * Re-anchor a single comment against the current document lines.
+ */
+export function reanchorComment(comment, documentLines, opts = {}) {
+    const threshold = opts.threshold ?? DEFAULT_THRESHOLD;
+    const commentId = comment.id;
+    const selectedText = comment.selected_text;
+    // No selected_text and no line — nothing to anchor
+    if (!selectedText && comment.line == null) {
+        return {
+            commentId,
+            status: "anchored",
+            score: 1.0,
+            reason: "Document-level comment (no anchor needed).",
+        };
+    }
+    // -----------------------------------------------------------------------
+    // Step 0: Diff-based shift
+    // -----------------------------------------------------------------------
+    if (selectedText && comment.line != null && opts.diffHunks?.length) {
+        const { shift, modified } = getLineShift(opts.diffHunks, comment.line);
+        if (!modified) {
+            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 : undefined;
+            // Verify the selected text still matches at the shifted position
+            const textAtShifted = extractText(documentLines, shiftedLine, shiftedEndLine, comment.start_column, comment.end_column);
+            if (textAtShifted === selectedText) {
+                return {
+                    commentId,
+                    status: shift === 0 ? "anchored" : "shifted",
+                    score: 1.0,
+                    newLine: shiftedLine,
+                    newEndLine: shiftedEndLine,
+                    reason: shift === 0
+                        ? "Diff confirms text unchanged at original position."
+                        : `Diff shifted by ${shift > 0 ? "+" : ""}${shift} line(s).`,
+                };
+            }
+        }
+        // Fall through — line was modified or text doesn't match after shift
+    }
+    // -----------------------------------------------------------------------
+    // Step 1: Exact text match
+    // -----------------------------------------------------------------------
+    if (selectedText) {
+        const exactCandidates = exactMatch(documentLines, selectedText);
+        if (exactCandidates.length === 1) {
+            const c = exactCandidates[0];
+            return {
+                commentId,
+                status: "anchored",
+                score: 1.0,
+                newLine: c.line,
+                newEndLine: c.endLine,
+                newStartColumn: c.startColumn,
+                newEndColumn: c.endColumn,
+                reason: "Exact text match (unique).",
+            };
+        }
+        if (exactCandidates.length > 1 && comment.line != null) {
+            // Disambiguate by proximity to original line
+            const best = closestToLine(exactCandidates, comment.line);
+            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}).`,
+            };
+        }
+        // -----------------------------------------------------------------------
+        // Step 1.5: Normalized + high-threshold fuzzy match
+        // -----------------------------------------------------------------------
+        // Try whitespace-normalized match first
+        const normCandidates = normalizedMatch(documentLines, selectedText);
+        if (normCandidates.length === 1) {
+            const c = normCandidates[0];
+            return {
+                commentId,
+                status: "fuzzy",
+                score: c.score,
+                newLine: c.line,
+                newEndLine: c.endLine,
+                newStartColumn: c.startColumn,
+                newEndColumn: c.endColumn,
+                anchoredText: c.text,
+                previousSelectedText: selectedText,
+                reason: "Normalized whitespace match.",
+            };
+        }
+        // High threshold fuzzy
+        const fuzzyCandidates = fuzzySearch(documentLines, selectedText, HIGH_THRESHOLD, comment.line);
+        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 {
+                commentId,
+                status: "fuzzy",
+                score: best.score,
+                newLine: best.line,
+                newEndLine: best.endLine,
+                newStartColumn: best.startColumn,
+                newEndColumn: best.endColumn,
+                anchoredText: best.text,
+                previousSelectedText: selectedText,
+                reason: `High-confidence fuzzy match (score ${best.score.toFixed(3)}).`,
+            };
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Step 2: Line/column fallback
+    // -----------------------------------------------------------------------
+    if (comment.line != null) {
+        const lineIdx = comment.line - 1;
+        if (lineIdx >= 0 && lineIdx < documentLines.length) {
+            const qualifier = opts.commitIsStale
+                ? " (commit is stale — line may have shifted)"
+                : "";
+            // If we have selected_text, check if current line text is a decent fuzzy match
+            if (selectedText) {
+                const lineText = documentLines[lineIdx];
+                const candidates = fuzzySearch([lineText], selectedText, DEFAULT_THRESHOLD);
+                if (candidates.length > 0) {
+                    return {
+                        commentId,
+                        status: "fuzzy",
+                        score: candidates[0].score,
+                        newLine: comment.line,
+                        newEndLine: comment.end_line,
+                        anchoredText: candidates[0].text,
+                        previousSelectedText: selectedText,
+                        reason: `Line-fallback with fuzzy text match (score ${candidates[0].score.toFixed(3)})${qualifier}.`,
+                    };
+                }
+            }
+            // Pure line fallback
+            return {
+                commentId,
+                status: opts.commitIsStale ? "ambiguous" : "anchored",
+                score: opts.commitIsStale ? 0.5 : 0.8,
+                newLine: comment.line,
+                newEndLine: comment.end_line,
+                reason: `Line/column fallback${qualifier}.`,
+            };
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Step 3: Lower-threshold fuzzy search
+    // -----------------------------------------------------------------------
+    if (selectedText) {
+        const lowCandidates = fuzzySearch(documentLines, selectedText, threshold, comment.line);
+        if (lowCandidates.length === 1) {
+            const c = lowCandidates[0];
+            return {
+                commentId,
+                status: "fuzzy",
+                score: c.score,
+                newLine: c.line,
+                newEndLine: c.endLine,
+                newStartColumn: c.startColumn,
+                newEndColumn: c.endColumn,
+                anchoredText: c.text,
+                previousSelectedText: selectedText,
+                reason: `Low-threshold fuzzy match (score ${c.score.toFixed(3)}).`,
+            };
+        }
+        if (lowCandidates.length > 1) {
+            // Ambiguous — multiple low-confidence matches
+            const best = lowCandidates[0];
+            return {
+                commentId,
+                status: "ambiguous",
+                score: best.score,
+                newLine: best.line,
+                newEndLine: best.endLine,
+                reason: `Ambiguous: ${lowCandidates.length} fuzzy matches (best score ${best.score.toFixed(3)}).`,
+            };
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Step 4: Orphan
+    // -----------------------------------------------------------------------
+    return {
+        commentId,
+        status: "orphaned",
+        score: 0,
+        reason: "No match found. Comment is orphaned.",
+    };
+}
+// ---------------------------------------------------------------------------
+// Batch re-anchoring
+// ---------------------------------------------------------------------------
+/**
+ * Re-anchor all comments in an MRSF document.
+ */
+export async function reanchorDocument(doc, documentLines, opts = {}) {
+    const results = [];
+    const threshold = opts.threshold ?? DEFAULT_THRESHOLD;
+    // Determine git context
+    let diffHunks;
+    let commitIsStale = false;
+    if (!opts.noGit && (await isGitAvailable())) {
+        const repoRoot = opts.repoRoot ?? (await findRepoRoot(opts.cwd));
+        if (repoRoot && opts.documentPath) {
+            const relPath = path.relative(repoRoot, opts.documentPath);
+            const head = await getCurrentCommit(repoRoot);
+            // Use a shared fromCommit for all comments, or per-comment
+            const globalFrom = opts.fromCommit;
+            for (const comment of doc.comments) {
+                const commentCommit = globalFrom ?? comment.commit;
+                if (commentCommit && head && commentCommit !== head) {
+                    commitIsStale = true;
+                    // Get diff for this commit range
+                    const hunks = await getDiff(commentCommit, head, relPath, repoRoot);
+                    const result = reanchorComment(comment, documentLines, {
+                        diffHunks: hunks,
+                        threshold,
+                        commitIsStale: true,
+                    });
+                    results.push(result);
+                    continue;
+                }
+                // non-stale or no commit
+                results.push(reanchorComment(comment, documentLines, { threshold, commitIsStale: false }));
+            }
+            return results;
+        }
+    }
+    // No git — pure text-based re-anchoring
+    for (const comment of doc.comments) {
+        results.push(reanchorComment(comment, documentLines, { threshold }));
+    }
+    return results;
+}
+/**
+ * Apply re-anchor results to the document's comments.
+ * Mutates the document in place and returns the number of changed comments.
+ */
+export function applyReanchorResults(doc, results, opts = {}) {
+    let changed = 0;
+    const resultMap = new Map(results.map((r) => [r.commentId, r]));
+    for (const comment of doc.comments) {
+        const result = resultMap.get(comment.id);
+        if (!result)
+            continue;
+        let isChanged = false;
+        if (result.newLine != null && result.newLine !== comment.line) {
+            comment.line = result.newLine;
+            isChanged = true;
+        }
+        if (result.newEndLine != null && result.newEndLine !== comment.end_line) {
+            comment.end_line = result.newEndLine;
+            isChanged = true;
+        }
+        if (result.newStartColumn != null && result.newStartColumn !== comment.start_column) {
+            comment.start_column = result.newStartColumn;
+            isChanged = true;
+        }
+        if (result.newEndColumn != null && result.newEndColumn !== comment.end_column) {
+            comment.end_column = result.newEndColumn;
+            isChanged = true;
+        }
+        // Handle anchored_text / selected_text per §6.2 & §7.4 Step 3a.
+        // By default, selected_text is preserved (SHOULD NOT modify).
+        // anchored_text records the text currently at the resolved position.
+        if (result.anchoredText != null && result.anchoredText !== comment.selected_text) {
+            if (opts.updateText) {
+                // Opt-in: replace selected_text and clear anchored_text
+                comment.selected_text = result.anchoredText;
+                delete comment.anchored_text;
+            }
+            else {
+                // Default: preserve selected_text, record current text in anchored_text
+                comment.anchored_text = result.anchoredText;
+            }
+            isChanged = true;
+        }
+        else if (result.anchoredText != null && result.anchoredText === comment.selected_text) {
+            // Text matches exactly — clear any stale anchored_text
+            if (comment.anchored_text) {
+                delete comment.anchored_text;
+                isChanged = true;
+            }
+        }
+        // Audit fields (x_ extension prefix per §10)
+        if (isChanged || result.status !== "anchored") {
+            comment.x_reanchor_status = result.status;
+            comment.x_reanchor_score = result.score;
+        }
+        if (isChanged)
+            changed++;
+    }
+    return changed;
+}
+/**
+ * High-level re-anchor for a single sidecar file path.
+ */
+export async function reanchorFile(sidecarPath, opts = {}) {
+    const doc = await parseSidecar(sidecarPath);
+    const docPath = sidecarToDocument(sidecarPath);
+    const documentLines = await readDocumentLines(docPath);
+    const repoRoot = !opts.noGit ? await findRepoRoot(opts.cwd) : null;
+    const results = await reanchorDocument(doc, documentLines, {
+        ...opts,
+        documentPath: docPath,
+        repoRoot: repoRoot ?? undefined,
+    });
+    let changed = 0;
+    let written = false;
+    if (!opts.dryRun) {
+        changed = applyReanchorResults(doc, results, { updateText: opts.updateText });
+        if (changed > 0 || opts.autoUpdate) {
+            await writeSidecar(sidecarPath, doc);
+            written = true;
+        }
+    }
+    return { results, changed, written };
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Extract text from document lines at the given position.
+ * Lines array is 1-based (index 0 is unused), so lines[line] is the content.
+ */
+function extractText(lines, line, endLine, startColumn, endColumn) {
+    const startIdx = line; // 1-based array: lines[1] = first line
+    const endIdx = endLine ?? line;
+    if (startIdx < 1 || endIdx >= lines.length)
+        return null;
+    if (startIdx === endIdx) {
+        const text = lines[startIdx];
+        if (startColumn != null && endColumn != null) {
+            return text.slice(startColumn, endColumn);
+        }
+        return text;
+    }
+    // Multi-line
+    const result = [];
+    for (let i = startIdx; i <= endIdx; i++) {
+        let l = lines[i];
+        if (i === startIdx && startColumn != null)
+            l = l.slice(startColumn);
+        if (i === endIdx && endColumn != null)
+            l = l.slice(0, endColumn);
+        result.push(l);
+    }
+    return result.join("\n");
+}
+/**
+ * Pick the candidate closest to a hint line.
+ */
+function closestToLine(candidates, targetLine) {
+    return candidates.reduce((best, c) => Math.abs(c.line - targetLine) < Math.abs(best.line - targetLine) ? c : best);
+}
+//# sourceMappingURL=reanchor.js.map

package/dist/lib/resolve-files.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Shared helper for resolving CLI file arguments.
+ *
+ * When a user passes a Markdown document path (e.g. `docs/api.md`) instead of
+ * a sidecar path, we auto-discover the corresponding sidecar.  This avoids
+ * the confusing "Failed to parse YAML" error on raw Markdown files.
+ */
+/**
+ * Resolve a list of CLI file arguments to sidecar paths.
+ *
+ * - If `files` is empty, discover all sidecars from the workspace root.
+ * - If a file already looks like a sidecar (`.review.yaml`/`.review.json`),
+ *   resolve it to an absolute path.
+ * - If a file ends in `.md` (or any non-sidecar extension), treat it as a
+ *   document path and discover its sidecar via §3.3.
+ */
+export declare function resolveSidecarPaths(files: string[], cwd: string): Promise<string[]>;
+//# sourceMappingURL=resolve-files.d.ts.map

package/dist/lib/resolve-files.js

@@ -0,0 +1,42 @@
+/**
+ * Shared helper for resolving CLI file arguments.
+ *
+ * When a user passes a Markdown document path (e.g. `docs/api.md`) instead of
+ * a sidecar path, we auto-discover the corresponding sidecar.  This avoids
+ * the confusing "Failed to parse YAML" error on raw Markdown files.
+ */
+import path from "node:path";
+import { discoverSidecar, findWorkspaceRoot, discoverAllSidecars } from "../lib/discovery.js";
+const SIDECAR_EXTENSIONS = [".review.yaml", ".review.json"];
+function isSidecarPath(file) {
+    return SIDECAR_EXTENSIONS.some((ext) => file.endsWith(ext));
+}
+/**
+ * Resolve a list of CLI file arguments to sidecar paths.
+ *
+ * - If `files` is empty, discover all sidecars from the workspace root.
+ * - If a file already looks like a sidecar (`.review.yaml`/`.review.json`),
+ *   resolve it to an absolute path.
+ * - If a file ends in `.md` (or any non-sidecar extension), treat it as a
+ *   document path and discover its sidecar via §3.3.
+ */
+export async function resolveSidecarPaths(files, cwd) {
+    if (files.length === 0) {
+        const root = findWorkspaceRoot(cwd);
+        return discoverAllSidecars(root ?? cwd);
+    }
+    const resolved = [];
+    for (const f of files) {
+        const abs = path.resolve(cwd, f);
+        if (isSidecarPath(abs)) {
+            resolved.push(abs);
+        }
+        else {
+            // Treat as a document path → discover its sidecar
+            const sidecar = await discoverSidecar(abs, { cwd });
+            resolved.push(sidecar);
+        }
+    }
+    return resolved;
+}
+//# sourceMappingURL=resolve-files.js.map

package/dist/lib/types.d.ts

@@ -0,0 +1,151 @@
+/**
+ * MRSF Types — shared type definitions for the MRSF CLI and library.
+ */
+/** A parsed MRSF sidecar document. */
+export interface MrsfDocument {
+    mrsf_version: string;
+    document: string;
+    comments: Comment[];
+    /** Catch-all for unknown / x_-prefixed extension fields at the top level. */
+    [key: string]: unknown;
+}
+/** A single review comment. */
+export interface Comment {
+    id: string;
+    author: string;
+    timestamp: string;
+    text: string;
+    resolved: boolean;
+    line?: number;
+    end_line?: number;
+    start_column?: number;
+    end_column?: number;
+    selected_text?: string;
+    selected_text_hash?: string;
+    anchored_text?: string;
+    commit?: string;
+    type?: string;
+    severity?: "low" | "medium" | "high";
+    reply_to?: string;
+    /** Catch-all for unknown / x_-prefixed extension fields. */
+    [key: string]: unknown;
+}
+export interface MrsfConfig {
+    sidecar_root?: string;
+}
+export type DiagnosticSeverity = "error" | "warning";
+export interface ValidationDiagnostic {
+    severity: DiagnosticSeverity;
+    message: string;
+    /** Path within the document, e.g. "/comments/0/end_line". */
+    path?: string;
+    /** The comment id this diagnostic relates to, if applicable. */
+    commentId?: string;
+}
+export interface ValidationResult {
+    valid: boolean;
+    errors: ValidationDiagnostic[];
+    warnings: ValidationDiagnostic[];
+}
+export type ReanchorStatus = "anchored" | "shifted" | "fuzzy" | "ambiguous" | "orphaned";
+export interface ReanchorResult {
+    commentId: string;
+    status: ReanchorStatus;
+    /** Confidence score 0.0–1.0; 1.0 for exact/shifted. */
+    score: number;
+    /** Updated line (if changed). */
+    newLine?: number;
+    newEndLine?: number;
+    newStartColumn?: number;
+    newEndColumn?: number;
+    /** Text currently at the resolved anchor position (for anchored_text field). */
+    anchoredText?: string;
+    /** Previous selected_text before update (for audit / --update-text). */
+    previousSelectedText?: string;
+    /** Human-readable explanation of the resolution. */
+    reason: string;
+}
+export interface FuzzyCandidate {
+    /** Matched text in the document. */
+    text: string;
+    /** 1-based start line of the match. */
+    line: number;
+    /** 1-based end line (inclusive). */
+    endLine: number;
+    /** 0-based start column on the start line. */
+    startColumn: number;
+    /** 0-based end column on the end line. */
+    endColumn: number;
+    /** Similarity score 0.0–1.0. */
+    score: number;
+}
+export interface DiffHunk {
+    /** Original file start line (1-based). */
+    oldStart: number;
+    /** Number of lines in the original. */
+    oldCount: number;
+    /** New file start line (1-based). */
+    newStart: number;
+    /** Number of lines in the new file. */
+    newCount: number;
+    /** Raw diff lines (prefixed with +, -, or space). */
+    lines: string[];
+}
+export interface AddCommentOptions {
+    text: string;
+    author: string;
+    line?: number;
+    end_line?: number;
+    start_column?: number;
+    end_column?: number;
+    type?: string;
+    severity?: "low" | "medium" | "high";
+    commit?: string;
+    reply_to?: string;
+    /** Override auto-generated id. */
+    id?: string;
+    /** Override auto-generated timestamp. */
+    timestamp?: string;
+}
+export interface CommentFilter {
+    open?: boolean;
+    resolved?: boolean;
+    orphaned?: boolean;
+    author?: string;
+    type?: string;
+    severity?: "low" | "medium" | "high";
+}
+export type AnchorHealth = "fresh" | "stale" | "orphaned" | "unknown";
+export interface StatusResult {
+    commentId: string;
+    health: AnchorHealth;
+    commitAge?: string;
+    reason: string;
+}
+export interface BaseOptions {
+    /** Working directory (defaults to process.cwd()). */
+    cwd?: string;
+    /** Path to .mrsf.yaml config. */
+    configPath?: string;
+}
+export interface ReanchorOptions extends BaseOptions {
+    /** Dry run — report without modifying files. */
+    dryRun?: boolean;
+    /** Fuzzy match threshold 0.0–1.0 (default 0.6). */
+    threshold?: number;
+    /** Write updated anchors back to sidecar. */
+    autoUpdate?: boolean;
+    /** Only process sidecars for staged Markdown files. */
+    staged?: boolean;
+    /** Disable git integration. */
+    noGit?: boolean;
+    /** Override from-commit for all comments. */
+    fromCommit?: string;
+    /** Update selected_text to match anchored_text (opt-in per §6.2). */
+    updateText?: boolean;
+}
+export interface ValidateOptions extends BaseOptions {
+    /** Treat warnings as errors. */
+    strict?: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/types.js

@@ -0,0 +1,5 @@
+/**
+ * MRSF Types — shared type definitions for the MRSF CLI and library.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/lib/validator.d.ts

@@ -0,0 +1,13 @@
+/**
+ * MRSF Validator — JSON Schema + cross-field validation per §10.
+ */
+import type { MrsfDocument, ValidationResult, ValidateOptions } from "./types.js";
+/**
+ * Validate an MRSF document (parsed object).
+ */
+export declare function validate(doc: MrsfDocument, options?: ValidateOptions): Promise<ValidationResult>;
+/**
+ * Validate from a file path — convenience wrapper.
+ */
+export declare function validateFile(filePath: string, options?: ValidateOptions): Promise<ValidationResult>;
+//# sourceMappingURL=validator.d.ts.map