visualproof 0.0.0-stage → 0.2.0

package/dist/shared/comment.js

@@ -0,0 +1,285 @@
+// What a comment on a declaration is (ReviewSpec, "Comments", decided 2026-10-09): plain text, kept
+// in the logs as written and given to agents as written, that the page reads as light Markdown —
+// quotes, code, bold, italics, declarations' names in backticks (web/src/markdown.ts renders it).
+// Two kinds of quote carry a reference the page follows:
+//
+// - a quote of an earlier opinion is a Markdown quote whose first line, the attribution, links to
+//   it: `> [**Alice** (2026-10-09)](opinion:Fermat42.comm#Alice@2026-10-09T08:12:30.123Z):`;
+// - a quote of source code is a fenced Lean block under a header that links to the lines:
+//   `[Mathlib/NumberTheory/FLT/Four.lean:34–37](source:Fermat42.comm#L34-L37)`.
+//
+// Both are ordinary Markdown links with a scheme only the page interprets, so that an export or an
+// agent reads sensible Markdown and the logs stay text. A part of a reference is percent-encoded
+// only where it would end the link or the part, so that names stay readable.
+//
+// This is the format alone, with no page in it: the references both ways, the blocks a comment is
+// made of, what a quote of an opinion keeps, a quote of source lines, and where either goes in the
+// text being written; tested in test/comment.test.ts.
+/** the longest comment, in UTF-16 units, as the server takes it (server/reviewapi.ts,
+ *  server/agent.ts, `invalid` in shared/review.ts) */
+export const MAX_COMMENT = 10000;
+/** a quote of an opinion keeps at most this many lines of its comment, and this many characters */
+export const QUOTE_LINES = 4;
+export const QUOTE_CHARS = 300;
+/** what would end a link or a part of a reference: encoded where it is part of one */
+const UNSAFE = /[\s()[\]#@%<>"'`\\\p{Cc}]/gu;
+const encode = (s) => s.replace(UNSAFE, (c) => [...new TextEncoder().encode(c)].map((b) => `%${b.toString(16).toUpperCase().padStart(2, "0")}`).join(""));
+const decode = (s) => {
+    try {
+        return decodeURIComponent(s);
+    }
+    catch {
+        return null;
+    }
+};
+/** `opinion:<name>#<by>@<at>`: the opinion `by` gave on `name` at `at`. */
+export function opinionRef(name, by, at) {
+    return `opinion:${encode(name)}#${encode(by)}@${encode(at)}`;
+}
+/** `source:<name>#L<from>-L<to>` (one line: `#L<from>`): lines of the file declaration `name` is
+ *  in, from 1. */
+export function sourceRef(name, from, to) {
+    return `source:${encode(name)}#L${from}${to > from ? `-L${to}` : ""}`;
+}
+/** what a time in a reference looks like: as the logs write it */
+const ISO = /^\d{4}-\d\d-\d\dT\d\d:\d\d(?::\d\d(?:\.\d+)?)?(?:Z|[+-]\d\d:\d\d)$/;
+const fine = (s, max) => s !== null && s.length > 0 && s.length <= max && !/\p{Cc}/u.test(s);
+/** A reference read back: an opinion's or source lines', or null for anything else (another
+ *  scheme, a part that does not decode, a time that is not one, lines that are not). */
+export function parseRef(url) {
+    const op = /^opinion:([^#@\s]+)#([^#@\s]+)@([^#@\s]+)$/.exec(url);
+    if (op) {
+        const [name, by, at] = [decode(op[1]), decode(op[2]), decode(op[3])];
+        if (!fine(name, 2000) || !fine(by, 120) || !fine(at, 40) || !ISO.test(at))
+            return null;
+        return { kind: "opinion", name, by, at };
+    }
+    const src = /^source:([^#@\s]+)#L([1-9]\d{0,6})(?:-L([1-9]\d{0,6}))?$/.exec(url);
+    if (src) {
+        const name = decode(src[1]);
+        const from = Number(src[2]);
+        const to = src[3] === undefined ? from : Number(src[3]);
+        if (!fine(name, 2000) || to < from)
+            return null;
+        return { kind: "source", name, from, to };
+    }
+    return null;
+}
+/** A reference written out again: the one form the page puts in its own attributes. */
+export function refText(r) {
+    return r.kind === "opinion" ? opinionRef(r.name, r.by, r.at) : sourceRef(r.name, r.from, r.to);
+}
+const FENCE = /^ {0,3}(`{3,})([^`]*)$/;
+const QUOTE = /^ {0,3}>/;
+/** a line that is a link and nothing else: a code quote's header, a quote's attribution */
+const LINK_LINE = /^\[([^\]\n]+)\]\(((?:opinion|source):[^()\s]+)\):?\s*$/;
+/** A code quote's header: the line, its label and where it links to; null for any other line. */
+function sourceHead(line) {
+    const m = LINK_LINE.exec(line);
+    const ref = m ? parseRef(m[2]) : null;
+    return m && ref?.kind === "source" ? { line, label: m[1], ref } : null;
+}
+/** A quote's attribution, its first line: who said it, linking to the opinion; null for any
+ *  other line. */
+export function attribution(line) {
+    const m = LINK_LINE.exec(line);
+    const ref = m ? parseRef(m[2]) : null;
+    return m && ref?.kind === "opinion" ? { label: m[1], ref } : null;
+}
+/** The blocks of a comment, as Markdown reads them: a fence runs to a line of at least as many
+ *  backticks (or to the end), a quote is the lines that start with `>`, a paragraph runs to a
+ *  blank line or to either; a line linking to source lines right above a fence is that fence's
+ *  header. Blank lines only separate. */
+export function blocks(text) {
+    const lines = text.split(/\r?\n/);
+    const out = [];
+    const opens = (k) => k < lines.length && FENCE.test(lines[k]);
+    const fence = (k, head) => {
+        const m = FENCE.exec(lines[k]);
+        const n = m[1].length;
+        const body = [];
+        let j = k + 1;
+        for (; j < lines.length; j++) {
+            const c = /^ {0,3}(`{3,})\s*$/.exec(lines[j]);
+            if (c && c[1].length >= n)
+                break;
+            body.push(lines[j]);
+        }
+        const closed = j < lines.length;
+        out.push({ kind: "fence", lang: m[2].trim().split(/\s+/)[0] ?? "", lines: body, closed, head });
+        return closed ? j + 1 : j;
+    };
+    let k = 0;
+    while (k < lines.length) {
+        const l = lines[k];
+        if (opens(k)) {
+            k = fence(k, null);
+            continue;
+        }
+        const head = opens(k + 1) ? sourceHead(l) : null;
+        if (head) {
+            k = fence(k + 1, head);
+            continue;
+        }
+        if (QUOTE.test(l)) {
+            const q = [];
+            for (; k < lines.length && QUOTE.test(lines[k]); k++)
+                q.push(lines[k].replace(/^ {0,3}> ?/, ""));
+            out.push({ kind: "quote", lines: q });
+            continue;
+        }
+        if (!l.trim()) {
+            k++;
+            continue;
+        }
+        const p = [];
+        for (; k < lines.length && lines[k].trim() && !opens(k) && !QUOTE.test(lines[k]) && !(opens(k + 1) && sourceHead(lines[k])); k++)
+            p.push(lines[k]);
+        out.push({ kind: "para", lines: p });
+    }
+    return out;
+}
+// ---------------------------------------------------------------- quoting
+/** The longest run of backticks in `lines`: a fence around them is longer, so that none of them
+ *  closes it. */
+const longestTicks = (lines) => Math.max(0, ...lines.map((l) => Math.max(0, ...(l.match(/`+/g) ?? []).map((t) => t.length))));
+/** `s` cut to at most `n` characters, at a space where one is near the end, never inside a
+ *  surrogate pair. */
+function cut(s, n) {
+    let at = s.lastIndexOf(" ", n);
+    if (at < n * 0.6)
+        at = n;
+    if (/[\uD800-\uDBFF]/.test(s[at - 1] ?? ""))
+        at--;
+    return s.slice(0, at).trimEnd();
+}
+/** What a quote keeps of a comment: the commenter's own words — the quotes in it left out (the
+ *  opinions they quote are a click away from it), a code quote's code too, under its header —
+ *  at most QUOTE_LINES lines and QUOTE_CHARS characters, "…" where it was cut. A fence it cuts
+ *  into is closed. */
+export function quoteBody(comment) {
+    const out = [];
+    let lines = 0;
+    let chars = 0;
+    let cutShort = false;
+    const full = () => lines >= QUOTE_LINES || chars >= QUOTE_CHARS;
+    /** one line kept, cut where the characters run out */
+    const take = (l) => {
+        if (full()) {
+            cutShort = true;
+            return false;
+        }
+        const left = QUOTE_CHARS - chars;
+        const s = l.length > left ? `${cut(l, left)}…` : l;
+        if (s !== l)
+            cutShort = true;
+        out.push(s);
+        lines++;
+        chars += s.length;
+        return true;
+    };
+    for (const b of blocks(comment)) {
+        if (b.kind === "quote")
+            continue;
+        if (full()) {
+            cutShort = true;
+            break;
+        }
+        if (out.length)
+            out.push("");
+        if (b.kind === "para")
+            for (const l of b.lines)
+                take(l);
+        else if (b.head)
+            take(b.head.line);
+        else {
+            const ticks = "`".repeat(Math.max(3, longestTicks(b.lines) + 1));
+            out.push(`${ticks}${b.lang}`);
+            for (const l of b.lines)
+                if (!take(l))
+                    break;
+            out.push(ticks);
+        }
+    }
+    while (out.length && !out[out.length - 1])
+        out.pop();
+    if (cutShort && !out[out.length - 1]?.endsWith("…"))
+        out.push("…");
+    return out.length ? out : ["…"];
+}
+/** A quote of an opinion on declaration `name`, to write a comment under: its attribution — who,
+ *  an agent marked so, and the day — linking to it, then what quoteBody keeps of its comment. */
+export function quoteOpinion(name, o) {
+    // what would break the link or the bold is left out of the name shown; the reference has it whole
+    const who = o.by.replace(/[[\]*`\\\n]/g, "").trim() || "?";
+    const head = `[**${who}** (${o.agent ? "agent, " : ""}${o.at.slice(0, 10)})](${opinionRef(name, o.by, o.at)}):`;
+    return [head, ...quoteBody(o.comment)].map((l) => (l ? `> ${l}` : ">")).join("\n");
+}
+/** The lines `first`–`last` (indices into `lines`, from 0) of the code a source window shows — the
+ *  text of declaration `name`, which starts at line `start` (from 0) of `file` — quoted: a header
+ *  giving the file and the lines, linking to them, over a fenced Lean block of the lines as they
+ *  are written. */
+export function quoteCode(q) {
+    const body = q.lines.slice(q.first, q.last + 1);
+    const from = q.start + q.first + 1;
+    const to = q.start + q.last + 1;
+    const ticks = "`".repeat(Math.max(3, longestTicks(body) + 1));
+    const label = `${q.file.replace(/\[/g, "(").replace(/\]/g, ")")}:${from}${to > from ? `–${to}` : ""}`;
+    return `[${label}](${sourceRef(q.name, from, to)})\n${ticks}lean\n${body.join("\n")}\n${ticks}`;
+}
+/** The lines of `text` a selection from offset `from` to `to` touches, whole (indices from 0), or
+ *  null when it holds nothing. Only line breaks count: a line wrapped on the screen is one line.
+ *  A selection that starts on a line's break, or ends just after one (a line selected with its
+ *  break, as a triple click does), does not take the line it only touches there. */
+export function selectedLines(text, from, to) {
+    if (to < from)
+        [from, to] = [to, from];
+    from = Math.max(0, Math.min(from, text.length));
+    to = Math.max(0, Math.min(to, text.length));
+    if (to <= from)
+        return null;
+    const lineAt = (off) => {
+        let n = 0;
+        for (let k = 0; k < off; k++)
+            if (text.charCodeAt(k) === 10)
+                n++;
+        return n;
+    };
+    let first = lineAt(from);
+    let last = lineAt(to);
+    if (text[from] === "\n" && from + 1 < to)
+        first++;
+    if (last > first && text[to - 1] === "\n")
+        last--;
+    return { first, last: Math.max(first, last) };
+}
+/** Where quoted lines `from`–`to` of a file (from 1) are in a declaration's text now — `lines`,
+ *  which start at line `start` of the file (from 0) — as indices into `lines`: where they were, if
+ *  the text there reads as `quoted` does; else where `quoted` is found in it (the file changed above
+ *  it since); else what is left of where they were; null when nothing is. */
+export function locateLines(lines, start, from, to, quoted) {
+    const a = from - 1 - start;
+    const b = to - 1 - start;
+    if (quoted?.length) {
+        const at = (k) => quoted.every((q, d) => lines[k + d]?.trimEnd() === q.trimEnd());
+        if (a >= 0 && at(a))
+            return [a, a + quoted.length - 1];
+        for (let k = 0; k + quoted.length <= lines.length; k++)
+            if (at(k))
+                return [k, k + quoted.length - 1];
+    }
+    const x = Math.max(a, 0);
+    const y = Math.min(b, lines.length - 1);
+    return x <= y ? [x, y] : null;
+}
+/** `block` put into a comment being written, `value`, in place of what is selected there
+ *  (`from`–`to`), on lines of its own: a blank line before it where text comes before, and after
+ *  it a paragraph of its own where the caret goes, for the reader to write on — apart from what
+ *  comes after, if anything does. The text, and where the caret goes. */
+export function insertBlock(value, from, to, block) {
+    const before = value.slice(0, from);
+    const rest = value.slice(to).replace(/^\n+/, "");
+    const lead = !before || before.endsWith("\n\n") ? "" : before.endsWith("\n") ? "\n" : "\n\n";
+    const head = `${before}${lead}${block}\n\n`;
+    return { value: head + (rest ? `\n\n${rest}` : ""), caret: head.length };
+}

package/dist/shared/context.js

@@ -0,0 +1,157 @@
+// The context a declaration is read in (TCBSpec.md, decision 4): what is in force where it is
+// written — its namespaces and sections, what is opened, the `variable`s, universes, local and
+// scoped notation, instances and attributes, options — shown with its text as a block of Lean, and
+// recorded with it as the text an opinion judged. The page (the source window, the text an opinion
+// is compared with), the server (server/reviewapi.ts, which binds what an opinion judged) and the
+// agents' API (server/agent.ts) all read it here, so all three say the same.
+//
+// It comes from the usage pass (server/usage.ts) where that elaborated the module: the elaborator's
+// own scope before the command, in the same shape (FileContext, `exact`), with the opens resolved and
+// the variables Lean included in the declaration marked. Elsewhere — a module the pass has not
+// reached or could not elaborate, a file changed since it was compiled — it is read from the file's
+// text (shared/scope.ts, `contextAt`), without elaborating it. `readContext` is the one place that
+// chooses.
+import { excerptOf } from "./excerpt.js";
+import { contextAt } from "./scope.js";
+/** The elaborator's context for the unit `name`, when the pass has one for its module and the text
+ *  read now (Lake hash `hash`) is the one it elaborated; null otherwise. */
+export function exactContext(m, name, hash) {
+    if (!m || !hash || m.hash !== hash)
+        return null;
+    const d = m.decls[name];
+    const c = d && m.contexts[d[0]];
+    if (!c)
+        return null;
+    const used = new Set(d.slice(1));
+    return { ...c, exact: true, variables: c.variables.map((v, k) => (used.has(k) ? { ...v, used: true } : v)) };
+}
+/** The context in force at line `upto` (0-based) of a file, where a declaration's text starts: the
+ *  elaborator's (`exactContext`) where there is one, else read from the text. */
+export function readContext(lines, upto, exact = null) {
+    if (exact)
+        return exact;
+    // the block is the text as written: which namespaces of the graph an `open` brings in is not
+    // part of it, so it is the same wherever it is read
+    return contextAt(lines, upto, () => false);
+}
+/** The context as commands of Lean, in the order they are written. */
+export function contextLines(c) {
+    const out = [];
+    const inn = (x) => (x.in ? " in" : "");
+    for (const b of c.blocks) {
+        const text = b.kind === "namespace" ? `namespace ${b.name}`
+            : b.kind === "mutual" ? "mutual"
+                : `${b.noncomputable ? "noncomputable " : ""}section${b.name ? ` ${b.name}` : ""}`;
+        out.push({ line: b.line, kind: b.kind, text });
+    }
+    for (const o of c.opens)
+        out.push({ line: o.line, kind: "open", text: o.text + inn(o) });
+    for (const v of c.variables)
+        out.push({ line: v.line, kind: "variable", text: `variable ${v.text}${inn(v)}`, binds: binderNames(v.text), ...(v.used ? { used: true } : {}) });
+    for (const u of c.universes)
+        out.push({ line: u.line, kind: "universe", text: `universe ${u.text}` });
+    for (const o of c.options)
+        out.push({ line: o.line, kind: "option", text: `set_option ${o.text}${inn(o)}` });
+    for (const x of c.local)
+        out.push({ line: x.line, kind: "local", text: x.text + inn(x) });
+    // a block opens before what is written in it on the same line (never, in practice)
+    const rank = (k) => (k === "namespace" || k === "section" || k === "mutual" ? 0 : 1);
+    return out.sort((a, b) => a.line - b.line || rank(a.kind) - rank(b.kind));
+}
+/** The context as one block of Lean, a command per line; "" where nothing is in force. */
+export function contextText(c) {
+    return contextLines(c)
+        .map((l) => l.text)
+        .join("\n");
+}
+/** The text an opinion records as judged: the context block, a blank line, then the declaration's
+ *  text; just the text where no context is in force. */
+export function withContext(context, text) {
+    return context ? `${context}\n\n${text}` : text;
+}
+/** What an opinion on the declaration `name` judges, in its file's `lines`: its context and its
+ *  text, as the source window shows them. `edited`: the file is not the text that was compiled,
+ *  and the declaration is found by name in it; null when it is not there. `exact`: its context as
+ *  the elaborator has it (`exactContext`), when there is one. */
+export function judgedText(lines, edited, name, range, exact = null) {
+    const at = excerptOf(lines, edited, name, range);
+    if (!at)
+        return null;
+    const text = lines.slice(at.start, at.end + 1).join("\n");
+    return { text: withContext(contextText(readContext(lines, at.start, edited ? null : exact)), text), edited };
+}
+/** The names a `variable` command's binders bind: `(x y : α)`, `{α : Type}`, `[inst : C α]`
+ *  give theirs; an anonymous instance binder `[C α]` gives none. */
+export function binderNames(binders) {
+    const names = [];
+    const open = "({[⦃", close = ")}]⦄";
+    let depth = 0, start = -1;
+    for (let k = 0; k < binders.length; k++) {
+        const ch = binders[k];
+        if (open.includes(ch)) {
+            if (depth++ === 0)
+                start = k + 1;
+        }
+        else if (close.includes(ch) && depth > 0) {
+            if (--depth === 0) {
+                const inside = binders.slice(start, k);
+                const colon = topColon(inside);
+                if (colon >= 0)
+                    for (const w of inside.slice(0, colon).trim().split(/\s+/))
+                        if (w && w !== "_" && IDENT.test(w))
+                            names.push(w);
+            }
+        }
+    }
+    return names;
+}
+const IDENT = /^[\p{L}_][\p{L}\p{N}_'!?₀-₉ₐ-ₜ.]*$/u;
+/** Where the binder's ` : ` is, outside any bracket; -1 when there is none. */
+function topColon(s) {
+    let depth = 0;
+    for (let k = 0; k < s.length; k++) {
+        const ch = s[k];
+        if ("({[⦃".includes(ch))
+            depth++;
+        else if (")}]⦄".includes(ch))
+            depth--;
+        else if (ch === ":" && depth === 0 && s[k + 1] !== "=")
+            return k;
+    }
+    return -1;
+}
+const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+/** Which `variable` lines of a context the declaration uses: where the context is the
+ *  elaborator's, those Lean included (`used`); elsewhere those binding a name that occurs in its
+ *  statement or its text, and the anonymous instance binders about such a name — a hint for the
+ *  eye, read from the words alone: Lean includes a variable by what the elaborated declaration
+ *  mentions, which a word can only suggest. */
+export function usedVariables(lines, texts, exact = false) {
+    if (exact)
+        return new Set(lines.flatMap((l, k) => (l.used ? [k] : [])));
+    const occurs = (name) => {
+        const re = new RegExp(`(?<![\\p{L}\\p{N}_'!?.])${escapeRe(name)}(?![\\p{L}\\p{N}_'!?])`, "u");
+        return texts.some((t) => re.test(t));
+    };
+    const used = new Set();
+    const usedNames = new Set();
+    lines.forEach((l, k) => {
+        if (l.kind !== "variable" || !l.binds?.length)
+            return;
+        const hit = l.binds.filter(occurs);
+        if (hit.length) {
+            used.add(k);
+            for (const n of hit)
+                usedNames.add(n);
+        }
+    });
+    // `variable [DecidableEq α]` is about `α`: used when `α` is
+    lines.forEach((l, k) => {
+        if (l.kind !== "variable" || l.binds?.length || used.has(k))
+            return;
+        for (const w of l.text.split(/[^\p{L}\p{N}_'!?₀-₉ₐ-ₜ.]+/u))
+            if (usedNames.has(w))
+                used.add(k);
+    });
+    return used;
+}

package/dist/shared/doc/authors.js

@@ -0,0 +1,98 @@
+// The author line of a view's exported document (ExportSpec decision 15, the owner's, 2026-10-09):
+// the people who left a trace on the view, in the order of their first trace. A trace is
+//   - making the view: its maker as its record has them, once it is kept (a view nobody keeps is
+//     only what its query looks like, ViewSpec decision 6: opening it makes nothing), and whoever
+//     saved it for everyone (the timeline's `created`);
+//   - renaming, rescoping, laying it out afresh, keeping it at a past build, adding a note of the
+//     project to it or taking one out of it: the timeline's view events for its id;
+//   - a pin dropped on it that is still kept (who dropped each, server/views.ts);
+//   - a note written or edited on it: the notes it holds (their writers and last edits) and the
+//     timeline's notes written and edited on it, a note deleted since among them; and the items it
+//     shows (AttachmentSpec decision 17, the owner's of 2026-10-11: every note of the project on the
+//     Project; their writers and last edits);
+//   - the review of what it prints (the owner's decision, 2026-10-10): an opinion given on one of the
+//     declarations of the project it holds, an approval or a comment, its key marks and its target
+//     mark (`reviewTraces`).
+// People only: what an agent did is no trace (its opinions are advice), nor what a private reader
+// arranged (recorded without a name, CollabSpec decision 8; their review keeps it), nor what the
+// server itself did (its moves of renamed declarations, under its own name). Someone invited by a personal link is named as they are called now (their link's
+// id is on what they did). The timeline keeps 90 days, so a rename or a re-layout older than that is
+// forgotten; a pin, a note and the maker are kept with the view.
+import { CLUSTER_MODES } from "../places.js";
+/** Everything left on view `v` that may make an author: its record, who dropped each of its pins
+ *  (`pins`, the server's), the timeline's events, and the items it shows (`shown`, shared/noteplace.ts,
+ *  itemsShownOn). Events from before the view was made are another view's of
+ *  the same id. Unsorted. */
+export function viewTraces(v, pins, events, shown = []) {
+    const mark = (t) => ({ by: t.by, ...(t.agent ? { agent: true } : {}), ...(t.person ? { person: t.person } : {}), at: t.at });
+    const ours = [];
+    for (const e of events) {
+        if ((e.kind === "view" || (e.kind === "note" && (e.what === "created" || e.what === "edited"))) && e.view === v.id && e.at >= v.at)
+            ours.push(mark(e));
+    }
+    for (const n of [...(v.notes ?? []), ...shown]) {
+        ours.push(mark(n));
+        if (n.edited)
+            ours.push(mark(n.edited));
+    }
+    for (const mode of CLUSTER_MODES)
+        for (const kind of ["nodes", "clusters"]) {
+            const set = pins?.[mode]?.[kind];
+            if (!set)
+                continue;
+            for (const [key, who] of Object.entries(set))
+                if (Object.hasOwn(v.pins[mode][kind], key))
+                    ours.push(mark(who));
+        }
+    if (!v.kept || !v.by)
+        return ours;
+    // a record made before makers were marked says nothing of an agent: one whose name acted on this
+    // view as an agent, and is no person's link, is taken for that agent
+    const agent = !!v.agent || (!v.person && ours.some((t) => t.agent && t.by === v.by));
+    return [mark({ by: v.by, agent, person: v.person, at: v.at }), ...ours];
+}
+/** What the review says of the declarations a view holds (`held`: their names, on the graph its board
+ *  is of, with `d` the review as that board reads it): each opinion given on one, an approval or a
+ *  comment, each key mark on one, and its target mark. Unsorted. */
+export function reviewTraces(d, held) {
+    const mark = (t) => ({ by: t.by, ...(t.agent ? { agent: true } : {}), ...(t.person ? { person: t.person } : {}), at: t.at });
+    const names = new Set(held);
+    const out = [];
+    for (const name of names) {
+        if (Object.hasOwn(d.opinions, name))
+            for (const o of d.opinions[name])
+                out.push(mark(o));
+        if (Object.hasOwn(d.targets, name))
+            out.push(mark(d.targets[name]));
+    }
+    for (const marks of Object.values(d.keys))
+        for (const [name, k] of Object.entries(marks))
+            if (names.has(name))
+                out.push(mark(k));
+    return out;
+}
+/** The people among `traces`, by the name each goes by now (`nameOf`: the name of someone invited
+ *  by a personal link, by its id; null where it is not known, and the name the trace carries is
+ *  used), once each, in the order of their first trace (a tie in the order given). `notPeople`: names
+ *  that are no one's (the server's own). */
+export function authorsOf(traces, nameOf, notPeople = []) {
+    const order = traces.map((t, k) => ({ t, k })).sort((a, b) => (a.t.at < b.t.at ? -1 : a.t.at > b.t.at ? 1 : a.k - b.k));
+    const out = [];
+    const seen = new Set();
+    for (const { t } of order) {
+        if (!t.by || t.agent)
+            continue;
+        if (!t.person && notPeople.includes(t.by))
+            continue;
+        const name = ((t.person && nameOf(t.person)) || t.by).trim();
+        if (!name || seen.has(name))
+            continue;
+        seen.add(name);
+        out.push(name);
+    }
+    return out;
+}
+/** The author line as it prints: "Alice", "Alice and Bob", "Alice, Bob and Carol"; "" for nobody. */
+export function authorLine(names) {
+    return names.length > 1 ? `${names.slice(0, -1).join(", ")} and ${names[names.length - 1]}` : (names[0] ?? "");
+}