@shiyuphan/follow-me 0.5.1 → 0.7.1

package/dist/src/coverage.js

@@ -0,0 +1,397 @@
+import { realpathSync } from "node:fs";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+import { isRepoPath, isSha, tipStartOf } from "./diff.js";
+import { GitError, pathsChanged } from "./git.js";
+import { isFields } from "./plan.js";
+/** lcov input that cannot be read, with the 1-based line it fails on. */
+export class LcovError extends Error {
+    name = "LcovError";
+    line;
+    constructor(line, reason) {
+        super(`lcov line ${line}: ${reason}`);
+        this.line = line;
+    }
+}
+const RECORD = /^([A-Z][A-Z0-9_]*):(.*)$/;
+const DA = /^([1-9][0-9]*),([0-9]+)(?:,.*)?$/;
+const BRDA = /^([1-9][0-9]*),([^,]+),(.+),(-|[0-9]+)$/;
+/**
+ * Reads lcov's tracefile format: TN names the test of the records after it, SF opens a file, DA
+ * and BRDA give line and branch hits, end_of_record closes it. Other records are skipped.
+ */
+export function parseLcov(text) {
+    const records = [];
+    let test = null;
+    let open = null;
+    const close = () => {
+        if (open !== null)
+            records.push(open);
+        open = null;
+    };
+    const rows = text.split("\n");
+    for (const [i, raw] of rows.entries()) {
+        const n = i + 1;
+        const row = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
+        if (row.trim() === "")
+            continue;
+        if (row === "end_of_record") {
+            close();
+            continue;
+        }
+        const m = RECORD.exec(row);
+        if (m === null)
+            throw new LcovError(n, `"${row.slice(0, 60)}" is not an lcov record`);
+        const [, key = "", value = ""] = m;
+        if (key === "TN") {
+            test = value.trim() === "" ? null : value.trim();
+            continue;
+        }
+        if (key === "SF") {
+            close();
+            if (value === "")
+                throw new LcovError(n, "SF needs a path");
+            open = { path: value, test, lines: new Map(), branches: new Map() };
+            continue;
+        }
+        if (key !== "DA" && key !== "BRDA")
+            continue;
+        if (open === null)
+            throw new LcovError(n, `${key} comes before any SF`);
+        if (key === "DA") {
+            const da = DA.exec(value);
+            if (da === null)
+                throw new LcovError(n, `DA needs <line>,<hits>, got "${value}"`);
+            const line = Number(da[1]);
+            open.lines.set(line, (open.lines.get(line) ?? 0) + Number(da[2]));
+            continue;
+        }
+        const br = BRDA.exec(value);
+        if (br === null) {
+            throw new LcovError(n, `BRDA needs <line>,<block>,<branch>,<taken>, got "${value}"`);
+        }
+        const line = Number(br[1]);
+        const id = `${br[2]},${br[3]}`;
+        const taken = br[4] !== "-" && Number(br[4]) > 0;
+        const branches = open.branches.get(line) ?? new Map();
+        branches.set(id, (branches.get(id) ?? false) || taken);
+        open.branches.set(line, branches);
+    }
+    close();
+    if (records.length === 0)
+        throw new LcovError(rows.length, "no SF record; is this lcov?");
+    return records;
+}
+/**
+ * Where an lcov path is at the tip: absolute, or relative to cwd and failing that to the root,
+ * symlinks resolved, then relative to the root. Null outside the repo or for a file the tip lacks.
+ */
+export function tipPlacer(root, cwd, atTip) {
+    const real = (p) => {
+        try {
+            return realpathSync(p);
+        }
+        catch {
+            return p;
+        }
+    };
+    const tops = [root, real(root)];
+    return (raw) => {
+        const tried = isAbsolute(raw) ? [raw] : [resolve(cwd, raw), resolve(root, raw)];
+        for (const abs of tried.flatMap((p) => [p, real(p)])) {
+            for (const top of tops) {
+                const rel = relative(top, abs);
+                if (rel === "" || rel.startsWith("..") || isAbsolute(rel))
+                    continue;
+                const path = Buffer.from(rel.split(sep).join("/"), "utf8").toString("latin1");
+                if (isRepoPath(path) && atTip.has(path))
+                    return path;
+            }
+        }
+        return null;
+    };
+}
+/** Sums hits and joins branches over records of the same file; drops what `place` rejects. */
+export function runOf(records, place) {
+    const lines = new Map();
+    const branches = new Map();
+    const tests = new Map();
+    for (const record of records) {
+        const path = place(record.path);
+        if (path === null)
+            continue;
+        const hits = lines.get(path) ?? new Map();
+        for (const [line, n] of record.lines)
+            hits.set(line, (hits.get(line) ?? 0) + n);
+        lines.set(path, hits);
+        const joined = branches.get(path) ?? new Map();
+        for (const [line, ids] of record.branches) {
+            const on = joined.get(line) ?? new Map();
+            for (const [id, taken] of ids)
+                on.set(id, (on.get(id) ?? false) || taken);
+            joined.set(line, on);
+        }
+        branches.set(path, joined);
+        if (record.test === null)
+            continue;
+        const ran = tests.get(record.test) ?? new Map();
+        const set = ran.get(path) ?? new Set();
+        for (const [line, n] of record.lines)
+            if (n > 0)
+                set.add(line);
+        ran.set(path, set);
+        tests.set(record.test, ran);
+    }
+    const files = new Map();
+    for (const [path, hits] of lines) {
+        const counted = new Map();
+        for (const [line, ids] of branches.get(path) ?? []) {
+            counted.set(line, [[...ids.values()].filter(Boolean).length, ids.size]);
+        }
+        files.set(path, { lines: sorted(hits), branches: sorted(counted) });
+    }
+    return {
+        files,
+        tests: new Map([...tests].map(([id, ran]) => [
+            id,
+            new Map([...ran].map(([path, set]) => [path, [...set].sort((a, b) => a - b)])),
+        ])),
+    };
+}
+function sorted(map) {
+    return new Map([...map].sort(([a], [b]) => a - b));
+}
+/** The lines of each file with at least one hit. */
+function hitLines(files) {
+    return new Map([...files].map(([path, f]) => [path, [...f.lines].flatMap(([l, n]) => (n > 0 ? [l] : []))]));
+}
+/**
+ * Per-test runs only add: a line keeps the larger count, so they never inflate an aggregate run
+ * of the same suite, and running the same test twice changes nothing.
+ */
+function mergeMax(a, b) {
+    const out = new Map(a);
+    for (const [path, f] of b) {
+        const had = out.get(path);
+        if (had === undefined) {
+            out.set(path, f);
+            continue;
+        }
+        const lines = new Map(had.lines);
+        for (const [l, n] of f.lines)
+            lines.set(l, Math.max(n, lines.get(l) ?? 0));
+        const branches = new Map(had.branches);
+        for (const [l, [taken, total]] of f.branches) {
+            const [t, n] = branches.get(l) ?? [0, 0];
+            branches.set(l, [Math.max(taken, t), Math.max(total, n)]);
+        }
+        out.set(path, { lines: sorted(lines), branches: sorted(branches) });
+    }
+    return out;
+}
+/**
+ * The coverage after this run. A plain run replaces everything, its TN blocks becoming its tests.
+ * A named test's run adds to what is already there for the same tip, and starts over otherwise.
+ */
+export function recordRun(prior, run, at) {
+    const { tip, takenAt, test } = at;
+    if (test === undefined) {
+        const tests = new Map([...run.tests].map(([id, lines]) => [id, { lines }]));
+        return { tip, takenAt, files: run.files, tests };
+    }
+    const base = prior !== null && prior.tip === tip ? prior : null;
+    const tests = new Map(base?.tests ?? []);
+    const entry = {
+        ...(test.at === undefined ? {} : { at: test.at }),
+        lines: hitLines(run.files),
+    };
+    tests.set(test.id, entry);
+    const files = base === null ? run.files : mergeMax(base.files, run.files);
+    return { tip, takenAt, files, tests };
+}
+/**
+ * Per file, the branch's added rows that lcov calls executable, and how many ran. Every added
+ * row is a tip line, which is where the run was taken. Files without such rows are left out.
+ */
+export function changedLines(units, files) {
+    const out = new Map();
+    for (const unit of units.values()) {
+        if (unit.kind !== "hunk")
+            continue;
+        const file = files.get(unit.path);
+        if (file === undefined)
+            continue;
+        let line = tipStartOf(unit, units);
+        let { covered, executable } = out.get(unit.path) ?? { covered: 0, executable: 0 };
+        for (const row of unit.body) {
+            const hits = row.op === "+" ? file.lines.get(line) : undefined;
+            if (hits !== undefined) {
+                executable += 1;
+                if (hits > 0)
+                    covered += 1;
+            }
+            if (row.op !== "-")
+                line += 1;
+        }
+        if (executable > 0)
+            out.set(unit.path, { covered, executable });
+    }
+    return out;
+}
+export function totalOf(tallies) {
+    let covered = 0;
+    let executable = 0;
+    for (const t of tallies) {
+        covered += t.covered;
+        executable += t.executable;
+    }
+    return { covered, executable };
+}
+/**
+ * Covered files whose content at `tip` differs from where the run was taken, in file order.
+ * When the run's commit is gone from the repo, every file is stale.
+ */
+export async function staleFiles(repo, coverage, tip) {
+    if (coverage.tip === tip)
+        return [];
+    let changed;
+    try {
+        changed = await pathsChanged(repo, coverage.tip, tip);
+    }
+    catch (error) {
+        if (!(error instanceof GitError))
+            throw error;
+        changed = new Set(coverage.files.keys());
+    }
+    return [...coverage.files.keys()].filter((p) => changed.has(p));
+}
+/** The files whose coverage still describes the tip. */
+export function freshFiles(coverage, stale) {
+    const gone = new Set(stale);
+    return new Map([...coverage.files].filter(([path]) => !gone.has(path)));
+}
+export function serializeCoverage(c) {
+    const files = Object.fromEntries([...c.files].map(([path, f]) => [
+        path,
+        {
+            lines: Object.fromEntries(f.lines),
+            ...(f.branches.size === 0 ? {} : { branches: Object.fromEntries(f.branches) }),
+        },
+    ]));
+    const tests = Object.fromEntries([...c.tests].map(([id, t]) => [
+        id,
+        {
+            ...(t.at === undefined ? {} : { at: t.at }),
+            lines: Object.fromEntries([...t.lines].map(([p, ls]) => [p, [...ls]])),
+        },
+    ]));
+    return { tip: c.tip, takenAt: c.takenAt, files, ...(c.tests.size === 0 ? {} : { tests }) };
+}
+const LINE_KEY = /^[1-9][0-9]*$/;
+function isCount(v) {
+    return typeof v === "number" && Number.isInteger(v) && v >= 0;
+}
+function isLine(v) {
+    return typeof v === "number" && Number.isInteger(v) && v >= 1;
+}
+function entries(v) {
+    return isFields(v) ? Object.entries(v) : null;
+}
+function parseLoc(v) {
+    if (!isFields(v))
+        return null;
+    const { path, start, end } = v;
+    if (typeof path !== "string" || !isRepoPath(path) || !isLine(start) || !isLine(end))
+        return null;
+    return end < start ? null : { path, start, end };
+}
+/** Like parseLoc, for argv: "path:line" or "path:start-end", the path placed like lcov's. */
+export function parseLocArg(raw, place) {
+    const m = /^(.+):([1-9][0-9]*)(?:-([1-9][0-9]*))?$/.exec(raw);
+    if (m === null)
+        return `--at ${raw} is not <path>:<line> or <path>:<start>-<end>`;
+    const path = place(m[1] ?? "");
+    if (path === null)
+        return `--at ${raw} names no file of the branch tip`;
+    const start = Number(m[2]);
+    const end = m[3] === undefined ? start : Number(m[3]);
+    return end < start ? `--at ${raw} runs backwards` : { path, start, end };
+}
+function parseFile(v) {
+    if (!isFields(v))
+        return "a file is not an object";
+    const lines = entries(v.lines);
+    if (lines === null)
+        return "lines is not an object";
+    const hits = new Map();
+    for (const [key, n] of lines) {
+        if (!LINE_KEY.test(key) || !isCount(n))
+            return `line ${key} has no hit count`;
+        hits.set(Number(key), n);
+    }
+    const branchEntries = entries(v.branches ?? {});
+    if (branchEntries === null)
+        return "branches is not an object";
+    const branches = new Map();
+    for (const [key, pair] of branchEntries) {
+        if (!LINE_KEY.test(key) || !Array.isArray(pair) || pair.length !== 2) {
+            return `branches of line ${key} are not [taken, total]`;
+        }
+        const [taken, total] = pair;
+        if (!isCount(taken) || !isCount(total) || taken > total) {
+            return `branches of line ${key} are not [taken, total]`;
+        }
+        branches.set(Number(key), [taken, total]);
+    }
+    return { lines: sorted(hits), branches: sorted(branches) };
+}
+function parseTest(v) {
+    if (!isFields(v))
+        return "a test is not an object";
+    const at = v.at === undefined ? undefined : parseLoc(v.at);
+    if (at === null)
+        return "at is not a { path, start, end }";
+    const lineEntries = entries(v.lines);
+    if (lineEntries === null)
+        return "lines is not an object";
+    const lines = new Map();
+    for (const [path, list] of lineEntries) {
+        if (!isRepoPath(path) || !Array.isArray(list) || !list.every(isLine)) {
+            return `lines of ${path} are not line numbers`;
+        }
+        lines.set(path, list);
+    }
+    return { ...(at === undefined ? {} : { at }), lines };
+}
+/** The one place coverage.json becomes a Coverage. */
+export function parseCoverage(v) {
+    if (!isFields(v))
+        return "not an object";
+    const { tip, takenAt } = v;
+    if (typeof tip !== "string" || !isSha(tip))
+        return "tip is not an object id";
+    if (typeof takenAt !== "string")
+        return "takenAt is not a time";
+    const fileEntries = entries(v.files);
+    if (fileEntries === null)
+        return "files is not an object";
+    const files = new Map();
+    for (const [path, raw] of fileEntries) {
+        if (!isRepoPath(path))
+            return "a file has no path";
+        const file = parseFile(raw);
+        if (typeof file === "string")
+            return `${path}: ${file}`;
+        files.set(path, file);
+    }
+    const testEntries = entries(v.tests ?? {});
+    if (testEntries === null)
+        return "tests is not an object";
+    const tests = new Map();
+    for (const [id, raw] of testEntries) {
+        const test = parseTest(raw);
+        if (typeof test === "string")
+            return `test ${id}: ${test}`;
+        tests.set(id, test);
+    }
+    return { tip, takenAt, files, tests };
+}

package/dist/src/definition.js

@@ -0,0 +1,226 @@
+import { posix } from "node:path";
+import { splitLines, tipStartOf } from "./diff.js";
+import { blobsAt, grepTip } from "./git.js";
+export const MAX_CANDIDATES = 10;
+const PREVIEW_LINES = 8;
+/** An ASCII identifier as JS, Python, Go, Rust, JVM languages, Ruby and C spell one. */
+export function isIdentifier(s) {
+    return /^[A-Za-z_$][A-Za-z0-9_$]{0,127}$/.test(s);
+}
+const JS_MODS = "((static|async|public|private|protected|readonly|override|get|set)\\s+)*";
+const RUST_VIS = "(pub([(][^)]*[)])?\\s+)?";
+const JAVA_MODS = "((public|private|protected|static|final|abstract|synchronized|native|default|strictfp)\\s+)*";
+const JVM_CLASS_MODS = "((public|private|protected|static|final|abstract|sealed|data|open|internal|inner|enum|annotation)\\s+)*";
+const KOTLIN_MODS = "((public|private|protected|internal|override|open|abstract|suspend|inline|operator|infix|tailrec|external|actual|expect)\\s+)*";
+const STATEMENT = /^\s*(return|new|throw|else|case|yield|await|typedef|delete|goto)\b/;
+const LANGUAGES = [
+    {
+        extensions: [".js", ".jsx", ".mjs", ".cjs", ".ts", ".tsx", ".mts", ".cts"],
+        patterns: [
+            {
+                kind: "function",
+                source: "^\\s*(export\\s+)?(default\\s+)?(async\\s+)?function\\s*[*]?\\s*NAME\\s*[(<]",
+            },
+            {
+                kind: "const",
+                source: "^\\s*(export\\s+)?(declare\\s+)?(const|let|var)\\s+NAME\\s*(:[^=]*)?=",
+            },
+            {
+                kind: "class",
+                source: "^\\s*(export\\s+)?(default\\s+)?(declare\\s+)?(abstract\\s+)?class\\s+NAMEEND",
+            },
+            {
+                kind: "type",
+                source: "^\\s*(export\\s+)?(declare\\s+)?(interface|type|(const\\s+)?enum)\\s+NAMEEND",
+            },
+            {
+                kind: "method",
+                source: `^\\s+${JS_MODS}[*]?NAME\\s*(<[^>]*>)?[(].*[)]\\s*(:[^={;]+)?[{]\\s*$`,
+                reject: /^\s*(if|for|while|switch|catch|return)\b/,
+            },
+        ],
+    },
+    {
+        extensions: [".py", ".pyi"],
+        patterns: [
+            { kind: "function", source: "^(async\\s+)?def\\s+NAME\\s*[(]" },
+            { kind: "method", source: "^\\s+(async\\s+)?def\\s+NAME\\s*[(]" },
+            { kind: "class", source: "^\\s*class\\s+NAME\\s*[(:]" },
+        ],
+    },
+    {
+        extensions: [".go"],
+        patterns: [
+            { kind: "function", source: "^func\\s+NAME\\s*[[(]" },
+            { kind: "method", source: "^func\\s*[(][^)]*[)]\\s*NAME\\s*[[(]" },
+            { kind: "type", source: "^\\s*type\\s+NAMEEND" },
+        ],
+    },
+    {
+        extensions: [".rs"],
+        patterns: [
+            {
+                kind: "function",
+                source: `^${RUST_VIS}((const|async|unsafe|extern)\\s+("[^"]*"\\s+)?)*fn\\s+NAME\\s*[<(]`,
+            },
+            {
+                kind: "method",
+                source: `^\\s+${RUST_VIS}((const|async|unsafe|extern)\\s+("[^"]*"\\s+)?)*fn\\s+NAME\\s*[<(]`,
+            },
+            { kind: "class", source: `^\\s*${RUST_VIS}struct\\s+NAMEEND` },
+            { kind: "type", source: `^\\s*${RUST_VIS}(enum|trait|type)\\s+NAMEEND` },
+            { kind: "other", source: "^\\s*impl(<[^>]*>)?\\s+([A-Za-z0-9_:<>, ]+\\s+for\\s+)?NAMEEND" },
+        ],
+    },
+    {
+        extensions: [".java", ".kt", ".kts"],
+        patterns: [
+            { kind: "class", source: `^\\s*${JVM_CLASS_MODS}(class|object|record)\\s+NAMEEND` },
+            { kind: "type", source: `^\\s*${JVM_CLASS_MODS}(interface|enum|@interface)\\s+NAMEEND` },
+            {
+                kind: "function",
+                source: `^\\s*${KOTLIN_MODS}fun\\s+(<[^>]*>\\s*)?([A-Za-z0-9_.<>]+[.])?NAME\\s*[(]`,
+            },
+            {
+                kind: "method",
+                source: `^\\s*${JAVA_MODS}(<[^>]*>\\s+)?[A-Za-z_][A-Za-z0-9_<>,.?]*(\\[\\])*\\s+NAME\\s*[(][^;]*$`,
+                reject: STATEMENT,
+            },
+        ],
+    },
+    {
+        extensions: [".rb"],
+        patterns: [
+            { kind: "method", source: "^\\s*def\\s+(self[.])?NAMEEND" },
+            { kind: "class", source: "^\\s*class\\s+NAMEEND" },
+            { kind: "other", source: "^\\s*module\\s+NAMEEND" },
+        ],
+    },
+    {
+        extensions: [".c", ".h", ".cc", ".cpp", ".cxx", ".hh", ".hpp", ".hxx"],
+        patterns: [
+            {
+                kind: "function",
+                source: "^[A-Za-z_][A-Za-z0-9_ *&<>,:~]*[ *&]([A-Za-z_][A-Za-z0-9_]*::)*NAME\\s*[(][^;]*$",
+                reject: STATEMENT,
+            },
+            { kind: "function", source: "^NAME\\s*[(][^;]*$" },
+            { kind: "class", source: "^\\s*(typedef\\s+)?(struct|class|union)\\s+NAME\\s*([{:]|$)" },
+            { kind: "type", source: "^\\s*(typedef\\s+)?enum\\s+(class\\s+)?NAME\\s*([{:]|$)" },
+        ],
+    },
+];
+const END = "([^A-Za-z0-9_$]|$)";
+function spell(source, name) {
+    return source
+        .replaceAll("NAMEEND", `${name.replaceAll("$", "[$]")}${END}`)
+        .replaceAll("NAME", name.replaceAll("$", "[$]"));
+}
+function toEre(source) {
+    return source.replaceAll("\\s", "[[:space:]]");
+}
+function languageOf(path) {
+    const ext = posix.extname(path).toLowerCase();
+    return LANGUAGES.find((l) => l.extensions.includes(ext)) ?? null;
+}
+/** What the match defines by the patterns of its file's language, or null when it is no definition. */
+function kindOf(match, name) {
+    const language = languageOf(match.path);
+    if (language === null)
+        return null;
+    const hit = language.patterns.find((p) => new RegExp(spell(p.source, name)).test(match.text) && !p.reject?.test(match.text));
+    return hit?.kind ?? null;
+}
+/** Same file as `from` first, then the same directory, then the rest, each in path and line order. */
+export function rank(found, from) {
+    const tier = (path) => {
+        if (from === null)
+            return 2;
+        if (path === from)
+            return 0;
+        return posix.dirname(path) === posix.dirname(from) ? 1 : 2;
+    };
+    return found
+        .map((f, i) => ({ f, i, t: tier(f.path) }))
+        .sort((a, b) => a.t - b.t || a.i - b.i)
+        .map(({ f }) => f);
+}
+const NOWHERE = { unit: null, row: null, commit: null };
+/**
+ * The hunk row that holds tip line `line` of `path`, and the commit that writes it: the owner of a
+ * change row, or the first commit taking the unit for a context row.
+ */
+export function place(units, commits, path, line) {
+    for (const unit of units.values()) {
+        if (unit.kind !== "hunk" || unit.path !== path)
+            continue;
+        const row = rowAt(unit, tipStartOf(unit, units), line);
+        if (row === null)
+            continue;
+        const body = unit.body[row];
+        const change = body !== undefined && body.op !== " " ? body.change : null;
+        const takes = (c) => c.refs.some((r) => r.unit === unit.id &&
+            (change === null || r.select.kind === "rest" || r.select.changes.includes(change)));
+        const k = commits.findIndex(takes);
+        return { unit: unit.id, row, commit: k === -1 ? null : k };
+    }
+    return NOWHERE;
+}
+function rowAt(hunk, tipStart, line) {
+    let tipLine = tipStart;
+    for (const [row, body] of hunk.body.entries()) {
+        if (body.op === "-")
+            continue;
+        if (tipLine === line)
+            return row;
+        tipLine += 1;
+    }
+    return null;
+}
+function stripEol(line) {
+    return line.replace(/\r?\n$/, "");
+}
+/**
+ * Where names are defined at one branch tip and where each lands in the plan. Built per hosted
+ * version, so a swap starts a fresh one; matches are cached per name and file lines per path.
+ */
+export function definitionIndex(repo, tip, units, commits) {
+    const foundByName = new Map();
+    const linesByPath = new Map();
+    const find = (name) => {
+        const cached = foundByName.get(name);
+        if (cached !== undefined)
+            return cached;
+        const patterns = [
+            ...new Set(LANGUAGES.flatMap((l) => l.patterns.map((p) => toEre(spell(p.source, name))))),
+        ];
+        const pathspecs = LANGUAGES.flatMap((l) => l.extensions.map((e) => `*${e}`));
+        const found = grepTip(repo, tip, patterns, pathspecs).then((matches) => matches.flatMap((m) => {
+            const kind = kindOf(m, name);
+            return kind === null ? [] : [{ path: m.path, newLine: m.line, kind }];
+        }));
+        foundByName.set(name, found);
+        // A failed grep is not an answer; the next request tries again.
+        found.catch(() => foundByName.delete(name));
+        return found;
+    };
+    const load = async (paths) => {
+        const missing = [...new Set(paths)].filter((p) => !linesByPath.has(p));
+        if (missing.length === 0)
+            return;
+        for (const [path, bytes] of await blobsAt(repo, tip, missing)) {
+            linesByPath.set(path, splitLines(bytes).map(stripEol));
+        }
+    };
+    return {
+        lookup: async (name, from) => {
+            const ranked = rank(await find(name), from).slice(0, MAX_CANDIDATES);
+            await load(ranked.map((f) => f.path));
+            return ranked.map((f) => ({
+                ...f,
+                ...place(units, commits, f.path, f.newLine),
+                preview: (linesByPath.get(f.path) ?? []).slice(f.newLine - 1, f.newLine - 1 + PREVIEW_LINES),
+            }));
+        },
+    };
+}