sift-light 1.0.0

package/src/file-metadata-filter.ts

@@ -0,0 +1,46 @@
+import { resolve } from "node:path";
+import { abortError } from "./errors.js";
+import { getSourceRevision, matchesModificationTime } from "./source.js";
+import { MAX_SOURCE_REVISION_CONCURRENCY, type SourceRevision } from "./types.js";
+
+export interface ModificationTimeFilterResult {
+  paths: string[];
+  partial: boolean;
+  reasons: string[];
+}
+
+/** Apply a worktree mtime filter to an already enumerated path set with bounded metadata reads. */
+export async function filterPathsByModificationTime(
+  cwd: string,
+  paths: readonly string[],
+  modifiedAfterMs?: number,
+  modifiedBeforeMs?: number,
+  signal?: AbortSignal,
+): Promise<ModificationTimeFilterResult> {
+  if (modifiedAfterMs === undefined && modifiedBeforeMs === undefined)
+    return { paths: [...paths], partial: false, reasons: [] };
+
+  const retained: string[] = [];
+  const reasons = new Set<string>();
+  for (let offset = 0; offset < paths.length; offset += MAX_SOURCE_REVISION_CONCURRENCY) {
+    if (signal?.aborted) throw abortError();
+    const batch = paths.slice(offset, offset + MAX_SOURCE_REVISION_CONCURRENCY);
+    // oxlint-disable-next-line no-await-in-loop -- batches keep filesystem metadata concurrency and memory bounded.
+    const revisions = await Promise.all(
+      batch.map(async (path): Promise<{ path: string; revision?: SourceRevision }> => {
+        const revision = await getSourceRevision(resolve(cwd, path));
+        return revision ? { path, revision } : { path };
+      }),
+    );
+    for (const { path, revision } of revisions) {
+      if (!revision) {
+        reasons.add(
+          `Modification time unavailable for ${path}; it was excluded from the filtered set`,
+        );
+        continue;
+      }
+      if (matchesModificationTime(revision, modifiedAfterMs, modifiedBeforeMs)) retained.push(path);
+    }
+  }
+  return { paths: retained, partial: reasons.size > 0, reasons: [...reasons] };
+}

package/src/format.ts

@@ -0,0 +1,407 @@
+import { readFile } from "node:fs/promises";
+import { abortError } from "./errors.js";
+import { excerptText } from "./excerpt.js";
+import { getSourceRevision, sameSourceRevision } from "./source.js";
+import {
+  DEFAULT_RESULT_TOKEN_BUDGET,
+  ESTIMATED_CHARACTERS_PER_TOKEN,
+  MAX_CONTEXT_LINES,
+  MAX_DISPLAYED_OCCURRENCES,
+  MAX_RESULT_BYTES,
+  MAX_SOURCE_FILE_BYTES,
+} from "./types.js";
+import type { MatchRecord, SearchSnapshot, SourceRevision } from "./types.js";
+
+const RESULT_METADATA_RESERVE_BYTES = 1024;
+const RESULT_METADATA_RESERVE_CHARACTERS = 512;
+
+export class MatchPageSoftLimitError extends Error {
+  constructor() {
+    super("A single match exceeds the estimated-token detail target");
+    this.name = "MatchPageSoftLimitError";
+  }
+}
+
+function pageBodyCharacterLimit(resultTokenBudget = DEFAULT_RESULT_TOKEN_BUDGET): number {
+  if (!Number.isSafeInteger(resultTokenBudget) || resultTokenBudget <= 0) {
+    throw new Error("Result token budget must be a positive safe integer");
+  }
+  const limit =
+    resultTokenBudget * ESTIMATED_CHARACTERS_PER_TOKEN - RESULT_METADATA_RESERVE_CHARACTERS;
+  if (limit <= 0) {
+    throw new Error("Result token budget cannot fit reserved response metadata");
+  }
+  return limit;
+}
+
+export interface FormattedPage {
+  body: string;
+  returnedMatches: number;
+  nextOffset: number;
+  hasNext: boolean;
+  hasMatchRanges: boolean;
+  hasByteRanges: boolean;
+  occurrenceRangesOmitted: number;
+  occurrenceMatchesTruncated: number;
+  firstMatchIndex?: number;
+  lastMatchIndex?: number;
+  contextOmittedFiles: string[];
+  contextChangedFiles: string[];
+}
+
+function formatMetadataMatchLine(match: MatchRecord, matchIndex: number): string {
+  const occurrences = match.occurrences.length;
+  const occurrenceLabel = occurrences === 1 ? "occurrence" : "occurrences";
+  return ` ${match.lineNumber}: ${String(occurrences)} ${occurrenceLabel} {match #${String(matchIndex)}}`;
+}
+
+/** Returns location metadata only; source text is intentionally never part of public results. */
+export async function formatMatchMetadataPage(
+  snapshot: SearchSnapshot,
+  offset: number,
+  signal?: AbortSignal,
+  options: MatchPageOptions = {},
+): Promise<FormattedPage> {
+  const maxPageBodyBytes =
+    MAX_RESULT_BYTES - Math.max(RESULT_METADATA_RESERVE_BYTES, options.metadataReserveBytes ?? 0);
+  if (maxPageBodyBytes <= 0)
+    throw new Error("Continuation metadata exceeds the response byte budget; select fewer paths");
+  const maxPageBodyCharacters = pageBodyCharacterLimit(options.resultTokenBudget);
+  const output: string[] = [];
+  let returnedMatches = 0;
+  let nextOffset = offset;
+  let currentFile: string | undefined;
+  let outputBytes = 0;
+  let outputCharacters = 0;
+  let firstMatchIndex: number | undefined;
+  let lastMatchIndex: number | undefined;
+  let hasMatchRanges = false;
+  while (nextOffset < snapshot.matches.length && returnedMatches < snapshot.request.pageSize) {
+    if (signal?.aborted) throw abortError();
+    const matchIndex = nextOffset;
+    const match = snapshot.matches[matchIndex];
+    if (!match) break;
+    nextOffset += 1;
+    if (options.include && !options.include(match, matchIndex)) continue;
+    const fileHeader = match.displayPath === currentFile ? "" : `${match.displayPath}\n`;
+    const separator = output.length === 0 ? "" : fileHeader.length === 0 ? "\n" : "\n\n";
+    const addition = `${separator}${fileHeader}${formatMetadataMatchLine(match, matchIndex + 1)}`;
+    const additionBytes = Buffer.byteLength(addition);
+    const additionCharacters = addition.length;
+    if (
+      outputBytes + additionBytes > maxPageBodyBytes ||
+      outputCharacters + additionCharacters > maxPageBodyCharacters
+    ) {
+      if (returnedMatches > 0) {
+        nextOffset = matchIndex;
+        break;
+      }
+      if (additionBytes > maxPageBodyBytes)
+        throw new Error("A single match exceeds the reserved result budget");
+      throw new MatchPageSoftLimitError();
+    }
+    output.push(addition);
+    outputBytes += additionBytes;
+    outputCharacters += additionCharacters;
+    currentFile = match.displayPath;
+    returnedMatches += 1;
+    hasMatchRanges ||= match.occurrences.length > 0;
+    firstMatchIndex ??= matchIndex;
+    lastMatchIndex = matchIndex;
+  }
+  const hasNext = snapshot.matches
+    .slice(nextOffset)
+    .some((match, index) => !options.include || options.include(match, nextOffset + index));
+  const page: FormattedPage = {
+    body: output.join(""),
+    returnedMatches,
+    nextOffset,
+    hasNext,
+    hasMatchRanges,
+    hasByteRanges: false,
+    occurrenceRangesOmitted: 0,
+    occurrenceMatchesTruncated: 0,
+    contextOmittedFiles: [],
+    contextChangedFiles: [],
+  };
+  if (firstMatchIndex !== undefined) page.firstMatchIndex = firstMatchIndex;
+  if (lastMatchIndex !== undefined) page.lastMatchIndex = lastMatchIndex;
+  return page;
+}
+
+export interface MatchPageOptions {
+  resultTokenBudget?: number;
+  metadataReserveBytes?: number;
+  include?: (match: MatchRecord, index: number) => boolean;
+}
+
+type ContextLoad = { status: "available"; lines: string[] } | { status: "changed" | "unavailable" };
+
+type ContextCache = Map<string, ContextLoad>;
+
+function compactLine(line: string): string {
+  const clean = line.replaceAll("\r", "").trimEnd();
+  return excerptText(clean).text;
+}
+
+function matchLocationSuffix(match: MatchRecord): string {
+  if (match.occurrences.length === 0) return "";
+  const displayed = match.occurrences.slice(0, MAX_DISPLAYED_OCCURRENCES);
+  const ranges = displayed.map(({ range }) => {
+    const start = range.start.character + 1;
+    const end = Math.max(start, range.end.character);
+    const suffix = range.encoding === "utf-8" ? "b" : "";
+    return `${start}-${end}${suffix}`;
+  });
+  const omitted = match.occurrences.length - displayed.length;
+  const notice =
+    omitted > 0
+      ? ` [ranges: ${String(displayed.length)} of ${String(match.occurrences.length)} shown; ${String(omitted)} omitted; mode=inspect with this path/line for source]`
+      : "";
+  return ` [${ranges.join(",")}]${notice}`;
+}
+
+function formatMatchLine(match: MatchRecord, matchIndex: number): string {
+  return ` ${match.lineNumber}: ${match.lineContent}${matchLocationSuffix(match)} {match #${String(matchIndex)}}${match.lineTruncated ? " [line excerpt truncated]" : ""}`;
+}
+
+async function loadContextLines(
+  match: MatchRecord,
+  expectedRevision: SourceRevision | undefined,
+  cache: ContextCache,
+  signal?: AbortSignal,
+): Promise<ContextLoad> {
+  const cached = cache.get(match.absolutePath);
+  if (cached) return cached;
+
+  try {
+    if (signal?.aborted) throw abortError();
+    if (!expectedRevision || expectedRevision.size > MAX_SOURCE_FILE_BYTES) {
+      const unavailable = { status: "unavailable" as const };
+      cache.set(match.absolutePath, unavailable);
+      return unavailable;
+    }
+    const beforeRevision = await getSourceRevision(match.absolutePath);
+    if (!beforeRevision || !sameSourceRevision(expectedRevision, beforeRevision)) {
+      const changed = { status: "changed" as const };
+      cache.set(match.absolutePath, changed);
+      return changed;
+    }
+    const content = await readFile(match.absolutePath, { encoding: "utf8", signal });
+    const afterRevision = await getSourceRevision(match.absolutePath);
+    if (!afterRevision || !sameSourceRevision(expectedRevision, afterRevision)) {
+      const changed = { status: "changed" as const };
+      cache.set(match.absolutePath, changed);
+      return changed;
+    }
+    const available = {
+      status: "available" as const,
+      lines: content.replaceAll("\r", "").split("\n"),
+    };
+    cache.set(match.absolutePath, available);
+    return available;
+  } catch (error) {
+    if (signal?.aborted || (error instanceof Error && error.name === "AbortError")) {
+      throw abortError();
+    }
+    const unavailable = { status: "unavailable" as const };
+    cache.set(match.absolutePath, unavailable);
+    return unavailable;
+  }
+}
+
+interface MatchContextWindow {
+  startLine: number;
+  endLine: number;
+}
+
+interface FormattedMatchBlock {
+  text: string;
+  contextStatus: "available" | "changed" | "unavailable" | "none";
+}
+
+function matchContextWindows(
+  snapshot: SearchSnapshot,
+  include: MatchPageOptions["include"],
+): Map<MatchRecord, MatchContextWindow> {
+  const windows = new Map<MatchRecord, MatchContextWindow>();
+  const context = Math.min(Math.max(0, snapshot.request.context), MAX_CONTEXT_LINES);
+  if (context === 0) return windows;
+
+  const selectedFiles = new Map<string, MatchRecord[]>();
+  for (const [index, match] of snapshot.matches.entries()) {
+    if (include && !include(match, index)) continue;
+    const matches = selectedFiles.get(match.absolutePath) ?? [];
+    matches.push(match);
+    selectedFiles.set(match.absolutePath, matches);
+  }
+  for (const matches of selectedFiles.values()) {
+    const ordered = matches.toSorted((left, right) => left.lineNumber - right.lineNumber);
+    for (const [index, match] of ordered.entries()) {
+      const previous = ordered[index - 1];
+      const next = ordered[index + 1];
+      // Each context line belongs to its nearest selected match; ties belong to the earlier one.
+      // This partitions overlapping windows without guessing what a previous cursor page emitted.
+      windows.set(match, {
+        startLine: Math.max(
+          1,
+          match.lineNumber - context,
+          previous ? Math.floor((previous.lineNumber + match.lineNumber) / 2) + 1 : 1,
+        ),
+        endLine: Math.min(
+          match.lineNumber + context,
+          next ? Math.floor((match.lineNumber + next.lineNumber) / 2) : Number.MAX_SAFE_INTEGER,
+        ),
+      });
+    }
+  }
+  return windows;
+}
+
+async function formatBlock(
+  match: MatchRecord,
+  matchIndex: number,
+  expectedRevision: SourceRevision | undefined,
+  window: MatchContextWindow | undefined,
+  cache: ContextCache,
+  allMatchLines: Map<string, Set<number>>,
+  signal?: AbortSignal,
+): Promise<FormattedMatchBlock> {
+  const matchingLine = formatMatchLine(match, matchIndex);
+  if (!window) return { text: matchingLine, contextStatus: "none" };
+
+  const contextLoad = await loadContextLines(match, expectedRevision, cache, signal);
+  if (contextLoad.status !== "available") {
+    return { text: matchingLine, contextStatus: contextLoad.status };
+  }
+  const { lines } = contextLoad;
+  const output: string[] = [];
+  for (let lineNumber = window.startLine; lineNumber <= window.endLine; lineNumber += 1) {
+    if (lineNumber === match.lineNumber) {
+      output.push(matchingLine);
+    } else if (
+      lineNumber <= lines.length &&
+      !allMatchLines.get(match.absolutePath)?.has(lineNumber)
+    ) {
+      output.push(` ${lineNumber}- ${compactLine(lines[lineNumber - 1] ?? "")}`);
+    }
+  }
+  return { text: output.join("\n"), contextStatus: "available" };
+}
+
+export async function formatMatchPage(
+  snapshot: SearchSnapshot,
+  offset: number,
+  signal?: AbortSignal,
+  options: MatchPageOptions = {},
+): Promise<FormattedPage> {
+  const maxPageBodyBytes =
+    MAX_RESULT_BYTES - Math.max(RESULT_METADATA_RESERVE_BYTES, options.metadataReserveBytes ?? 0);
+  if (maxPageBodyBytes <= 0)
+    throw new Error("Continuation metadata exceeds the response byte budget; select fewer paths");
+  const maxPageBodyCharacters = pageBodyCharacterLimit(options.resultTokenBudget);
+  const cache: ContextCache = new Map();
+  const omittedFiles = new Set<string>();
+  const changedFiles = new Set<string>();
+  const output: string[] = [];
+  let returnedMatches = 0;
+  let nextOffset = offset;
+  let currentFile: string | undefined;
+  let outputBytes = 0;
+  let outputCharacters = 0;
+  let firstMatchIndex: number | undefined;
+  let lastMatchIndex: number | undefined;
+  let hasMatchRanges = false;
+  let hasByteRanges = false;
+  let occurrenceRangesOmitted = 0;
+  let occurrenceMatchesTruncated = 0;
+  const contextWindows = matchContextWindows(snapshot, options.include);
+  const allMatchLines = new Map<string, Set<number>>();
+  if (contextWindows.size > 0) {
+    for (const match of snapshot.matches) {
+      const lines = allMatchLines.get(match.absolutePath) ?? new Set<number>();
+      lines.add(match.lineNumber);
+      allMatchLines.set(match.absolutePath, lines);
+    }
+  }
+
+  while (nextOffset < snapshot.matches.length && returnedMatches < snapshot.request.pageSize) {
+    if (signal?.aborted) throw abortError();
+    const matchIndex = nextOffset;
+    const match = snapshot.matches[matchIndex];
+    if (!match) break;
+    nextOffset += 1;
+    if (options.include && !options.include(match, matchIndex)) continue;
+    // Formatting is sequential because each block consumes the remaining shared byte budget.
+    // oxlint-disable-next-line no-await-in-loop -- the shared output budget is consumed in order.
+    let block = await formatBlock(
+      match,
+      matchIndex + 1,
+      snapshot.sourceRevisions.get(match.absolutePath),
+      contextWindows.get(match),
+      cache,
+      allMatchLines,
+      signal,
+    );
+    const fileHeader = match.displayPath === currentFile ? "" : `${match.displayPath}\n`;
+    const separator = output.length === 0 ? "" : fileHeader.length === 0 ? "\n" : "\n\n";
+    let addition = `${separator}${fileHeader}${block.text}`;
+    let additionBytes = Buffer.byteLength(addition);
+    let additionCharacters = addition.length;
+    const exceedsBudget = () =>
+      outputBytes + additionBytes > maxPageBodyBytes ||
+      outputCharacters + additionCharacters > maxPageBodyCharacters;
+
+    if (exceedsBudget()) {
+      if (returnedMatches > 0) {
+        nextOffset = matchIndex;
+        break;
+      }
+      block = { text: formatMatchLine(match, matchIndex + 1), contextStatus: "unavailable" };
+      addition = `${fileHeader}${block.text}`;
+      additionBytes = Buffer.byteLength(addition);
+      additionCharacters = addition.length;
+    }
+    if (additionBytes > maxPageBodyBytes) {
+      throw new Error("A single match exceeds the reserved result budget");
+    }
+    if (additionCharacters > maxPageBodyCharacters) throw new MatchPageSoftLimitError();
+
+    output.push(addition);
+    outputBytes += additionBytes;
+    outputCharacters += additionCharacters;
+    currentFile = match.displayPath;
+    returnedMatches += 1;
+    hasMatchRanges ||= match.occurrences.length > 0;
+    hasByteRanges ||= match.occurrences
+      .slice(0, MAX_DISPLAYED_OCCURRENCES)
+      .some(({ range }) => range.encoding === "utf-8");
+    const omittedRanges = Math.max(0, match.occurrences.length - MAX_DISPLAYED_OCCURRENCES);
+    occurrenceRangesOmitted += omittedRanges;
+    if (omittedRanges > 0) occurrenceMatchesTruncated += 1;
+    if (block.contextStatus === "changed") changedFiles.add(match.displayPath);
+    if (block.contextStatus === "unavailable") omittedFiles.add(match.displayPath);
+    firstMatchIndex ??= matchIndex;
+    lastMatchIndex = matchIndex;
+  }
+
+  const hasNext = snapshot.matches
+    .slice(nextOffset)
+    .some((match, index) => !options.include || options.include(match, nextOffset + index));
+
+  const page: FormattedPage = {
+    body: output.join(""),
+    returnedMatches,
+    nextOffset,
+    hasNext,
+    hasMatchRanges,
+    hasByteRanges,
+    occurrenceRangesOmitted,
+    occurrenceMatchesTruncated,
+    contextOmittedFiles: [...omittedFiles].toSorted((left, right) => left.localeCompare(right)),
+    contextChangedFiles: [...changedFiles].toSorted((left, right) => left.localeCompare(right)),
+  };
+  if (firstMatchIndex !== undefined) page.firstMatchIndex = firstMatchIndex;
+  if (lastMatchIndex !== undefined) page.lastMatchIndex = lastMatchIndex;
+  return page;
+}

package/src/git-diff.ts

@@ -0,0 +1,195 @@
+import { setImmediate } from "node:timers/promises";
+import { MAX_GIT_DIFF_WORK } from "./analysis-limits.js";
+import { abortError, SiftLightError } from "./errors.js";
+
+export interface GitLineRange {
+  startLine: number;
+  endLine: number;
+}
+
+export class GitDiffLimitError extends SiftLightError {}
+
+/** One work counter is shared by every file and rename comparison in a request. */
+export class GitDiffBudget {
+  work = 0;
+
+  readonly maxWork: number;
+  readonly signal: AbortSignal | undefined;
+
+  constructor(maxWork = MAX_GIT_DIFF_WORK, signal?: AbortSignal) {
+    this.maxWork = maxWork;
+    this.signal = signal;
+  }
+
+  tick(): boolean {
+    if (this.signal?.aborted) throw abortError();
+    this.work += 1;
+    if (this.work > this.maxWork) {
+      throw new GitDiffLimitError(
+        `Git line comparison exceeds the ${String(this.maxWork)} step limit`,
+      );
+    }
+    return this.work % 4096 === 0;
+  }
+}
+
+/* oxlint-disable no-await-in-loop -- sequential CPU work yields regularly for cancellation. */
+async function sourceLines(content: Buffer, budget: GitDiffBudget): Promise<string[]> {
+  const lines: string[] = [];
+  for (let start = 0; start < content.length;) {
+    if (budget.tick()) await setImmediate();
+    const newline = content.indexOf(10, start);
+    const end = newline === -1 ? content.length : newline + 1;
+    // Latin-1 is a reversible byte mapping, so malformed UTF-8 and CRLF remain distinct.
+    lines.push(content.toString("latin1", start, end));
+    start = end;
+  }
+  return lines;
+}
+
+/* oxlint-enable no-await-in-loop */
+
+export function sourceLineCount(content: Buffer): number {
+  if (content.length === 0) return 0;
+  let count = content[content.length - 1] === 10 ? 0 : 1;
+  for (const byte of content) if (byte === 10) count += 1;
+  return count;
+}
+
+function diagonal(vector: Int32Array, distance: number, k: number): number {
+  return vector[k + distance + 1] ?? -1;
+}
+
+function prependLine(ranges: GitLineRange[], line: number): void {
+  const last = ranges.at(-1);
+  if (last && last.startLine === line + 1) last.startLine = line;
+  else ranges.push({ startLine: line, endLine: line });
+}
+
+function reconstruct(
+  trace: Int32Array[],
+  oldLength: number,
+  newLength: number,
+  prefix: number,
+): { oldRanges: GitLineRange[]; newRanges: GitLineRange[] } {
+  let x = oldLength;
+  let y = newLength;
+  const oldRanges: GitLineRange[] = [];
+  const newRanges: GitLineRange[] = [];
+  for (let distance = trace.length - 1; distance > 0; distance -= 1) {
+    const previous = trace[distance - 1];
+    if (!previous) throw new Error("Missing Git line comparison trace");
+    const k = x - y;
+    const previousK =
+      k === -distance ||
+      (k !== distance &&
+        diagonal(previous, distance - 1, k - 1) < diagonal(previous, distance - 1, k + 1))
+        ? k + 1
+        : k - 1;
+    const previousX = diagonal(previous, distance - 1, previousK);
+    const previousY = previousX - previousK;
+    while (x > previousX && y > previousY) {
+      x -= 1;
+      y -= 1;
+    }
+    if (x === previousX) {
+      prependLine(newRanges, prefix + y);
+      y -= 1;
+    } else {
+      prependLine(oldRanges, prefix + x);
+      x -= 1;
+    }
+  }
+  return { oldRanges: oldRanges.toReversed(), newRanges: newRanges.toReversed() };
+}
+
+/** Myers shortest edit script over raw LF-delimited lines, with bounded trace and cancellation. */
+/* oxlint-disable no-await-in-loop -- each frontier depends on its predecessor; yields allow cancellation. */
+export async function changedLineRanges(
+  oldContent: Buffer,
+  newContent: Buffer,
+  budget = new GitDiffBudget(),
+): Promise<{ oldRanges: GitLineRange[]; newRanges: GitLineRange[] }> {
+  if (budget.signal?.aborted) throw abortError();
+  if (oldContent.equals(newContent)) return { oldRanges: [], newRanges: [] };
+  const oldLines = await sourceLines(oldContent, budget);
+  const newLines = await sourceLines(newContent, budget);
+  let prefix = 0;
+  while (
+    prefix < oldLines.length &&
+    prefix < newLines.length &&
+    oldLines[prefix] === newLines[prefix]
+  ) {
+    if (budget.tick()) await setImmediate();
+    prefix += 1;
+  }
+  let oldEnd = oldLines.length;
+  let newEnd = newLines.length;
+  while (oldEnd > prefix && newEnd > prefix && oldLines[oldEnd - 1] === newLines[newEnd - 1]) {
+    if (budget.tick()) await setImmediate();
+    oldEnd -= 1;
+    newEnd -= 1;
+  }
+  const n = oldEnd - prefix;
+  const m = newEnd - prefix;
+  if (n === 0 || m === 0) {
+    return {
+      oldRanges: n === 0 ? [] : [{ startLine: prefix + 1, endLine: oldEnd }],
+      newRanges: m === 0 ? [] : [{ startLine: prefix + 1, endLine: newEnd }],
+    };
+  }
+  const trace: Int32Array[] = [];
+  for (let distance = 0; distance <= n + m; distance += 1) {
+    const current = new Int32Array(2 * distance + 3).fill(-1);
+    const previous = trace[distance - 1];
+    for (let k = -distance; k <= distance; k += 2) {
+      if (budget.tick()) await setImmediate();
+      let x = 0;
+      if (previous) {
+        x =
+          k === -distance ||
+          (k !== distance &&
+            diagonal(previous, distance - 1, k - 1) < diagonal(previous, distance - 1, k + 1))
+            ? diagonal(previous, distance - 1, k + 1)
+            : diagonal(previous, distance - 1, k - 1) + 1;
+      }
+      let y = x - k;
+      while (x < n && y < m && oldLines[prefix + x] === newLines[prefix + y]) {
+        if (budget.tick()) await setImmediate();
+        x += 1;
+        y += 1;
+      }
+      current[k + distance + 1] = x;
+      if (x >= n && y >= m) {
+        trace.push(current);
+        return reconstruct(trace, n, m, prefix);
+      }
+    }
+    trace.push(current);
+  }
+  throw new Error("Git line comparison did not produce an edit script");
+}
+
+/* oxlint-enable no-await-in-loop */
+
+/** A bounded byte-weighted line multiset score; this is explicitly heuristic, not rename history. */
+export async function sourceSimilarity(
+  oldContent: Buffer,
+  newContent: Buffer,
+  budget: GitDiffBudget,
+): Promise<number> {
+  if (oldContent.equals(newContent)) return 100;
+  const maximum = Math.max(oldContent.length, newContent.length);
+  if (maximum === 0 || Math.min(oldContent.length, newContent.length) / maximum < 0.5) return 0;
+  const counts = new Map<string, number>();
+  for (const line of await sourceLines(oldContent, budget))
+    counts.set(line, (counts.get(line) ?? 0) + 1);
+  let commonBytes = 0;
+  for (const line of await sourceLines(newContent, budget)) {
+    const remaining = counts.get(line) ?? 0;
+    if (remaining === 0) continue;
+    counts.set(line, remaining - 1);
+    commonBytes += line.length;
+  }
+  return Math.min(99, Math.floor((100 * commonBytes) / maximum));
+}