@shiyuphan/follow-me 0.8.0 → 0.9.0

package/README.md

@@ -75,11 +75,16 @@ The red blob in the party hat is your branch tip. Nothing follow-me does moves i
 ![Cmd-clicking format in pow opens a peek of its definition, which lives outside this branch](assets/screenshots/definition.png)
 *Cmd-click a name to jump to where it is defined, even in a later commit, and Alt+Left to come back. A definition the branch does not change opens as a peek.*
 
+When your agent's answer names code, like `src/lib.js:4-5`, each place becomes a numbered chip. Hover the answer to tint those lines, click a chip to jump there and Alt+Left to come back. An answer that names several places is a walkthrough: press Enter on it, then `.` and `,` to step.
+
+![An agent reply naming three places as numbered chips, one in a later commit, with those lines tinted and numbered in the code and the walkthrough bar at step 1 of 3](assets/screenshots/refs.png)
+*A walkthrough. Each place the agent names is tinted and numbered on the code, the current step strongest, and the bar at the bottom says where you are.*
+
 ![Coverage while reading: gutter bars mark covered, partly covered and uncovered lines, with counts per commit, per file and for the branch, and a popover listing the test that ran a line](assets/screenshots/coverage.png)
 *Coverage while reading. Your agent runs the tests with coverage and passes the lcov to `follow-me coverage`; follow-me never runs anything. Bars show covered, partly covered and uncovered lines, `x` jumps to the next uncovered line, and clicking a bar lists the tests that ran it.*
 
-![A state machine reply: each state is marked by whether a test reached it, and clicking a state jumps to its code](assets/screenshots/state-machine.png)
-*Your agent offers what it can draw, like "a state machine for this guard", as chips under the commit. Tap one and it answers with the diagram, each state marked by whether a test reached it. Click a state to jump to its code.*
+![A checkout state machine reply: each state marked by whether a test reached it, tested transitions green with a count of their tests, one untested transition red and dashed, the sequences no one test drives, and a table naming the tests of each state and move](assets/screenshots/state-machine.png)
+*Your agent offers what it can draw, like "a state machine for this guard", as chips under the commit. Tap one and it answers with the diagram, each state marked by whether a test reached it. A transition is green with the number of tests that take it, or red and dashed when none does. When the tests run one at a time, the table names them, and a list names the sequences each step of which has a test but no one test drives. Click a state or a transition to jump to its code.*
 
 ![A diagram opened in the lightbox at full size](assets/screenshots/diagram.png)
 *Diagrams sit full width under the commit or reply they explain, and open full size on click.*
@@ -87,7 +92,7 @@ The red blob in the party hat is your branch tip. Nothing follow-me does moves i
 ![The hand-off page: every kept item with its original-branch path and line, an include checkbox, and copy buttons](assets/screenshots/handoff.png)
 *Submit review. Each item carries the original branch's path and line, so your agent can post it to the merge request as is.*
 
-Keys: `[` shows or hides the index, `j` and `k` move between commits, Cmd-click (Ctrl-click) goes to a definition and Alt+Left comes back, arrows and Shift+arrows pick rows inside a hunk, `c` comments on the pick, `v` marks a commit viewed, `g` shows or hides coverage and `x` jumps to the next uncovered line, `?` lists the rest. An unfinished review autosaves and comes back when the page is opened again.
+Keys: `[` shows or hides the index, `j` and `k` move between commits, Cmd-click (Ctrl-click) goes to a definition and Alt+Left comes back, arrows and Shift+arrows pick rows inside a hunk, `c` comments on the pick, `v` marks a commit viewed, `g` shows or hides coverage and `x` jumps to the next uncovered line, `.` and `,` step through the agent's walkthrough, `?` lists the rest. An unfinished review autosaves and comes back when the page is opened again.
 
 ### Reviewing someone else's branch
 

package/dist/src/cli.js

@@ -13,6 +13,7 @@ import { findSkillDir, InstallError, runInstall, runUninstall, syncSkills, } fro
 import { naiveDraft } from "./naive.js";
 import { isCommentId, isConcernId, isFields, OFFERS_PER_COMMIT, OFFERS_PER_PLAN, serializePlanFile, validatePlan, } from "./plan.js";
 import { renderEvents, renderPrompt, renderReport, renderShownComment, renderShownConcern, renderShownDefinitions, renderShownUnit, reportItems, } from "./prompt.js";
+import { parseRefText, refsIn, repoPathOfTyped, resolveRefs } from "./refs.js";
 import { RegistrationError, sessionIdOf } from "./server.js";
 import { BranchMovedError, cleanSessions, coverageAt, extractSession, MissingDraftError, NotARepositoryError, openSession, SessionFileError, SessionLockedError, sessionComments, sinceLastPlan, } from "./session.js";
 import { checkSyntax } from "./syntax.js";
@@ -38,9 +39,9 @@ Other commands:
                                             tip lines
   explain [--commit <n>] [--unit <id>] [--lines <a-b>] --body <text> [--diagram <file>]
                                             start a thread on the page without being asked
-  show <h_…|c_…|k_…|path:line[@n|@base]|name>
+  show <h_…|c_…|k_…|path:a[-b][@n|@base]|name>
                                             print a unit, a comment's thread, a concern, the
-                                            lines around path:line in commit n, or where a name
+                                            lines around path:a-b in commit n, or where a name
                                             is defined, instead of reading files
   report [--json] [--markdown]              print the report of the latest review; --json lists
                                             the items to post to a merge request
@@ -92,16 +93,17 @@ Interactive loop (while the review page is open):
   reply <commentId> --body <text> [--diagram <file> [--map <file>]]
                                             answer under a comment on the page; the diagram is
                                             Mermaid source, the map JSON tying its states to
-                                            tip lines
+                                            tip lines. \`path:a-b[@n]\` in backticks in the body
+                                            points at code, and is refused if it does not exist
   explain [--commit <n>] [--unit <id>] [--lines <a-b>] --body <text> [--diagram <file>]
                                             start a thread on the page without being asked;
                                             --lines are change lines of the unit, commits count
                                             from 1; with no target it is about the whole plan.
                                             watch leaves these out like your replies
-  show <h_…|c_…|k_…|path:line[@n|@base]|name> [--branch <name>]
+  show <h_…|c_…|k_…|path:a[-b][@n|@base]|name> [--branch <name>]
                                             print a unit with the commits that take it, a
                                             comment with its rows and thread, a concern with its
-                                            lines, the lines around path:line at the tip, in
+                                            lines, the lines around path:a-b at the tip, in
                                             commit n of the plan, or in the base, or each place
                                             a name is defined at the tip with the commit it
                                             lands in
@@ -1529,11 +1531,13 @@ async function reply(cwd, args) {
     const open = await openOnServer(session, null);
     if (open === null)
         return notOpen(session);
+    const refs = await bodyRefs(session, open.summary.version, body);
     const id = await postReply(open.port, open.summary, commentId, {
         author: "agent",
         body,
         ...(diagram === undefined ? {} : { diagram }),
         ...(map === undefined ? {} : { map }),
+        ...(refs.length === 0 ? {} : { refs }),
     });
     say(`replied ${id} to ${commentId}`);
     next(`run follow-me again; ${STILL_WORKING}`);
@@ -1586,6 +1590,33 @@ async function readMap(session, file, diagram) {
         throw new UsageError(`${file}:\n  ${problems.join("\n  ")}`);
     return map;
 }
+/**
+ * The refs --body writes, resolved against plan `version` and the tip. Every one that does not
+ * resolve is named at once, as --map's are.
+ */
+async function bodyRefs(session, version, body) {
+    const specs = refsIn(body);
+    if (specs.length === 0)
+        return [];
+    const { root, diff } = session;
+    const otherChanged = new Set([...diff.units.values()].flatMap((u) => (diff.textFiles.has(u.path) ? [] : [u.path])));
+    const asked = [...new Set(specs.map((s) => repoPathOfTyped(s.path)))].filter((p) => isRepoPath(p) && !diff.textFiles.has(p) && !otherChanged.has(p));
+    const tip = asked.length === 0 ? new Set() : await pathsAt(root, diff.tip);
+    const present = asked.filter((p) => tip.has(p));
+    const unchanged = new Map([...(await blobsAt(root, diff.tip, present))].map(([p, bytes]) => [p, splitLines(bytes)]));
+    const { refs, problems } = resolveRefs(specs, {
+        tip: diff.tip,
+        textFiles: diff.textFiles,
+        otherChanged,
+        unchanged,
+        commits: projectedCommits(session, version),
+        version,
+    });
+    if (problems.length > 0) {
+        throw new UsageError(`--body points at code that does not resolve:\n  ${problems.join("\n  ")}`);
+    }
+    return refs;
+}
 /** The Mermaid source in --diagram's file, or undefined without the flag. */
 function diagramOf(args) {
     const file = args.values.get("diagram");
@@ -1693,17 +1724,19 @@ async function explain(cwd, args) {
     if (open === null)
         return notOpen(session);
     const target = explainTarget(session, open.summary.version, args);
+    const refs = await bodyRefs(session, open.summary.version, body);
     const id = await postComment(open.port, open.summary, {
         ...target,
         body,
         author: "agent",
         ...(diagram === undefined ? {} : { diagram }),
+        ...(refs.length === 0 ? {} : { refs }),
     });
     say(`explained ${id}`);
     next(`run follow-me again; ${STILL_WORKING}`);
     return 0;
 }
-const SHOW_USAGE = "usage: follow-me show <h_…|c_…|k_…|path:line[@<commit>|@base]|name>";
+const SHOW_USAGE = "usage: follow-me show <h_…|c_…|k_…|path:a[-b][@<commit>|@base]|name>";
 /** Every comment the session has, with the plan version it was made on: live ones first. */
 async function knownComments(session) {
     const open = await openOnServer(session, null);
@@ -1717,14 +1750,16 @@ async function knownComments(session) {
 }
 const SHOW_MARGIN = 3;
 /**
- * The lines around path:line as commit `at` of the latest plan writes the file (1-based), the
- * base, or the tip when `at` is undefined. Read from the plan, so it works before any apply.
+ * The lines around path:a-b as commit `at` of the latest plan writes the file (1-based), the
+ * base, or the tip when `at` is null. Read from the plan, so it works before any apply.
  */
 function showLines(session, raw) {
-    const m = /^(.+):(\d+)(?:@(\d+|base))?$/.exec(raw);
-    const [, typed, lineRaw, at] = m ?? [];
-    if (typed === undefined || lineRaw === undefined)
+    const spec = parseRefText(raw);
+    if (spec === null)
         throw new UsageError(SHOW_USAGE);
+    const { path: typed, start, end, at } = spec;
+    if (end < start)
+        throw new UsageError(`${raw} ends before it starts`);
     const path = Buffer.from(typed, "utf8").toString("latin1");
     const file = [...session.diff.textFiles.values()].find((f) => f.path === path);
     if (file === undefined) {
@@ -1732,7 +1767,7 @@ function showLines(session, raw) {
     }
     let text;
     let label;
-    if (at === undefined) {
+    if (at === null) {
         text = file.tip?.bytes ?? null;
         label = "the tip";
     }
@@ -1743,7 +1778,7 @@ function showLines(session, raw) {
     else {
         const latest = session.plans().at(-1);
         const commits = latest === undefined ? [] : projectedCommits(session, latest.version);
-        const n = Number(at);
+        const n = at;
         if (n < 1 || n > commits.length) {
             throw new UsageError(`@${at} is not one of the ${commits.length} commits of the plan`);
         }
@@ -1762,18 +1797,18 @@ function showLines(session, raw) {
     const lines = Buffer.from(text, "latin1").toString("utf8").split("\n");
     if (lines.at(-1) === "")
         lines.pop();
-    const line = Number(lineRaw);
-    if (line < 1 || line > lines.length) {
+    if (start < 1 || end > lines.length) {
         return `${typed} has ${plural(lines.length, "line")} in ${label}\n`;
     }
-    const from = Math.max(1, line - SHOW_MARGIN);
-    const to = Math.min(lines.length, line + SHOW_MARGIN);
+    const from = Math.max(1, start - SHOW_MARGIN);
+    const to = Math.min(lines.length, end + SHOW_MARGIN);
     const width = String(to).length;
     const rows = lines.slice(from - 1, to).map((l, i) => {
         const n = from + i;
-        return `${n === line ? ">" : " "} ${String(n).padStart(width)}  ${l}`;
+        return `${n >= start && n <= end ? ">" : " "} ${String(n).padStart(width)}  ${l}`;
     });
-    return `${typed}:${line} in ${label}\n${rows.join("\n")}\n`;
+    const span = end > start ? `${start}-${end}` : `${start}`;
+    return `${typed}:${span} in ${label}\n${rows.join("\n")}\n`;
 }
 /** Expands a ref the agent was given to the lines and thread it names, so no file read is needed. */
 async function showRef(cwd, args) {

package/dist/src/comments.js

@@ -148,6 +148,55 @@ export function mapOffTip(map, lines, show = (path) => path) {
         ...(map.transitions ?? []).flatMap((t, i) => t.at.flatMap((loc, j) => check(loc, `map.transitions[${i}].at[${j}]`))),
     ];
 }
+function parseSpan(v) {
+    if (v === null)
+        return null;
+    if (!isFields(v) || !isLine(v.start) || !isLine(v.end) || v.end < v.start) {
+        return "expected null or { start, end } with 1 <= start <= end";
+    }
+    return { start: v.start, end: v.end };
+}
+function parseCodeRef(v) {
+    if (!isFields(v))
+        return "expected an object";
+    const { n, path, start, end, at, quote, tip } = v;
+    if (!isLine(n))
+        return "n is not a number from 1";
+    if (typeof path !== "string" || !isRepoPath(path))
+        return "path is not a repo path";
+    if (!isLine(start) || !isLine(end) || end < start)
+        return "expected 1 <= start <= end";
+    if (at !== null && at !== "base" && !isLine(at))
+        return 'at is not a commit, "base" or null';
+    if (!isArray(quote) || !quote.every(isString))
+        return "quote is not a list of strings";
+    if (typeof tip !== "string" || !isSha(tip))
+        return "tip is not a commit sha";
+    const lines = parseSpan(v.lines);
+    const old = parseSpan(v.old);
+    if (typeof lines === "string")
+        return `lines: ${lines}`;
+    if (typeof old === "string")
+        return `old: ${old}`;
+    return { n, path, start, end, at, quote: quote.filter(isString), tip, lines, old };
+}
+/** refs as stored beside an agent's words: absent, or a list numbered 1, 2, 3 in order. */
+function parseCodeRefs(v) {
+    if (v === undefined)
+        return [];
+    if (!isArray(v))
+        return "refs is not a list";
+    const refs = [];
+    for (const [i, raw] of v.entries()) {
+        const ref = parseCodeRef(raw);
+        if (typeof ref === "string")
+            return `refs[${i}]: ${ref}`;
+        if (ref.n !== i + 1)
+            return `refs[${i}]: n is not ${i + 1}`;
+        refs.push(ref);
+    }
+    return refs;
+}
 /** A stored reply. Replies a client posts go through parseNewReply, which mints id and time. */
 export function parseReply(v) {
     if (!isFields(v)) {
@@ -165,32 +214,43 @@ export function parseReply(v) {
     const map = v.map === undefined ? undefined : parseStateMap(v.map, v.diagram);
     if (typeof map === "string")
         return map;
+    const refs = parseCodeRefs(v.refs);
+    if (typeof refs === "string")
+        return refs;
     return {
         id: v.id,
         author: v.author,
         body: v.body,
         ...(v.diagram === undefined ? {} : { diagram: v.diagram }),
         ...(map === undefined ? {} : { map }),
+        ...(refs.length === 0 ? {} : { refs }),
         createdAt: v.createdAt,
     };
 }
 /**
  * The body of POST .../replies: who speaks, what, and an optional Mermaid diagram. The body may be
- * empty only when the diagram is the answer.
+ * empty only when the diagram is the answer. Only the agent's words carry refs.
  */
 export function parseNewReply(v) {
-    if (!isFields(v))
+    if (!isFields(v)) {
         return "the reply is not an object";
+    }
     if (v.author !== "agent" && v.author !== "reviewer")
         return 'author is not "agent" or "reviewer"';
     if (typeof v.body !== "string")
         return "body is not a string";
+    const refs = parseCodeRefs(v.refs);
+    if (typeof refs === "string")
+        return refs;
+    if (refs.length > 0 && v.author !== "agent")
+        return "refs are only for the agent's words";
+    const withRefs = refs.length === 0 ? {} : { refs };
     if (v.diagram === undefined) {
         if (v.map !== undefined)
             return "map needs the diagram it ties to code";
         if (v.body.trim() === "")
             return "body is empty; a reply needs words or a diagram";
-        return { author: v.author, body: v.body };
+        return { author: v.author, body: v.body, ...withRefs };
     }
     if (typeof v.diagram !== "string")
         return "diagram is not a string";
@@ -205,6 +265,7 @@ export function parseNewReply(v) {
         body: v.body,
         diagram: v.diagram,
         ...(map === undefined ? {} : { map }),
+        ...withRefs,
     };
 }
 function isString(v) {
@@ -262,6 +323,11 @@ export function parseComment(v) {
             return "offer is only for a reviewer's question";
         }
     }
+    const refs = parseCodeRefs(v.refs);
+    if (typeof refs === "string")
+        return refs;
+    if (refs.length > 0 && v.author !== "agent")
+        return "refs are only for an agent's comment";
     const replies = parseList(v.replies, parseReply, "replies");
     if (typeof replies === "string")
         return replies;
@@ -281,6 +347,7 @@ export function parseComment(v) {
         ...(replies.length === 0 ? {} : { replies }),
         ...(v.author === "agent" ? { author: "agent" } : {}),
         ...(v.diagram === undefined ? {} : { diagram: v.diagram }),
+        ...(refs.length === 0 ? {} : { refs }),
         ...(offer === undefined ? {} : { offer }),
     };
 }

package/dist/src/coverage.js

@@ -15,9 +15,12 @@ export class LcovError extends Error {
 const RECORD = /^([A-Z][A-Z0-9_]*):(.*)$/;
 const DA = /^([1-9][0-9]*),([0-9]+)(?:,.*)?$/;
 const BRDA = /^([1-9][0-9]*),([^,]+),(.+),(-|[0-9]+)$/;
+/** FN:<start>,<name>, or lcov 2's FN:<start>,<end>,<name>. */
+const FN = /^([1-9][0-9]*),(?:([1-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.
+ * and BRDA give line and branch hits, FN a function's place, end_of_record closes it. Other
+ * records are skipped.
  */
 export function parseLcov(text) {
     const records = [];
@@ -50,10 +53,10 @@ export function parseLcov(text) {
             close();
             if (value === "")
                 throw new LcovError(n, "SF needs a path");
-            open = { path: value, test, lines: new Map(), branches: new Map() };
+            open = { path: value, test, lines: new Map(), branches: new Map(), functions: [] };
             continue;
         }
-        if (key !== "DA" && key !== "BRDA")
+        if (key !== "DA" && key !== "BRDA" && key !== "FN")
             continue;
         if (open === null)
             throw new LcovError(n, `${key} comes before any SF`);
@@ -65,15 +68,27 @@ export function parseLcov(text) {
             open.lines.set(line, (open.lines.get(line) ?? 0) + Number(da[2]));
             continue;
         }
+        if (key === "FN") {
+            const fn = FN.exec(value);
+            if (fn === null)
+                throw new LcovError(n, `FN needs <line>,<name>, got "${value}"`);
+            const start = Number(fn[1]);
+            const end = fn[2] === undefined ? undefined : Number(fn[2]);
+            const name = fn[3] ?? "";
+            if (end !== undefined && end < start)
+                throw new LcovError(n, "FN ends before it starts");
+            open.functions.push(end === undefined ? { name, start } : { name, start, end });
+            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 taken = br[4] === "-" ? 0 : Number(br[4]);
         const branches = open.branches.get(line) ?? new Map();
-        branches.set(id, (branches.get(id) ?? false) || taken);
+        branches.set(id, (branches.get(id) ?? 0) + taken);
         open.branches.set(line, branches);
     }
     close();
@@ -110,10 +125,42 @@ export function tipPlacer(root, cwd, atTip) {
         return null;
     };
 }
+/** Adds a record's branch counts into `into`, keeping lcov's branch order per line. */
+function countInto(into, path, record) {
+    const joined = into.get(path) ?? new Map();
+    for (const [line, ids] of record.branches) {
+        const on = joined.get(line) ?? new Map();
+        for (const [id, n] of ids)
+            on.set(id, (on.get(id) ?? 0) + n);
+        joined.set(line, on);
+    }
+    into.set(path, joined);
+}
+function countsOf(counting) {
+    const out = new Map();
+    for (const [path, byLine] of counting) {
+        if (byLine.size === 0)
+            continue;
+        out.set(path, sorted(new Map([...byLine].map(([line, ids]) => [line, [...ids.values()]]))));
+    }
+    return out;
+}
+/** Functions of both lists, once each by start and name, in line order. */
+function joinFunctions(a, b) {
+    const seen = new Map();
+    for (const f of [...a, ...b]) {
+        const key = `${f.start}|${f.name}`;
+        const had = seen.get(key);
+        if (had === undefined || (had.end === undefined && f.end !== undefined))
+            seen.set(key, f);
+    }
+    return [...seen.values()].sort((x, y) => x.start - y.start);
+}
 /** 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 functions = new Map();
     const tests = new Map();
     for (const record of records) {
         const path = place(record.path);
@@ -123,37 +170,42 @@ export function runOf(records, place) {
         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);
+        countInto(branches, path, record);
+        functions.set(path, joinFunctions(functions.get(path) ?? [], record.functions));
         if (record.test === null)
             continue;
-        const ran = tests.get(record.test) ?? new Map();
-        const set = ran.get(path) ?? new Set();
+        const ran = tests.get(record.test) ?? { lines: new Map(), branches: new Map() };
+        const set = ran.lines.get(path) ?? new Set();
         for (const [line, n] of record.lines)
             if (n > 0)
                 set.add(line);
-        ran.set(path, set);
+        ran.lines.set(path, set);
+        countInto(ran.branches, path, record);
         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]);
+            const n = [...ids.values()];
+            counted.set(line, [n.filter((c) => c > 0).length, n.length]);
         }
-        files.set(path, { lines: sorted(hits), branches: sorted(counted) });
+        const fns = functions.get(path) ?? [];
+        files.set(path, {
+            lines: sorted(hits),
+            branches: sorted(counted),
+            ...(fns.length === 0 ? {} : { functions: fns }),
+        });
     }
     return {
         files,
+        counts: countsOf(branches),
         tests: new Map([...tests].map(([id, ran]) => [
             id,
-            new Map([...ran].map(([path, set]) => [path, [...set].sort((a, b) => a - b)])),
+            {
+                lines: new Map([...ran.lines].map(([path, set]) => [path, [...set].sort((a, b) => a - b)])),
+                branches: countsOf(ran.branches),
+            },
         ])),
     };
 }
@@ -184,7 +236,12 @@ function mergeMax(a, b) {
             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) });
+        const functions = joinFunctions(had.functions ?? [], f.functions ?? []);
+        out.set(path, {
+            lines: sorted(lines),
+            branches: sorted(branches),
+            ...(functions.length === 0 ? {} : { functions }),
+        });
     }
     return out;
 }
@@ -197,7 +254,7 @@ export const PREVIEW_LINES = 8;
 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 }]));
+        const tests = new Map([...run.tests].map(([id, ran]) => [id, testEntry(ran)]));
         return { tip, takenAt, files: run.files, tests };
     }
     const base = prior !== null && prior.tip === tip ? prior : null;
@@ -205,12 +262,16 @@ export function recordRun(prior, run, at) {
     const entry = {
         ...(test.at === undefined ? {} : { at: test.at }),
         ...(test.preview === undefined ? {} : { preview: test.preview }),
-        lines: hitLines(run.files),
+        ...testEntry({ lines: hitLines(run.files), branches: run.counts }),
     };
     tests.set(test.id, entry);
     const files = base === null ? run.files : mergeMax(base.files, run.files);
     return { tip, takenAt, files, tests };
 }
+/** A test's lines, and its branch counts when the run had any. */
+function testEntry(ran) {
+    return { lines: ran.lines, ...(ran.branches.size === 0 ? {} : { branches: ran.branches }) };
+}
 /**
  * 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.
@@ -278,6 +339,7 @@ export function serializeCoverage(c) {
         {
             lines: Object.fromEntries(f.lines),
             ...(f.branches.size === 0 ? {} : { branches: Object.fromEntries(f.branches) }),
+            ...(f.functions === undefined ? {} : { functions: f.functions }),
         },
     ]));
     const tests = Object.fromEntries([...c.tests].map(([id, t]) => [
@@ -286,6 +348,11 @@ export function serializeCoverage(c) {
             ...(t.at === undefined ? {} : { at: t.at }),
             ...(t.preview === undefined ? {} : { preview: [...t.preview] }),
             lines: Object.fromEntries([...t.lines].map(([p, ls]) => [p, [...ls]])),
+            ...(t.branches === undefined
+                ? {}
+                : {
+                    branches: Object.fromEntries([...t.branches].map(([p, byLine]) => [p, Object.fromEntries(byLine)])),
+                }),
         },
     ]));
     return { tip: c.tip, takenAt: c.takenAt, files, ...(c.tests.size === 0 ? {} : { tests }) };
@@ -321,6 +388,52 @@ export function parseLocArg(raw, place) {
     const end = m[3] === undefined ? start : Number(m[3]);
     return end < start ? `--at ${raw} runs backwards` : { path, start, end };
 }
+function parseFunction(v) {
+    if (!isFields(v))
+        return null;
+    const { name, start, end } = v;
+    if (typeof name !== "string" || !isLine(start))
+        return null;
+    if (end === undefined)
+        return { name, start };
+    return isLine(end) && end >= start ? { name, start, end } : null;
+}
+function parseFunctions(v) {
+    if (v === undefined)
+        return undefined;
+    if (!Array.isArray(v))
+        return "functions is not a list";
+    const out = [];
+    for (const raw of v) {
+        const f = parseFunction(raw);
+        if (f === null)
+            return "a function is not a { name, start, end? }";
+        out.push(f);
+    }
+    return out;
+}
+function parseCounts(v) {
+    if (v === undefined)
+        return undefined;
+    const files = entries(v);
+    if (files === null)
+        return "branches is not an object";
+    const out = new Map();
+    for (const [path, raw] of files) {
+        const lines = entries(raw);
+        if (!isRepoPath(path) || lines === null)
+            return `branches of ${path} are not by line`;
+        const byLine = new Map();
+        for (const [key, counts] of lines) {
+            if (!LINE_KEY.test(key) || !Array.isArray(counts) || !counts.every(isCount)) {
+                return `branches of ${path}:${key} are not counts`;
+            }
+            byLine.set(Number(key), counts.filter(isCount));
+        }
+        out.set(path, sorted(byLine));
+    }
+    return out;
+}
 function parseFile(v) {
     if (!isFields(v))
         return "a file is not an object";
@@ -347,7 +460,14 @@ function parseFile(v) {
         }
         branches.set(Number(key), [taken, total]);
     }
-    return { lines: sorted(hits), branches: sorted(branches) };
+    const functions = parseFunctions(v.functions);
+    if (typeof functions === "string")
+        return functions;
+    return {
+        lines: sorted(hits),
+        branches: sorted(branches),
+        ...(functions === undefined ? {} : { functions }),
+    };
 }
 function parseTest(v) {
     if (!isFields(v))
@@ -370,10 +490,14 @@ function parseTest(v) {
         }
         lines.set(path, list);
     }
+    const branches = parseCounts(v.branches);
+    if (typeof branches === "string")
+        return branches;
     return {
         ...(at === undefined ? {} : { at }),
         ...(preview === undefined ? {} : { preview: preview.filter((l) => typeof l === "string") }),
         lines,
+        ...(branches === undefined ? {} : { branches }),
     };
 }
 /** The one place coverage.json becomes a Coverage. */