visualproof 0.2.0 → 0.3.0

package/dist/server/agent.js

@@ -34,6 +34,7 @@ import { join } from "node:path";
 import { gunzipSync } from "node:zlib";
 import { ACTIVITY_KINDS, ACTIVITY_WHO, cleanView, MAX_PINNED, SCHEMES, validName } from "../shared/collab.js";
 import { addressOf, readRegion, showing, writeSnapshot } from "../shared/sharesnap.js";
+import { encodeRecipe, readRecipe, RECIPE_PARAM, resolveRecipe, SAVE_PARAM } from "../shared/artrecipe.js";
 import { contextText, exactContext, readContext } from "../shared/context.js";
 import { compiledExcerpt, excerptOf } from "../shared/excerpt.js";
 import { tokenizeLean } from "../shared/lexer.js";
@@ -56,6 +57,7 @@ import { inTargets, nonStandardAxiom, offBoard, reviewQueue, TCB_SITES, whyChain
 import { reviewThen } from "../shared/pastgraph.js";
 import { contextAt, namespacesOf } from "../shared/scope.js";
 import { PLACES, search, SearchIndex, snippet } from "../shared/search.js";
+import { foldedAt, guessNames } from "../shared/declfind.js";
 import { fullWhen } from "../shared/titles.js";
 import { ALL_SITES, Graph } from "../shared/viewgraph.js";
 import { layoutKey, wholeLayout } from "../shared/board.js";
@@ -172,9 +174,6 @@ const PARTS = ["source", "context", "uses", "users", "describe", "print"];
 const WHERE = { statement: SITE_STMT, body: SITE_BODY, proof: SITE_PROOF, grammar: SITE_GRAMMAR };
 /** what a trusted standard axiom is trusted by */
 const STANDARD = "standard axiom";
-/** the last components of names Lean generates beside a declaration (extractor/Extract.lean,
- *  `generatedSuffixes`, and the like) */
-const GENERATED_LAST = /^(?:rec|recOn|casesOn|noConfusion|noConfusionType|ctorElim|ctorElimType|below|brecOn|binductionOn|ibelow|ctorIdx|toCtorIdx|ofNat|ofNat_ctorIdx|sizeOf_spec|injEq|inj|eq_def|induct|mutual_induct|fun_cases|induct_unfolding|ext_iff|congr_simp|mk|elim|(?:eq|match|proof)_\d+|_.*)$/;
 /** The graph on show, as the API reads it: built from the server's prepared view once per
  *  version. The page's review route reads it too (server/reviewapi.ts). */
 export class View {
@@ -372,41 +371,9 @@ export class AgentApi {
             this.view = new View(g.version, g.prep.metaGz, g.prep.edgesGz);
         return this.view;
     }
-    /** Up to five names like `name`: the same name in another case; then the same last component,
-     *  or one a typo or two away, in the same namespace first; then what the search finds. */
+    /** Up to five names like `name` (shared/declfind.ts, `guessNames`). */
     guess(v, name) {
-        const g = v.g;
-        const dot = name.lastIndexOf(".");
-        const last = name.slice(dot + 1).toLowerCase();
-        const ns = dot < 0 ? "" : name.slice(0, dot);
-        const scored = new Map();
-        const offer = (n, score) => {
-            if ((scored.get(n) ?? Infinity) > score)
-                scored.set(n, score);
-        };
-        const lower = name.toLowerCase();
-        const most = last.length < 5 ? 1 : 2;
-        // the graph's declarations, and the names Lean generated from a command that they fold
-        for (const name of [...g.nodes.map((n) => n.name), ...g.foldedInto.keys()]) {
-            if (name.toLowerCase() === lower)
-                offer(name, -1);
-            const k = name.lastIndexOf(".");
-            const d = editDistance(name.slice(k + 1).toLowerCase(), last, most);
-            if (d <= most)
-                offer(name, 2 * d + (name.slice(0, Math.max(0, k)) === ns ? 0 : 1));
-        }
-        let rank = 0;
-        for (const q of [name.slice(dot + 1), name.replace(/\./g, " ")]) {
-            if (q.trim().length < 2)
-                continue;
-            const f = search(v.index, q);
-            for (const h of [...f.hits.name, ...f.hits.statement].slice(0, 10))
-                offer(g.nodes[h.i].name, 10 + rank++);
-        }
-        return [...scored]
-            .sort((a, b) => a[1] - b[1] || a[0].length - b[0].length || (a[0] < b[0] ? -1 : 1))
-            .slice(0, 5)
-            .map(([n]) => n);
+        return guessNames(v.g, v.index, name);
     }
     /** A declaration by its full name, or the answer that there is none (with what was meant). A
      *  name the graph folds into a declaration is that declaration (`folded` says so). */
@@ -419,35 +386,10 @@ export class AgentApi {
         const guesses = this.guess(v, name.trim());
         return fail(404, `There is no declaration ${name} in the graph.`, guesses.length ? `Did you mean ${guesses[0]}? Names are full, as the search gives them.` : "Search for it: GET /api/agent/search?q=<words>.", { didYouMean: guesses });
     }
-    /** The declaration a name the graph has no node for is folded into: a declaration Lean generated
-     *  from a command (ViewNode.also), or a constructor, recursor, field, equation lemma… of a
-     *  declaration or of one so generated, which is a name one component below it. A name one
-     *  component below a declaration that is a typo or two away from a declaration beside it is
-     *  taken for that typo, not for something folded, unless its last component is one Lean
-     *  generates. */
+    /** The declaration a name the graph has no node for is folded into (shared/declfind.ts,
+     *  `foldedAt`). */
     foldedAt(v, name) {
-        const g = v.g;
-        const direct = g.foldedInto.get(name);
-        if (direct !== undefined)
-            return direct;
-        const dot = name.lastIndexOf(".");
-        if (dot <= 0)
-            return undefined;
-        const head = name.slice(0, dot), last = name.slice(dot + 1);
-        const at = g.byName.get(head) ?? g.foldedInto.get(head);
-        if (at === undefined || !last)
-            return undefined;
-        if (!GENERATED_LAST.test(last)) {
-            const most = last.length < 5 ? 1 : 2;
-            const near = (n) => n.length > head.length + 1 && n.startsWith(head + ".") && !n.includes(".", head.length + 1) && editDistance(n.slice(head.length + 1).toLowerCase(), last.toLowerCase(), most) <= most;
-            for (const n of g.nodes)
-                if (near(n.name))
-                    return undefined;
-            for (const n of g.foldedInto.keys())
-                if (near(n))
-                    return undefined;
-        }
-        return at;
+        return foldedAt(v.g, name);
     }
     /** What an answer about `asked` says when that name is folded into declaration `i`. */
     folded(v, asked, i) {
@@ -514,8 +456,10 @@ export class AgentApi {
         return {
             by: o.by,
             agent: !!o.agent,
-            // someone invited by a personal link: the name is theirs (CollabSpec decision 9)
-            ...(o.person ? { verified: true } : {}),
+            // someone invited by a personal link: the name is theirs (CollabSpec decision 9), unless
+            // someone else recorded it for them at the same screen, who is named (ReviewSpec decision 8)
+            ...(o.person && !o.recordedBy ? { verified: true } : {}),
+            ...(o.recordedBy ? { recordedBy: o.recordedBy.by } : {}),
             verdict: o.verdict,
             ...(o.comment ? { comment: o.comment } : {}),
             at: o.at,
@@ -2046,7 +1990,7 @@ export class AgentApi {
         // what the review's logs record, as the page reads it
         for (const [name, ops] of Object.entries(d.opinions))
             for (const o of ops)
-                out.push({ at: o.at, kind: "opinion", by: o.by, agent: !!o.agent, name, verdict: o.verdict, ...(o.comment ? { comment: o.comment } : {}) });
+                out.push({ at: o.at, kind: "opinion", by: o.by, ...(o.recordedBy ? { recordedBy: o.recordedBy.by } : {}), agent: !!o.agent, name, verdict: o.verdict, ...(o.comment ? { comment: o.comment } : {}) });
         // what an agent did at level full is marked as an agent's, as its advice is
         for (const [name, t] of Object.entries(d.targets))
             out.push({ at: t.at, kind: "target", by: t.by, agent: !!t.agent, name });
@@ -2228,6 +2172,10 @@ export class AgentApi {
             unit = v.g.nodes[i].name;
         }
         const verdict = b.verdict;
+        // an agent's advice is its own: people record for one another at one screen, agents never
+        // (ReviewSpec decision 8)
+        if (b.for !== undefined)
+            return fail(403, "An agent records no opinion for anyone else.", "Leave out for: your advice is your own.");
         // "dispute" was the old name of a comment (renamed 2026-10-09): refused, with the new name
         if (verdict === "dispute")
             return fail(400, "verdict is approve or comment: \"dispute\" is now \"comment\".", "Use comment: send {name, verdict: \"comment\", comment}.");
@@ -2528,6 +2476,66 @@ export class AgentApi {
         }
         return { place: cleanView(next), temporary };
     }
+    /** A link to a picture of the board (ExportSpec decision 20, drafted 2026-10-15): a recipe
+     *  (shared/artrecipe.ts) checked, and resolved against the board of the view it names — the
+     *  Project's layout in the view's clustering — so that a name, a target or a cluster the board has
+     *  not is refused here rather than drawn as a picture unlike the one meant; the selection it gives
+     *  goes in the address, the recipe after it. The page that opens the link resolves it again
+     *  against the board it opens on, opens the artwork mode, and saves the files asked for. Nothing
+     *  changes here, and the link holds no key. */
+    async artwork(a) {
+        const no = needAgent(a.caller);
+        if (no)
+            return no;
+        const b = body(a);
+        const read = readRecipe(b.recipe);
+        if ("error" in read)
+            return fail(400, read.error, read.hint);
+        const r = read.recipe;
+        const save = b.save === undefined || b.save === null ? [] : typeof b.save === "string" ? b.save.split(",").map((k) => k.trim()) : null;
+        if (!save || save.some((k) => k !== "png" && k !== "svg"))
+            return fail(400, "save is png, svg or png,svg.", "The files the page saves once the board is ready; left out, none.");
+        const v = this.graph();
+        if (!(v instanceof View))
+            return v;
+        let sel = null;
+        if (r.selection) {
+            const i = this.find(v, r.selection.name, "selection.name");
+            if (typeof i !== "number")
+                return i;
+            sel = v.g.nodes[i].name;
+        }
+        const rec = r.view && r.view !== PROJECT ? this.world.views?.book.get(r.view) : undefined;
+        if (r.view && r.view !== PROJECT && !rec)
+            return fail(404, `There is no view ${r.view}.`, "GET /api/agent/views lists them; left out, the Project.");
+        const L = v.meta.layouts[rec?.clustering ?? "namespace"];
+        const res = resolveRecipe(r, {
+            clusters: L.clusters,
+            clusterOf: (name) => {
+                const i = v.g.byName.get(name);
+                return i === undefined ? undefined : L.cluster[i];
+            },
+            targets: Object.keys(this.world.review.data.targets),
+            projectCount: v.meta.projectCount,
+        });
+        if (res.problems.length)
+            return fail(404, `The recipe names what the board has not: ${res.problems.join("; ")}.`, "Clusters by key (GET /api/agent/views/view lists a view's), declarations and targets by full name (GET /api/agent/search; the targets: GET /api/agent/targets). A target of the review the graph no longer has is left out unsaid where the recipe does not name it.", { problems: res.problems });
+        const address = addressOf({ view: rec ? rec.id : null, scope: null, mode: r.selection?.mode ?? "tcb", selection: null, sel });
+        const link = `${a.base ?? ""}/#${address}&${RECIPE_PARAM}=${encodeRecipe(r)}${save.length ? `&${SAVE_PARAM}=${[...new Set(save)].join(",")}` : ""}`;
+        const look = res.look;
+        return ok({
+            ok: true,
+            link,
+            length: link.length,
+            size: [look.w, look.h],
+            names: look.labels === "chosen" ? res.named : look.labels,
+            targets: look.targets === "chosen" ? look.shownTargets : look.targets,
+            selection: sel ? { name: sel, mode: r.selection.mode ?? "tcb" } : null,
+            // names and targets beyond what the artwork carries, left out: said, not refused
+            left: res.left,
+            note: "It holds no key: it opens for whoever is let in already, or for a script that enters with the key (scripts/artwork-batch.mjs). The page that opens it resolves the recipe again against its board, opens the artwork mode fitted to the whole board, and saves the files asked for on that machine; nothing comes back here.",
+        });
+    }
     /** A link to what the agent looks at, or to a place it gives over its own, as a person's Share makes
      *  one with Exactly what I see (CollabSpec decision 7, the owner's decision of 2026-10-12): the
      *  address, and after it a snapshot of everything followed, which the page that opens it applies
@@ -2920,6 +2928,12 @@ export class AgentApi {
                 returns: "{ok, link, exact, carries: what the link opens on, length, note, temporary?}",
                 run: (a) => this.viewLink(a),
             },
+            {
+                method: "POST", path: "/api/agent/artwork", about: "A link that opens the board as a picture, in the artwork mode, as the recipe says (ExportSpec decision 20): its size, its look, names by a rule, the targets marked, the selection — in words that hold on any project, so that one recipe makes the same kind of picture of every codebase; the page saves the PNG or SVG where asked, once the board is ready. It changes nothing, and holds no key. A name, a target or a cluster the board has not is refused (404, problems).",
+                params: { recipe: "the picture: {size, orientation, style, theme, transparent, colouring, border, title, subtitle, titleSize, footSize, source, names, targets, keys, notes, edges, selection, lit, view}, each optional (GET /api/agent/docs/export, \"Artwork\")", save: "png, svg or png,svg: the files the page saves once the board is ready; left out, none" },
+                returns: "{ok, link, length, size: [w, h], names: {clusters, decls: written wherever they fall; ruled: by the rule, each only where it covers no other name} | how the board writes them, targets, selection, left: names and targets left out for room, note}",
+                run: (a) => this.artwork(a),
+            },
             {
                 method: "POST", path: "/api/agent/pins", needs: "full", about: "Drop or let go of pins on the Project view, as people drag (for another view: POST /api/agent/views/arrange): one batch, recorded in the timeline with what it replaced, undoable at once.",
                 params: { mode: "namespace (default) or module", pins: `[{name or cluster, at: [x, y] in the parent's coordinates (GET /api/agent/place), or null to let go}], at most ${MAX_PINS}` },
@@ -3174,6 +3188,8 @@ export function doingOf(a) {
             return of("going to", clip(b.sel)) ?? of("going to the view of", clip(b.review)) ?? "moving its view";
         case "/api/agent/view/link":
             return "making a link to what it looks at";
+        case "/api/agent/artwork":
+            return "making a link to a picture of the board";
         case "/api/agent/ask-follow":
             return clip(b.who) ? `asking ${clip(b.who)} to follow it` : "asking everyone to follow it";
         case "/api/agent/opinion":
@@ -3226,24 +3242,6 @@ const str = (x) => (typeof x === "string" ? x : null);
 export function whoOf(c) {
     return { name: c.name ?? "", ...(c.token ? { token: c.token.id } : {}) };
 }
-/** The edit distance between two short strings, or `most + 1` once it is more than `most`. */
-function editDistance(a, b, most) {
-    if (Math.abs(a.length - b.length) > most)
-        return most + 1;
-    let prev = Array.from({ length: b.length + 1 }, (_, j) => j);
-    for (let i = 1; i <= a.length; i++) {
-        const row = [i];
-        let best = i;
-        for (let j = 1; j <= b.length; j++) {
-            row[j] = Math.min(prev[j] + 1, row[j - 1] + 1, prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
-            best = Math.min(best, row[j]);
-        }
-        if (best > most)
-            return most + 1;
-        prev = row;
-    }
-    return Math.min(prev[b.length], most + 1);
-}
 /** An integer parameter within bounds, `dflt` when absent or not a number. */
 function clampInt(s, dflt, lo, hi) {
     const n = s === null || s.trim() === "" ? NaN : Number(s);

package/dist/server/agentdocs.js

@@ -16,7 +16,7 @@ export const DOC_TOPICS = [
     { topic: "following", title: "Following", about: "where people are, your view, links to it, what people see" },
     { topic: "views", title: "Views and the layout", about: "queries, views, places, pins" },
     { topic: "library", title: "The library and links", about: "papers and images, their pages, links to them" },
-    { topic: "export", title: "Exported documents", about: "a view's document, typeset" },
+    { topic: "export", title: "Exported documents", about: "a view's document, typeset; a picture" },
     { topic: "history", title: "History and activity", about: "the timeline, builds, renames, the lost-and-found" },
     { topic: "talking", title: "Talking with people", about: "your inbox, replies, your state" },
     { topic: "mcp", title: "VisualProof's MCP server", about: "installing it, its tools and their actions" },

package/dist/server/artcmd.js

@@ -0,0 +1,335 @@
+// The artwork command (ExportSpec decision 21): `visualproof artwork <lean-project> --recipe <file>`
+// makes the picture a recipe says (decision 20) without a browser — the same picture as the page's,
+// by the page's own code. The build is read as `visualproof export` reads it; the board is the
+// Project's, laid out as the site keeps it (or as a new site would); the recipe is resolved as the
+// page resolves it; the board is drawn by the page's canvas without a graphics card (its renderer
+// kept to its data, the names measured from the fonts the package ships) on a screen of the given
+// size, the frame placed and fitted as the artwork mode places and fits it; the SVG is written as
+// the page's Save SVG writes it, and the PNG is that SVG drawn by resvg with the same fonts.
+// Nothing is written but the files: the site is read, never written (pipeline `readOnlySite`), and
+// without --site none is read.
+import { readFileSync, readdirSync } from "node:fs";
+import { createRequire } from "node:module";
+import { join } from "node:path";
+import { createDeflate, crc32, gunzipSync } from "node:zlib";
+import { readRecipe, resolveRecipe } from "../shared/artrecipe.js";
+import { textMeasurer } from "../shared/artfonts.js";
+import { boardSet, lightUp, wholeLayout } from "../shared/board.js";
+import { declAt, guessNames } from "../shared/declfind.js";
+import { litKeyEdges } from "../shared/keys.js";
+import { emptyReview } from "../shared/review.js";
+import { SearchIndex } from "../shared/search.js";
+import { Graph } from "../shared/viewgraph.js";
+import { PROJECT } from "../shared/views.js";
+import { artName, artSvg, borderInset, cleanSettings, cssTheme, drawBackdrop, frameRect, sourceLine, SvgContext, themeBackground, titleOf, titleRoom, writeOver } from "../web/src/artwork.js";
+import { GraphCanvas, themeOf } from "../web/src/canvas.js";
+import { ART_SANS } from "../web/src/halo.js";
+import { ReviewFlow } from "../web/src/reviewqueue.js";
+import { declPick, edgeMode, selectionQuery } from "../web/src/selection.js";
+import { statusCodes } from "../web/src/status.js";
+import { gitSource } from "./history.js";
+import { WEB, WEBFONTS } from "./pipeline.js";
+/** the faces of a picture's names, from the package's own TrueType files (scripts/artfonts.py) */
+const TTF = join(WEBFONTS, "ttf");
+let metrics = null;
+/** How wide text is in a font, as the package's faces draw it. */
+function measurer() {
+    metrics ??= JSON.parse(readFileSync(join(WEBFONTS, "metrics.json"), "utf8"));
+    return textMeasurer(metrics);
+}
+/** The page's font faces, each its WOFF2 written in, as the page's Save SVG writes them (web/src/
+ *  artframe.ts, faces): from the style sheet's rules, the files beside it. */
+export function facesOf(css) {
+    const out = [];
+    for (const m of css.matchAll(/@font-face\s*\{([^}]*)\}/g)) {
+        const body = m[1];
+        const get = (k) => new RegExp(`${k}\\s*:\\s*([^;]+)`).exec(body)?.[1].trim();
+        const family = get("font-family")?.replace(/["']/g, "").trim() ?? "";
+        if (family !== "Source Sans 3" && family !== "Source Serif 4" && family !== "Jost")
+            continue;
+        const file = /url\(["']?\/fonts\/([a-z0-9-]+\.woff2)["']?\)/.exec(body)?.[1];
+        if (!file)
+            continue;
+        const b64 = readFileSync(join(WEBFONTS, file)).toString("base64");
+        out.push(`@font-face{font-family:"${family}";font-style:${get("font-style") || "normal"};font-weight:${get("font-weight") || "400"};src:url(data:font/woff2;base64,${b64}) format("woff2");unicode-range:${get("unicode-range") || "U+0-10FFFF"}}`);
+    }
+    return out.join("");
+}
+/** The Project view as a site keeps it (its pins, folds, hidden levels and clustering: server/views.ts,
+ *  readProjectView), or as a new site has it. */
+export function projectView(kept) {
+    const empty = () => ({ namespace: [], module: [] });
+    return (kept ?? {
+        id: PROJECT,
+        name: null,
+        scope: { op: "all" },
+        clustering: "namespace",
+        pins: { namespace: { clusters: {}, nodes: {} }, module: { clusters: {}, nodes: {} } },
+        folds: empty(),
+        hidden: empty(),
+        by: null,
+        at: new Date(0).toISOString(),
+        kept: true,
+    });
+}
+/** The picture a recipe says, of the build `prep` — its graph and layouts — with the review and the
+ *  Project view a site keeps (or none). */
+export function makeArtwork(prep, review, project, ask) {
+    const read = readRecipe(ask.recipe);
+    if ("error" in read)
+        return { problems: [`${read.error} ${read.hint}`] };
+    const r = read.recipe;
+    if (r.view && r.view !== PROJECT)
+        return { problems: [`the command draws the Project view: the recipe names the view ${r.view}`] };
+    const meta = JSON.parse(gunzipSync(prep.metaGz).toString("utf8"));
+    const raw = gunzipSync(prep.edgesGz);
+    const g = new Graph(meta, new Int32Array(raw.buffer, raw.byteOffset, raw.byteLength / 4));
+    const data = review ?? emptyReview();
+    // the board: the Project's, on the server's layout under the levels it hides
+    const mode = project.clustering;
+    const bs = boardSet(g, data, project.scope);
+    const L = wholeLayout(meta.layouts[mode], g.nodes, mode, project.hidden[mode]);
+    // the targets: the review's with a site, those the recipe names without one
+    const onGraph = (n) => g.byName.has(n);
+    const targets = review ? Object.keys(data.targets) : Array.isArray(r.targets) ? r.targets.filter(onGraph) : [];
+    const problems = [];
+    let sel = null;
+    if (r.selection) {
+        // as the agents' API finds a declaration (shared/declfind.ts): a name it folds is the declaration
+        // it is folded into; none, what was likely meant
+        const i = declAt(g, r.selection.name);
+        if (i !== undefined)
+            sel = { name: g.nodes[i].name, mode: r.selection.mode ?? "tcb" };
+        else {
+            const meant = guessNames(g, new SearchIndex(meta.nodes, meta.projectCount), r.selection.name.trim());
+            problems.push(`no declaration ${r.selection.name} in the graph${meant.length ? ` (did you mean ${meant[0]}?)` : ""}`);
+        }
+    }
+    const res = resolveRecipe(r, {
+        clusters: L.clusters,
+        clusterOf: (name) => {
+            const i = g.byName.get(name);
+            return i === undefined ? undefined : L.cluster[i];
+        },
+        targets,
+        projectCount: g.projectCount,
+    });
+    problems.push(...res.problems);
+    if (problems.length)
+        return { problems };
+    const s = cleanSettings(res.look, { scheme: "kind", theme: "light" });
+    // the theme as the mode sets it (web/src/main.ts, drawLook): the board's style in the artwork's,
+    // the cells and the starfield in the dark one
+    const css = readFileSync(join(WEB, "style.css"), "utf8");
+    const v = cssTheme(css, s.style === "board" ? s.theme === "dark" : true);
+    const measure = measurer();
+    // the board, drawn without a browser on a screen of the size asked
+    const scratch = new SvgContext(measure, ART_SANS);
+    const none = () => { };
+    const C = new GraphCanvas(null, null, null, g, { nodeClick: none, clusterClick: none, backgroundClick: none, hover: none, pinsChanged: none, foldChanged: none }, { w: ask.screen.w, h: ask.screen.h, theme: themeOf(v), ctx: scratch });
+    C.setGraph(g);
+    C.setLayout(L, project.pins[mode], project.folds[mode], mode);
+    C.setShowExternals(bs.whole ? bs.outside : true);
+    // the review on it, as the page's syncStatus puts it (no build's file states: none is known here)
+    const idx = targets.map((n) => g.byName.get(n)).filter((j) => j !== undefined);
+    C.setStatus(statusCodes(data, g, new Map()));
+    C.setTargets(idx);
+    const flow = new ReviewFlow({ graph: () => g, review: () => data, reader: () => null });
+    const keys = new Map();
+    for (const t of idx)
+        for (const k of flow.keys(t).keys)
+            if (k !== t)
+                keys.set(k, [...(keys.get(k) ?? []), t]);
+    C.setKeys([...keys.keys()], [...keys.values()]);
+    // the artwork's look, as drawLook gives it
+    C.setScheme(s.scheme);
+    C.setEdges(s.edges !== "none");
+    C.setArt({ labels: s.labels, namesFrom: s.namesFrom, hidden: new Set(s.hiddenNames), shown: new Set(s.shownNames), ruled: new Set(s.ruledNames), edges: s.edges, targets: s.targets, shownTargets: new Set(s.shownTargets), keys: s.keys, style: s.style });
+    // the selection, as the page's apply makes it
+    const picks = sel ? [declPick(sel.mode, sel.name)] : [];
+    const q = selectionQuery(picks);
+    const lit = q && lightUp(g, data, bs, q);
+    const keyEdges = sel?.mode === "keys" && lit && lit.count ? litKeyEdges(idx.map((t) => flow.keys(t)), (i) => lit.set[i] === 1).flat() : null;
+    if (s.targets === "highlight") {
+        const alone = new Uint8Array(g.n);
+        for (const i of idx)
+            alone[i] = 1;
+        C.setActivation(edgeMode(picks), [], alone, [], null);
+    }
+    else if (!s.selection)
+        C.setActivation(edgeMode(picks), [], null, [], null);
+    else
+        C.setActivation(edgeMode(picks), sel ? [g.byName.get(sel.name)] : [], lit?.set ?? null, [], keyEdges);
+    // the frame, placed and fitted as the mode places and fits it (web/src/artframe.ts, place, open)
+    const rect = frameRect(ask.screen, s);
+    // the title's line counts the targets marked: the review's, or the recipe's where there is no site
+    const own = titleOf(meta.project.name, meta.projectCount, review ? Object.keys(data.targets).length : targets.length);
+    const below = titleRoom(rect.h, s, own);
+    const cam = C.fitCam({ x: rect.x, y: rect.y + below, w: rect.w, h: rect.h - below });
+    if (cam)
+        C.jumpTo(cam);
+    C.settle();
+    // what the names are: those written, and those a rule chose that would have covered another
+    const written = C.writtenNames();
+    const name = (id) => id.slice(2).replace("⟨external⟩", "External");
+    const git = s.source ? gitSource(ask.root) : null;
+    const source = git ? sourceLine(git) : null;
+    // the SVG, as the page's Save SVG writes it (artframe saveFile); notes are not drawn here
+    const ground = s.background !== "transparent";
+    const bg = ground && s.style === "board" ? themeBackground(v) : null;
+    const svg = artSvg(rect, s, bg, ART_SANS, measure, (pen) => {
+        const ctx = pen;
+        if (ground)
+            drawBackdrop(ctx, s.style, rect);
+        if (s.border) {
+            const i = borderInset(rect);
+            pen.clipRect("inside", rect.x + i, rect.y + i, rect.w - 2 * i, rect.h - 2 * i);
+            pen.raw(`<g clip-path="url(#inside)">`);
+        }
+        for (const sh of C.artShapes(rect))
+            pen.shape(sh);
+        C.drawMarks(ctx);
+        if (s.border)
+            pen.raw(`</g>`);
+        writeOver(ctx, s, rect, own, source, v);
+    }, facesOf(css));
+    const title = ask.name ?? (s.title || meta.project.name);
+    return {
+        problems: [],
+        look: s,
+        names: {
+            written: [...written].map(name),
+            ruledSkipped: s.ruledNames.filter((id) => !written.has(id)).map(name),
+            left: res.left,
+        },
+        targets: s.targets === "chosen" ? s.shownTargets : s.targets === "plain" ? [] : idx.map((j) => g.nodes[j].name),
+        selection: sel,
+        notesLeftOut: s.notes ? (project.notes ?? []).length : 0,
+        svg,
+        file: (kind) => artName(title, kind),
+    };
+}
+let wasmReady = null;
+let ttfs = null;
+/** resvg's WebAssembly build, ready, with the package's TrueType faces and none of the system's
+ *  (decision 21: the PNG agrees with the SVG, and is the same on every machine) */
+async function renderer() {
+    const { initWasm, Resvg } = await import("@resvg/resvg-wasm");
+    wasmReady ??= initWasm(readFileSync(createRequire(import.meta.url).resolve("@resvg/resvg-wasm/index_bg.wasm")));
+    await wasmReady;
+    ttfs ??= readdirSync(TTF)
+        .filter((f) => f.endsWith(".ttf"))
+        .sort()
+        .map((f) => new Uint8Array(readFileSync(join(TTF, f))));
+    const opts = { font: { fontBuffers: ttfs, loadSystemFonts: false, defaultFontFamily: "Source Sans 3" } };
+    return (svg) => new Resvg(svg, opts);
+}
+/** The most pixels a PNG is drawn in at once. resvg holds a picture four times over and more (its
+ *  clipped groups' layers and their masks: 17 bytes a pixel) in WebAssembly's memory, which is at
+ *  most 4 GiB: a picture of 80 million pixels takes 1.9 GB, the largest (16384 × 16384) more than
+ *  there is. A larger one is drawn in bands of BAND_PIXELS (the largest: 2.0 GB). */
+export const PNG_PIXELS = 80_000_000;
+/** A band's pixels: resvg's layers reach up to twice the band's height beyond it, so that a band
+ *  costs 35 bytes a pixel, 0.7 GB, and the picture is drawn about three times as long. */
+const BAND_PIXELS = 20_000_000;
+/** An artwork's SVG (artSvg's: its root's viewBox the frame, its width and height the picture's) as
+ *  it draws rows `y0` to `y0 + rows` of the picture: its viewBox moved down, the background's
+ *  rectangle (its `100%`, which a moved viewBox would not move) in the frame's units, and the frame's
+ *  clip left out, as the band is within the frame. The border's clip is kept, and given a rectangle
+ *  as large as the frame that draws nothing: resvg 2.6 fails (WebAssembly's `unreachable`) on a
+ *  clipped group whose contents lie more than twice the band's height away from it. */
+export function bandSvg(svg, y0, rows) {
+    const root = /^<svg ([^>]*?)viewBox="0 0 ([\d.]+) ([\d.]+)" width="(\d+)" height="(\d+)"/.exec(svg);
+    const board = /<g clip-path="url\(#frame\)"><g transform="translate\(([-\d.]+) ([-\d.]+)\)">/.exec(svg);
+    if (!root || !board)
+        throw new Error("not an artwork's SVG");
+    const [W, H, PH] = [Number(root[2]), Number(root[3]), Number(root[5])];
+    const f = H / PH;
+    return svg
+        .replace(root[0], `<svg ${root[1]}viewBox="0 ${y0 * f} ${W} ${rows * f}" width="${root[4]}" height="${rows}"`)
+        .replace(`<rect width="100%" height="100%"`, `<rect width="${W}" height="${H}"`)
+        .replace(board[0], `<g><g transform="translate(${board[1]} ${board[2]})">`)
+        .replace(`<g clip-path="url(#inside)">`, `<g clip-path="url(#inside)"><rect x="${-Number(board[1])}" y="${-Number(board[2])}" width="${W}" height="${H}" fill="#000" fill-opacity="0"/>`);
+}
+/** An SVG drawn as a PNG at the size its root says, by resvg. A picture of more than `most` pixels
+ *  is drawn in bands of about `band` pixels (bandSvg) and written as one PNG, row by row: the same
+ *  picture, its pixels a few levels apart where translucent shapes overlap (resvg's layers round
+ *  otherwise than one drawing). */
+export async function pngOf(svg, most = PNG_PIXELS, band = BAND_PIXELS) {
+    const render = await renderer();
+    const m = /^<svg [^>]*?width="(\d+)" height="(\d+)"/.exec(svg);
+    const [w, h] = m ? [Number(m[1]), Number(m[2])] : [0, 0];
+    const failed = (e) => new Error(`the PNG${m ? `, ${w} × ${h},` : ""} could not be drawn (${e instanceof Error ? e.message : String(e)})`);
+    if (!m || w * h <= most) {
+        const r = render(svg);
+        let png;
+        try {
+            const image = r.render();
+            png = image.asPng();
+            image.free();
+        }
+        catch (e) {
+            // resvg is not called again once it has failed: the command ends
+            throw failed(e);
+        }
+        r.free();
+        return png;
+    }
+    // the rows, each its filter byte (none) and its pixels, demultiplied as resvg's own PNG has them
+    // (tiny-skia's `demultiply`)
+    const deflate = createDeflate({ level: 6 });
+    const out = [];
+    deflate.on("data", (b) => out.push(b));
+    const done = new Promise((ok, fail) => {
+        deflate.on("end", ok);
+        deflate.on("error", fail);
+    });
+    // bands of even heights, so that none is a sliver
+    const count = Math.ceil(h / Math.max(1, Math.floor(band / w)));
+    const rows = Math.ceil(h / count);
+    for (let y = 0; y < h; y += rows) {
+        const n = Math.min(rows, h - y);
+        const r = render(bandSvg(svg, y, n));
+        let px;
+        try {
+            const image = r.render();
+            px = image.pixels;
+            image.free();
+        }
+        catch (e) {
+            throw failed(e);
+        }
+        r.free();
+        const lines = Buffer.alloc(n * (w * 4 + 1));
+        for (let row = 0; row < n; row++) {
+            const o = row * (w * 4 + 1) + 1, from = row * w * 4;
+            for (let x = 0; x < w * 4; x += 4) {
+                const a = px[from + x + 3];
+                lines[o + x + 3] = a;
+                if (a === 255)
+                    for (let c = 0; c < 3; c++)
+                        lines[o + x + c] = px[from + x + c];
+                else if (a > 0)
+                    for (let c = 0; c < 3; c++)
+                        lines[o + x + c] = Math.min(255, Math.floor(px[from + x + c] / (a / 255) + 0.5));
+            }
+        }
+        if (!deflate.write(lines))
+            await new Promise((ok) => deflate.once("drain", ok));
+    }
+    deflate.end();
+    await done;
+    const chunk = (type, data) => {
+        const head = Buffer.alloc(8);
+        head.writeUInt32BE(data.length, 0);
+        head.write(type, 4, "latin1");
+        const crc = Buffer.alloc(4);
+        crc.writeUInt32BE(crc32(Buffer.concat([head.subarray(4), data])) >>> 0, 0);
+        return Buffer.concat([head, data, crc]);
+    };
+    const ihdr = Buffer.alloc(13);
+    ihdr.writeUInt32BE(w, 0);
+    ihdr.writeUInt32BE(h, 4);
+    ihdr.set([8, 6, 0, 0, 0], 8);
+    return new Uint8Array(Buffer.concat([Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]), chunk("IHDR", ihdr), chunk("IDAT", Buffer.concat(out)), chunk("IEND", Buffer.alloc(0))]));
+}

package/dist/server/live.js

@@ -913,6 +913,12 @@ export class Live {
         }
         return made;
     }
+    /** The holder of a personal link in force who goes by `name` (CollabSpec decision 9): whom an
+     *  opinion recorded for that name is for (ReviewSpec decision 8). */
+    invited(name) {
+        const r = this.invites.holder(name);
+        return r ? { id: r.id, name: r.name } : undefined;
+    }
     /** The usage pass's contexts of a module (shared/context.ts), when the graph on show has them. */
     contextsOf(module) {
         return this.graph?.prep.usage?.contexts[module] ?? null;