wiki-graph-core 0.3.1

package/dist/evidence-selection/anchor-resolver.js

@@ -0,0 +1,783 @@
+import { normalizeText, splitTextIntoSentences } from "./text.js";
+const MIN_AUTO_RESOLVE_GAP = 0.07;
+const MIN_AUTO_RESOLVE_SCORE = 0.9;
+const MIN_BOUNDARY_BONUS_LENGTH = 12;
+const MIN_CANDIDATE_SCORE = 0.55;
+const VERY_HIGH_CONFIDENCE_SCORE = 0.97;
+const MAX_BOUNDARY_BONUS = 0.08;
+const MAX_CANDIDATE_DISPLAY = 3;
+class EvidenceResolver {
+  resolve(evidence, candidateSentenceIds, candidateTexts) {
+    const startValue = evidence.start_anchor ?? evidence.start;
+    const endValue = evidence.end_anchor ?? evidence.end;
+    const [startAnchor, startFailure] = this.parseAnchor(
+      startValue,
+      "start_anchor"
+    );
+    if (startFailure !== void 0) {
+      return [void 0, startFailure];
+    }
+    let endAnchor;
+    if (endValue !== void 0) {
+      const [parsedEndAnchor, endFailure] = this.parseAnchor(
+        endValue,
+        "end_anchor"
+      );
+      if (endFailure !== void 0) {
+        return [void 0, endFailure];
+      }
+      endAnchor = parsedEndAnchor;
+    }
+    const [startCandidate, startStrategy, startResolveFailure] = this.resolveAnchor({
+      anchor: startAnchor,
+      candidateSentenceIds,
+      candidateTexts,
+      label: "start_anchor"
+    });
+    if (startResolveFailure !== void 0) {
+      return [void 0, startResolveFailure];
+    }
+    if (startCandidate === void 0) {
+      return [
+        void 0,
+        {
+          candidates: [],
+          code: "none",
+          fieldName: "start_anchor",
+          message: "start_anchor could not be matched: no candidate selected"
+        }
+      ];
+    }
+    if (endAnchor === void 0) {
+      return [
+        {
+          confidence: startCandidate.score,
+          sentenceIds: [startCandidate.sentenceId],
+          strategy: startStrategy
+        },
+        void 0
+      ];
+    }
+    const [endCandidate, endStrategy, endResolveFailure] = this.resolveAnchor({
+      anchor: endAnchor,
+      candidateSentenceIds,
+      candidateTexts,
+      label: "end_anchor",
+      minIndex: startCandidate.index
+    });
+    if (endResolveFailure !== void 0) {
+      return [void 0, endResolveFailure];
+    }
+    if (endCandidate === void 0) {
+      return [
+        void 0,
+        {
+          candidates: [],
+          code: "none",
+          fieldName: "end_anchor",
+          message: "end_anchor could not be matched: no candidate selected"
+        }
+      ];
+    }
+    if (endCandidate.index < startCandidate.index) {
+      return [
+        void 0,
+        {
+          candidates: [],
+          code: "invalid_range",
+          fieldName: "end_anchor",
+          message: `Invalid evidence range: end_anchor resolved before start_anchor (${startCandidate.occurrenceId} -> ${endCandidate.occurrenceId}).`
+        }
+      ];
+    }
+    return [
+      {
+        confidence: Math.min(startCandidate.score, endCandidate.score),
+        sentenceIds: candidateSentenceIds.slice(
+          startCandidate.index,
+          endCandidate.index + 1
+        ),
+        strategy: `${startStrategy}+${endStrategy}`
+      },
+      void 0
+    ];
+  }
+  resolveWithOverrides(input) {
+    const startValue = input.evidence.start_anchor ?? input.evidence.start;
+    const endValue = input.evidence.end_anchor ?? input.evidence.end;
+    const [startAnchor, startFailure] = this.parseAnchor(
+      startValue,
+      "start_anchor"
+    );
+    if (startFailure !== void 0) {
+      return [void 0, startFailure];
+    }
+    const startCandidateOverride = input.overrides.start_anchor;
+    const [startCandidate, startStrategy, startResolveFailure] = startCandidateOverride === void 0 ? this.resolveAnchor({
+      anchor: startAnchor,
+      candidateSentenceIds: input.candidateSentenceIds,
+      candidateTexts: input.candidateTexts,
+      label: "start_anchor"
+    }) : [startCandidateOverride, "choice_final", void 0];
+    if (startResolveFailure !== void 0) {
+      return [void 0, startResolveFailure];
+    }
+    if (startCandidate === void 0) {
+      return [
+        void 0,
+        {
+          candidates: [],
+          code: "none",
+          fieldName: "start_anchor",
+          message: "start_anchor could not be matched: no candidate selected"
+        }
+      ];
+    }
+    if (endValue === void 0) {
+      return [
+        {
+          confidence: startCandidate.score,
+          sentenceIds: [startCandidate.sentenceId],
+          strategy: startStrategy
+        },
+        void 0
+      ];
+    }
+    const [endAnchor, endFailure] = this.parseAnchor(endValue, "end_anchor");
+    if (endFailure !== void 0) {
+      return [void 0, endFailure];
+    }
+    const endCandidateOverride = input.overrides.end_anchor;
+    const [endCandidate, endStrategy, endResolveFailure] = endCandidateOverride === void 0 ? this.resolveAnchor({
+      anchor: endAnchor,
+      candidateSentenceIds: input.candidateSentenceIds,
+      candidateTexts: input.candidateTexts,
+      label: "end_anchor",
+      minIndex: startCandidate.index
+    }) : [endCandidateOverride, "choice_final", void 0];
+    if (endResolveFailure !== void 0) {
+      return [void 0, endResolveFailure];
+    }
+    if (endCandidate === void 0) {
+      return [
+        void 0,
+        {
+          candidates: [],
+          code: "none",
+          fieldName: "end_anchor",
+          message: "end_anchor could not be matched: no candidate selected"
+        }
+      ];
+    }
+    if (endCandidate.index < startCandidate.index) {
+      return [
+        void 0,
+        {
+          candidates: [],
+          code: "invalid_range",
+          fieldName: "end_anchor",
+          message: `Invalid evidence range: end_anchor resolved before start_anchor (${startCandidate.occurrenceId} -> ${endCandidate.occurrenceId}).`
+        }
+      ];
+    }
+    return [
+      {
+        confidence: Math.min(startCandidate.score, endCandidate.score),
+        sentenceIds: input.candidateSentenceIds.slice(
+          startCandidate.index,
+          endCandidate.index + 1
+        ),
+        strategy: `${startStrategy}+${endStrategy}`
+      },
+      void 0
+    ];
+  }
+  parseAnchor(value, fieldName) {
+    const [anchor, error] = this.#parseAnchor(value);
+    if (error !== void 0) {
+      return [
+        void 0,
+        {
+          candidates: [],
+          code: "invalid_anchor",
+          fieldName,
+          message: `Invalid evidence.${fieldName}: ${error}`
+        }
+      ];
+    }
+    return [this.#normalizeAnchor(anchor, fieldName), void 0];
+  }
+  resolveAnchor(input) {
+    if (input.anchor === void 0) {
+      return [
+        void 0,
+        "invalid",
+        {
+          candidates: [],
+          code: "invalid",
+          fieldName: input.label,
+          message: `${input.label} is missing`
+        }
+      ];
+    }
+    let candidates = this.rankAnchor(
+      input.anchor,
+      input.candidateSentenceIds,
+      input.candidateTexts,
+      input.label
+    );
+    const minIndex = input.minIndex;
+    if (minIndex !== void 0) {
+      candidates = candidates.filter(
+        (candidate) => candidate.index >= minIndex
+      );
+    }
+    if (candidates.length === 0) {
+      return [
+        void 0,
+        "none",
+        {
+          candidates: [],
+          code: "none",
+          fieldName: input.label,
+          message: `${input.label} could not be matched: no candidates available`
+        }
+      ];
+    }
+    const exactRaw = candidates.filter((candidate) => candidate.exactRaw);
+    if (exactRaw.length === 1) {
+      return [exactRaw[0], "exact_raw", void 0];
+    }
+    if (exactRaw.length > 1) {
+      return [
+        void 0,
+        "ambiguous_exact_raw",
+        this.#buildAmbiguousFailure(
+          input.label,
+          "ambiguous_exact_raw",
+          exactRaw
+        )
+      ];
+    }
+    const exactSubstring = candidates.filter(
+      (candidate) => candidate.exactSubstring
+    );
+    if (exactSubstring.length === 1 && this.#anchorLength(input.anchor) >= 8) {
+      return [exactSubstring[0], "exact_substring", void 0];
+    }
+    if (exactSubstring.length > 1 && this.#anchorLength(input.anchor) >= 8) {
+      const selected = this.#tryAutoSelectScoredDuplicates(exactSubstring);
+      if (selected !== void 0) {
+        return [selected, "exact_substring_scored", void 0];
+      }
+      return [
+        void 0,
+        "ambiguous_exact_substring",
+        this.#buildAmbiguousFailure(
+          input.label,
+          "ambiguous_exact_substring",
+          exactSubstring
+        )
+      ];
+    }
+    const exactNormalized = candidates.filter(
+      (candidate) => candidate.exactNormalized
+    );
+    if (exactNormalized.length === 1) {
+      return [exactNormalized[0], "exact_normalized", void 0];
+    }
+    if (exactNormalized.length > 1) {
+      const selected = this.#tryAutoSelectScoredDuplicates(exactNormalized);
+      if (selected !== void 0) {
+        return [selected, "exact_normalized_scored", void 0];
+      }
+      return [
+        void 0,
+        "ambiguous_exact_normalized",
+        this.#buildAmbiguousFailure(
+          input.label,
+          "ambiguous_exact_normalized",
+          exactNormalized
+        )
+      ];
+    }
+    const topCandidate = candidates[0];
+    if (topCandidate === void 0) {
+      return [
+        void 0,
+        "none",
+        {
+          candidates: [],
+          code: "none",
+          fieldName: input.label,
+          message: `${input.label} could not be matched: no candidates available`
+        }
+      ];
+    }
+    const secondScore = candidates[1]?.score ?? 0;
+    const gap = topCandidate.score - secondScore;
+    if (topCandidate.score < MIN_CANDIDATE_SCORE) {
+      return [
+        void 0,
+        "low_confidence",
+        {
+          candidates: candidates.slice(0, MAX_CANDIDATE_DISPLAY),
+          code: "low_confidence",
+          fieldName: input.label,
+          message: `${input.label} could not be matched confidently. Best candidate score=${topCandidate.score.toFixed(3)}.`
+        }
+      ];
+    }
+    if (candidates.length === 1) {
+      return [topCandidate, "auto_top1_single_candidate", void 0];
+    }
+    if (topCandidate.score >= VERY_HIGH_CONFIDENCE_SCORE) {
+      return [topCandidate, "auto_top1_very_high", void 0];
+    }
+    if (topCandidate.score >= MIN_AUTO_RESOLVE_SCORE && gap >= MIN_AUTO_RESOLVE_GAP) {
+      return [topCandidate, "auto_top1", void 0];
+    }
+    return [
+      void 0,
+      "ambiguous_ranked",
+      this.#buildAmbiguousFailure(input.label, "ambiguous_ranked", candidates)
+    ];
+  }
+  rankAnchor(anchor, candidateSentenceIds, candidateTexts, label) {
+    const ranked = [];
+    for (const [index, sentenceId] of candidateSentenceIds.entries()) {
+      const text = candidateTexts[index] ?? "";
+      const prevText = index > 0 ? candidateTexts[index - 1] ?? "" : "";
+      const nextText = index < candidateTexts.length - 1 ? candidateTexts[index + 1] ?? "" : "";
+      const match = this.#scoreAnchor(anchor, text, label);
+      ranked.push({
+        exactNormalized: match.exactNormalized,
+        exactRaw: match.exactRaw,
+        exactSubstring: match.exactSubstring,
+        index,
+        nextText,
+        occurrenceId: `S${index + 1}`,
+        prevText,
+        score: match.score,
+        sentenceId,
+        text
+      });
+    }
+    ranked.sort((left, right) => {
+      if (left.score !== right.score) {
+        return right.score - left.score;
+      }
+      if (left.exactRaw !== right.exactRaw) {
+        return left.exactRaw ? -1 : 1;
+      }
+      if (left.exactSubstring !== right.exactSubstring) {
+        return left.exactSubstring ? -1 : 1;
+      }
+      if (left.exactNormalized !== right.exactNormalized) {
+        return left.exactNormalized ? -1 : 1;
+      }
+      return left.index - right.index;
+    });
+    return ranked;
+  }
+  #scoreAnchor(anchor, candidateText, label) {
+    if (anchor.mode === "head_tail") {
+      return this.#scoreHeadTail(anchor, candidateText);
+    }
+    return this.#scoreTextQuery(anchor.text ?? "", candidateText, label);
+  }
+  #scoreHeadTail(anchor, candidateText) {
+    const head = anchor.head ?? "";
+    const tail = anchor.tail ?? "";
+    const candidateNormalized = normalizeText(candidateText);
+    const headNormalized = normalizeText(head);
+    const tailNormalized = normalizeText(tail);
+    if (headNormalized === "" || tailNormalized === "") {
+      return createEmptyTextMatchScore();
+    }
+    const headPosition = candidateNormalized.indexOf(headNormalized);
+    const tailPosition = candidateNormalized.lastIndexOf(tailNormalized);
+    if (headPosition !== -1 && tailPosition !== -1 && headPosition <= tailPosition) {
+      const coveredChars = headNormalized.length + tailNormalized.length;
+      const coverage = Math.min(
+        1,
+        coveredChars / Math.max(1, candidateNormalized.length)
+      );
+      return {
+        exactNormalized: false,
+        exactRaw: false,
+        exactSubstring: true,
+        matchEnd: tailPosition + tailNormalized.length,
+        matchStart: headPosition,
+        score: 0.82 + 0.18 * coverage
+      };
+    }
+    const headMatch = this.#scoreTextQuery(head, candidateText, "start_anchor");
+    const tailMatch = this.#scoreTextQuery(tail, candidateText, "end_anchor");
+    const ordered = headMatch.matchStart <= tailMatch.matchStart ? 1 : 0.85;
+    return {
+      exactNormalized: false,
+      exactRaw: false,
+      exactSubstring: false,
+      matchEnd: Math.max(headMatch.matchEnd, tailMatch.matchEnd),
+      matchStart: Math.min(headMatch.matchStart, tailMatch.matchStart),
+      score: (headMatch.score + tailMatch.score) / 2 * ordered
+    };
+  }
+  #scoreTextQuery(queryText, candidateText, label) {
+    const queryRaw = queryText.trim();
+    const candidateRaw = candidateText.trim();
+    const queryNormalized = normalizeText(queryRaw);
+    const candidateNormalized = normalizeText(candidateRaw);
+    if (queryNormalized === "" || candidateNormalized === "") {
+      return createEmptyTextMatchScore();
+    }
+    if (queryRaw === candidateRaw) {
+      return {
+        exactNormalized: true,
+        exactRaw: true,
+        exactSubstring: true,
+        matchEnd: candidateNormalized.length,
+        matchStart: 0,
+        score: 1
+      };
+    }
+    if (queryNormalized === candidateNormalized) {
+      return {
+        exactNormalized: true,
+        exactRaw: false,
+        exactSubstring: false,
+        matchEnd: candidateNormalized.length,
+        matchStart: 0,
+        score: 0.995
+      };
+    }
+    if (candidateNormalized.includes(queryNormalized)) {
+      const matchStart = candidateNormalized.indexOf(queryNormalized);
+      const coverage = queryNormalized.length / Math.max(1, candidateNormalized.length);
+      const boundaryBonus = this.#boundaryBonus({
+        candidateNormalized,
+        label,
+        matchEnd: matchStart + queryNormalized.length,
+        matchStart,
+        queryNormalized
+      });
+      return {
+        exactNormalized: false,
+        exactRaw: false,
+        exactSubstring: true,
+        matchEnd: matchStart + queryNormalized.length,
+        matchStart,
+        score: Math.min(1, 0.75 + 0.25 * coverage + boundaryBonus)
+      };
+    }
+    if (queryNormalized.includes(candidateNormalized)) {
+      const coverage = candidateNormalized.length / Math.max(1, queryNormalized.length);
+      return {
+        exactNormalized: false,
+        exactRaw: false,
+        exactSubstring: false,
+        matchEnd: candidateNormalized.length,
+        matchStart: 0,
+        score: Math.min(0.92, 0.78 + 0.14 * coverage)
+      };
+    }
+    let bestScore = 0;
+    let bestStart = -1;
+    let bestEnd = -1;
+    const maxWindow = Math.min(
+      candidateNormalized.length,
+      Math.max(
+        queryNormalized.length,
+        Math.floor(queryNormalized.length * 1.2)
+      )
+    );
+    const minWindow = Math.min(
+      maxWindow,
+      Math.max(1, Math.floor(queryNormalized.length * 0.8))
+    );
+    const queryChars = new Set(queryNormalized);
+    for (let windowSize = minWindow; windowSize <= maxWindow; windowSize += 1) {
+      for (let start = 0; start <= candidateNormalized.length - windowSize; start += 1) {
+        const window = candidateNormalized.slice(start, start + windowSize);
+        const windowChars = new Set(window);
+        const unionSize = (/* @__PURE__ */ new Set([...queryChars, ...windowChars])).size;
+        const overlapSize = [...queryChars].filter(
+          (char) => windowChars.has(char)
+        ).length;
+        const jaccard = unionSize === 0 ? 0 : overlapSize / unionSize;
+        if (jaccard < 0.35) {
+          continue;
+        }
+        const totalScore = 0.35 * charNgramScore(queryNormalized, window) + 0.35 * sequenceSimilarity(queryNormalized, window) + 0.2 * levenshteinSimilarity(queryNormalized, window) + 0.1 * lengthPenalty(queryNormalized, window) + this.#boundaryBonus({
+          candidateNormalized,
+          label,
+          matchEnd: start + windowSize,
+          matchStart: start,
+          queryNormalized
+        });
+        if (totalScore > bestScore) {
+          bestScore = Math.min(1, totalScore);
+          bestStart = start;
+          bestEnd = start + windowSize;
+        }
+      }
+    }
+    return {
+      exactNormalized: false,
+      exactRaw: false,
+      exactSubstring: false,
+      matchEnd: bestEnd,
+      matchStart: bestStart,
+      score: bestScore
+    };
+  }
+  #parseAnchor(value) {
+    if (value === void 0 || value === null) {
+      return [void 0, "anchor is required"];
+    }
+    if (typeof value === "string") {
+      const stripped = value.trim();
+      if (stripped === "") {
+        return [void 0, "anchor string is empty"];
+      }
+      if (stripped.includes("...")) {
+        const parts = stripped.split("...").map((part) => part.trim()).filter((part) => part !== "");
+        if (parts.length >= 2) {
+          const head2 = parts[0];
+          const tail2 = parts[parts.length - 1];
+          if (head2 === void 0 || tail2 === void 0) {
+            return [void 0, "anchor string is empty"];
+          }
+          return [
+            {
+              head: head2,
+              mode: "head_tail",
+              tail: tail2
+            },
+            void 0
+          ];
+        }
+      }
+      return [{ mode: "full", text: stripped }, void 0];
+    }
+    if (typeof value !== "object") {
+      return [void 0, `expected string or object, got ${typeof value}`];
+    }
+    const rawValue = value;
+    const mode = rawValue.mode === "head_tail" || rawValue.head !== void 0 ? "head_tail" : "full";
+    if (mode === "full") {
+      const text = typeof rawValue.text === "string" ? rawValue.text.trim() : "";
+      if (text === "") {
+        return [void 0, "full anchor requires non-empty 'text'"];
+      }
+      return [{ mode: "full", text }, void 0];
+    }
+    const head = typeof rawValue.head === "string" ? rawValue.head.trim() : "";
+    const tail = typeof rawValue.tail === "string" ? rawValue.tail.trim() : "";
+    if (head !== "" && tail === "") {
+      return [{ mode: "full", text: head }, void 0];
+    }
+    if (head === "" && tail !== "") {
+      return [{ mode: "full", text: tail }, void 0];
+    }
+    if (head === "" || tail === "") {
+      return [
+        void 0,
+        "head_tail anchor requires non-empty 'head' and 'tail'"
+      ];
+    }
+    return [{ head, mode: "head_tail", tail }, void 0];
+  }
+  #normalizeAnchor(anchor, fieldName) {
+    if (anchor === void 0) {
+      return void 0;
+    }
+    if (anchor.mode === "head_tail") {
+      const boundaryText = fieldName === "end_anchor" ? this.#selectBoundarySentence(anchor.tail ?? "", "end_anchor") : this.#selectBoundarySentence(anchor.head ?? "", "start_anchor");
+      return boundaryText === "" ? void 0 : {
+        mode: "full",
+        text: boundaryText
+      };
+    }
+    const normalizedText = this.#selectBoundarySentence(
+      anchor.text ?? "",
+      fieldName
+    );
+    return {
+      mode: "full",
+      text: normalizedText
+    };
+  }
+  #selectBoundarySentence(text, fieldName) {
+    const sentences = splitTextIntoSentences(text);
+    if (sentences.length <= 1) {
+      return text.trim();
+    }
+    return fieldName === "end_anchor" ? sentences[sentences.length - 1] ?? text.trim() : sentences[0] ?? text.trim();
+  }
+  #boundaryBonus(input) {
+    if (input.matchStart < 0 || input.matchEnd < 0) {
+      return 0;
+    }
+    if (input.queryNormalized.length < MIN_BOUNDARY_BONUS_LENGTH) {
+      return 0;
+    }
+    if (input.label === "start_anchor" && input.matchStart !== 0) {
+      return 0;
+    }
+    if (input.label === "end_anchor" && input.matchEnd !== input.candidateNormalized.length) {
+      return 0;
+    }
+    const coverage = input.queryNormalized.length / Math.max(1, input.candidateNormalized.length);
+    return MAX_BOUNDARY_BONUS * (0.5 + 0.5 * Math.min(1, coverage));
+  }
+  #tryAutoSelectScoredDuplicates(candidates) {
+    if (candidates.length === 0) {
+      return void 0;
+    }
+    if (candidates.length === 1) {
+      return candidates[0];
+    }
+    const topCandidate = candidates[0];
+    if (topCandidate === void 0) {
+      return void 0;
+    }
+    const secondScore = candidates[1]?.score ?? 0;
+    if (topCandidate.score >= MIN_AUTO_RESOLVE_SCORE && topCandidate.score - secondScore >= MIN_AUTO_RESOLVE_GAP) {
+      return topCandidate;
+    }
+    return void 0;
+  }
+  #buildAmbiguousFailure(label, code, candidates) {
+    const topCandidates = candidates.slice(0, MAX_CANDIDATE_DISPLAY);
+    const formatted = topCandidates.map((candidate) => formatCandidate(candidate)).join("\n");
+    return {
+      candidates: topCandidates,
+      code,
+      fieldName: label,
+      message: `${label} is ambiguous. Top candidates:
+${formatted}
+Please provide a more specific anchor or surrounding context.`
+    };
+  }
+  #anchorLength(anchor) {
+    if (anchor.mode === "head_tail") {
+      return normalizeText(anchor.head ?? "").length + normalizeText(anchor.tail ?? "").length;
+    }
+    return normalizeText(anchor.text ?? "").length;
+  }
+}
+function createEmptyTextMatchScore() {
+  return {
+    exactNormalized: false,
+    exactRaw: false,
+    exactSubstring: false,
+    matchEnd: -1,
+    matchStart: -1,
+    score: 0
+  };
+}
+function charNgramScore(left, right) {
+  const leftBigrams = charNgrams(left, 2);
+  const rightBigrams = charNgrams(right, 2);
+  const leftTrigrams = charNgrams(left, 3);
+  const rightTrigrams = charNgrams(right, 3);
+  return (diceCoefficient(leftBigrams, rightBigrams) + diceCoefficient(leftTrigrams, rightTrigrams)) / 2;
+}
+function charNgrams(text, size) {
+  if (text.length <= size) {
+    return text === "" ? /* @__PURE__ */ new Set() : /* @__PURE__ */ new Set([text]);
+  }
+  const result = /* @__PURE__ */ new Set();
+  for (let index = 0; index <= text.length - size; index += 1) {
+    result.add(text.slice(index, index + size));
+  }
+  return result;
+}
+function diceCoefficient(left, right) {
+  if (left.size === 0 || right.size === 0) {
+    return 0;
+  }
+  let overlap = 0;
+  for (const value of left) {
+    if (right.has(value)) {
+      overlap += 1;
+    }
+  }
+  return 2 * overlap / (left.size + right.size);
+}
+function levenshteinSimilarity(left, right) {
+  if (left === right) {
+    return 1;
+  }
+  if (left === "" || right === "") {
+    return 0;
+  }
+  let previous = Array.from({ length: right.length + 1 }, (_, index) => index);
+  let current = new Array(right.length + 1).fill(0);
+  for (const [leftIndex, leftChar] of [...left].entries()) {
+    current[0] = leftIndex + 1;
+    for (const [rightIndex, rightChar] of [...right].entries()) {
+      const insertCost = (current[rightIndex] ?? 0) + 1;
+      const deleteCost = (previous[rightIndex + 1] ?? 0) + 1;
+      const replaceCost = (previous[rightIndex] ?? 0) + (leftChar === rightChar ? 0 : 1);
+      current[rightIndex + 1] = Math.min(insertCost, deleteCost, replaceCost);
+    }
+    [previous, current] = [current, previous];
+  }
+  const distance = previous[right.length] ?? Math.max(left.length, right.length);
+  return 1 - distance / Math.max(left.length, right.length);
+}
+function lengthPenalty(left, right) {
+  return 1 - Math.abs(left.length - right.length) / Math.max(left.length, right.length);
+}
+function sequenceSimilarity(left, right) {
+  if (left === right) {
+    return 1;
+  }
+  const leftLength = left.length;
+  const rightLength = right.length;
+  if (leftLength === 0 || rightLength === 0) {
+    return 0;
+  }
+  const matrix = Array.from(
+    { length: leftLength + 1 },
+    () => new Array(rightLength + 1).fill(0)
+  );
+  let longest = 0;
+  for (let leftIndex = 1; leftIndex <= leftLength; leftIndex += 1) {
+    for (let rightIndex = 1; rightIndex <= rightLength; rightIndex += 1) {
+      if (left[leftIndex - 1] !== right[rightIndex - 1]) {
+        continue;
+      }
+      const currentRow = matrix[leftIndex];
+      if (currentRow === void 0) {
+        continue;
+      }
+      currentRow[rightIndex] = (matrix[leftIndex - 1]?.[rightIndex - 1] ?? 0) + 1;
+      longest = Math.max(longest, currentRow[rightIndex] ?? 0);
+    }
+  }
+  return 2 * longest / (leftLength + rightLength);
+}
+function formatCandidate(candidate) {
+  return `  - ${candidate.occurrenceId} score=${candidate.score.toFixed(3)}
+    prev: ${truncate(candidate.prevText)}
+    text: ${truncate(candidate.text, 120)}
+    next: ${truncate(candidate.nextText)}`;
+}
+function truncate(text, limit = 80) {
+  const stripped = text.replace(/\s+/gu, " ").trim();
+  if (stripped === "") {
+    return "(none)";
+  }
+  if (stripped.length <= limit) {
+    return stripped;
+  }
+  return `${stripped.slice(0, limit - 3)}...`;
+}
+export {
+  EvidenceResolver
+};
+//# sourceMappingURL=anchor-resolver.js.map