@mrsf/cli 0.6.0 → 0.7.0

package/dist/evaluation/generate-reanchor-cases.d.ts

@@ -0,0 +1,10 @@
+import type { EvaluationCase } from "./reanchor-eval.js";
+export interface GenerateCasesOptions {
+    seed: number;
+    caseCount?: number;
+    blocksPerCase?: number;
+    commentsPerCase?: number;
+    mutationsPerCase?: number;
+}
+export declare function generateEvaluationCases(options: GenerateCasesOptions): EvaluationCase[];
+//# sourceMappingURL=generate-reanchor-cases.d.ts.map

package/dist/evaluation/generate-reanchor-cases.js

@@ -0,0 +1,301 @@
+const MUTATION_TYPES = [
+    "insert-block",
+    "delete-block",
+    "move-block",
+    "rewrite-block",
+    "duplicate-block",
+    "swap-blocks",
+    "whitespace-block",
+    "split-block",
+    "merge-blocks",
+    "rename-heading",
+];
+export function generateEvaluationCases(options) {
+    const caseCount = positiveInteger(options.caseCount ?? 10, "caseCount");
+    const blocksPerCase = positiveInteger(options.blocksPerCase ?? 12, "blocksPerCase");
+    const commentsPerCase = positiveInteger(options.commentsPerCase ?? 4, "commentsPerCase");
+    const mutationsPerCase = positiveInteger(options.mutationsPerCase ?? 5, "mutationsPerCase");
+    const seed = unsignedSeed(options.seed);
+    return Array.from({ length: caseCount }, (_, index) => generateCase({
+        seed: (seed + index) >>> 0,
+        blocksPerCase,
+        commentsPerCase,
+        mutationsPerCase,
+    }));
+}
+function generateCase(options) {
+    const random = new SeededRandom(options.seed);
+    const sourceBlocks = createSourceBlocks(options.seed, options.blocksPerCase);
+    const source = renderBlocks(sourceBlocks);
+    const trackedComments = selectComments(sourceBlocks, source, options.commentsPerCase, random);
+    const targetBlocks = sourceBlocks.map((block) => ({ ...block }));
+    const operations = [];
+    let nextBlockNumber = sourceBlocks.length + 1;
+    for (let index = 0; index < options.mutationsPerCase; index += 1) {
+        const preferredType = random.pick(MUTATION_TYPES);
+        const operation = applyMutation(preferredType, targetBlocks, trackedComments, random, () => `generated-${options.seed}-block-${nextBlockNumber++}`);
+        operations.push(operation);
+    }
+    const target = renderBlocks(targetBlocks);
+    const comments = trackedComments.map((comment) => createEvaluationComment(comment, targetBlocks, target));
+    const categories = [
+        "generated",
+        ...new Set(operations.map((operation) => operation.type)),
+    ];
+    return {
+        id: `generated-${options.seed}`,
+        description: `Seeded mutation case ${options.seed} with ${operations.length} operations.`,
+        categories,
+        source: { text: source.text },
+        target: { text: target.text },
+        generation: {
+            generator_version: 1,
+            seed: options.seed,
+            blocks_per_case: options.blocksPerCase,
+            comments_per_case: Math.min(options.commentsPerCase, options.blocksPerCase),
+            operations,
+        },
+        comments,
+    };
+}
+function createSourceBlocks(seed, count) {
+    return Array.from({ length: count }, (_, index) => {
+        const number = index + 1;
+        return {
+            id: `generated-${seed}-block-${number}`,
+            text: number % 4 === 1
+                ? `## Section ${number} for seed ${seed}`
+                : `Paragraph ${number} describes behavior token-${seed}-${number}.`,
+        };
+    });
+}
+function selectComments(blocks, rendered, requestedCount, random) {
+    const available = blocks.map((_, index) => index);
+    random.shuffle(available);
+    return available
+        .slice(0, Math.min(requestedCount, blocks.length))
+        .sort((left, right) => left - right)
+        .map((blockIndex, commentIndex) => {
+        const block = blocks[blockIndex];
+        const range = rendered.ranges.get(block.id);
+        if (!range)
+            throw new Error(`Missing source range for ${block.id}.`);
+        return {
+            id: `generated-comment-${commentIndex + 1}`,
+            sourceLine: range.line,
+            selectedText: block.text,
+            targetBlockId: block.id,
+        };
+    });
+}
+function applyMutation(preferredType, blocks, comments, random, nextBlockId) {
+    if (preferredType === "insert-block") {
+        const id = nextBlockId();
+        const position = random.nextInt(blocks.length + 1);
+        blocks.splice(position, 0, {
+            id,
+            text: `Inserted paragraph ${id} describes new material.`,
+        });
+        return { type: "insert-block", block_ids: [id] };
+    }
+    if (preferredType === "delete-block" && blocks.length > 1) {
+        const index = random.nextInt(blocks.length);
+        const [removed] = blocks.splice(index, 1);
+        for (const comment of comments) {
+            if (comment.targetBlockId === removed.id) {
+                delete comment.targetBlockId;
+            }
+        }
+        return { type: "delete-block", block_ids: [removed.id] };
+    }
+    if (preferredType === "move-block" && blocks.length > 1) {
+        const from = random.nextInt(blocks.length);
+        let to = random.nextInt(blocks.length);
+        if (to === from)
+            to = (to + 1) % blocks.length;
+        const [moved] = blocks.splice(from, 1);
+        blocks.splice(to, 0, moved);
+        return { type: "move-block", block_ids: [moved.id] };
+    }
+    if (preferredType === "rewrite-block") {
+        const block = random.pick(blocks);
+        block.text = rewriteFirstWord(block.text);
+        return { type: "rewrite-block", block_ids: [block.id] };
+    }
+    if (preferredType === "duplicate-block") {
+        const source = random.pick(blocks);
+        const duplicateId = nextBlockId();
+        const sourceIndex = blocks.indexOf(source);
+        blocks.splice(sourceIndex + 1, 0, {
+            id: duplicateId,
+            text: source.text,
+        });
+        return {
+            type: "duplicate-block",
+            block_ids: [source.id, duplicateId],
+        };
+    }
+    if (preferredType === "swap-blocks" && blocks.length > 1) {
+        const first = random.nextInt(blocks.length);
+        let second = random.nextInt(blocks.length);
+        if (first === second)
+            second = (second + 1) % blocks.length;
+        [blocks[first], blocks[second]] = [blocks[second], blocks[first]];
+        return {
+            type: "swap-blocks",
+            block_ids: [blocks[second].id, blocks[first].id],
+        };
+    }
+    if (preferredType === "whitespace-block") {
+        const block = random.pick(blocks);
+        block.text = block.text.replace(/ /g, "  ");
+        return { type: "whitespace-block", block_ids: [block.id] };
+    }
+    if (preferredType === "split-block") {
+        const candidates = blocks.filter((block) => block.text.includes(" "));
+        const block = random.pick(candidates.length > 0 ? candidates : blocks);
+        const splitAt = splitPosition(block.text);
+        block.text = `${block.text.slice(0, splitAt)}\n\n${block.text.slice(splitAt + 1)}`;
+        return { type: "split-block", block_ids: [block.id] };
+    }
+    if (preferredType === "merge-blocks" && blocks.length > 1) {
+        const firstIndex = random.nextInt(blocks.length - 1);
+        const first = blocks[firstIndex];
+        const [second] = blocks.splice(firstIndex + 1, 1);
+        first.text = `${first.text} ${second.text}`;
+        for (const comment of comments) {
+            if (comment.targetBlockId === second.id) {
+                comment.targetBlockId = first.id;
+            }
+        }
+        return { type: "merge-blocks", block_ids: [first.id, second.id] };
+    }
+    if (preferredType === "rename-heading") {
+        const headings = blocks.filter((block) => block.text.startsWith("#"));
+        if (headings.length > 0) {
+            const heading = random.pick(headings);
+            heading.text = heading.text.replace("Section", "Topic");
+            return { type: "rename-heading", block_ids: [heading.id] };
+        }
+    }
+    return applyMutation("insert-block", blocks, comments, random, nextBlockId);
+}
+function createEvaluationComment(tracked, targetBlocks, target) {
+    if (!tracked.targetBlockId) {
+        return {
+            id: tracked.id,
+            anchor: {
+                line: tracked.sourceLine,
+                selected_text: tracked.selectedText,
+            },
+            expected: {
+                status: "orphaned",
+                rationale: "The semantic source block was deleted.",
+            },
+        };
+    }
+    const targetBlock = targetBlocks.find((block) => block.id === tracked.targetBlockId);
+    const blockRange = target.ranges.get(tracked.targetBlockId);
+    if (!targetBlock || !blockRange) {
+        throw new Error(`Missing target block ${tracked.targetBlockId}.`);
+    }
+    const exactIndex = targetBlock.text.indexOf(tracked.selectedText);
+    const exact = exactIndex >= 0;
+    const range = exact
+        ? exactRangeWithinBlock(blockRange.line, targetBlock.text, tracked.selectedText, exactIndex)
+        : blockRange;
+    return {
+        id: tracked.id,
+        anchor: {
+            line: tracked.sourceLine,
+            selected_text: tracked.selectedText,
+        },
+        expected: {
+            status: exact ? "anchored" : "fuzzy",
+            ranges: [range],
+            rationale: exact
+                ? "The original selection remains inside its semantic block."
+                : "The semantic block remains but its selected text changed.",
+        },
+    };
+}
+function exactRangeWithinBlock(blockLine, blockText, selectedText, index) {
+    const linesBefore = blockText.slice(0, index).split("\n").length - 1;
+    const selectedLines = selectedText.split("\n").length;
+    const line = blockLine + linesBefore;
+    return {
+        line,
+        end_line: line + selectedLines - 1,
+    };
+}
+function renderBlocks(blocks) {
+    const ranges = new Map();
+    let line = 1;
+    for (const block of blocks) {
+        const lineCount = block.text.split("\n").length;
+        ranges.set(block.id, {
+            line,
+            end_line: line + lineCount - 1,
+        });
+        line += lineCount + 1;
+    }
+    return {
+        text: `${blocks.map((block) => block.text).join("\n\n")}\n`,
+        ranges,
+    };
+}
+function rewriteFirstWord(text) {
+    return text.replace(/^(\W*)([\p{L}\p{N}]+)/u, "$1$2-revised");
+}
+function splitPosition(text) {
+    const midpoint = Math.floor(text.length / 2);
+    const after = text.indexOf(" ", midpoint);
+    if (after >= 0)
+        return after;
+    const before = text.lastIndexOf(" ", midpoint);
+    return before >= 0 ? before : midpoint;
+}
+function positiveInteger(value, name) {
+    if (!Number.isSafeInteger(value) || value < 1) {
+        throw new Error(`${name} must be a positive integer.`);
+    }
+    return value;
+}
+function unsignedSeed(value) {
+    if (!Number.isSafeInteger(value) || value < 0 || value > 0xffffffff) {
+        throw new Error("seed must be an integer between 0 and 4294967295.");
+    }
+    return value >>> 0;
+}
+class SeededRandom {
+    state;
+    constructor(seed) {
+        this.state = seed === 0 ? 0x9e3779b9 : seed >>> 0;
+    }
+    nextInt(maxExclusive) {
+        if (!Number.isSafeInteger(maxExclusive) || maxExclusive < 1) {
+            throw new Error("Random upper bound must be a positive integer.");
+        }
+        return Math.floor(this.next() * maxExclusive);
+    }
+    pick(values) {
+        if (values.length === 0)
+            throw new Error("Cannot pick from an empty array.");
+        return values[this.nextInt(values.length)];
+    }
+    shuffle(values) {
+        for (let index = values.length - 1; index > 0; index -= 1) {
+            const other = this.nextInt(index + 1);
+            [values[index], values[other]] = [values[other], values[index]];
+        }
+    }
+    next() {
+        let value = this.state;
+        value ^= value << 13;
+        value ^= value >>> 17;
+        value ^= value << 5;
+        this.state = value >>> 0;
+        return this.state / 0x100000000;
+    }
+}
+//# sourceMappingURL=generate-reanchor-cases.js.map

package/dist/evaluation/reanchor-eval.d.ts

@@ -0,0 +1,111 @@
+import type { ReanchorResult, ReanchorStatus } from "../lib/types.js";
+export interface EvaluationDocument {
+    text?: string;
+    path?: string;
+}
+export interface EvaluationAnchor {
+    line?: number;
+    end_line?: number;
+    start_column?: number;
+    end_column?: number;
+    selected_text?: string;
+    selected_text_hash?: string;
+    commit?: string;
+}
+export interface EvaluationRange {
+    line: number;
+    end_line?: number;
+    start_column?: number;
+    end_column?: number;
+}
+export interface EvaluationExpectation {
+    status: ReanchorStatus;
+    ranges?: EvaluationRange[];
+    rationale?: string;
+}
+export interface EvaluationComment {
+    id: string;
+    anchor: EvaluationAnchor;
+    expected: EvaluationExpectation;
+}
+export interface EvaluationCase {
+    id: string;
+    description?: string;
+    categories: string[];
+    source: EvaluationDocument;
+    target: EvaluationDocument;
+    generation?: EvaluationGeneration;
+    comments: EvaluationComment[];
+}
+export interface EvaluationGeneration {
+    generator_version: 1;
+    seed: number;
+    blocks_per_case: number;
+    comments_per_case: number;
+    operations: EvaluationMutation[];
+}
+export interface EvaluationMutation {
+    type: "insert-block" | "delete-block" | "move-block" | "rewrite-block" | "duplicate-block" | "swap-blocks" | "whitespace-block" | "split-block" | "merge-blocks" | "rename-heading";
+    block_ids: string[];
+}
+export interface EvaluationCommentResult {
+    caseId: string;
+    commentId: string;
+    expected: EvaluationExpectation;
+    actual: ReanchorResult;
+    statusCorrect: boolean;
+    rangeCorrect: boolean;
+    passed: boolean;
+    durationMs: number;
+}
+export interface EvaluationSummary {
+    algorithm: string;
+    cases: number;
+    comments: number;
+    passed: number;
+    failed: number;
+    exactRangeMatches: number;
+    statusMatches: number;
+    incorrectConfidentRelocations: number;
+    durationMs: number;
+    timingMs: {
+        median: number;
+        p95: number;
+        max: number;
+        perComment: number;
+        reconciliationMax: number;
+    };
+    results: EvaluationCommentResult[];
+}
+export interface EvaluationBaseline {
+    version: 1;
+    algorithm: string;
+    cases: number;
+    comments: number;
+    metrics: {
+        passed: number;
+        failed: number;
+        exactRangeMatches: number;
+        statusMatches: number;
+        incorrectConfidentRelocations: number;
+    };
+    results: EvaluationBaselineResult[];
+}
+export interface EvaluationBaselineResult {
+    caseId: string;
+    commentId: string;
+    expectedStatus: ReanchorStatus;
+    actual: ReanchorResult;
+    statusCorrect: boolean;
+    rangeCorrect: boolean;
+    passed: boolean;
+}
+export interface LoadedEvaluationCase {
+    casePath: string;
+    value: EvaluationCase;
+}
+export declare function loadEvaluationCases(casesPath: string, schemaPath: string): Promise<LoadedEvaluationCase[]>;
+export declare function evaluateCases(cases: LoadedEvaluationCase[]): Promise<EvaluationSummary>;
+export declare function createEvaluationBaseline(summary: EvaluationSummary): EvaluationBaseline;
+export declare function findBaselineDifferences(expected: EvaluationBaseline, actual: EvaluationBaseline): string[];
+//# sourceMappingURL=reanchor-eval.d.ts.map

package/dist/evaluation/reanchor-eval.js

@@ -0,0 +1,266 @@
+import Ajv2020Module from "ajv/dist/2020.js";
+import { readFile, readdir } from "node:fs/promises";
+import path from "node:path";
+import { performance } from "node:perf_hooks";
+import { reanchorComment, toReanchorLines } from "../lib/reanchor-core.js";
+import { createRevisionProjection } from "../lib/revision-projection.js";
+import { createAnchorContextIndex } from "../lib/anchor-context.js";
+import { createFuzzySearchIndex, } from "../lib/fuzzy.js";
+import { reconcileCommentAnchors } from "../lib/global-reconciliation.js";
+const Ajv2020 = Ajv2020Module;
+export async function loadEvaluationCases(casesPath, schemaPath) {
+    const schema = JSON.parse(await readFile(schemaPath, "utf8"));
+    const validator = new Ajv2020({
+        allErrors: true,
+        strict: true,
+        strictRequired: false,
+    }).compile(schema);
+    const files = await findJsonFiles(casesPath);
+    const loaded = [];
+    const caseIds = new Set();
+    for (const casePath of files) {
+        const parsed = JSON.parse(await readFile(casePath, "utf8"));
+        const values = Array.isArray(parsed) ? parsed : [parsed];
+        for (const [index, value] of values.entries()) {
+            const location = values.length === 1 ? casePath : `${casePath}[${index}]`;
+            assertValidCase(validator, value, location);
+            if (caseIds.has(value.id)) {
+                throw new Error(`Duplicate evaluation case id "${value.id}" in ${location}.`);
+            }
+            caseIds.add(value.id);
+            loaded.push({ casePath, value });
+        }
+    }
+    if (loaded.length === 0) {
+        throw new Error(`No evaluation cases found in ${casesPath}.`);
+    }
+    return loaded;
+}
+export async function evaluateCases(cases) {
+    const startedAt = performance.now();
+    const results = [];
+    const reconciliationTimings = [];
+    for (const loadedCase of cases) {
+        const sourceText = await readEvaluationDocument(loadedCase.value.source, loadedCase.casePath);
+        validateSourceSelections(loadedCase.value, sourceText);
+        const targetText = await readEvaluationDocument(loadedCase.value.target, loadedCase.casePath);
+        const sourceLines = toReanchorLines(sourceText);
+        const documentLines = toReanchorLines(targetText);
+        const revisionProjection = createRevisionProjection(sourceLines, documentLines);
+        const anchorContext = createAnchorContextIndex(sourceLines, documentLines);
+        let fuzzySearchIndex;
+        const getFuzzySearchIndex = () => {
+            fuzzySearchIndex ??= createFuzzySearchIndex(documentLines);
+            return fuzzySearchIndex;
+        };
+        const caseComments = [];
+        const caseResults = [];
+        for (const evaluationComment of loadedCase.value.comments) {
+            const comment = toComment(evaluationComment);
+            const commentStartedAt = performance.now();
+            const actual = reanchorComment(comment, documentLines, {
+                revisionProjection,
+                anchorContext,
+                getFuzzySearchIndex,
+            });
+            const durationMs = performance.now() - commentStartedAt;
+            caseComments.push(comment);
+            caseResults.push({
+                evaluationComment,
+                comment,
+                actual,
+                durationMs,
+            });
+        }
+        const reconciliationStartedAt = performance.now();
+        const reconciled = reconcileCommentAnchors(caseComments, caseResults.map((result) => result.actual), anchorContext);
+        reconciliationTimings.push(performance.now() - reconciliationStartedAt);
+        for (const [index, caseResult] of caseResults.entries()) {
+            const { evaluationComment, comment, durationMs, } = caseResult;
+            const actual = reconciled[index];
+            const statusCorrect = actual.status === evaluationComment.expected.status;
+            const rangeCorrect = matchesExpectedRange(actual, comment, evaluationComment.expected.ranges);
+            results.push({
+                caseId: loadedCase.value.id,
+                commentId: evaluationComment.id,
+                expected: evaluationComment.expected,
+                actual,
+                statusCorrect,
+                rangeCorrect,
+                passed: statusCorrect && rangeCorrect,
+                durationMs,
+            });
+        }
+    }
+    const durationMs = performance.now() - startedAt;
+    const timings = results
+        .map((result) => result.durationMs)
+        .sort((left, right) => left - right);
+    return {
+        algorithm: "baseline",
+        cases: cases.length,
+        comments: results.length,
+        passed: results.filter((result) => result.passed).length,
+        failed: results.filter((result) => !result.passed).length,
+        exactRangeMatches: results.filter((result) => result.rangeCorrect).length,
+        statusMatches: results.filter((result) => result.statusCorrect).length,
+        incorrectConfidentRelocations: results.filter((result) => (result.actual.status === "anchored" || result.actual.status === "shifted")
+            && (result.expected.ranges?.length
+                ? !result.rangeCorrect
+                : result.expected.status === "ambiguous"
+                    || result.expected.status === "orphaned")).length,
+        durationMs,
+        timingMs: {
+            median: percentile(timings, 0.5),
+            p95: percentile(timings, 0.95),
+            max: timings.at(-1) ?? 0,
+            perComment: results.length > 0 ? durationMs / results.length : 0,
+            reconciliationMax: Math.max(0, ...reconciliationTimings),
+        },
+        results,
+    };
+}
+function percentile(sortedValues, quantile) {
+    if (sortedValues.length === 0)
+        return 0;
+    const index = Math.max(0, Math.ceil(sortedValues.length * quantile) - 1);
+    return sortedValues[index];
+}
+export function createEvaluationBaseline(summary) {
+    return {
+        version: 1,
+        algorithm: summary.algorithm,
+        cases: summary.cases,
+        comments: summary.comments,
+        metrics: {
+            passed: summary.passed,
+            failed: summary.failed,
+            exactRangeMatches: summary.exactRangeMatches,
+            statusMatches: summary.statusMatches,
+            incorrectConfidentRelocations: summary.incorrectConfidentRelocations,
+        },
+        results: summary.results.map((result) => ({
+            caseId: result.caseId,
+            commentId: result.commentId,
+            expectedStatus: result.expected.status,
+            actual: result.actual,
+            statusCorrect: result.statusCorrect,
+            rangeCorrect: result.rangeCorrect,
+            passed: result.passed,
+        })),
+    };
+}
+export function findBaselineDifferences(expected, actual) {
+    const differences = [];
+    if (expected.version !== actual.version) {
+        differences.push(`Baseline version changed from ${expected.version} to ${actual.version}.`);
+    }
+    if (expected.algorithm !== actual.algorithm) {
+        differences.push(`Algorithm changed from ${expected.algorithm} to ${actual.algorithm}.`);
+    }
+    const expectedHeader = {
+        cases: expected.cases,
+        comments: expected.comments,
+        metrics: expected.metrics,
+    };
+    const actualHeader = {
+        cases: actual.cases,
+        comments: actual.comments,
+        metrics: actual.metrics,
+    };
+    if (JSON.stringify(expectedHeader) !== JSON.stringify(actualHeader)) {
+        differences.push(`Summary changed: expected ${JSON.stringify(expectedHeader)}, `
+            + `received ${JSON.stringify(actualHeader)}.`);
+    }
+    const expectedResults = new Map(expected.results.map((result) => [baselineResultKey(result), result]));
+    const actualResults = new Map(actual.results.map((result) => [baselineResultKey(result), result]));
+    for (const [key, expectedResult] of expectedResults) {
+        const actualResult = actualResults.get(key);
+        if (!actualResult) {
+            differences.push(`Result ${key} is missing.`);
+        }
+        else if (JSON.stringify(expectedResult) !== JSON.stringify(actualResult)) {
+            differences.push(`Result ${key} changed.`);
+        }
+    }
+    for (const key of actualResults.keys()) {
+        if (!expectedResults.has(key)) {
+            differences.push(`Result ${key} is new.`);
+        }
+    }
+    return differences;
+}
+function baselineResultKey(result) {
+    return `${result.caseId}/${result.commentId}`;
+}
+async function findJsonFiles(rootPath) {
+    const entries = await readdir(rootPath, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+        const entryPath = path.join(rootPath, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...await findJsonFiles(entryPath));
+        }
+        else if (entry.isFile() && entry.name.endsWith(".json")) {
+            files.push(entryPath);
+        }
+    }
+    return files;
+}
+function assertValidCase(validator, value, casePath) {
+    if (validator(value))
+        return;
+    const details = (validator.errors ?? [])
+        .map(formatValidationError)
+        .join("\n");
+    throw new Error(`Invalid evaluation case ${casePath}:\n${details}`);
+}
+function formatValidationError(error) {
+    return `  ${error.instancePath || "/"} ${error.message ?? "is invalid"}`;
+}
+async function readEvaluationDocument(document, casePath) {
+    if (document.text != null)
+        return document.text;
+    if (document.path != null) {
+        return readFile(path.resolve(path.dirname(casePath), document.path), "utf8");
+    }
+    throw new Error(`Evaluation document in ${casePath} has neither text nor path.`);
+}
+function validateSourceSelections(evaluationCase, sourceText) {
+    const normalizedSource = sourceText.replace(/\r\n/g, "\n");
+    for (const comment of evaluationCase.comments) {
+        const selectedText = comment.anchor.selected_text?.replace(/\r\n/g, "\n");
+        if (selectedText != null && !normalizedSource.includes(selectedText)) {
+            throw new Error(`Evaluation case ${evaluationCase.id}/${comment.id} has selected_text `
+                + "that does not occur in its source document.");
+        }
+    }
+}
+function toComment(evaluationComment) {
+    return {
+        id: evaluationComment.id,
+        author: "MRSF evaluation",
+        timestamp: "1970-01-01T00:00:00Z",
+        text: "Reanchoring evaluation fixture",
+        resolved: false,
+        ...evaluationComment.anchor,
+    };
+}
+function matchesExpectedRange(actual, original, expectedRanges) {
+    if (!expectedRanges?.length)
+        return true;
+    const actualRange = {
+        line: actual.newLine ?? original.line ?? 0,
+        end_line: actual.newEndLine ?? original.end_line ?? actual.newLine ?? original.line,
+        start_column: actual.newStartColumn ?? original.start_column,
+        end_column: actual.newEndColumn ?? original.end_column,
+    };
+    return expectedRanges.some((expected) => actualRange.line === expected.line
+        && (expected.end_line == null
+            || (actualRange.end_line ?? actualRange.line) === expected.end_line)
+        && (expected.start_column == null
+            || actualRange.start_column === expected.start_column)
+        && (expected.end_column == null
+            || actualRange.end_column === expected.end_column));
+}
+//# sourceMappingURL=reanchor-eval.js.map