@mrsf/cli 0.4.3 → 0.5.0

package/dist/browser.cjs

@@ -0,0 +1,887 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/browser.ts
+var browser_exports = {};
+__export(browser_exports, {
+  DEFAULT_THRESHOLD: () => DEFAULT_THRESHOLD2,
+  HIGH_THRESHOLD: () => HIGH_THRESHOLD2,
+  applyReanchorResults: () => applyReanchorResults2,
+  combinedScore: () => combinedScore2,
+  exactMatch: () => exactMatch2,
+  formatAuthor: () => formatAuthor2,
+  fuzzySearch: () => fuzzySearch2,
+  levenshteinScore: () => levenshteinScore2,
+  mrsfSchema: () => mrsfSchema,
+  newCommentId: () => newCommentId2,
+  normalizedMatch: () => normalizedMatch2,
+  parseAuthor: () => parseAuthor2,
+  reanchorComment: () => reanchorComment2,
+  reanchorDocumentLines: () => reanchorDocumentLines2,
+  reanchorDocumentText: () => reanchorDocumentText2,
+  resolveAnchor: () => resolveAnchor2,
+  toReanchorLines: () => toReanchorLines2,
+  tokenLcsScore: () => tokenLcsScore2,
+  validateDocument: () => validateDocument2
+});
+module.exports = __toCommonJS(browser_exports);
+
+// src/lib/fuzzy.ts
+var import_fastest_levenshtein = require("fastest-levenshtein");
+function exactMatch(lines, needle) {
+  if (!needle) return [];
+  const results = [];
+  const needleLines = needle.split("\n");
+  const needleLineCount = needleLines.length;
+  for (let startLine = 1; startLine <= lines.length - needleLineCount; startLine++) {
+    const windowLines = lines.slice(startLine, startLine + needleLineCount);
+    const windowText = windowLines.join("\n");
+    if (needleLineCount === 1) {
+      let col = 0;
+      const line = windowLines[0];
+      while (col < line.length) {
+        const idx = line.indexOf(needle, col);
+        if (idx === -1) break;
+        results.push({
+          text: needle,
+          line: startLine,
+          endLine: startLine,
+          startColumn: idx,
+          endColumn: idx + needle.length,
+          score: 1
+        });
+        col = idx + 1;
+      }
+    } else {
+      const idx = windowText.indexOf(needle);
+      if (idx !== -1) {
+        const beforeMatch = windowText.slice(0, idx);
+        const linesBeforeEnd = beforeMatch.split("\n");
+        const startCol = linesBeforeEnd[linesBeforeEnd.length - 1].length;
+        const afterMatch = needle.split("\n");
+        const endCol = afterMatch[afterMatch.length - 1].length;
+        if (startCol === 0 || linesBeforeEnd.length === 1) {
+          results.push({
+            text: needle,
+            line: startLine + linesBeforeEnd.length - 1,
+            endLine: startLine + linesBeforeEnd.length - 1 + afterMatch.length - 1,
+            startColumn: startCol,
+            endColumn: endCol,
+            score: 1
+          });
+        }
+      }
+    }
+  }
+  return results;
+}
+function normalize(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function normalizedMatch(lines, needle) {
+  const normNeedle = normalize(needle);
+  if (!normNeedle) return [];
+  const results = [];
+  const needleLineEstimate = needle.split("\n").length;
+  const minWindow = Math.max(1, needleLineEstimate - 1);
+  const maxWindow = Math.min(lines.length - 1, needleLineEstimate + 2);
+  for (let winSize = minWindow; winSize <= maxWindow; winSize++) {
+    for (let startLine = 1; startLine + winSize - 1 < lines.length; startLine++) {
+      const windowLines = lines.slice(startLine, startLine + winSize);
+      const windowText = windowLines.join("\n");
+      const normWindow = normalize(windowText);
+      if (normWindow.includes(normNeedle)) {
+        results.push({
+          text: windowText,
+          line: startLine,
+          endLine: startLine + winSize - 1,
+          startColumn: 0,
+          endColumn: windowLines[windowLines.length - 1].length,
+          score: 0.95
+        });
+      }
+    }
+  }
+  return deduplicateCandidates(results);
+}
+function tokenize(text) {
+  return text.split(/\s+/).filter((t) => t.length > 0);
+}
+function lcsLength(a, b) {
+  const m = a.length;
+  const n = b.length;
+  let prev = new Array(n + 1).fill(0);
+  let curr = new Array(n + 1).fill(0);
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      if (a[i - 1] === b[j - 1]) {
+        curr[j] = prev[j - 1] + 1;
+      } else {
+        curr[j] = Math.max(prev[j], curr[j - 1]);
+      }
+    }
+    [prev, curr] = [curr, prev];
+    curr.fill(0);
+  }
+  return prev[n];
+}
+function tokenLcsScore(a, b) {
+  const tokA = tokenize(a);
+  const tokB = tokenize(b);
+  if (tokA.length === 0 && tokB.length === 0) return 1;
+  if (tokA.length === 0 || tokB.length === 0) return 0;
+  const lcs = lcsLength(tokA, tokB);
+  return lcs / Math.max(tokA.length, tokB.length);
+}
+function levenshteinScore(a, b) {
+  if (a.length === 0 && b.length === 0) return 1;
+  const maxLen = Math.max(a.length, b.length);
+  if (maxLen === 0) return 1;
+  const dist = (0, import_fastest_levenshtein.distance)(a, b);
+  return 1 - dist / maxLen;
+}
+function combinedScore(needle, candidate) {
+  const tScore = tokenLcsScore(needle, candidate);
+  let lScore;
+  if (needle.length < 500 && candidate.length < 500) {
+    lScore = levenshteinScore(needle, candidate);
+  } else {
+    lScore = tScore;
+  }
+  return tScore * 0.6 + lScore * 0.4;
+}
+function fuzzySearch(lines, needle, threshold = 0.6, hintLine) {
+  if (!needle) return [];
+  const needleLines = needle.split("\n");
+  const needleLineCount = needleLines.length;
+  const candidates = [];
+  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 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
+        });
+      }
+    }
+  }
+  if (needleLineCount === 1 && needle.length < 200) {
+    for (let lineNum = 1; lineNum < lines.length; lineNum++) {
+      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++) {
+        for (let col = 0; col + len <= line.length; col++) {
+          const sub = line.substring(col, col + len);
+          const score = combinedScore(needle, sub);
+          if (score >= threshold) {
+            candidates.push({
+              text: sub,
+              line: lineNum,
+              endLine: lineNum,
+              startColumn: col,
+              endColumn: col + len,
+              score
+            });
+          }
+        }
+      }
+    }
+  }
+  let deduped = deduplicateCandidates(candidates);
+  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) };
+    });
+  }
+  return deduped.sort((a, b) => b.score - a.score);
+}
+function deduplicateCandidates(candidates) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const c of candidates) {
+    const key = `${c.line}:${c.startColumn}:${c.endLine}:${c.endColumn}`;
+    const existing = seen.get(key);
+    if (!existing || c.score > existing.score) {
+      seen.set(key, c);
+    }
+  }
+  return Array.from(seen.values());
+}
+
+// src/lib/identity.ts
+var import_uuid = require("uuid");
+function formatAuthor(name, handle) {
+  const trimmedName = name.trim();
+  const trimmedHandle = handle?.trim();
+  return trimmedHandle ? `${trimmedName} (${trimmedHandle})` : trimmedName;
+}
+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 };
+}
+function newCommentId() {
+  return (0, import_uuid.v4)();
+}
+
+// src/lib/reanchor-core.ts
+var HIGH_THRESHOLD = 0.8;
+var DEFAULT_THRESHOLD = 0.6;
+function toReanchorLines(documentText) {
+  return ["", ...documentText.replace(/\r\n/g, "\n").split("\n")];
+}
+function reanchorComment(comment, documentLines, opts = {}) {
+  const threshold = opts.threshold ?? DEFAULT_THRESHOLD;
+  const commentId = comment.id;
+  const selectedText = comment.selected_text;
+  if (!selectedText && comment.line == null) {
+    return {
+      commentId,
+      status: "anchored",
+      score: 1,
+      reason: "Document-level comment (no anchor needed)."
+    };
+  }
+  if (comment.line != null && opts.diffHunks?.length) {
+    const { shift, modified } = getLineShift(opts.diffHunks, comment.line);
+    if (!selectedText) {
+      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;
+      return {
+        commentId,
+        status: shift === 0 ? "anchored" : "shifted",
+        score: 1,
+        newLine: shiftedLine,
+        newEndLine: shiftedEndLine,
+        reason: shift === 0 ? "Line-only comment unchanged (diff confirms position)." : `Line-only comment shifted by ${shift > 0 ? "+" : ""}${shift} line(s) via diff.`
+      };
+    }
+    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 : void 0;
+      const textAtShifted = extractText(
+        documentLines,
+        shiftedLine,
+        shiftedEndLine,
+        comment.start_column,
+        comment.end_column
+      );
+      if (textAtShifted === selectedText) {
+        return {
+          commentId,
+          status: shift === 0 ? "anchored" : "shifted",
+          score: 1,
+          newLine: shiftedLine,
+          newEndLine: shiftedEndLine,
+          reason: shift === 0 ? "Diff confirms text unchanged at original position." : `Diff shifted by ${shift > 0 ? "+" : ""}${shift} line(s).`
+        };
+      }
+    }
+  }
+  if (selectedText) {
+    const exactCandidates = exactMatch(documentLines, selectedText);
+    if (exactCandidates.length === 1) {
+      const candidate = exactCandidates[0];
+      return {
+        commentId,
+        status: "anchored",
+        score: 1,
+        newLine: candidate.line,
+        newEndLine: candidate.endLine,
+        newStartColumn: candidate.startColumn,
+        newEndColumn: candidate.endColumn,
+        reason: "Exact text match (unique)."
+      };
+    }
+    if (exactCandidates.length > 1 && comment.line != null) {
+      const best = closestToLine(exactCandidates, comment.line);
+      return {
+        commentId,
+        status: "anchored",
+        score: 1,
+        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}).`
+      };
+    }
+    const normCandidates = normalizedMatch(documentLines, selectedText);
+    if (normCandidates.length === 1) {
+      const candidate = normCandidates[0];
+      return {
+        commentId,
+        status: "fuzzy",
+        score: candidate.score,
+        newLine: candidate.line,
+        newEndLine: candidate.endLine,
+        newStartColumn: candidate.startColumn,
+        newEndColumn: candidate.endColumn,
+        anchoredText: candidate.text,
+        previousSelectedText: selectedText,
+        reason: "Normalized whitespace match."
+      };
+    }
+    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)}).`
+      };
+    }
+  }
+  if (comment.line != null) {
+    const lineIdx = comment.line;
+    if (lineIdx > 0 && lineIdx < documentLines.length) {
+      const qualifier = opts.commitIsStale ? " (commit is stale \u2014 line may have shifted)" : "";
+      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}.`
+          };
+        }
+      }
+      const isLineOnly = !selectedText;
+      return {
+        commentId,
+        status: isLineOnly ? "anchored" : opts.commitIsStale ? "ambiguous" : "anchored",
+        score: isLineOnly ? 1 : opts.commitIsStale ? 0.5 : 0.8,
+        newLine: comment.line,
+        newEndLine: comment.end_line,
+        reason: isLineOnly ? "Line-only comment (no selected_text to verify)." : `Line/column fallback${qualifier}.`
+      };
+    }
+  }
+  if (selectedText) {
+    const lowCandidates = fuzzySearch(
+      documentLines,
+      selectedText,
+      threshold,
+      comment.line
+    );
+    if (lowCandidates.length === 1) {
+      const candidate = lowCandidates[0];
+      return {
+        commentId,
+        status: "fuzzy",
+        score: candidate.score,
+        newLine: candidate.line,
+        newEndLine: candidate.endLine,
+        newStartColumn: candidate.startColumn,
+        newEndColumn: candidate.endColumn,
+        anchoredText: candidate.text,
+        previousSelectedText: selectedText,
+        reason: `Low-threshold fuzzy match (score ${candidate.score.toFixed(3)}).`
+      };
+    }
+    if (lowCandidates.length > 1) {
+      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)}).`
+      };
+    }
+  }
+  return {
+    commentId,
+    status: "orphaned",
+    score: 0,
+    reason: "No match found. Comment is orphaned."
+  };
+}
+function reanchorDocumentLines(doc, documentLines, opts = {}) {
+  return doc.comments.map((comment) => reanchorComment(comment, documentLines, opts));
+}
+function reanchorDocumentText(doc, documentText, opts = {}) {
+  return reanchorDocumentLines(doc, toReanchorLines(documentText), opts);
+}
+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));
+}
+function applyReanchorResults(doc, results, opts = {}) {
+  let changed = 0;
+  const resultMap = new Map(results.map((result) => [result.commentId, result]));
+  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;
+    }
+    if (result.anchoredText != null && result.anchoredText !== comment.selected_text) {
+      if (opts.updateText) {
+        comment.selected_text = result.anchoredText;
+        delete comment.anchored_text;
+      } else {
+        comment.anchored_text = result.anchoredText;
+      }
+      isChanged = true;
+    } else if (result.anchoredText != null && result.anchoredText === comment.selected_text) {
+      if (comment.anchored_text) {
+        delete comment.anchored_text;
+        isChanged = true;
+      }
+    }
+    if (isChanged || result.status !== "anchored") {
+      comment.x_reanchor_status = result.status;
+      comment.x_reanchor_score = result.score;
+    }
+    if (opts.force && opts.headCommit && (result.status === "anchored" || result.status === "shifted") && result.score >= HIGH_THRESHOLD) {
+      comment.commit = opts.headCommit;
+      delete comment.x_reanchor_status;
+      delete comment.x_reanchor_score;
+      if (comment.anchored_text && comment.anchored_text === comment.selected_text) {
+        delete comment.anchored_text;
+      }
+      isChanged = true;
+    }
+    if (isChanged) {
+      changed += 1;
+    }
+  }
+  return changed;
+}
+function extractText(lines, line, endLine, startColumn, endColumn) {
+  const startIdx = 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;
+  }
+  const result = [];
+  for (let index = startIdx; index <= endIdx; index += 1) {
+    let currentLine = lines[index];
+    if (index === startIdx && startColumn != null) currentLine = currentLine.slice(startColumn);
+    if (index === endIdx && endColumn != null) currentLine = currentLine.slice(0, endColumn);
+    result.push(currentLine);
+  }
+  return result.join("\n");
+}
+function closestToLine(candidates, targetLine) {
+  return candidates.reduce(
+    (best, candidate) => Math.abs(candidate.line - targetLine) < Math.abs(best.line - targetLine) ? candidate : best
+  );
+}
+function getLineShift(diffHunks, line) {
+  let shift = 0;
+  let modified = false;
+  for (const hunk of diffHunks) {
+    const oldStart = hunk.oldStart;
+    const oldEnd = hunk.oldStart + Math.max(hunk.oldCount, 1) - 1;
+    if (line >= oldStart && line <= oldEnd && hunk.oldCount > 0) {
+      modified = true;
+    }
+    if (line > oldEnd || hunk.oldCount === 0 && line >= oldStart) {
+      shift += hunk.newCount - hunk.oldCount;
+    }
+  }
+  return { shift, modified };
+}
+
+// src/lib/validate-core.ts
+var import_ajv = __toESM(require("ajv"), 1);
+var import_ajv_formats = __toESM(require("ajv-formats"), 1);
+
+// mrsf.schema.json
+var mrsf_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://github.com/wictorwilen/MRSF/raw/main/mrsf.schema.json",
+  title: "Markdown Review Sidecar Format (MRSF) v1.0",
+  description: "Schema for MRSF review sidecar files. See MRSF-v1.0.md for the full specification.",
+  type: "object",
+  required: ["mrsf_version", "document", "comments"],
+  additionalProperties: true,
+  properties: {
+    mrsf_version: {
+      type: "string",
+      pattern: "^1\\.\\d+$",
+      description: "MRSF format version. MUST be a supported major.minor version (e.g., 1.0)."
+    },
+    document: {
+      type: "string",
+      description: "Relative path to the Markdown document being reviewed."
+    },
+    comments: {
+      type: "array",
+      items: {
+        type: "object",
+        required: ["id", "author", "timestamp", "text", "resolved"],
+        additionalProperties: true,
+        properties: {
+          id: {
+            type: "string",
+            description: "Globally unique, opaque, collision-resistant identifier for the comment."
+          },
+          author: {
+            type: "string",
+            description: "Creator of the comment. SHOULD follow the convention 'Display Name (identifier)'."
+          },
+          timestamp: {
+            type: "string",
+            format: "date-time",
+            description: "ISO 8601 / RFC 3339 timestamp of comment creation; SHOULD include timezone offset."
+          },
+          text: {
+            type: "string",
+            maxLength: 16384,
+            description: "The content of the review comment. MUST be plain text."
+          },
+          resolved: {
+            type: "boolean",
+            description: "Whether the comment has been resolved."
+          },
+          commit: {
+            type: "string",
+            description: "Git commit hash associated with the comment. SHOULD be the full (long) SHA."
+          },
+          type: {
+            type: "string",
+            description: "Categorization of the comment. Recommended values listed in examples.",
+            examples: [
+              "suggestion",
+              "issue",
+              "question",
+              "accuracy",
+              "style",
+              "clarity"
+            ]
+          },
+          severity: {
+            type: "string",
+            description: "Importance level of the comment.",
+            enum: ["low", "medium", "high"]
+          },
+          reply_to: {
+            type: "string",
+            description: "ID of another comment in the same file that this comment replies to."
+          },
+          line: {
+            type: "integer",
+            minimum: 1,
+            description: "Starting line number (1-based) in the target document."
+          },
+          end_line: {
+            type: "integer",
+            minimum: 1,
+            description: "Ending line number (inclusive, 1-based). MUST be >= line."
+          },
+          start_column: {
+            type: "integer",
+            minimum: 0,
+            description: "Starting column index (0-based) within the starting line."
+          },
+          end_column: {
+            type: "integer",
+            minimum: 0,
+            description: "Ending column index. MUST be >= start_column when on the same line."
+          },
+          selected_text: {
+            type: "string",
+            maxLength: 4096,
+            description: "Exact text selected by the reviewer. SHOULD NOT be modified by re-anchoring tools. SHOULD NOT exceed 4096 characters."
+          },
+          anchored_text: {
+            type: "string",
+            maxLength: 4096,
+            description: "Text currently found at the resolved anchor position. Populated by re-anchoring tools when the document text differs from selected_text. SHOULD be omitted when identical to selected_text."
+          },
+          selected_text_hash: {
+            type: "string",
+            pattern: "^[a-f0-9]{64}$",
+            description: "Hex-encoded SHA-256 hash of selected_text. Immutable after creation; used for fast exact-match detection during re-anchoring, integrity verification, and staleness checks. SHOULD NOT be modified by re-anchoring tools unless selected_text is also replaced (opt-in behaviour), in which case it MUST be recomputed."
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/lib/schema.ts
+var mrsfSchema = mrsf_schema_default;
+
+// src/lib/validate-core.ts
+var Ajv = import_ajv.default.default ?? import_ajv.default;
+var addFormats = import_ajv_formats.default.default ?? import_ajv_formats.default;
+function validateDocument(doc, schema = mrsfSchema) {
+  const errors = [];
+  const warnings = [];
+  validateSchema(doc, schema, errors);
+  validateCrossFields(doc, errors, warnings);
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+function validateSchema(doc, rawSchema, errors) {
+  const { $schema, ...schema } = rawSchema;
+  void $schema;
+  const ajv = new Ajv({ allErrors: true, strict: false });
+  addFormats(ajv);
+  const ajvValidate = ajv.compile(schema);
+  const schemaValid = ajvValidate(doc);
+  if (!schemaValid && ajvValidate.errors) {
+    for (const err of ajvValidate.errors) {
+      errors.push({
+        severity: "error",
+        code: "schema-violation",
+        message: `${err.instancePath || "/"}: ${err.message ?? "schema error"}`,
+        path: err.instancePath || "/"
+      });
+    }
+  }
+}
+function validateCrossFields(doc, errors, warnings, hash) {
+  if (!Array.isArray(doc.comments)) return;
+  const ids = /* @__PURE__ */ new Set();
+  const allIds = doc.comments.map((x) => x.id);
+  for (let i = 0; i < doc.comments.length; i++) {
+    const c = doc.comments[i];
+    const prefix = `/comments/${i}`;
+    if (c.id) {
+      if (ids.has(c.id)) {
+        errors.push({
+          severity: "error",
+          code: "duplicate-id",
+          message: `Duplicate comment id "${c.id}"`,
+          path: `${prefix}/id`,
+          commentId: c.id
+        });
+      }
+      ids.add(c.id);
+    }
+    if (c.line != null && c.end_line != null && c.end_line < c.line) {
+      errors.push({
+        severity: "error",
+        code: "end-line-before-line",
+        message: `end_line (${c.end_line}) must be \u2265 line (${c.line})`,
+        path: `${prefix}/end_line`,
+        commentId: c.id
+      });
+    }
+    if (c.start_column != null && c.end_column != null && (c.line == null || c.end_line == null || c.line === c.end_line) && c.end_column < c.start_column) {
+      errors.push({
+        severity: "error",
+        code: "end-column-before-start-column",
+        message: `end_column (${c.end_column}) must be \u2265 start_column (${c.start_column}) on the same line`,
+        path: `${prefix}/end_column`,
+        commentId: c.id
+      });
+    }
+    if (c.selected_text && c.selected_text.length > 4096) {
+      errors.push({
+        severity: "error",
+        code: "selected-text-too-long",
+        message: `selected_text exceeds 4096 characters (${c.selected_text.length})`,
+        path: `${prefix}/selected_text`,
+        commentId: c.id
+      });
+    }
+    if (c.text && c.text.length > 16384) {
+      warnings.push({
+        severity: "warning",
+        code: "text-too-long",
+        message: `text exceeds recommended 16384 characters (${c.text.length})`,
+        path: `${prefix}/text`,
+        commentId: c.id
+      });
+    }
+    if (hash && c.selected_text && c.selected_text_hash) {
+      const expected = hash(c.selected_text);
+      if (c.selected_text_hash !== expected) {
+        warnings.push({
+          severity: "warning",
+          code: "hash-mismatch",
+          message: `selected_text_hash mismatch (expected ${expected.slice(0, 12)}\u2026, got ${c.selected_text_hash.slice(0, 12)}\u2026)`,
+          path: `${prefix}/selected_text_hash`,
+          commentId: c.id
+        });
+      }
+    }
+    if (c.reply_to && !ids.has(c.reply_to) && !allIds.includes(c.reply_to)) {
+      warnings.push({
+        severity: "warning",
+        code: "unresolved-reply-to",
+        message: `reply_to "${c.reply_to}" does not resolve to any comment id in this file`,
+        path: `${prefix}/reply_to`,
+        commentId: c.id
+      });
+    }
+    if (c.line != null && !c.selected_text) {
+      warnings.push({
+        severity: "warning",
+        code: "missing-selected-text",
+        message: "Comment has line anchors but no selected_text \u2014 anchoring will be fragile across edits",
+        path: `${prefix}/selected_text`,
+        commentId: c.id
+      });
+    }
+  }
+}
+
+// src/browser.ts
+var combinedScore2 = combinedScore;
+var exactMatch2 = exactMatch;
+var fuzzySearch2 = fuzzySearch;
+var levenshteinScore2 = levenshteinScore;
+var normalizedMatch2 = normalizedMatch;
+var tokenLcsScore2 = tokenLcsScore;
+var applyReanchorResults2 = applyReanchorResults;
+var DEFAULT_THRESHOLD2 = DEFAULT_THRESHOLD;
+var HIGH_THRESHOLD2 = HIGH_THRESHOLD;
+var reanchorComment2 = reanchorComment;
+var reanchorDocumentLines2 = reanchorDocumentLines;
+var reanchorDocumentText2 = reanchorDocumentText;
+var resolveAnchor2 = resolveAnchor;
+var toReanchorLines2 = toReanchorLines;
+var validateDocument2 = validateDocument;
+var formatAuthor2 = formatAuthor;
+var parseAuthor2 = parseAuthor;
+var newCommentId2 = newCommentId;
+//# sourceMappingURL=browser.cjs.map