visualproof 0.1.0 → 0.3.0

package/dist/web/src/selection.js

@@ -0,0 +1,272 @@
+// What the reader selects (decided 2026-10-07): a list of picks. A pick is one thing clicked under
+// one tool — a declaration x under Selection, Uses, TCB, Direct or Used by is decl(x), uses(x),
+// tcb(x), refs(x) or usedBy(x), and under Keys x with the key declarations in its TCB
+// (shared/query.ts, keysQuery); a
+// cluster is the same tools over all of its declarations — and the selection is the union of its
+// picks, itself a query of shared/query.ts: `pick or pick or …`. What is lit is that set, evaluated
+// on the whole graph and cut to what the board holds (shared/board.ts, lightUp), so a pick means the
+// same declarations on every board and a view of it holds what was lit. The mode is the tool: how
+// the next click selects.
+//
+// Uses, TCB, Keys and Direct are one mode, Rests on, at the granularities of what a declaration
+// rests on (decided 2026-10-08, ViewSpec decision 20): everything it uses, proofs included, ⊇ its
+// TCB ⊇ the key declarations in its TCB; and what it uses directly (one step, the owner's decision
+// of 2026-10-14). Each is a tool of its own, a step of that mode.
+//
+// Everything here is without the page, so that it can be tested: what a pick's query is and what
+// it says in words, reading picks back from a query (an address, a reader followed, an agent), what
+// a click or a shift-click does to the list, and how key 2 steps through Rests on. main.ts keeps the
+// list and the thing the panel tells of; web/src/selbar.ts shows the list.
+import { describe, keysQuery, parseQuery, printQuery, readKeys } from "../../shared/query.js";
+/** Every tool, as the address and presence name them (web/src/state.ts). */
+export const TOOLS = ["plain", "deps", "tcb", "keys", "refs", "apps"];
+const CLOSURE = { tcb: "tcb", deps: "uses", refs: "refs", apps: "usedBy" };
+const TOOL_OF = { tcb: "tcb", uses: "deps", refs: "refs", usedBy: "apps" };
+const EXT = "⟨external⟩";
+const keysOf = (k) => (k === null ? "targets" : [k]);
+/** A declaration clicked under a tool; under Keys, with the key declarations of `keys`. */
+export function declPick(tool, name, keys = null) {
+    const q = tool === "plain" ? { op: "decl", names: [name] } : tool === "keys" ? keysQuery(name, keysOf(keys)) : { op: CLOSURE[tool], of: [name] };
+    return { tool, root: { decl: name }, q };
+}
+/** A cluster's set under a tool. */
+function onSet(tool, set, keys) {
+    return tool === "plain" ? set : tool === "keys" ? keysQuery(set, keysOf(keys)) : { op: CLOSURE[tool], of: set };
+}
+/** The declarations a cluster holds, as a query, exactly as the cluster tree puts them (the layout,
+ *  shared/layout.ts): by namespace, the project's names under its key (an outside declaration may
+ *  share the namespace); by file, the modules under it; outside the project, the same among the
+ *  outside world — by namespace the names under its first component, that one name itself not
+ *  included (it sits in the outside world's own cluster). */
+export function clusterSet(key, mode) {
+    const external = { op: "external" };
+    if (key === EXT)
+        return external;
+    if (!key.startsWith(EXT + "."))
+        return mode === "module" ? { op: "file", prefix: key } : { op: "except", a: { op: "ns", prefix: key }, b: external };
+    const p = key.slice(EXT.length + 1);
+    if (mode === "module")
+        return { op: "and", a: { op: "file", prefix: p }, b: external };
+    return { op: "except", a: { op: "and", a: { op: "ns", prefix: p }, b: external }, b: { op: "decl", names: [p] } };
+}
+/** A cluster clicked under a tool; under Keys, with the key declarations of `keys`. */
+export function clusterPick(tool, cl, mode, keys = null) {
+    return { tool, root: { cluster: cl.key, by: cl.key === EXT ? null : mode }, q: onSet(tool, clusterSet(cl.key, mode), keys) };
+}
+/** The cluster a query stands for, when it is a cluster's set (or one written by hand as `ns(P)`). */
+function clusterOf(q) {
+    if (q.op === "external")
+        return { cluster: EXT, by: null };
+    if (q.op === "ns")
+        return { cluster: q.prefix, by: "namespace" };
+    const text = printQuery(q);
+    const head = q.op === "file" ? q : q.op === "except" || q.op === "and" ? (q.a.op === "and" ? q.a.a : q.a) : null;
+    if (!head || (head.op !== "ns" && head.op !== "file"))
+        return null;
+    const mode = head.op === "file" ? "module" : "namespace";
+    for (const key of [head.prefix, `${EXT}.${head.prefix}`])
+        if (printQuery(clusterSet(key, mode)) === text)
+            return { cluster: key, by: mode };
+    return null;
+}
+/** A part of a selection as a pick: a click's, when it reads as one; else a pick with no root. */
+export function pickOf(q) {
+    if (q.op === "decl" && q.names.length === 1)
+        return { tool: "plain", root: { decl: q.names[0] }, q };
+    const k = readKeys(q);
+    if (k)
+        return { tool: "keys", root: typeof k.from === "string" ? { decl: k.from } : clusterOf(k.from), q };
+    if (q.op === "tcb" || q.op === "refs" || q.op === "usedBy" || q.op === "uses") {
+        const root = Array.isArray(q.of) ? (q.of.length === 1 ? { decl: q.of[0] } : null) : q.of === "selection" ? null : clusterOf(q.of);
+        return { tool: TOOL_OF[q.op], root, q };
+    }
+    return { tool: "plain", root: clusterOf(q), q };
+}
+/** The selection's query: its picks joined by `or`; null when nothing is selected. */
+export function selectionQuery(picks) {
+    return picks.length ? picks.slice(1).reduce((a, p) => ({ op: "or", a, b: p.q }), picks[0].q) : null;
+}
+export function selectionText(picks) {
+    const q = selectionQuery(picks);
+    return q && printQuery(q);
+}
+/** The picks of a selection's query: the parts its `or`s join (left to right, as it is printed). */
+export function picksOf(q) {
+    return q.op === "or" ? [...picksOf(q.a), pickOf(q.b)] : [pickOf(q)];
+}
+/** The picks a selection's text says; none when it says nothing readable. */
+export function readSelection(text) {
+    if (!text)
+        return [];
+    try {
+        return picksOf(parseQuery(text));
+    }
+    catch {
+        return [];
+    }
+}
+/** Whether two picks are the same: the same query. */
+export function samePick(a, b) {
+    return printQuery(a.q) === printQuery(b.q);
+}
+const isCluster = (p) => !!p.root && "cluster" in p.root;
+/** The last part of a name or key, as a chip says it ("FLT", not "Mathlib.NumberTheory.FLT"); a part that
+ *  says little alone (a number, two letters) keeps the one before it. */
+function short(name) {
+    const parts = name.split(".");
+    const tail = parts[parts.length - 1];
+    return /^\d+$/.test(tail) || tail.length <= 2 ? parts.slice(-2).join(".") : tail;
+}
+/** A pick in a few words, as its chip says it: "Minimal", "TCB of not_fermat_42", "ns Fermat42". */
+export function pickWords(p) {
+    const r = p.root;
+    let what;
+    if (!r)
+        return describe(p.q);
+    if ("decl" in r)
+        what = short(r.decl);
+    else if (r.cluster === EXT)
+        what = "the outside world";
+    else {
+        const ext = r.cluster.startsWith(EXT + ".");
+        what = `${r.by === "module" ? "file" : "ns"} ${short(ext ? r.cluster.slice(EXT.length + 1) : r.cluster)}${ext ? " (outside)" : ""}`;
+    }
+    if (p.tool === "keys")
+        return `keys ${what} rests on`;
+    return p.tool === "tcb" ? `TCB of ${what}` : p.tool === "deps" ? `what ${what} uses` : p.tool === "refs" ? `what ${what} uses directly` : p.tool === "apps" ? `what uses ${what}` : what;
+}
+/** What the panel tells of when a pick was the last clicked: its root. */
+export function shownOf(p) {
+    const r = p?.root;
+    return !r ? null : "decl" in r ? { decl: r.decl } : { cluster: r.cluster };
+}
+/** Whether two things the panel may tell of are one. */
+export const sameShown = (a, b) => a === b || (!!a && !!b && ("decl" in a ? "decl" in b && a.decl === b.decl : "cluster" in b && a.cluster === b.cluster));
+/** Whether a set holds every member of another, which holds at least one. */
+function within(a, b) {
+    let any = false;
+    for (let i = 0; i < a.length; i++) {
+        if (!a[i])
+            continue;
+        if (!b[i])
+            return false;
+        any = true;
+    }
+    return any;
+}
+/** What a click does to the selection (`picks`, and `shown`, what the panel tells of). Without
+ *  shift, or under any tool but Selection, the selection becomes the one pick clicked. With shift,
+ *  under Selection, exactly one pick changes: it goes when it is a pick, and comes otherwise — a
+ *  cluster then taking the place of the picks it covers, since the union is what counts; something
+ *  a cluster picked covers already changes nothing, and `covered` says which cluster. `setOf` is
+ *  what a query lights up on the board (shared/board.ts, lightUp). */
+export function click(picks, shown, p, shift, setOf) {
+    if (!shift || p.tool !== "plain")
+        return { picks: [p], shown: shownOf(p), covered: null };
+    const k = picks.findIndex((x) => samePick(x, p));
+    if (k >= 0)
+        return remove(picks, shown, k);
+    const mine = setOf(p.q);
+    const by = picks.find((x) => isCluster(x) && within(mine, setOf(x.q)));
+    if (by)
+        return { picks, shown, covered: by };
+    const rest = isCluster(p) ? picks.filter((x) => !within(setOf(x.q), mine)) : picks;
+    return { picks: [...rest, p], shown: shownOf(p), covered: null };
+}
+/** Take the `k`th pick out (shift-click, or its chip's ×). The panel stays where it is, unless it
+ *  told of that pick: then it tells of the last pick left, if that has a root. */
+export function remove(picks, shown, k) {
+    const rest = picks.filter((_, j) => j !== k);
+    const told = sameShown(shown, shownOf(picks[k]));
+    return { picks: rest, shown: told ? shownOf(rest[rest.length - 1]) : shown, covered: null };
+}
+/** A pick's root under another tool: a declaration's, or a cluster's set; null for a pick with no
+ *  root (a part of a query written by hand), which no tool can be given again. Under Keys, `keys`
+ *  says whose key declarations, for that root. */
+export function withTool(p, tool, keys = () => null) {
+    const r = p.root;
+    if (!r)
+        return null;
+    if ("decl" in r)
+        return declPick(tool, r.decl, keys(r));
+    return { tool, root: r, q: onSet(tool, clusterSet(r.cluster, r.by ?? "namespace"), keys(r)) };
+}
+/** What the selection becomes when the tool changes (the owner's decision, 2026-10-07, after
+ *  using it): the pick last clicked — the one the panel tells of, else the last — alone, under the
+ *  new tool. From Selection to another tool only the last pick stays; back to Selection, only the
+ *  one thing clicked; from one step of Rests on to another, the same thing at the new step. Under
+ *  Keys, `keys` says whose key declarations (withTool). Unchanged (the same array) when nothing is
+ *  selected, or when that pick has no root. */
+export function retool(picks, shown, tool, keys = () => null) {
+    if (!picks.length)
+        return { picks, shown };
+    const last = picks.find((p) => sameShown(shownOf(p), shown)) ?? picks[picks.length - 1];
+    const next = withTool(last, tool, keys);
+    return next ? { picks: [next], shown: shownOf(next) } : { picks, shown };
+}
+/** The edges a selection draws (canvas.ts, MODE_SITES): a TCB's statement and body edges when every
+ *  pick is a TCB, else every edge between what is lit. (While the tool is Keys the canvas draws the
+ *  key graph's edges instead: shared/keys.ts, litKeyEdges.) */
+export function edgeMode(picks) {
+    return picks.length && picks.every((p) => p.tool === "tcb") ? "tcb" : "plain";
+}
+// ---------------------------------------------------------------- Rests on and its steps
+/** The steps of Rests on, as its switch shows them: from everything used to the few key
+ *  declarations, then what it uses directly (decided 2026-10-08 and 2026-10-14, ViewSpec decision 20). */
+export const STEPS = ["deps", "tcb", "keys", "refs"];
+/** Whether a tool is a step of Rests on. */
+export const restsOn = (t) => STEPS.includes(t);
+/** The step Rests on is entered at, with key 2 or its button: the step last used, TCB for a reader
+ *  who never chose. */
+export function enterStep(last) {
+    return last && restsOn(last) ? last : "tcb";
+}
+/** What key 2 makes the tool: Rests on at the step last used (enterStep) from any other mode; within
+ *  Rests on, the next step — TCB, Keys, Uses, Direct, TCB again. */
+export function keyTwo(now, last) {
+    if (!restsOn(now))
+        return enterStep(last);
+    const cycle = ["tcb", "keys", "deps", "refs"];
+    return cycle[(cycle.indexOf(now) + 1) % cycle.length];
+}
+// ---------------------------------------------------------------- clusters on the board
+const indexes = new WeakMap();
+/** A cluster of the layout by its key; -1 when the layout has none (another clustering, a board
+ *  that does not hold it). */
+export function clusterIndex(layout, key) {
+    let m = indexes.get(layout);
+    if (!m)
+        indexes.set(layout, (m = new Map(layout.clusters.map((c, k) => [c.key, k]))));
+    return m.get(key) ?? -1;
+}
+/** Where a pick's cluster is on a board of clustering `mode`: its index, or -1 when it is not a
+ *  cluster there. */
+export function clusterOn(r, layout, mode) {
+    return "cluster" in r && (r.by === null || r.by === mode) ? clusterIndex(layout, r.cluster) : -1;
+}
+/** The declarations a cluster holds, at any depth, in the layout's numbering. */
+export function clusterMembers(layout, c) {
+    const out = [];
+    const depth = layout.clusters[c].depth;
+    for (let j = 0; j < layout.cluster.length; j++) {
+        let x = layout.cluster[j];
+        while (x >= 0 && layout.clusters[x].depth > depth)
+            x = layout.clusters[x].parent;
+        if (x === c)
+            out.push(j);
+    }
+    return out;
+}
+/** What a cluster is, in a few words: a namespace, a folder or a file, of the project or outside it.
+ *  `isModule` says whether a key is one of the project's modules. */
+export function clusterWhat(cl, mode, isModule, hasKids) {
+    if (cl.key === EXT)
+        return "the outside world";
+    if (mode === "namespace")
+        return cl.ext ? "namespace, outside the project" : "namespace";
+    if (cl.ext)
+        return "folder, outside the project";
+    if (!isModule(cl.key))
+        return "folder";
+    return hasKids ? "file and folder" : "file";
+}

package/dist/web/src/status.js

@@ -0,0 +1,80 @@
+// The Status colour scheme (CanvasSpec, "Colour schemes", decided 2026-10-08): one colour per
+// declaration for where it stands, the most urgent state winning — its file's build failed or was
+// never built, it contains sorry, then what reviewers said (commented, stale, approved; which of a
+// comment and an approval wins is shared/review.ts's `VERDICT_ORDER`), and last whether it needs
+// review at all (not yet reviewed, trusted). A file being compiled shows so while it lasts. What
+// agents advise is not among the states: advice is never counted, and the panel shows it apart
+// (AgentSpec decision 2).
+import { statusOf, trusted } from "../../shared/review.js";
+/** The states, most urgent first; a declaration's code is its index here. The legend lists them in
+ *  this order, and the CSS colours are `--status-<state>`. */
+export const STATUSES = ["failed", "building", "sorry", "commented", "stale", "approved", "unreviewed", "trusted"];
+export const ST_FAILED = 0, ST_BUILDING = 1, ST_SORRY = 2, ST_COMMENTED = 3, ST_STALE = 4, ST_APPROVED = 5, ST_UNREVIEWED = 6, ST_TRUSTED = 7;
+/** How the legend and the hover tip name each state. */
+export const STATUS_LABEL = {
+    failed: "failed or not built",
+    building: "building",
+    sorry: "contains sorry",
+    commented: "commented",
+    stale: "stale",
+    approved: "approved",
+    unreviewed: "not yet reviewed",
+    trusted: "trusted",
+};
+/** What each state means, for the legend's tooltips. */
+export const STATUS_HINT = {
+    failed: "Its file failed to compile in the last build, or was never built: shown as it was last built",
+    building: "Its file is being compiled right now",
+    sorry: "It rests on sorry: its own, or through anything it uses",
+    commented: "A reviewer's latest word on its present version is a comment",
+    stale: "It has opinions, none on its present version",
+    approved: "A reviewer approved its present version, and no reviewer's latest word on it is a comment",
+    unreviewed: "Nobody has given an opinion on it yet, and nothing trusts it",
+    trusted: "Trusted without review (Mathlib, Lean core, a trusted prefix, the standard axioms), with no opinion on it",
+};
+/** Where one declaration stands. `file` is its file's build status, when the page is live.
+ *
+ *  "Contains sorry" is read from the axioms it rests on (sorryAx), which Lean collects through
+ *  everything it uses: a declaration that ends up depending on a sorry anywhere below it is shown
+ *  so, not only the one that writes it (the owner's decision, 2026-10-08). Out of date, queued and
+ *  blocked files are shown as last built, and so by their review. */
+export function statusState(d, g, i, file, sorryAx) {
+    if (file?.state === "building")
+        return ST_BUILDING;
+    if (file?.state === "failed" || file?.state === "unbuilt")
+        return ST_FAILED;
+    if (sorryAx)
+        return ST_SORRY;
+    const v = g.nodes[i];
+    const s = statusOf(d, v.name, v.hash);
+    if (s === "commented")
+        return ST_COMMENTED;
+    if (s === "stale")
+        return ST_STALE;
+    if (s === "approved")
+        return ST_APPROVED;
+    return trusted(d, v.name, v.module, g.isExt(i)) ? ST_TRUSTED : ST_UNREVIEWED;
+}
+/** Every declaration of `g`'s state, as codes (indices into STATUSES). `files` holds the build
+ *  status of the project's files, by module; empty in a snapshot or before the first report. */
+export function statusCodes(d, g, files) {
+    const out = new Uint8Array(g.n);
+    // whether each set of axioms holds sorryAx, worked out once per set rather than per declaration
+    const sorrySets = new Map();
+    for (let i = 0; i < g.n; i++) {
+        const ax = g.nodes[i].ax;
+        let s = sorrySets.get(ax);
+        if (s === undefined)
+            sorrySets.set(ax, (s = g.axiomsOf(i).includes("sorryAx")));
+        out[i] = statusState(d, g, i, g.isExt(i) ? undefined : files.get(g.nodes[i].module), s);
+    }
+    return out;
+}
+/** How many declarations are in each state, of those `counted` keeps: the legend's progress. */
+export function statusCounts(codes, counted = () => true) {
+    const n = new Array(STATUSES.length).fill(0);
+    for (let i = 0; i < codes.length; i++)
+        if (counted(i))
+            n[codes[i]]++;
+    return n;
+}

package/dist/web/src/visitors.js

@@ -0,0 +1,318 @@
+// Visitors (ViewSpec decision 27): navigation never leaves the board. Going to a declaration the
+// board on show does not hold — from the panel, a target's review list, a link in a comment, a name
+// in the source, the search, a step of Rests on or Used by — shows it on this board as a temporary point,
+// a visitor, drawn dashed with its edges to what the board holds, so that one sees why one came.
+//
+// A visitor shows in its own place in the cluster hierarchy (the owner's decision, 2026-10-11): in
+// its own cluster where the board draws it, else inside the deepest cluster of its path the board
+// draws (or at the top level), in temporary clusters for the levels between — dashed circles with
+// their names in italics, shared by the visitors they hold. Nothing of it is the view's: the board's
+// clusters and declarations keep their places, and what made way for a visitor returns when it goes.
+//
+// A visitor is the reader's own: never part of the view's scope, arrangement or layout memory, and
+// not seen by the others on the view — but those who follow the reader see the leader's visitors, as
+// they see the leader's selection (presence carries them: PresenceView.visitors). The last few stay
+// as a trail one steps back along; they go when the selection is cleared or the board changes. One
+// that comes to be in the board's scope (Add to view, a key mark on a target's Key view) is a member
+// at once, and leaves the trail.
+//
+// This file holds the trail, the temporary clusters a set of visitors needs and how they are packed,
+// where the outermost of them is put in a cluster of the board, and the references a visitor's edges
+// draw, all as pure functions; web/src/visits.ts lays them on the board's scene, web/src/main.ts
+// keeps the trail of the board on show and web/src/canvas.ts draws it.
+import { packEnclose, packSiblings } from "d3-hierarchy";
+import { SITE_BODY, SITE_STMT } from "../../shared/graph.js";
+import { EXT_KEY, pathOf as clusterPath } from "../../shared/layout.js";
+import { LEAF_R } from "./scene.js";
+/** How many visitors the trail keeps: the last few, which stepping back walks along. */
+export const TRAIL = 6;
+/** The trail with `v` its newest: one that is a visitor already keeps its place and becomes the
+ *  newest; the oldest go beyond TRAIL. */
+export function visit(trail, v) {
+    const was = trail.find((x) => x.name === v.name);
+    const rest = trail.filter((x) => x.name !== v.name);
+    return [...rest, was ?? v].slice(-TRAIL);
+}
+/** The trail without what is no visitor now: what the board holds (a member since: Add to view, a
+ *  rescope, a key mark on a Key view) and what its graph does not have. The same array where
+ *  nothing went, so that a caller can tell. */
+export function stillVisiting(trail, visiting) {
+    const out = trail.filter((v) => visiting(v.name));
+    return out.length === trail.length ? trail : out;
+}
+/** Where each visitor belongs on a board (ViewSpec decision 27): its cluster path by `mode`, as the
+ *  board's tree would have it — the hidden levels taken out, so that a hidden level's members are in
+ *  its parent (decision 24), a structure in its own namespace where the board or a visitor has names
+ *  under it (`isPrefix`) — met with the clusters the board draws (`drawn`: key → index of the
+ *  layout's clusters). The deepest level the board draws holds the visitor; the levels beneath it are
+ *  temporary clusters, one tree under each cluster of the board, so that visitors share the ones they
+ *  have in common, and a level that holds nothing but one level is merged with it, as the board's own
+ *  are (`NumberTheory.FLT`), the outside world's apart. A function of the set and the board alone, in
+ *  any order of the visitors: a follower computes the same. */
+export function planVisitors(mode, drawn, hidden, nodes, isPrefix) {
+    const level = (key, label) => ({ key, label, kids: new Map(), visitors: [] });
+    // per cluster of the board (-1: the top level), the levels under it that it does not draw
+    const under = new Map();
+    nodes.forEach((n, k) => {
+        const parts = clusterPath(mode, { name: n.name, module: n.module, ...(n.ext ? { ext: true } : {}) }, isPrefix(n.name) ? new Set([n.name]) : new Set());
+        const levels = [];
+        let key = "";
+        for (const part of parts) {
+            key = key ? `${key}.${part}` : part;
+            if (!hidden.has(key))
+                levels.push({ key, part });
+        }
+        let d = levels.length - 1;
+        while (d >= 0 && !drawn.has(levels[d].key))
+            d--;
+        const inn = d >= 0 ? drawn.get(levels[d].key) : -1;
+        let at = under.get(inn) ?? level("", "");
+        under.set(inn, at);
+        for (const lv of levels.slice(d + 1)) {
+            const next = at.kids.get(lv.key) ?? level(lv.key, lv.part === EXT_KEY ? "External" : lv.part);
+            at.kids.set(lv.key, next);
+            at = next;
+        }
+        at.visitors.push(k);
+    });
+    // a level holding nothing but one level says nothing: one circle, the labels joined
+    const merge = (lv) => {
+        for (const [key, first] of [...lv.kids]) {
+            let kid = first;
+            while (!kid.visitors.length && kid.kids.size === 1 && kid.key !== EXT_KEY) {
+                const only = [...kid.kids.values()][0];
+                only.label = `${kid.label}.${only.label}`;
+                kid = only;
+            }
+            lv.kids.set(key, kid);
+            merge(kid);
+        }
+    };
+    const temps = [];
+    const at = nodes.map(() => ({ in: -1, up: -1 }));
+    const walk = (lv, inn, up) => {
+        let count = lv.visitors.length;
+        for (const k of lv.visitors)
+            at[k] = { in: inn, up };
+        for (const kid of [...lv.kids.values()].sort((a, b) => cmp(a.key, b.key))) {
+            const t = temps.length;
+            temps.push({ key: kid.key, label: kid.label, in: inn, up, count: 0 });
+            temps[t].count = walk(kid, inn, t);
+            count += temps[t].count;
+        }
+        return count;
+    };
+    for (const [inn, root] of [...under].sort((a, b) => a[0] - b[0])) {
+        merge(root);
+        walk(root, inn, -1);
+    }
+    return { temps, at };
+}
+const cmp = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+/** The gap between packed discs, as the layout leaves it. */
+const GAP = 2.5;
+/** Room between a temporary cluster's contents and its circle, for its name: a cluster's own
+ *  (web/src/scene.ts, padOf), by how many visitors it holds. */
+export function tempPad(count) {
+    return 10 + Math.min(14, Math.sqrt(count));
+}
+export function packPlan(plan, names) {
+    const T = plan.temps.length;
+    const out = { r: new Array(T).fill(0), x: new Array(T).fill(0), y: new Array(T).fill(0), vx: names.map(() => 0), vy: names.map(() => 0) };
+    const kids = plan.temps.map(() => []);
+    plan.temps.forEach((tc, t) => tc.up >= 0 && kids[tc.up].push({ t, k: -1, key: tc.key }));
+    plan.at.forEach((a, k) => a.up >= 0 && kids[a.up].push({ t: -1, k, key: names[k] }));
+    // inside out: a temporary cluster comes after the one it is in (planVisitors)
+    for (let t = T - 1; t >= 0; t--) {
+        const list = kids[t].sort((a, b) => cmp(a.key, b.key));
+        const discs = list.map((c) => ({ x: 0, y: 0, r: (c.t >= 0 ? out.r[c.t] : LEAF_R) + GAP / 2 }));
+        if (discs.length > 1)
+            packSiblings(discs);
+        const enc = discs.length ? packEnclose(discs) : { x: 0, y: 0, r: LEAF_R };
+        list.forEach((c, j) => {
+            const dx = discs[j].x - enc.x, dy = discs[j].y - enc.y;
+            if (c.t >= 0) {
+                out.x[c.t] = dx;
+                out.y[c.t] = dy;
+            }
+            else {
+                out.vx[c.k] = dx;
+                out.vy[c.k] = dy;
+            }
+        });
+        out.r[t] = enc.r + tempPad(plan.temps[t].count);
+    }
+    return out;
+}
+/** Where what a visitor brings, a disc of radius `r`, goes in a cluster of the board: the spot
+ *  nearest `prefer` (in the cluster's coordinates) where it covers none of the cluster's children
+ *  (`bodies`), a gap kept, within `room` of the cluster's origin — the room its contents have, its
+ *  name's above it (Infinity at the top level) — and where `ok` says no name is written (the
+ *  avoidance of the clusters' labels). Rings round `prefer` are tried outwards. Null where no such
+ *  spot is: then it goes against the rim (rimSpot), and what it covers makes way. */
+export function freeSpot(bodies, room, r, prefer, ok = () => true) {
+    const lim = room - r;
+    if (!(lim >= 0))
+        return null;
+    // the declarations through a grid, the larger bodies each
+    const CELL = 4 * LEAF_R;
+    const grid = new Map();
+    const big = [];
+    const cellOf = (i, j) => (i + 100000) * 200003 + (j + 100000);
+    bodies.forEach((b, j) => {
+        if (b.r > 2 * LEAF_R)
+            return void big.push(j);
+        const key = cellOf(Math.floor(b.x / CELL), Math.floor(b.y / CELL));
+        const cell = grid.get(key);
+        if (cell)
+            cell.push(j);
+        else
+            grid.set(key, [j]);
+    });
+    const near = Math.ceil((r + 2 * LEAF_R + GAP) / CELL);
+    const free = (x, y) => {
+        for (const j of big) {
+            const b = bodies[j];
+            if ((b.x - x) ** 2 + (b.y - y) ** 2 < (b.r + r + GAP) ** 2)
+                return false;
+        }
+        const gx = Math.floor(x / CELL), gy = Math.floor(y / CELL);
+        for (let i = gx - near; i <= gx + near; i++)
+            for (let j = gy - near; j <= gy + near; j++)
+                for (const k of grid.get(cellOf(i, j)) ?? []) {
+                    const b = bodies[k];
+                    if ((b.x - x) ** 2 + (b.y - y) ** 2 < (b.r + r + GAP) ** 2)
+                        return false;
+                }
+        return true;
+    };
+    // the preferred spot, brought into the room
+    let [px, py] = prefer;
+    const d0 = Math.hypot(px, py);
+    if (d0 > lim)
+        [px, py] = [(px * lim) / d0, (py * lim) / d0];
+    // how far to look: across the room, or at the top level a little past everything there is
+    let reach = lim + Math.hypot(px, py);
+    if (!Number.isFinite(reach)) {
+        reach = 2 * r + GAP;
+        for (const b of bodies)
+            reach = Math.max(reach, Math.hypot(b.x - px, b.y - py) + b.r + 2 * r + GAP);
+    }
+    const step = Math.max(r / 2, reach / 120, 1);
+    for (let rho = 0; rho <= reach + step; rho += step) {
+        const m = rho === 0 ? 1 : Math.ceil((2 * Math.PI * rho) / step);
+        for (let q = 0; q < m; q++) {
+            // from the lower right round: the clusters' names are at their tops
+            const a = Math.PI / 4 + (q * 2 * Math.PI) / m;
+            const x = px + rho * Math.cos(a), y = py + rho * Math.sin(a);
+            if (Math.hypot(x, y) > lim + 1e-9)
+                continue;
+            if (free(x, y) && ok(x, y))
+                return [x, y];
+        }
+    }
+    return null;
+}
+/** Where what a visitor brings goes when no spot of a cluster is free (freeSpot): against the rim of
+ *  its room, at the angle where it covers least of the cluster's children (by how deep it overlaps
+ *  them), the nearest `prefer`'s direction among equals (the lower right where `prefer` is the
+ *  middle). What it covers makes way (web/src/scene.ts, the held room); the circle grows only where
+ *  that cannot fit otherwise. */
+export function rimSpot(bodies, room, r, prefer) {
+    const lim = Math.max(0, room - r);
+    const want = Math.hypot(prefer[0], prefer[1]) > 1e-6 ? Math.atan2(prefer[1], prefer[0]) : Math.PI / 4;
+    if (!Number.isFinite(lim))
+        return [prefer[0], prefer[1]];
+    let best = [lim * Math.cos(want), lim * Math.sin(want)];
+    let bestCost = Infinity, bestTurn = Infinity;
+    for (let q = 0; q < 72; q++) {
+        const a = want + (q * 2 * Math.PI) / 72;
+        const x = lim * Math.cos(a), y = lim * Math.sin(a);
+        let cost = 0;
+        for (const b of bodies)
+            cost += Math.max(0, b.r + r + GAP - Math.hypot(b.x - x, b.y - y));
+        const turn = Math.min(q, 72 - q);
+        if (cost < bestCost - 1e-6 || (Math.abs(cost - bestCost) <= 1e-6 && turn < bestTurn)) {
+            [best, bestCost, bestTurn] = [[x, y], cost, turn];
+        }
+    }
+    return best;
+}
+/** Whether a disc of radius `r` round a point of the world is clear of every box of `boxes` (left,
+ *  top, right, bottom, four numbers a box): what a visitor's spot keeps clear of the clusters' names
+ *  as they are written on the board, so that it never sits on a circle's label. */
+export function clearOfBoxes(boxes, x, y, r) {
+    for (let j = 0; j + 3 < boxes.length; j += 4) {
+        // the nearest point of the box to the spot, within r of it or not
+        const nx = Math.max(boxes[j], Math.min(x, boxes[j + 2]));
+        const ny = Math.max(boxes[j + 1], Math.min(y, boxes[j + 3]));
+        if ((nx - x) ** 2 + (ny - y) ** 2 <= r * r)
+            return false;
+    }
+    return true;
+}
+// ---------------------------------------------------------------------------------- presence
+/** The trail as a follower is told it (PresenceView.visitors), read back with care: at most TRAIL
+ *  visitors, each a name, where it was reached from and its place where one is given (a page of
+ *  before 2026-10-11 gives a place of the world instead, which is not read: the follower places it). */
+export function readVisitors(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    const out = [];
+    const finite = (p) => Array.isArray(p) && p.length === 2 && p.every((n) => typeof n === "number" && Number.isFinite(n) && Math.abs(n) < 1e8);
+    for (const x of raw.slice(0, TRAIL)) {
+        const o = x && typeof x === "object" ? x : null;
+        if (!o || typeof o.decl !== "string" || !o.decl || o.decl.length > 2000)
+            continue;
+        const place = typeof o.in === "string" && o.in.length <= 2000 && finite(o.spot) ? { in: o.in, at: [o.spot[0], o.spot[1]] } : null;
+        out.push({ name: o.decl, from: typeof o.from === "string" && o.from.length <= 2000 ? o.from : null, place });
+    }
+    return out;
+}
+/** The trail as presence carries it: each visitor's declaration, where it came from, its place (the
+ *  board's cluster and the spot in it), and where it is drawn in the world (`world`), which pages of
+ *  before 2026-10-11 read. */
+export function shareVisitors(trail, world = () => null) {
+    const r = (n) => Math.round(n * 10) / 10;
+    return trail.map((v, k) => {
+        const w = world(k);
+        return {
+            decl: v.name,
+            ...(w ? { at: [r(w[0]), r(w[1])] } : {}),
+            ...(v.from ? { from: v.from } : {}),
+            ...(v.place ? { in: v.place.in, spot: [r(v.place.at[0]), r(v.place.at[1])] } : {}),
+        };
+    });
+}
+// ---------------------------------------------------------------------------------- edges
+/** The most edges a visitor draws to the board: one used everywhere would be a wall of them. */
+export const MAX_EDGES = 400;
+/** A visitor's references, as its edges are drawn: to and from what the board holds (`toView`: a
+ *  declaration of the whole graph on the board, or -1) and the other visitors (`visitorOf`: its
+ *  index in the trail, or -1). Each is [the other end, whether it uses the visitor (in) or the
+ *  visitor uses it (out), whether the reference is in a statement or a body (strong) or only in a
+ *  proof or on grammar]. At most MAX_EDGES to the board, the strong first. */
+export function visitorEdges(g, v, toView, visitorOf) {
+    const strong = (site) => (site & (SITE_STMT | SITE_BODY)) !== 0;
+    const board = new Map();
+    const visitors = new Map();
+    const take = (u, incoming, site) => {
+        if (u === v)
+            return;
+        const j = toView(u);
+        const m = j >= 0 ? board : visitors;
+        const end = j >= 0 ? j : visitorOf(u);
+        if (end < 0)
+            return;
+        const key = `${end}${incoming ? "<" : ">"}`;
+        const was = m.get(key);
+        if (!was || (!was[2] && strong(site)))
+            m.set(key, [end, incoming, strong(site) || !!was?.[2]]);
+    };
+    for (let e = g.outStart[v]; e < g.outStart[v + 1]; e++)
+        take(g.outDst[e], false, g.outSite[e]);
+    for (let e = g.inStart[v]; e < g.inStart[v + 1]; e++)
+        take(g.inSrc[e], true, g.inSite[e]);
+    const all = [...board.values()].sort((a, b) => Number(b[2]) - Number(a[2]));
+    return { board: all.slice(0, MAX_EDGES), visitors: [...visitors.values()] };
+}