@shiyuphan/follow-me 0.7.1 → 0.9.0

package/dist/src/comments.js

@@ -1,5 +1,6 @@
+import { parseLoc } from "./coverage.js";
 import { isRepoPath, isSha, isUnitId } from "./diff.js";
-import { diagramProblem, isArray, isCommentId, isConcernId, isFields, isPlanVersion, isSeverity, parsePlacedConcern, } from "./plan.js";
+import { diagramProblem, isArray, isCommentId, isConcernId, isFields, isOfferId, isPlanVersion, isSeverity, parsePlacedConcern, } from "./plan.js";
 /**
  * The wire formats of review state, parsed once at the boundary: comments, replies, concern
  * decisions, the review file, its autosaved draft and the events a hosted session logs. Every
@@ -48,10 +49,159 @@ function parseAnchor(v) {
     }
     return { kind: "hunk", unit: v.unit, commit, changes, offsets };
 }
+function parseLocs(v, at, needed) {
+    const what = `${at}: expected a list of { path, start, end }${needed ? " with at least one place" : ""}`;
+    if (!isArray(v) || (needed && v.length === 0))
+        return what;
+    const out = [];
+    for (const [i, raw] of v.entries()) {
+        const loc = parseLoc(raw);
+        if (loc === null)
+            return `${at}[${i}]: expected { path, start, end } with 1 <= start <= end`;
+        out.push(loc);
+    }
+    return out;
+}
+const TRANSITION_ENDS = ["from", "to"];
+function escapeRegExp(text) {
+    return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+ * Boundary parse of a reply's state map. Every state has at least one place, every transition
+ * names states of the map, and with a stateDiagram every state name appears in it. The reason
+ * names the bad entry, as map.states.<name>[i] or map.transitions[i].<field>.
+ */
+export function parseStateMap(v, diagram) {
+    if (!isFields(v))
+        return "map: expected { states, transitions }";
+    if (!isFields(v.states) || Object.keys(v.states).length === 0) {
+        return "map.states: expected an object of state name to places";
+    }
+    const states = [];
+    for (const [name, raw] of Object.entries(v.states)) {
+        if (name.trim() === "")
+            return "map.states: a state has an empty name";
+        const locs = parseLocs(raw, `map.states.${name}`, true);
+        if (typeof locs === "string")
+            return locs;
+        states.push([name, locs]);
+    }
+    const named = new Set(states.map(([name]) => name));
+    const transitions = [];
+    const rawTransitions = v.transitions ?? [];
+    if (!isArray(rawTransitions))
+        return "map.transitions: expected a list";
+    for (const [i, raw] of rawTransitions.entries()) {
+        const at = `map.transitions[${i}]`;
+        if (!isFields(raw))
+            return `${at}: expected { from, to, event, at }`;
+        for (const end of TRANSITION_ENDS) {
+            const state = raw[end];
+            if (typeof state !== "string" || !named.has(state)) {
+                return `${at}.${end}: ${JSON.stringify(state)} is not a state in map.states`;
+            }
+        }
+        const { from, to, event } = raw;
+        if (typeof from !== "string" || typeof to !== "string")
+            return `${at}: expected from and to`;
+        if (event !== undefined && typeof event !== "string")
+            return `${at}.event: expected a string`;
+        const locs = parseLocs(raw.at, `${at}.at`, false);
+        if (typeof locs === "string")
+            return locs;
+        transitions.push({ from, to, ...(event === undefined ? {} : { event }), at: locs });
+    }
+    const first = (diagram ?? "")
+        .split("\n")
+        .find((line) => line.trim() !== "")
+        ?.trim() ?? "";
+    if (first.startsWith("stateDiagram")) {
+        for (const name of named) {
+            if (!new RegExp(`(^|[^\\w])${escapeRegExp(name)}([^\\w]|$)`, "m").test(diagram ?? "")) {
+                return `map.states.${name}: not a state of the stateDiagram`;
+            }
+        }
+    }
+    return {
+        states: Object.fromEntries(states),
+        ...(transitions.length === 0 ? {} : { transitions }),
+    };
+}
+/**
+ * Where a map points past the tip: a path the tip has no file at, or lines beyond its end. lines
+ * holds the line count of every tip file the map names that exists; show prints a path.
+ */
+export function mapOffTip(map, lines, show = (path) => path) {
+    const check = (loc, at) => {
+        const count = lines.get(loc.path);
+        if (count === undefined)
+            return [`${at}: ${show(loc.path)} is not a file at the tip`];
+        if (loc.end > count) {
+            return [
+                `${at}: lines ${loc.start}-${loc.end} are past the end of ${show(loc.path)}, which has ${count} lines at the tip`,
+            ];
+        }
+        return [];
+    };
+    return [
+        ...Object.entries(map.states).flatMap(([name, locs]) => locs.flatMap((loc, i) => check(loc, `map.states.${name}[${i}]`))),
+        ...(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))
+    if (!isFields(v)) {
         return "not an object";
+    }
     if (!isReplyId(v.id))
         return "id is not a reply id";
     if (v.author !== "agent" && v.author !== "reviewer")
@@ -61,30 +211,62 @@ export function parseReply(v) {
     }
     if (v.diagram !== undefined && typeof v.diagram !== "string")
         return "diagram is not a string";
+    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 of POST .../replies: who speaks, what, and an optional Mermaid diagram. The body may be
+ * 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" || v.body.trim() === "")
-        return "body is not a non-empty string";
-    if (v.diagram === undefined)
-        return { author: v.author, body: v.body };
+    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, ...withRefs };
+    }
     if (typeof v.diagram !== "string")
         return "diagram is not a string";
     const problem = diagramProblem(v.diagram);
     if (problem !== null)
         return `diagram: ${problem}`;
-    return { author: v.author, body: v.body, diagram: v.diagram };
+    const map = v.map === undefined ? undefined : parseStateMap(v.map, v.diagram);
+    if (typeof map === "string")
+        return map;
+    return {
+        author: v.author,
+        body: v.body,
+        diagram: v.diagram,
+        ...(map === undefined ? {} : { map }),
+        ...withRefs,
+    };
 }
 function isString(v) {
     return typeof v === "string";
@@ -133,6 +315,19 @@ export function parseComment(v) {
     const severity = v.severity;
     if (severity !== undefined && !isSeverity(severity))
         return "severity is unknown";
+    const offer = v.offer;
+    if (offer !== undefined) {
+        if (!isOfferId(offer))
+            return "offer is not an offer id";
+        if (v.kind !== "question" || v.author !== undefined) {
+            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;
@@ -152,6 +347,8 @@ 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 }),
     };
 }
 function withDecision(concern, v) {
@@ -363,6 +560,9 @@ export function parseReview(v) {
     const concernsCarried = parseList(v.carriedConcerns, parseCarriedConcern, "carriedConcerns");
     if (typeof concernsCarried === "string")
         return concernsCarried;
+    const dismissed = parseIds(v.dismissedOffers, isOfferId, "dismissedOffers", "offer");
+    if (typeof dismissed === "string")
+        return dismissed;
     return {
         schema: v.schema,
         mode,
@@ -376,6 +576,7 @@ export function parseReview(v) {
         ...(earlier.length === 0 ? {} : { earlierReplies: earlier }),
         ...(carried === null ? {} : { carried }),
         ...(concernsCarried.length === 0 ? {} : { carriedConcerns: concernsCarried }),
+        ...(dismissed.length === 0 ? {} : { dismissedOffers: dismissed }),
     };
 }
 function lenient(items, parse) {
@@ -403,6 +604,7 @@ export function parseDraft(v) {
         earlierReplies: lenient(v.earlierReplies, parseEarlierReplies),
         carried: v.carried === undefined ? null : lenient(v.carried, parseCarriedRef),
         carriedConcerns: lenient(v.carriedConcerns, parseCarriedConcern),
+        dismissedOffers: lenientIds(v.dismissedOffers, isOfferId),
     };
 }
 export function parseEvent(v) {
@@ -444,6 +646,10 @@ export function parseEvent(v) {
             }
             return { seq, type: v.type, commentId: id, resolved: v.resolved };
         }
+        case "offer-dismissed":
+            return isOfferId(v.offer)
+                ? { seq, type: v.type, offer: v.offer }
+                : "offer is not an offer id";
         case "version": {
             if (!isPlanVersion(v.version) || typeof v.hash !== "string")
                 return "malformed version event";

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,10 +236,17 @@ 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;
 }
+/** How many tip lines a test outside the branch's changes carries for the page's peek. */
+export const PREVIEW_LINES = 8;
 /**
  * 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.
@@ -195,19 +254,24 @@ function mergeMax(a, b) {
 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;
     const tests = new Map(base?.tests ?? []);
     const entry = {
         ...(test.at === undefined ? {} : { at: test.at }),
-        lines: hitLines(run.files),
+        ...(test.preview === undefined ? {} : { preview: test.preview }),
+        ...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.
@@ -275,13 +339,20 @@ 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]) => [
         id,
         {
             ...(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 }) };
@@ -296,7 +367,8 @@ function isLine(v) {
 function entries(v) {
     return isFields(v) ? Object.entries(v) : null;
 }
-function parseLoc(v) {
+/** A { path, start, end } with 1 <= start <= end, or null. */
+export function parseLoc(v) {
     if (!isFields(v))
         return null;
     const { path, start, end } = v;
@@ -316,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";
@@ -342,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))
@@ -350,6 +475,11 @@ function parseTest(v) {
     const at = v.at === undefined ? undefined : parseLoc(v.at);
     if (at === null)
         return "at is not a { path, start, end }";
+    const preview = v.preview;
+    if (preview !== undefined &&
+        !(Array.isArray(preview) && preview.every((l) => typeof l === "string"))) {
+        return "preview is not a list of lines";
+    }
     const lineEntries = entries(v.lines);
     if (lineEntries === null)
         return "lines is not an object";
@@ -360,7 +490,15 @@ function parseTest(v) {
         }
         lines.set(path, list);
     }
-    return { ...(at === undefined ? {} : { at }), lines };
+    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. */
 export function parseCoverage(v) {

package/dist/src/host.js

@@ -320,6 +320,29 @@ export async function fetchComments(port, summary) {
     }
     return out;
 }
+/**
+ * Offers accepted during the hosted review, on this version or a carried one, whose comment has no
+ * reply from the agent yet, oldest first.
+ */
+export async function fetchWaitingOffers(port, summary) {
+    const state = await call(port, "GET", `${summary.url}api/state`);
+    if (!isFields(state))
+        throw new RegistrationError("the server sent no state");
+    const comments = Array.isArray(state["comments"]) ? state["comments"] : [];
+    const carried = Array.isArray(state["carried"]) ? state["carried"] : [];
+    const said = [
+        ...comments.map((raw) => parseComment(raw)),
+        ...carried.map((raw) => {
+            const c = parseCarried(raw);
+            return typeof c === "string" ? c : c.comment;
+        }),
+    ];
+    return said
+        .flatMap((c) => (typeof c === "string" ? [] : [c]))
+        .filter((c) => !(c.replies ?? []).some((r) => r.author === "agent"))
+        .sort((a, b) => a.createdAt.localeCompare(b.createdAt))
+        .flatMap((c) => (c.offer === undefined ? [] : [{ offer: c.offer, comment: c.id }]));
+}
 /** One long poll of the session's event log: what happened after `since`, or nothing at timeout. */
 export async function pollEvents(port, summary, since, timeoutMs) {
     const path = `${summary.url}api/events?since=${since}&timeout=${timeoutMs}`;