@mrsf/cli 0.6.0 → 0.7.1

package/dist/index.d.ts

@@ -12,6 +12,10 @@ import * as validator from "./lib/validator.js";
 import * as fuzzy from "./lib/fuzzy.js";
 import * as git from "./lib/git.js";
 import * as reanchor from "./lib/reanchor.js";
+import * as anchorContext from "./lib/anchor-context.js";
+import * as globalReconciliation from "./lib/global-reconciliation.js";
+import * as revisionProjection from "./lib/revision-projection.js";
+import * as confidenceCalibration from "./lib/confidence-calibration.js";
 import * as comments from "./lib/comments.js";
 import * as identity from "./lib/identity.js";
 import * as validateCore from "./lib/validate-core.js";
@@ -44,7 +48,9 @@ export declare const fuzzySearch: typeof fuzzy.fuzzySearch;
 export declare const combinedScore: typeof fuzzy.combinedScore;
 export declare const isGitAvailable: typeof git.isGitAvailable;
 export declare const findRepoRoot: typeof git.findRepoRoot;
+export declare const getGitUserName: typeof git.getGitUserName;
 export declare const getCurrentCommit: typeof git.getCurrentCommit;
+export declare const resolveCommit: typeof git.resolveCommit;
 export declare const isStale: typeof git.isStale;
 export declare const getDiff: typeof git.getDiff;
 export declare const getLineShift: typeof git.getLineShift;
@@ -62,6 +68,13 @@ export declare const resolveAnchor: typeof reanchor.resolveAnchor;
 export declare const reanchorDocument: typeof reanchor.reanchorDocument;
 export declare const applyReanchorResults: typeof reanchor.applyReanchorResults;
 export declare const reanchorFile: typeof reanchor.reanchorFile;
+export declare const createAnchorContextIndex: typeof anchorContext.createAnchorContextIndex;
+export declare const reconcileCommentAnchors: typeof globalReconciliation.reconcileCommentAnchors;
+export declare const createRevisionProjection: typeof revisionProjection.createRevisionProjection;
+export declare const calibrateAnchorEvidence: typeof confidenceCalibration.calibrateAnchorEvidence;
+export type { AnchorContextIndex, ContextAnchorCandidate, ContextAnchorResolution, } from "./lib/anchor-context.js";
+export type { ProjectedAnchor, RevisionProjectionIndex, } from "./lib/revision-projection.js";
+export type { CalibratedAnchor, ConfidenceBand, } from "./lib/confidence-calibration.js";
 export declare const addComment: typeof comments.addComment;
 export declare const editComment: typeof comments.editComment;
 export declare const normalizeCommentExtensions: typeof comments.normalizeCommentExtensions;

package/dist/index.js

@@ -12,6 +12,10 @@ import * as validator from "./lib/validator.js";
 import * as fuzzy from "./lib/fuzzy.js";
 import * as git from "./lib/git.js";
 import * as reanchor from "./lib/reanchor.js";
+import * as anchorContext from "./lib/anchor-context.js";
+import * as globalReconciliation from "./lib/global-reconciliation.js";
+import * as revisionProjection from "./lib/revision-projection.js";
+import * as confidenceCalibration from "./lib/confidence-calibration.js";
 import * as comments from "./lib/comments.js";
 import * as identity from "./lib/identity.js";
 import * as validateCore from "./lib/validate-core.js";
@@ -49,7 +53,9 @@ export const combinedScore = fuzzy.combinedScore;
 // Git
 export const isGitAvailable = git.isGitAvailable;
 export const findRepoRoot = git.findRepoRoot;
+export const getGitUserName = git.getGitUserName;
 export const getCurrentCommit = git.getCurrentCommit;
+export const resolveCommit = git.resolveCommit;
 export const isStale = git.isStale;
 export const getDiff = git.getDiff;
 export const getLineShift = git.getLineShift;
@@ -68,6 +74,10 @@ export const resolveAnchor = reanchor.resolveAnchor;
 export const reanchorDocument = reanchor.reanchorDocument;
 export const applyReanchorResults = reanchor.applyReanchorResults;
 export const reanchorFile = reanchor.reanchorFile;
+export const createAnchorContextIndex = anchorContext.createAnchorContextIndex;
+export const reconcileCommentAnchors = globalReconciliation.reconcileCommentAnchors;
+export const createRevisionProjection = revisionProjection.createRevisionProjection;
+export const calibrateAnchorEvidence = confidenceCalibration.calibrateAnchorEvidence;
 // Comments
 export const addComment = comments.addComment;
 export const editComment = comments.editComment;

package/dist/lib/anchor-context.d.ts

@@ -0,0 +1,46 @@
+import type { Comment, ReanchorStatus } from "./types.js";
+export declare const MAX_CONTEXT_CANDIDATE_BLOCKS = 64;
+type BlockType = "heading" | "code" | "list" | "table" | "blockquote" | "paragraph";
+interface MarkdownBlock {
+    startLine: number;
+    endLine: number;
+    type: BlockType;
+    text: string;
+    headingPath: string[];
+}
+interface DocumentBlockIndex {
+    lines: string[];
+    blocks: MarkdownBlock[];
+    lineToBlock: Map<number, number>;
+    tokenPostings: Map<string, number[]>;
+}
+export interface AnchorContextIndex {
+    source: DocumentBlockIndex;
+    target: DocumentBlockIndex;
+}
+export interface ContextAnchorResolution {
+    status: Extract<ReanchorStatus, "anchored" | "fuzzy" | "ambiguous" | "orphaned">;
+    score: number;
+    line?: number;
+    endLine?: number;
+    startColumn?: number;
+    endColumn?: number;
+    text?: string;
+    candidateMargin: number;
+    reason: string;
+}
+export interface ContextAnchorCandidate {
+    score: number;
+    line: number;
+    endLine: number;
+    startColumn?: number;
+    endColumn?: number;
+    text: string;
+    exact: boolean;
+}
+export declare function createAnchorContextIndex(sourceLines: string[], targetLines: string[]): AnchorContextIndex;
+export declare function resolveContextAnchor(comment: Comment, index: AnchorContextIndex): ContextAnchorResolution | undefined;
+export declare function findContextAnchorCandidates(comment: Comment, index: AnchorContextIndex): ContextAnchorCandidate[];
+export declare function getAnchorContextScope(comment: Comment, index: AnchorContextIndex): string | undefined;
+export {};
+//# sourceMappingURL=anchor-context.d.ts.map

package/dist/lib/anchor-context.js

@@ -0,0 +1,474 @@
+import { combinedScore } from "./fuzzy.js";
+const MATCH_THRESHOLD = 0.35;
+const AMBIGUITY_MARGIN = 0.03;
+export const MAX_CONTEXT_CANDIDATE_BLOCKS = 64;
+export function createAnchorContextIndex(sourceLines, targetLines) {
+    return {
+        source: createDocumentBlockIndex(sourceLines),
+        target: createDocumentBlockIndex(targetLines),
+    };
+}
+export function resolveContextAnchor(comment, index) {
+    if (comment.line == null || !comment.selected_text)
+        return undefined;
+    const sourceBlockIndex = index.source.lineToBlock.get(comment.line);
+    if (sourceBlockIndex == null)
+        return undefined;
+    const sourceBlock = index.source.blocks[sourceBlockIndex];
+    const sourceText = extractText(index.source.lines, comment.line, comment.end_line, comment.start_column, comment.end_column);
+    if (sourceText !== comment.selected_text)
+        return undefined;
+    const textAtCurrentPosition = extractText(index.target.lines, comment.line, comment.end_line, comment.start_column, comment.end_column);
+    if (textAtCurrentPosition === comment.selected_text) {
+        return {
+            status: "anchored",
+            score: 1,
+            line: comment.line,
+            endLine: comment.end_line ?? comment.line,
+            startColumn: comment.start_column,
+            endColumn: comment.end_column,
+            text: comment.selected_text,
+            candidateMargin: 1,
+            reason: "Source-verified anchor remains exact at its stored position.",
+        };
+    }
+    const candidates = findContextAnchorCandidates(comment, index);
+    const best = candidates[0];
+    if (!best) {
+        if (index.target.lines.slice(1).join("\n").includes(comment.selected_text)) {
+            return undefined;
+        }
+        return {
+            status: "orphaned",
+            score: 0,
+            candidateMargin: 1,
+            reason: "Source block has no plausible structural or contextual match.",
+        };
+    }
+    if (candidates[1] && best.score - candidates[1].score < AMBIGUITY_MARGIN) {
+        return {
+            status: "ambiguous",
+            score: best.score,
+            line: best.line,
+            endLine: best.endLine,
+            candidateMargin: best.score - candidates[1].score,
+            reason: `Structural candidates are too close (${best.score.toFixed(3)} vs `
+                + `${candidates[1].score.toFixed(3)}).`,
+        };
+    }
+    const repeatedExactText = best.exact
+        && countOccurrences(index.target.lines.slice(1).join("\n"), comment.selected_text) > 1;
+    return {
+        status: best.exact && !repeatedExactText ? "anchored" : "fuzzy",
+        score: best.exact && !repeatedExactText ? 1 : best.score,
+        line: best.line,
+        endLine: best.endLine,
+        startColumn: best.startColumn,
+        endColumn: best.endColumn,
+        text: best.text,
+        candidateMargin: candidates[1] ? best.score - candidates[1].score : 1,
+        reason: best.exact && !repeatedExactText
+            ? "Markdown structure and bidirectional context disambiguate the exact anchor."
+            : repeatedExactText
+                ? "Markdown context selects one repeated exact anchor tentatively."
+                : "Markdown structure and bidirectional context locate the edited anchor.",
+    };
+}
+export function findContextAnchorCandidates(comment, index) {
+    if (comment.line == null || !comment.selected_text)
+        return [];
+    const sourceBlockIndex = index.source.lineToBlock.get(comment.line);
+    if (sourceBlockIndex == null)
+        return [];
+    const sourceBlock = index.source.blocks[sourceBlockIndex];
+    const sourceText = extractText(index.source.lines, comment.line, comment.end_line, comment.start_column, comment.end_column);
+    if (sourceText !== comment.selected_text)
+        return [];
+    return createCandidateWindows(sourceBlock, sourceBlockIndex, comment.line, index)
+        .map((candidate) => ({
+        ...candidate,
+        score: scoreCandidate(sourceBlock, sourceBlockIndex, candidate, index, comment.line),
+    }))
+        .filter((candidate) => candidate.score >= MATCH_THRESHOLD)
+        .sort((left, right) => right.score - left.score
+        || Math.abs(left.startLine - comment.line)
+            - Math.abs(right.startLine - comment.line))
+        .map((candidate) => {
+        const range = resolveCandidateRange(comment, sourceBlock, candidate, index.target);
+        return {
+            score: candidate.score,
+            line: range.line,
+            endLine: range.endLine,
+            startColumn: range.startColumn,
+            endColumn: range.endColumn,
+            text: range.text,
+            exact: range.text === comment.selected_text,
+        };
+    });
+}
+export function getAnchorContextScope(comment, index) {
+    if (comment.line == null)
+        return undefined;
+    const blockIndex = index.source.lineToBlock.get(comment.line);
+    if (blockIndex == null)
+        return undefined;
+    return index.source.blocks[blockIndex].headingPath.join("\u001f");
+}
+function createDocumentBlockIndex(lines) {
+    const blocks = [];
+    const lineToBlock = new Map();
+    const headings = [];
+    let line = 1;
+    while (line < lines.length) {
+        if (!lines[line].trim()) {
+            line += 1;
+            continue;
+        }
+        const startLine = line;
+        const marker = classifyLine(lines[line]);
+        if (marker.type === "heading") {
+            while (headings.length > 0
+                && headings[headings.length - 1].level >= marker.headingLevel) {
+                headings.pop();
+            }
+            const block = makeBlock(lines, startLine, startLine, "heading", headings.map((heading) => heading.title));
+            blocks.push(block);
+            headings.push({ level: marker.headingLevel, title: marker.headingTitle });
+            line += 1;
+            continue;
+        }
+        if (marker.type === "code") {
+            line += 1;
+            while (line < lines.length && !lines[line].trimStart().startsWith("```")) {
+                line += 1;
+            }
+            if (line < lines.length)
+                line += 1;
+        }
+        else {
+            line += 1;
+            while (line < lines.length
+                && lines[line].trim()
+                && continuesBlock(marker.type, lines[line])) {
+                line += 1;
+            }
+        }
+        blocks.push(makeBlock(lines, startLine, line - 1, marker.type, headings.map((heading) => heading.title)));
+    }
+    for (const [blockIndex, block] of blocks.entries()) {
+        for (let blockLine = block.startLine; blockLine <= block.endLine; blockLine += 1) {
+            lineToBlock.set(blockLine, blockIndex);
+        }
+    }
+    return {
+        lines,
+        blocks,
+        lineToBlock,
+        tokenPostings: createTokenPostings(blocks),
+    };
+}
+function makeBlock(lines, startLine, endLine, type, headingPath) {
+    return {
+        startLine,
+        endLine,
+        type,
+        text: lines.slice(startLine, endLine + 1).join("\n"),
+        headingPath,
+    };
+}
+function classifyLine(line) {
+    const heading = line.match(/^(#{1,6})\s+(.+)$/);
+    if (heading) {
+        return {
+            type: "heading",
+            headingLevel: heading[1].length,
+            headingTitle: heading[2].trim(),
+        };
+    }
+    if (line.trimStart().startsWith("```")) {
+        return { type: "code", headingLevel: 0, headingTitle: "" };
+    }
+    if (/^\s*(?:[-*+]|\d+\.)\s+/.test(line)) {
+        return { type: "list", headingLevel: 0, headingTitle: "" };
+    }
+    if (/^\s*\|/.test(line)) {
+        return { type: "table", headingLevel: 0, headingTitle: "" };
+    }
+    if (/^\s*>/.test(line)) {
+        return { type: "blockquote", headingLevel: 0, headingTitle: "" };
+    }
+    return { type: "paragraph", headingLevel: 0, headingTitle: "" };
+}
+function continuesBlock(type, line) {
+    if (type === "list")
+        return /^\s*(?:[-*+]|\d+\.)\s+/.test(line);
+    if (type === "table")
+        return /^\s*\|/.test(line);
+    if (type === "blockquote")
+        return /^\s*>/.test(line);
+    if (type === "paragraph") {
+        const next = classifyLine(line);
+        return next.type === "paragraph";
+    }
+    return false;
+}
+function createCandidateWindows(sourceBlock, sourceBlockIndex, originalLine, index) {
+    const target = index.target;
+    const candidates = [];
+    for (const start of retrieveCandidateBlocks(sourceBlock, sourceBlockIndex, originalLine, index)) {
+        const block = target.blocks[start];
+        candidates.push(toCandidateWindow(target, start, start));
+        if (sourceBlock.type === "paragraph"
+            && block.type === "paragraph"
+            && target.blocks[start + 1]?.type === "paragraph"
+            && samePath(block.headingPath, target.blocks[start + 1].headingPath)) {
+            candidates.push(toCandidateWindow(target, start, start + 1));
+        }
+    }
+    return candidates;
+}
+function createTokenPostings(blocks) {
+    const postings = new Map();
+    for (const [blockIndex, block] of blocks.entries()) {
+        for (const token of new Set(tokenize(block.text))) {
+            const blocksForToken = postings.get(token);
+            if (blocksForToken) {
+                blocksForToken.push(blockIndex);
+            }
+            else {
+                postings.set(token, [blockIndex]);
+            }
+        }
+    }
+    return postings;
+}
+/**
+ * Retrieve a small candidate pool using rare content tokens and directional
+ * neighbor evidence. Expensive similarity scoring is bounded to this pool.
+ */
+function retrieveCandidateBlocks(sourceBlock, sourceBlockIndex, originalLine, index) {
+    const votes = new Map();
+    const targetCount = index.target.blocks.length;
+    const addEvidence = (text, targetOffset, weight) => {
+        if (!text)
+            return;
+        const rankedTokens = [...new Set(tokenize(text))]
+            .map((token) => ({
+            token,
+            postings: index.target.tokenPostings.get(token) ?? [],
+        }))
+            .filter((item) => item.postings.length > 0)
+            .sort((left, right) => left.postings.length - right.postings.length)
+            .slice(0, 12);
+        for (const { postings } of rankedTokens) {
+            const rarity = Math.log1p(targetCount / postings.length);
+            for (const posting of postings) {
+                const candidate = posting + targetOffset;
+                if (candidate >= 0 && candidate < targetCount) {
+                    votes.set(candidate, (votes.get(candidate) ?? 0) + weight * rarity);
+                }
+            }
+        }
+    };
+    addEvidence(sourceBlock.text, 0, 1);
+    addEvidence(index.source.blocks[sourceBlockIndex - 1]?.text, 1, 0.7);
+    addEvidence(index.source.blocks[sourceBlockIndex + 1]?.text, -1, 0.7);
+    const nearbyBlock = closestBlockToLine(index.target.blocks, originalLine);
+    if (nearbyBlock != null) {
+        for (let offset = -2; offset <= 2; offset += 1) {
+            const candidate = nearbyBlock + offset;
+            if (candidate >= 0 && candidate < targetCount) {
+                votes.set(candidate, (votes.get(candidate) ?? 0) + 0.25);
+            }
+        }
+    }
+    return [...votes.entries()]
+        .sort((left, right) => right[1] - left[1]
+        || Math.abs(index.target.blocks[left[0]].startLine - originalLine)
+            - Math.abs(index.target.blocks[right[0]].startLine - originalLine)
+        || left[0] - right[0])
+        .slice(0, MAX_CONTEXT_CANDIDATE_BLOCKS)
+        .map(([blockIndex]) => blockIndex);
+}
+function closestBlockToLine(blocks, line) {
+    if (blocks.length === 0)
+        return undefined;
+    let low = 0;
+    let high = blocks.length - 1;
+    while (low <= high) {
+        const middle = Math.floor((low + high) / 2);
+        const block = blocks[middle];
+        if (line < block.startLine) {
+            high = middle - 1;
+        }
+        else if (line > block.endLine) {
+            low = middle + 1;
+        }
+        else {
+            return middle;
+        }
+    }
+    if (low >= blocks.length)
+        return blocks.length - 1;
+    if (high < 0)
+        return 0;
+    return Math.abs(blocks[low].startLine - line)
+        < Math.abs(blocks[high].endLine - line)
+        ? low
+        : high;
+}
+function toCandidateWindow(target, startBlock, endBlock) {
+    const first = target.blocks[startBlock];
+    const last = target.blocks[endBlock];
+    return {
+        startBlock,
+        endBlock,
+        startLine: first.startLine,
+        endLine: last.endLine,
+        type: first.type,
+        text: target.lines.slice(first.startLine, last.endLine + 1).join("\n"),
+        headingPath: first.headingPath,
+        score: 0,
+    };
+}
+function scoreCandidate(sourceBlock, sourceBlockIndex, candidate, index, originalLine) {
+    const content = textSimilarity(sourceBlock.text, candidate.text);
+    const type = sourceBlock.type === candidate.type ? 1 : 0;
+    const heading = pathSimilarity(sourceBlock.headingPath, candidate.headingPath);
+    const previous = neighborSimilarity(index.source.blocks[sourceBlockIndex - 1], index.target.blocks[candidate.startBlock - 1]);
+    const next = neighborSimilarity(index.source.blocks[sourceBlockIndex + 1], index.target.blocks[candidate.endBlock + 1]);
+    const proximity = Math.max(0, 1 - Math.abs(candidate.startLine - originalLine) / 100);
+    return Math.min(1, content * 0.45
+        + type * 0.1
+        + heading * 0.1
+        + previous * 0.15
+        + next * 0.15
+        + proximity * 0.05);
+}
+function neighborSimilarity(source, target) {
+    if (!source || !target)
+        return 0;
+    return textSimilarity(source.text, target.text);
+}
+function textSimilarity(left, right) {
+    return Math.max(tokenDice(left, right), combinedScore(normalizeText(left), normalizeText(right)));
+}
+function pathSimilarity(left, right) {
+    if (left.length === 0 || right.length === 0)
+        return 0;
+    return tokenDice(left.join(" "), right.join(" "));
+}
+function tokenDice(left, right) {
+    const leftTokens = tokenize(left);
+    const rightTokens = tokenize(right);
+    if (leftTokens.length === 0 || rightTokens.length === 0)
+        return 0;
+    const remaining = new Map();
+    for (const token of rightTokens) {
+        remaining.set(token, (remaining.get(token) ?? 0) + 1);
+    }
+    let overlap = 0;
+    for (const token of leftTokens) {
+        const count = remaining.get(token) ?? 0;
+        if (count > 0) {
+            overlap += 1;
+            remaining.set(token, count - 1);
+        }
+    }
+    return (2 * overlap) / (leftTokens.length + rightTokens.length);
+}
+function tokenize(text) {
+    return normalizeText(text).match(/[\p{L}\p{N}_-]+/gu) ?? [];
+}
+function normalizeText(text) {
+    return text.toLowerCase().replace(/\s+/g, " ").trim();
+}
+function samePath(left, right) {
+    return left.length === right.length
+        && left.every((item, index) => item === right[index]);
+}
+function resolveCandidateRange(comment, sourceBlock, candidate, target) {
+    const exactIndex = candidate.text.indexOf(comment.selected_text);
+    const selectedIsWholeBlock = comment.line === sourceBlock.startLine
+        && (comment.end_line ?? comment.line) === sourceBlock.endLine
+        && comment.start_column == null
+        && comment.end_column == null
+        && comment.selected_text === sourceBlock.text;
+    const sourceOccurrenceIsUnique = countOccurrences(sourceBlock.text, comment.selected_text) === 1;
+    if (exactIndex >= 0 && (selectedIsWholeBlock || sourceOccurrenceIsUnique)) {
+        return exactRange(candidate.startLine, candidate.text, comment.selected_text, exactIndex);
+    }
+    if (selectedIsWholeBlock) {
+        return {
+            line: candidate.startLine,
+            endLine: candidate.endLine,
+            text: candidate.text,
+        };
+    }
+    const relativeLine = comment.line - sourceBlock.startLine;
+    const line = Math.min(candidate.endLine, candidate.startLine + relativeLine);
+    const lineSpan = (comment.end_line ?? comment.line)
+        - comment.line;
+    const endLine = Math.min(candidate.endLine, line + lineSpan);
+    const startColumn = comment.start_column;
+    const endColumn = comment.end_column;
+    return {
+        line,
+        endLine,
+        startColumn,
+        endColumn,
+        text: extractText(target.lines, line, endLine, startColumn, endColumn) ?? "",
+    };
+}
+function countOccurrences(text, needle) {
+    if (!needle)
+        return 0;
+    let count = 0;
+    let offset = 0;
+    while (offset <= text.length - needle.length) {
+        const index = text.indexOf(needle, offset);
+        if (index < 0)
+            break;
+        count += 1;
+        offset = index + 1;
+    }
+    return count;
+}
+function exactRange(startLine, candidateText, selectedText, index) {
+    const before = candidateText.slice(0, index).split("\n");
+    const selectedLines = selectedText.split("\n");
+    const line = startLine + before.length - 1;
+    const startColumn = before.at(-1)?.length ?? 0;
+    const finalSelectedLineLength = selectedLines.at(-1)?.length ?? 0;
+    return {
+        line,
+        endLine: line + selectedLines.length - 1,
+        startColumn,
+        endColumn: selectedLines.length === 1
+            ? startColumn + finalSelectedLineLength
+            : finalSelectedLineLength,
+        text: selectedText,
+    };
+}
+function extractText(lines, line, endLine, startColumn, endColumn) {
+    const finalLine = endLine ?? line;
+    if (line < 1 || finalLine >= lines.length)
+        return null;
+    if (line === finalLine) {
+        const text = lines[line];
+        return startColumn != null && endColumn != null
+            ? text.slice(startColumn, endColumn)
+            : text;
+    }
+    const result = [];
+    for (let current = line; current <= finalLine; current += 1) {
+        let text = lines[current];
+        if (current === line && startColumn != null)
+            text = text.slice(startColumn);
+        if (current === finalLine && endColumn != null)
+            text = text.slice(0, endColumn);
+        result.push(text);
+    }
+    return result.join("\n");
+}
+//# sourceMappingURL=anchor-context.js.map

package/dist/lib/confidence-calibration.d.ts

@@ -0,0 +1,16 @@
+import type { ContextAnchorResolution } from "./anchor-context.js";
+import type { ProjectedAnchor } from "./revision-projection.js";
+import type { ReanchorResult } from "./types.js";
+export type ConfidenceBand = "certain" | "probable" | "ambiguous" | "orphaned";
+export interface CalibratedAnchor {
+    band: ConfidenceBand;
+    result: ReanchorResult;
+}
+/**
+ * Calibrate independent revision and structural evidence into a public result.
+ *
+ * Exact evidence is certain. Edited anchors are probable only when evidence
+ * agrees or one source has a decisive margin; conflicting evidence abstains.
+ */
+export declare function calibrateAnchorEvidence(commentId: string, selectedText: string, projected?: ProjectedAnchor, contextual?: ContextAnchorResolution): CalibratedAnchor | undefined;
+//# sourceMappingURL=confidence-calibration.d.ts.map