visualproof 0.0.0-stage → 0.1.0

package/dist/shared/askfollow.js

@@ -0,0 +1,46 @@
+// Asking others to follow (CollabSpec decision 10, AgentSpec decision 8; the owner's decisions of
+// 2026-10-12): what the server and the pages share of it — how long a request lasts, what a page
+// answers, how the answers of one person's pages make theirs, and the outcome in words.
+/** How long a request to follow is shown, and how soon after one the same asker may ask again. */
+export const ASK_MS = 30_000;
+/** How long the server waits past ASK_MS for an answer on its way before it counts none: a page's
+ *  own countdown answers first. */
+export const ASK_GRACE_MS = 3_000;
+/** What a page asked answers: Follow; Not now, or Esc; nothing before the request ran out (or a newer
+ *  one replaced it, or the page closed); or nothing to answer, its reader following the asker
+ *  already — such a reader is not asked, and is shown nothing. */
+export const ASK_ANSWERS = ["follow", "decline", "timeout", "following"];
+/** A person's part in a request, from the answers of their pages: following where one of them
+ *  followed; waiting while one may still answer; following already, declined, or no answer. */
+export function foldAnswers(xs) {
+    if (xs.includes("follow"))
+        return "follow";
+    if (xs.includes(null))
+        return "waiting";
+    if (xs.includes("following"))
+        return "following";
+    if (xs.includes("decline"))
+        return "decline";
+    return "timeout";
+}
+/** Each state in words, as the asker reads it. */
+export const ASK_WORDS = { follow: "following", decline: "declined", timeout: "no answer", following: "already following", waiting: "waiting" };
+/** The outcome of a request in a line, from each person's part (a private reader's each its own):
+ *  "2 following, 1 declined, 1 no answer". Those following the asker already were not asked, and are
+ *  not counted: null where nobody else was. */
+export function askLine(states) {
+    const asked = states.filter((s) => s !== "following");
+    if (!asked.length)
+        return null;
+    const parts = [];
+    for (const s of ["follow", "decline", "timeout", "waiting"]) {
+        const n = asked.filter((x) => x === s).length;
+        if (n)
+            parts.push(`${n} ${ASK_WORDS[s]}`);
+    }
+    return parts.join(", ");
+}
+/** An answer a page sent, checked: one of ASK_ANSWERS, or null. */
+export function cleanAnswer(x) {
+    return ASK_ANSWERS.includes(x) ? x : null;
+}

package/dist/shared/board.js

@@ -0,0 +1,332 @@
+// What a board shows (ViewSpec decision 2): the declarations its scope holds, laid out by the same
+// rules as the whole project. A scope that holds every declaration of the project is shown on the
+// server's own layout, with the outside world or without it; any other is taken out of the graph
+// and laid out on its own (CanvasSpec, "Navigation", implementation notes).
+//
+// A board is shared, so its picture must be the same on every page that shows it and stay put
+// when its set changes. The layout of a set is a function of the set (shared/layout.ts); what is
+// kept between sets is the layout's memory (shared/layout.ts `stabilize`), and that memory is the
+// board's, kept by the server per view and way of clustering together with the set it was made
+// for. A page that finds the memory made for the set it shows recalls that layout exactly; one
+// whose set changed lays it out again from the memory, keeping in place what stays, and hands the
+// new memory to the server. Pages that start from the same memory and the same set come to the
+// same picture, so whichever hands it over first, they agree. The server and the agents' API read
+// boards the same way.
+//
+// A board may hide levels of its cluster tree, per way of clustering (ViewSpec decision 24). A
+// board laid out on its own is laid out with them taken out, and its memory is made for its set
+// under those levels (`layoutKey`): hiding or showing one starts from the memory before and keeps
+// everything in place (shared/layout.ts, `regroup`), so a Re-layout is what packs the flattened
+// tree afresh. A whole-project board stays the server's layout, its hidden circles taken out
+// (`wholeLayout`): computed the same on every page from what they all have, it keeps no memory.
+// Pins are places in their parent's circle, so the pins of what a level hidden or shown gives
+// another parent are moved into that parent's coordinates, at the same place (`reframePins`).
+//
+// What a selection lights up on a board is computed on the whole graph and then cut to what the
+// board holds (the owner's decision, 2026-10-08): a board's own graph keeps only the edges among its
+// members, and a path through a declaration it leaves out — a lemma used only in a proof, a trusted
+// definition on a board of a target's review set — is still a path. So what is lit is exactly what a view of it holds
+// (`lightUp`, `zoomScope`), and Zoom in shows what was lit.
+import { clusterTree, computeLayout, memoryOf, regroup, stabilize, withLocal } from "./layout.js";
+import { evaluate, within } from "./query.js";
+import { Graph } from "./viewgraph.js";
+/** The declarations `set` holds, as a graph of their own (edges among them only). */
+export function subgraph(g, set) {
+    // whole-graph order keeps the project's declarations before the outside world, as Graph expects
+    const toFull = [];
+    const toSub = new Int32Array(g.n).fill(-1);
+    let projectCount = 0;
+    for (let i = 0; i < g.n; i++) {
+        if (!set[i])
+            continue;
+        toSub[i] = toFull.length;
+        toFull.push(i);
+        if (i < g.projectCount)
+            projectCount++;
+    }
+    const edges = [];
+    for (const u of toFull) {
+        for (let e = g.outStart[u]; e < g.outStart[u + 1]; e++) {
+            const v = g.outDst[e];
+            if (toSub[v] >= 0)
+                edges.push(toSub[u], toSub[v], g.outSite[e]);
+        }
+    }
+    const meta = {
+        ...g.meta,
+        nodes: toFull.map((i) => g.nodes[i]),
+        projectCount,
+        edgeCount: edges.length / 3,
+        layouts: {},
+    };
+    const sub = new Graph(meta, new Int32Array(edges));
+    // the other names a declaration answers to (a past graph's: its name now, web/src/past.ts) go with
+    // it
+    for (const [name, i] of g.byName)
+        if (toSub[i] >= 0 && g.nodes[i].name !== name && !sub.byName.has(name))
+            sub.byName.set(name, toSub[i]);
+    return { graph: sub, toFull: Int32Array.from(toFull), toSub };
+}
+/** A graph's edges as the layout reads them: (source, target, site) triples. */
+export function edgesOf(g) {
+    const edges = new Int32Array(3 * g.outDst.length);
+    let k = 0;
+    for (let u = 0; u < g.n; u++) {
+        for (let e = g.outStart[u]; e < g.outStart[u + 1]; e++) {
+            edges[k++] = u;
+            edges[k++] = g.outDst[e];
+            edges[k++] = g.outSite[e];
+        }
+    }
+    return edges;
+}
+/** A short key for a set of declarations, by their names: the same set gives the same key on
+ *  every page and on the server, whatever the numbering. */
+export function setKey(g, set) {
+    let sum = 0, mix = 0, count = 0;
+    for (let i = 0; i < g.n; i++) {
+        if (!set[i])
+            continue;
+        count++;
+        // two FNV-1a hashes of the name, combined so that the order does not matter
+        let h1 = 2166136261, h2 = 374761393;
+        for (const ch of g.nodes[i].name) {
+            const c = ch.codePointAt(0);
+            h1 = Math.imul(h1 ^ c, 16777619);
+            h2 = Math.imul(h2 ^ c, 2246822519);
+        }
+        sum = (sum + (h1 >>> 0)) >>> 0;
+        mix = (mix ^ Math.imul(h2, 3266489917)) >>> 0;
+    }
+    return `${count}.${sum.toString(36)}.${mix.toString(36)}`;
+}
+/** The board a scope makes of a graph and a review. A scope holding the whole project and either
+ *  all of the outside world or none of it is the server's layout; anything else is laid out on its
+ *  own. */
+export function boardSet(g, review, scope) {
+    const set = evaluate(scope, { g, review });
+    let own = 0, ext = 0;
+    for (let i = 0; i < g.n; i++)
+        if (set[i])
+            i < g.projectCount ? own++ : ext++;
+    const outsideAll = ext === g.n - g.projectCount;
+    const whole = own === g.projectCount && g.projectCount > 0 && (ext === 0 || outsideAll);
+    return { set, key: setKey(g, set), count: own + ext, whole, outside: whole && ext > 0, sub: whole ? null : subgraph(g, set) };
+}
+/** What query `q` lights up on board `bs` of graph `g` (the graph the board was taken from): the
+ *  query's set in the whole graph, then what of it the board holds — never the outside world on a
+ *  board without it. */
+export function lightUp(g, review, bs, q) {
+    const full = evaluate(q, { g, review });
+    let total = 0, count = 0;
+    if (!bs.sub) {
+        // the whole graph is the board's: cut in place what its scope leaves out
+        const every = bs.count === g.n;
+        for (let i = 0; i < g.n; i++) {
+            if (!full[i])
+                continue;
+            total++;
+            if (every || bs.set[i])
+                count++;
+            else
+                full[i] = 0;
+        }
+        return { set: full, count, inside: count === total };
+    }
+    const { toFull } = bs.sub;
+    const set = new Uint8Array(toFull.length);
+    for (let i = 0; i < g.n; i++)
+        total += full[i];
+    for (let j = 0; j < toFull.length; j++) {
+        if (!full[toFull[j]])
+            continue;
+        set[j] = 1;
+        count++;
+    }
+    return { set, count, inside: count === total };
+}
+/** The scope of a view of what `q` lights up on a board of scope `scope` (Zoom in, ViewSpec
+ *  decision 13): the query among what the board holds — its whole scope, so that the view holds
+ *  exactly what was lit, on a board of a target's review set what is in the target's TCB — or the query alone where it
+ *  holds nothing the board leaves out. Null when that view would hold nothing, or just what the
+ *  board holds: the sets are compared, not the texts, so a view of the selection does not offer
+ *  itself again. */
+export function zoomScope(q, scope, lit, bs) {
+    // what is lit lies within the board: as many as the board holds is the board itself
+    if (!lit.count || lit.count === bs.count)
+        return null;
+    return lit.inside ? q : within(q, scope);
+}
+/** The key a board's layout memory is made for: the set it holds (setKey) and, where any, the levels
+ *  it hides by that clustering — a memory made under other hidden levels is not recalled, and is
+ *  handed over anew. Without hidden levels it is the set's key alone, as memories were before. */
+export function layoutKey(set, hidden) {
+    if (!hidden.length)
+        return set;
+    let h1 = 2166136261, h2 = 374761393;
+    for (const ch of [...new Set(hidden)].sort().join("\n")) {
+        const c = ch.codePointAt(0);
+        h1 = Math.imul(h1 ^ c, 16777619);
+        h2 = Math.imul(h2 ^ c, 2246822519);
+    }
+    return `${set}~${(h1 >>> 0).toString(36)}.${(h2 >>> 0).toString(36)}`;
+}
+/** Whether two layout keys are of the same set, whatever levels they hide. */
+export const sameSet = (a, b) => a.split("~")[0] === b.split("~")[0];
+/** The key a board of a past build's graph keeps its memory under (HistorySpec decision 19, the
+ *  owner's decision of 2026-10-10): its layout key under the snapshot's id, so that the memory of a
+ *  past board and that of a board of the latest build are never taken for each other, though they
+ *  hold the same names. */
+export const pastSetKey = (snapshot, key) => `@${snapshot}:${key}`;
+/** The snapshot a memory's key says it is of (pastSetKey), or null for the latest build's. */
+export function snapshotOfKey(key) {
+    const m = /^@(\d+):/.exec(key);
+    return m ? Number(m[1]) : null;
+}
+/** The layout `mem` remembers, exactly, where it holds every declaration and cluster of `tree` in
+ *  the same cluster; null where it does not. `tree` gives the tree (clusterTree, or a fresh
+ *  layout). */
+export function recall(tree, g, mem) {
+    const clusters = tree.clusters.map((c) => {
+        const m = mem.clusters[c.key];
+        return m ? { ...c, x: m[0], y: m[1], r: m[2] } : null;
+    });
+    if (clusters.some((c) => c === null))
+        return null;
+    const x = [], y = [];
+    for (let i = 0; i < g.n; i++) {
+        const m = mem.nodes[g.nodes[i].name];
+        const c = tree.cluster[i];
+        if (!m || m[2] !== (c >= 0 ? tree.clusters[c].key : ""))
+            return null;
+        x.push(m[0]);
+        y.push(m[1]);
+    }
+    return withLocal({ x, y, lx: [], ly: [], cluster: tree.cluster, clusters: clusters });
+}
+/** A board's layout by `mode`, for the set `set` (setKey) of graph `g` with the levels `hidden`
+ *  hidden: recalled from the memory when it was made for this set and these levels; regrouped from
+ *  it when only the levels differ (nothing moves); else laid out afresh keeping in place what the
+ *  memory holds. `next` is the memory to hand to the server when it changed (null when the memory
+ *  already fits). */
+export function boardLayout(g, mode, set, memory, hidden = []) {
+    const key = layoutKey(set, hidden);
+    const quick = recalled(g, mode, key, memory, hidden);
+    if (quick)
+        return quick;
+    const layout = stabilize(computeLayout(mode, g.nodes, edgesOf(g), hidden), g.nodes, memory?.mem ?? null);
+    return { layout, next: { set: key, mem: memoryOf(layout, g.nodes) } };
+}
+/** The part of boardLayout that lays nothing out: the layout `memory` remembers for `key` (a layout
+ *  key, layoutKey or pastSetKey), recalled, or regrouped from it where only the hidden levels differ;
+ *  null where the board must be laid out, keeping in place what the memory holds. */
+export function recalled(g, mode, key, memory, hidden) {
+    if (!memory || !(memory.set === key || sameSet(memory.set, key)))
+        return null;
+    const tree = clusterTree(mode, g.nodes, hidden);
+    const L = memory.set === key ? recall(tree, g, memory.mem) : null;
+    if (L)
+        return { layout: L, next: null };
+    if (memory.set === key)
+        return null;
+    const layout = regroup(tree, g.nodes, memory.mem);
+    return { layout, next: { set: key, mem: memoryOf(layout, g.nodes) } };
+}
+/** A whole-project board with the levels `hidden` hidden: the server's layout `base` of `nodes`,
+ *  everything where it is there, the hidden levels' circles taken out (and a level the base has no
+ *  circle for drawn round what it holds). Every page computes the same from the same, so it keeps
+ *  no memory; Re-layout of the Project lays the base out anew. */
+export function wholeLayout(base, nodes, mode, hidden) {
+    if (!hidden.length)
+        return base;
+    return regroup(clusterTree(mode, nodes, hidden), nodes, memoryOf(base, nodes), base);
+}
+/** The pins of a board whose frame a change of hidden levels moves, as operations: a pin is a place
+ *  in its parent's coordinates, and a level hidden or shown gives what it holds directly another
+ *  parent. Each such pin is put in its new parent's coordinates at the same place on the board, with
+ *  the pins along both chains of parents. What is not pinned but would land elsewhere in its new
+ *  parent — the members of a level that was dragged, whose layout places are relative to where the
+ *  layout put it — is pinned where it is (at most `MAX_REFRAME` of them; beyond that they go to their
+ *  layout places). A hidden cluster's own pin is kept, for when it is shown again; what is in a
+ *  frame that stays is left alone. `before` and `after` are the board's layouts by `mode` of graph
+ *  `g`, under the levels hidden before and after. */
+/** the most places a change of hidden levels pins that were not pinned (shared/places.ts takes 2,000
+ *  operations at a time) */
+export const MAX_REFRAME = 1500;
+export function reframePins(g, before, after, pins, mode) {
+    const ops = [];
+    const byKey = (L) => new Map(L.clusters.map((c, k) => [c.key, k]));
+    const kb = byKey(before);
+    // where each cluster of `before` is on the board, its pins applied along its chain
+    const wb = new Map();
+    const worldB = (c) => {
+        if (c < 0)
+            return [0, 0];
+        let w = wb.get(c);
+        if (!w) {
+            const cl = before.clusters[c];
+            const [px, py] = worldB(cl.parent);
+            const [x, y] = pins.clusters[cl.key] ?? [cl.lx, cl.ly];
+            wb.set(c, (w = [px + x, py + y]));
+        }
+        return w;
+    };
+    const r = (v) => Math.round(v * 10) / 10;
+    const away = (x1, y1, x2, y2) => Math.hypot(x1 - x2, y1 - y2) > 0.5;
+    let extra = 0;
+    // the same after, parents first, with the pins as they are made
+    const wa = [];
+    const worldA = (c) => (c < 0 ? [0, 0] : wa[c]);
+    after.clusters.forEach((cl, c) => {
+        const [px, py] = worldA(cl.parent);
+        const was = kb.get(cl.key);
+        const pin = pins.clusters[cl.key];
+        const parentKey = (L, k) => (L.clusters[k].parent >= 0 ? L.clusters[L.clusters[k].parent].key : "");
+        const [bx, by] = was !== undefined ? worldB(was) : [0, 0];
+        // its parent changed: the same place on the board, in the new parent's coordinates, if pinned
+        // or if its layout place there is not where it was
+        if (was !== undefined && parentKey(before, was) !== parentKey(after, c) && (pin || (extra < MAX_REFRAME && away(bx, by, px + cl.lx, py + cl.ly)))) {
+            if (!pin)
+                extra++;
+            const at = [r(bx - px), r(by - py)];
+            ops.push({ op: "pin", mode, kind: "cluster", key: cl.key, at });
+            wa[c] = [px + at[0], py + at[1]];
+        }
+        else {
+            const [x, y] = pin ?? [cl.lx, cl.ly];
+            wa[c] = [px + x, py + y];
+        }
+    });
+    const index = new Map();
+    for (let i = 0; i < g.n; i++)
+        index.set(g.nodes[i].name, i);
+    const key = (L, c) => (c >= 0 ? L.clusters[c].key : "");
+    for (const [name, [x, y]] of Object.entries(pins.nodes)) {
+        const i = index.get(name);
+        if (i === undefined)
+            continue;
+        const cb = before.cluster[i], ca = after.cluster[i];
+        if (key(before, cb) === key(after, ca))
+            continue;
+        const [bx, by] = worldB(cb);
+        const [ax, ay] = worldA(ca);
+        ops.push({ op: "pin", mode, kind: "node", key: name, at: [r(bx + x - ax), r(by + y - ay)] });
+    }
+    // a declaration that is not pinned and changed parent: pinned where it is, if it would move
+    for (let i = 0; i < g.n && extra < MAX_REFRAME; i++) {
+        const name = g.nodes[i].name;
+        if (pins.nodes[name] || i >= before.cluster.length || i >= after.cluster.length)
+            continue;
+        const cb = before.cluster[i], ca = after.cluster[i];
+        if (key(before, cb) === key(after, ca))
+            continue;
+        const [bx, by] = worldB(cb);
+        const [ax, ay] = worldA(ca);
+        const x = bx + before.lx[i], y = by + before.ly[i];
+        if (!away(x, y, ax + after.lx[i], ay + after.ly[i]))
+            continue;
+        extra++;
+        ops.push({ op: "pin", mode, kind: "node", key: name, at: [r(x - ax), r(y - ay)] });
+    }
+    return ops;
+}

package/dist/shared/build.js

@@ -0,0 +1,2 @@
+// Build status, as the server reports it to the page.
+export {};

package/dist/shared/collab.js

@@ -0,0 +1,148 @@
+// What the server and the page share about the people on a server (CollabSpec.md): names, the
+// colour each name has, and what a reader tells the others about where they are.
+/** the most characters a name may have */
+export const MAX_NAME = 60;
+/** A name someone can be known by: 1–60 characters, no line breaks or other control characters. */
+export function validName(s) {
+    const t = s.trim();
+    return t.length > 0 && t.length <= MAX_NAME && t === s && !/[\u0000-\u001f\u007f]/.test(t);
+}
+/** `s` within `room` characters (counted as validName counts them): itself, or cut short with "…",
+ *  never inside a character. */
+export function cutShort(s, room) {
+    if (s.length <= room)
+        return s;
+    let out = "";
+    for (const ch of s) {
+        if (out.length + ch.length > room - 1)
+            break;
+        out += ch;
+    }
+    return out + "…";
+}
+/** The name Share gives an agent unless its person writes another (AgentSpec decision 7): "Alice's
+ *  AI", within the characters a name may have — a long name is cut short. */
+export function defaultAgentName(by) {
+    return `${cutShort(by.trim(), MAX_NAME - "'s AI".length)}'s AI`;
+}
+/** An agent's name told apart from the names `taken` (the tokens in force), whatever the case: the
+ *  name itself, else numbered — "Alice's AI 2", "Alice's AI 3" — within the characters a name may
+ *  have, the name cut short to make room for the number. */
+export function uniqueName(name, taken) {
+    const seen = new Set([...taken].map((t) => t.toLowerCase()));
+    for (let n = 1;; n++) {
+        const s = n === 1 ? name : `${cutShort(name, MAX_NAME - ` ${n}`.length)} ${n}`;
+        if (!seen.has(s.toLowerCase()))
+            return s;
+    }
+}
+/** Whether two names are the same name to a reader: whatever the case, and however Unicode writes
+ *  the same letters. A guest cannot take a name someone invited by a personal link holds in this
+ *  sense (CollabSpec decision 9), so that "alice" does not pass for "Alice". */
+export function sameName(a, b) {
+    const key = (s) => s.trim().normalize("NFKC").toLowerCase();
+    return key(a) === key(b);
+}
+/** Up to two letters for a name's round badge: the first letters of its first two words. */
+export function initials(name) {
+    const words = name.trim().split(/[\s._-]+/).filter(Boolean);
+    const first = (w) => [...w][0] ?? "";
+    return ((words.length > 1 ? first(words[0]) + first(words[1]) : [...name.trim()].slice(0, 2).join("")) || "?").toUpperCase();
+}
+/** A person's colour, fixed by their name: the same on every page and every server. */
+export function colorOf(name) {
+    let h = 2166136261;
+    for (const ch of name) {
+        h ^= ch.codePointAt(0);
+        h = Math.imul(h, 16777619);
+    }
+    // hues spread around the wheel, saturated and dark enough to read white initials on
+    const hue = ((h >>> 0) % 360 + 360) % 360;
+    return `hsl(${hue} 62% 46%)`;
+}
+/** the most source windows a reader pins at once (web/src/sources.ts): a few declarations side by
+ *  side, not a wall of them */
+export const MAX_PINNED = 6;
+/** The legend's schemes (CanvasSpec, "Colour schemes"). */
+export const SCHEMES = ["kind", "status"];
+/** Activity's filters: the kind of event, and whose (web/src/activity.ts). */
+export const ACTIVITY_KINDS = ["all", "review", "build", "change"];
+export const ACTIVITY_WHO = ["all", "agents", "people"];
+/** A session id: what a page calls itself for as long as it is open, in its event stream's address
+ *  only (the server keeps a page's streams few by it); it is never told to the others. */
+export function validSession(s) {
+    return typeof s === "string" && /^[0-9a-f-]{8,64}$/.test(s);
+}
+/** A view as a page sent it, checked and bounded; null when it is not one. */
+export function cleanView(v) {
+    if (!v || typeof v !== "object")
+        return null;
+    const o = v;
+    const str = (x, max = 2000) => (typeof x === "string" && x.length <= max ? x : null);
+    const num = (x) => (typeof x === "number" && Number.isFinite(x) ? x : null);
+    const cam = o.cam && typeof o.cam === "object" ? o.cam : null;
+    const cx = num(cam?.x), cy = num(cam?.y), ck = num(cam?.k);
+    const selection = str(o.selection, 20000);
+    const h = o.history && typeof o.history === "object" ? o.history.snapshot : null;
+    const snapshot = typeof h === "number" && Number.isInteger(h) && h > 0 && h < 1e9 ? h : null;
+    const source = o.source === true;
+    // the visitors, at most a trail's worth (web/src/visitors.ts, TRAIL), each a name, where it was
+    // reached from and its place: the cluster and the spot in it, and where it is drawn
+    const pair = (p) => Array.isArray(p) && p.length === 2 && p.every((n) => num(n) !== null && Math.abs(n) < 1e8) ? [p[0], p[1]] : null;
+    const visitors = (Array.isArray(o.visitors) ? o.visitors.slice(0, 8) : []).flatMap((w) => {
+        const x = w && typeof w === "object" ? w : null;
+        const decl = x ? str(x.decl) : null;
+        if (!decl)
+            return [];
+        const at = pair(x.at), spot = pair(x.spot), from = str(x.from), inn = typeof x.in === "string" ? str(x.in) : null;
+        return [{ decl, ...(at ? { at } : {}), ...(from ? { from } : {}), ...(inn !== null && spot ? { in: inn, spot } : {}) }];
+    });
+    // the reference window: a file by its hash, a page, the link it was opened on
+    const pw = o.paper && typeof o.paper === "object" ? o.paper : null;
+    const paper = pw && typeof pw.file === "string" && /^[0-9a-f]{64}$/.test(pw.file)
+        ? {
+            file: pw.file,
+            ...(Number.isInteger(pw.page) && pw.page >= 1 && pw.page <= 100000 ? { page: pw.page } : {}),
+            ...(typeof pw.link === "string" && /^l[0-9a-f]{12}$/.test(pw.link) ? { link: pw.link } : {}),
+            ...(pw.collapsed === true ? { collapsed: true } : {}),
+        }
+        : null;
+    // what the panels and the board show besides, each said or not at all (an older page says none)
+    const av = o.activity && typeof o.activity === "object" ? o.activity : null;
+    const one = (xs, x) => (xs.includes(x) ? x : null);
+    const kind = one(ACTIVITY_KINDS, av?.kind), who = one(ACTIVITY_WHO, av?.who);
+    const activity = av && typeof av.open === "boolean" && kind && who ? { open: av.open, kind, who, ...(typeof av.mine === "string" && validName(av.mine) ? { mine: av.mine } : {}) } : null;
+    const lost = o.lostFound && typeof o.lostFound === "object" ? o.lostFound.open : undefined;
+    const scheme = one(SCHEMES, o.scheme);
+    const pinned = Array.isArray(o.pinned)
+        ? o.pinned
+            .slice(0, MAX_PINNED)
+            .map((w) => {
+            const decl = w && typeof w === "object" ? str(w.decl) : null;
+            return decl ? { decl, collapsed: w.collapsed === true } : null;
+        })
+            .filter((w) => w !== null)
+        : [];
+    return {
+        mode: str(o.mode, 16) ?? "tcb",
+        sel: str(o.sel),
+        ...(selection !== null ? { selection } : {}),
+        source,
+        ...(source && o.sourceCollapsed === true ? { sourceCollapsed: true } : {}),
+        ...(pinned.length ? { pinned } : {}),
+        clusterMode: str(o.clusterMode, 16) ?? "namespace",
+        cam: cx !== null && cy !== null && ck !== null ? { x: cx, y: cy, k: ck } : null,
+        view: str(o.view, 300),
+        scope: str(o.scope, 4000),
+        tabs: Array.isArray(o.tabs) ? o.tabs.slice(0, 50).map((t) => str(t, 300)).filter((t) => t !== null) : [],
+        ...(snapshot !== null ? { history: { snapshot } } : {}),
+        ...(o.focus === null || str(o.focus) ? { focus: o.focus } : {}),
+        ...(visitors.length ? { visitors } : {}),
+        ...(paper ? { paper } : {}),
+        ...(activity ? { activity } : {}),
+        ...(typeof lost === "boolean" ? { lostFound: { open: lost } } : {}),
+        ...(scheme ? { scheme } : {}),
+        ...(typeof o.edges === "boolean" ? { edges: o.edges } : {}),
+        ...(typeof o.proofEdges === "boolean" ? { proofEdges: o.proofEdges } : {}),
+    };
+}