visualproof 0.1.0 → 0.3.0

package/dist/server/main.js

@@ -2,12 +2,15 @@
 // visualproof serve <path>   — read a built Lean project and serve its declaration graph
 // visualproof export <path>  — the same page, frozen into one HTML file
 import { historyAnswer } from "./historyapi.js";
+import { gitSource } from "./history.js";
 import { createHash } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, statSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { createServer } from "node:http";
-import { extname, join, resolve } from "node:path";
+import { basename, dirname, extname, join, resolve } from "node:path";
+import { tmpdir } from "node:os";
 import { gunzipSync, gzipSync } from "node:zlib";
-import { WEB, bundleDir, bundleDirIn, ensureBundle, prepare, useBundleDir } from "./pipeline.js";
+import { WEB, WEBFONTS, bundleDir, bundleDirIn, ensureBundle, prepare, useBundleDir } from "./pipeline.js";
+import { makeArtwork, pngOf, projectView } from "./artcmd.js";
 import { SiteBusy, cacheHome, dataHome, lockSite, openSite, projectDirs } from "./dirs.js";
 import { ProjectError, openProject, targetsInWords } from "./project.js";
 import { Live } from "./live.js";
@@ -15,8 +18,8 @@ import { ReviewStore } from "./review.js";
 import { isDeclName, LeanHover } from "./hover.js";
 import { Identities, layoutAuthor } from "./identity.js";
 import { LAYOUT_VERSION } from "../shared/graph.js";
-import { MAX_MEMORY_BYTES, Views } from "./views.js";
-import { cleanView, defaultAgentName, validSession } from "../shared/collab.js";
+import { MAX_MEMORY_BYTES, readProjectView, Views } from "./views.js";
+import { cleanView, defaultAgentName, validSession, withoutArtwork } from "../shared/collab.js";
 import { writeSnapshot } from "./snapshot.js";
 import { lakeTextHash } from "./status.js";
 import { invalidTemplate } from "../shared/editor.js";
@@ -48,6 +51,8 @@ function usage(code = 2) {
        visualproof purge-file <lean-project> <sha256> [--site dir] [--cache dir]
        visualproof export <lean-project> -o page.html [--label text] [--root Name]... [--graph saved.json]
                                          [--jobs ${DEFAULT_JOBS}] [--site dir] [--cache dir]
+       visualproof artwork <lean-project> --recipe recipe.json [-o name] [--png] [--svg] [--root Name]...
+                                         [--site dir] [--cache dir] [--jobs ${DEFAULT_JOBS}] [--screen 1920x1200] [--graph saved.json]
        visualproof doctor [<lean-project>] [--root Name]... [--site dir] [--cache dir]
        visualproof --version
 
@@ -72,6 +77,17 @@ function usage(code = 2) {
            the build; the project path still supplies the sources
   export   writes one self-contained HTML file: the page, its data and the sources, frozen
 
+  artwork  makes the picture an artwork recipe says (the agents' API's, docs/agent-api/export.md:
+           the size, the look, names by a rule, the targets, the selection), as the page's
+           artwork mode makes it, without a browser: an SVG and a PNG (--png or --svg for one),
+           named by -o (a name, or a path without its extension), else the recipe's title, else
+           the project. With --site, the board as that site keeps it (its layout, pins and folds)
+           and its review's targets; without, the board as a new site would lay it out, and the
+           targets the recipe names. --screen: the screen the board is drawn on, as a reader's
+           (default 1920x1200, at least 640x480): how large names are in the picture. It reads
+           the site, never writes it; it writes the files and the cache's extraction. Anything
+           that fails ends it with status 1. Notes are not drawn yet.
+
   --identity-header  behind a proxy that authenticates (Tailscale, oauth2-proxy, …): take each
            reader's name from this header instead of the name the page gives. Only use it when
            the proxy is the only way to reach the server: the header is believed as it comes.
@@ -131,9 +147,9 @@ function parseArgs(argv) {
         console.log(packageVersion());
         process.exit(0);
     }
-    if (cmd !== "serve" && cmd !== "export" && cmd !== "purge-file" && cmd !== "doctor")
+    if (cmd !== "serve" && cmd !== "export" && cmd !== "purge-file" && cmd !== "doctor" && cmd !== "artwork")
         usage();
-    const o = { cmd, path: "", roots: [], port: 4173, host: "127.0.0.1", site: null, cache: null, graph: null, out: null, label: "VisualProof", identityHeader: null, editor: null, agents: "full", accessKeyFile: null, jobs: DEFAULT_JOBS, publicUrl: null, libraryLimit: DEFAULT_LIBRARY_LIMIT, sha: null, publicRead: false };
+    const o = { cmd, path: "", roots: [], port: 4173, host: "127.0.0.1", site: null, cache: null, graph: null, out: null, label: "VisualProof", identityHeader: null, editor: null, agents: "full", accessKeyFile: null, jobs: DEFAULT_JOBS, publicUrl: null, libraryLimit: DEFAULT_LIBRARY_LIMIT, sha: null, publicRead: false, recipe: null, png: false, svg: false, screen: { w: 1920, h: 1200 } };
     for (let i = 0; i < rest.length; i++) {
         const a = rest[i];
         const val = () => rest[++i] ?? usage();
@@ -161,6 +177,18 @@ function parseArgs(argv) {
             o.accessKeyFile = resolve(val());
         else if (a === "--public")
             o.publicRead = true;
+        else if (a === "--recipe" && cmd === "artwork")
+            o.recipe = resolve(val());
+        else if (a === "--png" && cmd === "artwork")
+            o.png = true;
+        else if (a === "--svg" && cmd === "artwork")
+            o.svg = true;
+        else if (a === "--screen" && cmd === "artwork") {
+            const m = /^(\d+)x(\d+)$/.exec(val());
+            if (!m || +m[1] < 640 || +m[2] < 480 || +m[1] > 10000 || +m[2] > 10000)
+                usage();
+            o.screen = { w: +m[1], h: +m[2] };
+        }
         else if (a === "--public-url") {
             const u = val();
             if (!/^https?:\/\/[^\s/?#]+\/?$/.test(u)) {
@@ -196,7 +224,7 @@ function parseArgs(argv) {
         else
             usage();
     }
-    if ((!o.path && cmd !== "doctor") || (cmd === "export" && !o.out))
+    if ((!o.path && cmd !== "doctor") || (cmd === "export" && !o.out) || (cmd === "artwork" && !o.recipe))
         usage();
     // read-only for whoever comes, beside those the key or a link lets in: without a key, everyone is in
     // already; behind a sign-in, there is nobody else
@@ -221,6 +249,11 @@ export class App {
     live;
     hover;
     ids;
+    /** how long a read of the project's git (GET /api/git) is kept, whoever asks: git is run at most
+     *  once in that time, so what readers cost the server is bounded (CollabSpec decision 11); 0 in
+     *  the tests */
+    gitFreshMs = 3000;
+    gitRead = null;
     /** the agents' API (server/agent.ts), and what agents may change */
     agents;
     /** who may come in at all (server/access.ts); null: anyone who reaches the port */
@@ -265,6 +298,11 @@ export class App {
     async export(req, res, url, agent, readOnly = false) {
         const path = url.pathname;
         const api = this.agents;
+        // the document's outline, which the linear form draws: nothing is typeset for it
+        if (path === "/api/export/outline") {
+            const o = api.exportOutline(url.searchParams.get("view") ?? "", url.searchParams.get("version") ?? undefined);
+            return sendJson(res, o.body, o.status, o.headers);
+        }
         if (!this.exporter)
             return sendJson(res, { error: "This server does not export documents." }, 404);
         let a;
@@ -817,6 +855,9 @@ export class App {
                 return sendFile(req, res, join(WEB, "index.html"));
             if (path === "/style.css")
                 return sendFile(req, res, join(WEB, "style.css"));
+            // the fonts an artwork is drawn in (ExportSpec decision 19)
+            if (FONT_PATH.test(path))
+                return sendFile(req, res, join(WEBFONTS, path.slice("/fonts/".length)));
             // the page, and its workers: the one that lays out the Time Machine's past graphs
             // (web/src/layoutworker.ts), the one that chooses the overview's edges (web/src/edgeworker.ts),
             // and pdf.js's, which reads the library's PDFs for the reference window (AttachmentSpec decision 11)
@@ -937,8 +978,9 @@ export class App {
                 // its own event stream only, by the secret the stream was given (`hello`)
                 const name = this.ids.who(req);
                 const priv = !agent && b.private === true;
+                // agents have no artwork (ExportSpec decision 19): the page draws it
                 if (agent && name)
-                    live.presence.agentBeat(name, cleanView(b.view));
+                    live.presence.agentBeat(name, withoutArtwork(cleanView(b.view)));
                 else if (!live.beat(b.token, priv ? null : name, priv ? null : cleanView(b.view), !priv && b.idle === true, priv, !!this.ids.person(req)))
                     return sendJson(res, { error: "This heartbeat is not from an open event stream of this page's: it is sent with the token the stream says hello with.", stream: false }, 403);
                 return sendJson(res, { ok: true });
@@ -967,6 +1009,13 @@ export class App {
                 const a = this.agents.undo(me, agent, r.body?.id);
                 return sendJson(res, a.body, a.status);
             }
+            // the project's git source and commit as git says them now, not as the build was read (an
+            // artwork's foot, ExportSpec decision 19; the owner's decision of 2026-10-15)
+            if (path === "/api/git") {
+                if (!this.gitRead || Date.now() - this.gitRead.at >= this.gitFreshMs)
+                    this.gitRead = { git: gitSource(live.project.root), at: Date.now() };
+                return sendJson(res, { git: this.gitRead.git });
+            }
             if (path === "/api/meta" || path === "/api/edges") {
                 const g = live.graph;
                 if (!g)
@@ -1080,7 +1129,10 @@ export class App {
         }
     }
 }
+/** an artwork's font file (assets/webfonts/) */
+const FONT_PATH = /^\/fonts\/(source-sans-3|source-serif-4|jost)-[a-z-]+\.woff2$/;
 const TYPES = {
+    ".woff2": "font/woff2",
     ".html": "text/html; charset=utf-8",
     ".css": "text/css; charset=utf-8",
     ".js": "text/javascript; charset=utf-8",
@@ -1282,8 +1334,10 @@ async function main() {
         console.log(printReport(report, o.path || null));
         process.exit(report.checks.some((c) => c.level === "fail") ? 1 : 0);
     }
-    // a live server outlives any one failed task: log it and keep serving
-    process.on("unhandledRejection", (e) => console.error("unhandled:", e instanceof Error ? e.message : e));
+    // a live server outlives any one failed task: log it and keep serving (a picture is no server:
+    // whatever fails ends it, with status 1)
+    if (o.cmd !== "artwork")
+        process.on("unhandledRejection", (e) => console.error("unhandled:", e instanceof Error ? e.message : e));
     let project;
     try {
         project = openProject(o.path, o.roots, o.graph === null);
@@ -1295,6 +1349,9 @@ async function main() {
         }
         throw e;
     }
+    // a picture: the site read, never made, locked or written (ExportSpec decision 21)
+    if (o.cmd === "artwork")
+        return artworkCommand(project, o);
     const dirs = projectDirs(project.root, o.site, o.cache);
     openSite(dirs.site);
     mkdirSync(dirs.cache, { recursive: true });
@@ -1389,6 +1446,89 @@ async function main() {
     });
     live.start();
 }
+/** The artwork command (ExportSpec decision 21): the build read as an export reads it, the picture a
+ *  recipe says made of it (server/artcmd.ts), its files written; what it named said as the agents'
+ *  API says it; problems said, and exit status 1. */
+async function artworkCommand(project, o) {
+    const fail = (why) => {
+        console.error(`visualproof artwork: ${why}`);
+        process.exit(1);
+    };
+    try {
+        await artwork(project, o, fail);
+    }
+    catch (e) {
+        fail(e instanceof Error ? e.message : String(e));
+    }
+}
+async function artwork(project, o, fail) {
+    const dirs = projectDirs(project.root, o.site, o.cache);
+    const site = o.site ? dirs.site : null;
+    if (site && !existsSync(site))
+        fail(`there is no site at ${site}`);
+    let recipe;
+    try {
+        recipe = JSON.parse(readFileSync(o.recipe, "utf8"));
+    }
+    catch (e) {
+        fail(`the recipe ${o.recipe} cannot be read: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    // -o: a name, or a path without its extension, in a folder that is there
+    const outBase = o.out ? o.out.replace(/\.(png|svg)$/i, "") : null;
+    const dir = outBase ? dirname(outBase) : process.cwd();
+    if (!existsSync(dir))
+        fail(`there is no folder ${dir} to write the files in`);
+    mkdirSync(dirs.cache, { recursive: true });
+    const log = (l) => console.log(l);
+    let ex = o.graph ? undefined : await extract(project, dirs, log);
+    if (ex && o.jobs > 0) {
+        const pass = new UsagePass(project, dirs, o.jobs, log);
+        const plan = pass.plan(ex.graph);
+        if (plan.todo.length)
+            log(`usage pass: elaborating ${plan.todo.length} of ${plan.modules.length} modules, ${o.jobs} at a time`);
+        const results = await pass.run(plan);
+        if (results) {
+            ex = mergeUsage(ex, plan, results, pass.status.failed, pass.status.ms ?? 0);
+            saveMerged(dirs.cache, ex);
+        }
+    }
+    // the site's layout memory read and never written, nor the views laid out written to the cache;
+    // without a site, none read: the board as a new site lays it out
+    const prep = await prepare(project, dirs, o.graph, log, { ...(ex ? { extraction: ex } : {}), readOnlySite: true, ...(site ? {} : { freshLayout: true }) });
+    const kept = site ? readProjectView(site, LAYOUT_VERSION) : { view: null };
+    if (kept.why)
+        console.error(`visualproof artwork: the site's views cannot be read (${kept.why}): the Project view as a new site has it`);
+    const review = site ? new ReviewStore(project.root, site).data : null;
+    const a = makeArtwork(prep, review, projectView(kept.view), { recipe, screen: o.screen, name: outBase ? basename(outBase) : null, root: project.root });
+    if (!("svg" in a)) {
+        for (const p of a.problems)
+            console.error(`visualproof artwork: ${p}`);
+        process.exit(1);
+    }
+    const list = (xs) => (xs.length ? xs.join(", ") : "none");
+    console.log(`names written: ${list(a.names.written)}`);
+    if (a.names.ruledSkipped.length)
+        console.log(`names a rule chose, left out where they would cover another: ${list(a.names.ruledSkipped)}`);
+    if (a.names.left)
+        console.log(`names or targets left out for room: ${a.names.left}`);
+    console.log(`targets marked: ${list(a.targets)}`);
+    console.log(`selection: ${a.selection ? `${a.selection.mode} of ${a.selection.name}` : "none"}`);
+    if (a.notesLeftOut)
+        console.log(`notes: ${a.notesLeftOut} on the board, not drawn (the command draws no notes yet)`);
+    const both = !o.png && !o.svg;
+    const mb = (n) => `${(n / 1e6).toFixed(1)} MB`;
+    if (both || o.svg) {
+        const file = join(dir, a.file("svg"));
+        writeFileSync(file, a.svg);
+        console.log(`wrote ${file} (${mb(Buffer.byteLength(a.svg))})`);
+    }
+    if (both || o.png) {
+        const png = await pngOf(a.svg);
+        const file = join(dir, a.file("png"));
+        writeFileSync(file, png);
+        console.log(`wrote ${file} (${mb(png.length)}, ${a.look.w} × ${a.look.h})`);
+    }
+}
 // run as the command (`node src/server/main.ts`, the `visualproof` bin), not when a test imports App
 if (import.meta.main)
     void main();

package/dist/server/mcptools.js

@@ -149,7 +149,7 @@ export const TOOLS = [
         default: "move",
         actions: {
             move: { method: "POST", path: "/api/agent/view", says: "go to a view, a target's view, a declaration, its source; fields left out keep their value", args: ["view", "review", "sel", "selection", "mode", "source", "paper", "focus", "leave"] },
-            link: { method: "POST", path: "/api/agent/view/link", says: "a link that opens exactly what you look at, or a place you describe, to hand people in a reply", args: ["view", "review", "sel", "selection", "mode", "source", "paper", "focus", "sourceCollapsed", "pinned", "history", "region", "activity", "lostFound", "scheme", "edges", "proofEdges", "exact"] },
+            link: { method: "POST", path: "/api/agent/view/link", says: "a link that opens exactly what you look at, or a place you describe, to hand people in a reply", args: ["view", "review", "sel", "selection", "mode", "source", "paper", "focus", "sourceCollapsed", "pinned", "history", "region", "activity", "lostFound", "scheme", "edges", "exact"] },
             ask_follow: { method: "POST", path: "/api/agent/ask-follow", says: "ask the people on the page to follow you first", args: ["who", "wait"] },
         },
         args: {
@@ -157,7 +157,7 @@ export const TOOLS = [
             review: str("a target: be on its view"),
             sel: str("the declaration you look at"),
             selection: str("what you select, as a query: decl(A.b) or tcb(A.c)"),
-            mode: str("how you select: plain; Rests on's deps, tcb, keys; apps", ["plain", "deps", "tcb", "keys", "apps"]),
+            mode: str("how you select: plain; Rests on's deps, tcb, keys, refs (what it uses directly); apps", ["plain", "deps", "tcb", "keys", "refs", "apps"]),
             source: bool("the source window open on sel"),
             paper: PAPER,
             focus: str("your focus on the view: a target, \"none\", or \"view\" for the view's own"),
@@ -170,7 +170,6 @@ export const TOOLS = [
             lostFound: bool("link: the lost-and-found open"),
             scheme: str("link: the colouring", ["kind", "status"]),
             edges: bool("link: edges drawn"),
-            proofEdges: bool("link: proof edges drawn"),
             exact: bool("link: false for the view's address alone"),
             who: str("ask_follow: a person's name; left out, everyone"),
             wait: bool("ask_follow: false answers at once (default: wait for them, at most 30 s)"),
@@ -374,12 +373,13 @@ export const TOOLS = [
     },
     {
         name: "export",
-        about: "A view's document — every declaration of the project its board holds, in its sections and order: its model as JSON, or typeset as a PDF and saved on your machine.",
+        about: "A view's document — every declaration of the project its board holds, in its sections and order: its model as JSON, or typeset as a PDF and saved on your machine. Or a picture of the board: a link that opens it in the artwork mode as a recipe says.",
         actions: {
             model: { method: "GET", path: "/api/agent/export", says: "the document's model", args: ["view", "settings", "version"] },
             typeset: { method: "POST", path: "/api/agent/export", says: "start typesetting: a job", args: ["view", "settings", "version"] },
             job: { method: "GET", path: "/api/agent/export/job", says: "how the job is doing", args: ["id"] },
             file: { method: "GET", path: "/api/agent/export/file", saves: true, says: "a file of it saved on your machine", args: ["id", "what", "saveTo"] },
+            artwork: { method: "POST", path: "/api/agent/artwork", says: "a link to a picture of the board, as a recipe says", args: ["recipe", "save"] },
         },
         args: {
             view: str("the view's id: a target's Key view is open on key(<target>)"),
@@ -388,6 +388,8 @@ export const TOOLS = [
             id: str("the job's id"),
             what: str("pdf (default), tex, sty or zip", ["pdf", "tex", "sty", "zip"]),
             saveTo: SAVE_TO,
+            recipe: { type: "object", description: "the picture: size, orientation, style, theme, names (e.g. {clusters: 1}), targets, selection {name, mode}, title, subtitle, edges… (docs: export)" },
+            save: str("png, svg or png,svg: saved by the page once ready"),
         },
     },
 ];

package/dist/server/pastdoc.js

@@ -14,7 +14,7 @@ import { pastGraph } from "../shared/pastgraph.js";
 import { pageGraph } from "./history.js";
 import { MOST_DIFF, snapshotDiff } from "./historyapi.js";
 /** how many past builds are kept: a past graph and the texts read for a large view are large on a
- *  large project (the showcase's past graph: 13.7 MB of JSON) */
+ *  large project (Sphere-Packing-Lean's past graph: 13.7 MB of JSON) */
 const KEEP = 2;
 export class PastBuilds {
     w;

package/dist/server/pipeline.js

@@ -13,6 +13,9 @@ import { buildViewOffThread } from "./view.js";
 import { cacheHome } from "./dirs.js";
 /** the tool's own folder, `src/`; the repository is above it */
 export const SRC = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+/** the fonts the page draws an artwork's names and title in (ExportSpec decision 19): Source Sans 3
+ *  and Source Serif 4, their Latin and Greek, and Jost, its Latin, under the SIL Open Font License */
+export const WEBFONTS = join(SRC, "assets", "webfonts");
 export const REPO = resolve(SRC, "..");
 export const WEB = join(SRC, "web");
 /** The page's bundle made when the package was built (scripts/build.mjs), beside the page: an
@@ -38,8 +41,9 @@ export function bundleDir() {
  *  views from an older server are rebuilt rather than served. 7: a notation unit's statement is
  *  its command's text. 8: notation units carry their Lean constant, display form, what they
  *  interpret and their rules. 9: a node's hash is its version, beside the kernel's
- *  (server/versions.ts). */
-const VIEW_VERSION = 9;
+ *  (server/versions.ts). 10: the project's git source and commit (server/history.ts, gitSource). 11:
+ *  not them any more: they are asked when wanted (GET /api/git), not kept with the view. */
+const VIEW_VERSION = 11;
 function loadMemory(siteDir) {
     try {
         const mem = JSON.parse(readFileSync(join(siteDir, "layout-memory.json"), "utf8"));
@@ -60,7 +64,9 @@ export async function prepare(project, dirs, saved, log, opts = {}) {
     // `reuse`: lay out an extraction already held, without reading the build (which may be
     // half-written right now); `extraction`: one in hand (the usage pass's, merged); `provisional`:
     // the graph waits for its usage pass; `completes`: the fingerprint of the build's extraction that
-    // this graph, the usage pass's merged, completes
+    // this graph, the usage pass's merged, completes; `readOnlySite`: the site's layout memory read,
+    // never written, and the view laid out not kept in the cache either, which a server would take for
+    // its site's (the artwork command, ExportSpec decision 21)
     const held = opts.extraction ?? (opts.reuse ? cachedExtraction(dirs.cache, opts.reuse) : null);
     if (opts.reuse && !held)
         throw new Error("the graph on screen is no longer cached; it is laid out afresh at the next build");
@@ -69,7 +75,6 @@ export async function prepare(project, dirs, saved, log, opts = {}) {
         log(ex.cached ? `extraction ${ex.fingerprint} reused` : `extraction ${ex.fingerprint} done`);
     const usage = ex.graph.usage ?? null;
     const viewDir = join(dirs.cache, "view");
-    mkdirSync(viewDir, { recursive: true });
     const metaFile = join(viewDir, `${ex.fingerprint}-v${VIEW_VERSION}.meta.json.gz`);
     const edgeFile = join(viewDir, `${ex.fingerprint}-v${VIEW_VERSION}.edges.bin.gz`);
     const memory = opts.freshLayout ? null : loadMemory(dirs.site);
@@ -84,13 +89,17 @@ export async function prepare(project, dirs, saved, log, opts = {}) {
     const completing = memory !== null && opts.completes !== undefined && memory.fingerprint === opts.completes && memory.before !== undefined;
     const against = completing ? (memory.before ?? null) : (memory?.layouts ?? null);
     const view = await buildViewOffThread(project, ex, log, against);
-    saveMemory(dirs.site, ex.fingerprint, view.meta, opts.provisional ? against : undefined);
+    if (!opts.readOnlySite)
+        saveMemory(dirs.site, ex.fingerprint, view.meta, opts.provisional ? against : undefined);
     const metaGz = gzipSync(JSON.stringify(view.meta));
     const edgesGz = gzipSync(Buffer.from(view.edges.buffer, view.edges.byteOffset, view.edges.byteLength));
-    writeFileSync(metaFile, metaGz);
-    writeFileSync(edgeFile, edgesGz);
-    prune(viewDir, /\.meta\.json\.gz$/, 3);
-    prune(viewDir, /\.edges\.bin\.gz$/, 3);
+    if (!opts.readOnlySite) {
+        mkdirSync(viewDir, { recursive: true });
+        writeFileSync(metaFile, metaGz);
+        writeFileSync(edgeFile, edgesGz);
+        prune(viewDir, /\.meta\.json\.gz$/, 3);
+        prune(viewDir, /\.edges\.bin\.gz$/, 3);
+    }
     return { fingerprint: ex.fingerprint, cached: ex.cached, metaGz, edgesGz, usage };
 }
 function readdirRec(dir) {

package/dist/server/readonlygate.js

@@ -7,12 +7,12 @@ export function readOnlyAllows(method, path) {
     const read = method === "GET" || method === "HEAD";
     if (read) {
         // the page and its files
-        if (path === "/" || path === "/index.html" || path === "/style.css" || /^\/(app|layout|edges|pdfworker)\.js(\.map)?$/.test(path) || path.startsWith("/pdfjs/"))
+        if (path === "/" || path === "/index.html" || path === "/style.css" || /^\/(app|layout|edges|pdfworker)\.js(\.map)?$/.test(path) || path.startsWith("/pdfjs/") || path.startsWith("/fonts/"))
             return true;
         // the graph, its sources and Lean's answers, the review, what happened, the views, the history,
         // the library, the printed document's state and files, who the reader is and the link they
         // came by, and the event stream every change comes by
-        if (["/api/status", "/api/meta", "/api/edges", "/api/source", "/api/review", "/api/activity", "/api/identity", "/api/share"].includes(path))
+        if (["/api/status", "/api/meta", "/api/edges", "/api/git", "/api/source", "/api/review", "/api/activity", "/api/identity", "/api/share"].includes(path))
             return true;
         // a stream is opened by GET alone: a HEAD would take one of their places for nothing
         if (path === "/api/events")

package/dist/server/review.js

@@ -263,7 +263,10 @@ export class ReviewStore {
         this.refresh();
         const file = logFileName(name, false, person);
         const now = Object.hasOwn(this.data.people, person) ? this.data.people[person].name : null;
-        if (!this.files.has(file) || now === name.trim())
+        // one who has no log yet, but whom opinions were recorded for (ReviewSpec decision 8), is
+        // given one by the rename, so that those follow it
+        const spokenFor = Object.values(this.data.opinions).some((ops) => ops.some((o) => o.person === person && o.recordedBy));
+        if ((!this.files.has(file) && !spokenFor) || now === name.trim())
             return { change: null, unchanged: true };
         return this.write(file, () => nameEvent(person, name, this.nextTime()));
     }

package/dist/server/reviewapi.js

@@ -17,6 +17,7 @@
 // Every refusal is an answer: a status, and words that say what to do instead.
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
+import { MAX_NAME, sameName, validName } from "../shared/collab.js";
 import { exactContext, judgedText } from "../shared/context.js";
 import { MAX_TEXT, STANDARD_AXIOMS, validPrefix } from "../shared/review.js";
 import { reviewSet } from "../shared/reviewqueue.js";
@@ -102,6 +103,9 @@ export class ReviewApi {
                     return answer(refuse(400, "The comment is longer than 10,000 characters.", "Say it shorter."));
                 if (b.verdict === "comment" && !comment)
                     return answer(refuse(400, "A comment needs text.", "Write it in the box, then Comment."));
+                const voice = this.voice(b.for, who);
+                if ("status" in voice)
+                    return answer(voice);
                 const v = this.graph();
                 if ("status" in v)
                     return answer(v);
@@ -109,7 +113,7 @@ export class ReviewApi {
                 if ("status" in x)
                     return answer(x);
                 // an agent's opinion is advice, whatever its level (AgentSpec decision 2)
-                return this.record({ op: "opinion", name: x.name, by, verdict: b.verdict, ...(comment ? { comment } : {}), ...(x.hash ? { hash: x.hash } : {}), ...(x.text !== undefined ? { text: x.text } : x.statement !== undefined ? { statement: x.statement } : {}), ...agent }, who);
+                return this.record({ op: "opinion", name: x.name, by, verdict: b.verdict, ...(comment ? { comment } : {}), ...(x.hash ? { hash: x.hash } : {}), ...(x.text !== undefined ? { text: x.text } : x.statement !== undefined ? { statement: x.statement } : {}), ...voice, ...agent }, who);
             }
             case "target": {
                 if (typeof b.on !== "boolean")
@@ -173,6 +177,36 @@ export class ReviewApi {
                 return answer(refuse(400, "op is opinion, target, trust or key.", "Send {op, …}."));
         }
     }
+    /** Whose an opinion is to be (ReviewSpec decision 8): the asker's own where `asked` is absent or
+     *  names them; else another person's, recorded for them — by their link's id where `asked` is an
+     *  invited person's name, a guest's as the logs write it — and never an agent's, nor by an agent. */
+    voice(asked, who) {
+        if (asked === undefined)
+            return {};
+        if (who.agent)
+            return refuse(403, "An agent records no opinion for anyone else.", "Leave out for: your opinion is your own, and advice.");
+        if (typeof asked !== "string" || !validName(asked.trim()))
+            return refuse(400, `for is the name of the person the opinion is recorded for: 1–${MAX_NAME} characters, no line breaks.`, "Send {op: \"opinion\", name, verdict, for: \"<their name>\"}.");
+        const name = asked.trim();
+        const held = this.world.invited?.(name);
+        // one's own name, or one's own link: one's own opinion
+        if (held ? held.id === who.person : sameName(name, who.name.trim()))
+            return {};
+        // the writers the logs name, people's and agents', in any case
+        const d = this.world.review.data;
+        const writers = [
+            ...Object.values(d.opinions).flatMap((ops) => ops.map((o) => ({ by: o.by, agent: !!o.agent, person: !!o.person }))),
+            ...Object.values(d.targets).map((t) => ({ by: t.by, agent: !!t.agent, person: !!t.person })),
+            ...Object.values(d.keys).flatMap((marks) => Object.values(marks).map((m) => ({ by: m.by, agent: !!m.agent, person: !!m.person }))),
+        ];
+        if (writers.some((w) => w.agent && sameName(w.by, name)))
+            return refuse(400, `${name} is an agent: nobody records an opinion for an agent.`, "Record it for a person, or as your own.");
+        if (held)
+            return { for: held.name, forPerson: held.id };
+        // a guest already in the logs, as they write their name: "bob" is Bob
+        const guest = writers.find((w) => !w.agent && !w.person && sameName(w.by, name));
+        return { for: guest?.by ?? name };
+    }
     /** Append a writer's event to their log; the answer carries the change, which the page applies
      *  at once, and the event as written. */
     record(op, who) {

package/dist/server/snapshot.js

@@ -3,12 +3,20 @@
 import { readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { gunzipSync, gzipSync } from "node:zlib";
-import { WEB, bundleDir } from "./pipeline.js";
+import { WEB, WEBFONTS, bundleDir } from "./pipeline.js";
+import { gitSource } from "./history.js";
 import { lakeTextHash } from "./status.js";
 /** Text that sits inside a <script> element must not close it. */
 function scriptSafe(s) {
     return s.replace(/<\/script/gi, "<\\/script");
 }
+/** A snapshot's graph: the view's, with the project's git source and commit as the snapshot is
+ *  taken, since a snapshot has no server to ask (GET /api/git); as it was where the project is no
+ *  git repository. */
+export function withGit(root, meta, metaGz) {
+    const git = gitSource(root);
+    return git ? gzipSync(JSON.stringify({ ...meta, project: { ...meta.project, git } })) : metaGz;
+}
 export function writeSnapshot(project, prep, out, label, review, views) {
     const meta = JSON.parse(gunzipSync(prep.metaGz).toString("utf8"));
     // the sources a card can show: every project module's file, with the usage pass's contexts where
@@ -28,13 +36,15 @@ export function writeSnapshot(project, prep, out, label, review, views) {
         }
     }
     const b64 = (buf) => buf.toString("base64");
-    const css = readFileSync(join(WEB, "style.css"), "utf8");
+    const metaGz = withGit(project.root, meta, prep.metaGz);
+    // the artwork's fonts within the page, which has no server to ask for them
+    const css = readFileSync(join(WEB, "style.css"), "utf8").replace(/url\("\/fonts\/([a-z0-9-]+\.woff2)"\)/g, (_, f) => `url("data:font/woff2;base64,${b64(readFileSync(join(WEBFONTS, f)))}")`);
     const js = readFileSync(join(bundleDir(), "app.js"), "utf8").replace(/\n\/\/# sourceMappingURL=.*$/m, "");
     const info = { createdAt: new Date().toISOString(), label };
     const html = readFileSync(join(WEB, "index.html"), "utf8")
         .replace(`<link rel="stylesheet" href="/style.css">`, () => `<style>\n${css}\n</style>`)
         .replace(`<script type="module" src="/app.js"></script>`, () => `<script id="vp-static" type="application/json">${scriptSafe(JSON.stringify(info))}</script>\n` +
-        `<script id="vp-meta" type="application/octet-stream">${b64(prep.metaGz)}</script>\n` +
+        `<script id="vp-meta" type="application/octet-stream">${b64(metaGz)}</script>\n` +
         `<script id="vp-edges" type="application/octet-stream">${b64(prep.edgesGz)}</script>\n` +
         `<script id="vp-sources" type="application/octet-stream">${b64(gzipSync(JSON.stringify(sources)))}</script>\n` +
         // the review as it stood: shown, not changed (ReviewSpec decision 7)

package/dist/server/usage.js

@@ -11,7 +11,7 @@
 //
 // One process per module: a process cannot import twice. `jobs` run at once; import is bound by
 // memory bandwidth, and each worker holds hundreds of MB of its own besides the `.olean` files they
-// all map (on the showcase about 150 MB of its own, 1.2 to 1.6 GB resident with them). A module's result is cached in the
+// all map (on Sphere-Packing-Lean about 150 MB of its own, 1.2 to 1.6 GB resident with them). A module's result is cached in the
 // project's cache directory under a key
 // made of its `.olean` hash, the text it was compiled from, the options Lake compiled it with, and
 // the keys of the project modules it imports: after a build only the modules whose key changed run
@@ -25,7 +25,7 @@ import { SITE_BODY, SITE_GRAMMAR, SITE_PROOF, SITE_TCB } from "../shared/graph.j
 import { USAGE, USAGE_PROGRAM, leanProgram, prune } from "./extract.js";
 import { compiledTextHash, lakeTextHash } from "./status.js";
 /** How many workers run at once unless `--jobs` says otherwise: past about a quarter of the cores,
- *  more workers gain less and less (the showcase's cold pass on 32 cores: 320 s with 4, 195 s with
+ *  more workers gain less and less (Sphere-Packing-Lean's cold pass on 32 cores: 320 s with 4, 195 s with
  *  8, 148 s with 16). */
 export const DEFAULT_JOBS = 8;
 /** A worker still running after this long is stopped, and its module reported as failed. */

package/dist/server/views.js

@@ -59,7 +59,7 @@ const HOLD_MS = 60_000;
 /** the most views one private page holds */
 const MAX_HOLDS = 100;
 /** The most a board's layout memory may be when a page hands it over: room for a board of a large
- *  project's declarations many times over (the showcase's whole board, 7,851 declarations, is
+ *  project's declarations many times over (Sphere-Packing-Lean's whole board, 7,851 declarations, is
  *  1.8 MB; 50 MB is the owner's decision of 2026-10-14). */
 export const MAX_MEMORY_BYTES = 50 << 20;
 const isPins = (p) => {
@@ -161,6 +161,30 @@ function cleanMemory(x) {
             return null;
     return { set: m.set, mem: { nodes, clusters } };
 }
+/** The Project view as a site keeps it — its pins, folds, hidden levels and clustering — read and
+ *  nothing written (the artwork command, ExportSpec decision 21; the Views class sets aside a file
+ *  it cannot read): null where the site keeps none, or `why` where its views cannot be read. Pins
+ *  dropped under another way of laying out mean nothing in this one, as Views reads them. */
+export function readProjectView(siteDir, layoutVersion) {
+    const file = join(siteDir, "views.json");
+    if (!existsSync(file))
+        return { view: null };
+    try {
+        const raw = JSON.parse(readFileSync(file, "utf8"));
+        for (const r of Array.isArray(raw.views) ? raw.views : []) {
+            const v = readView(r);
+            if (typeof v === "string" || v.id !== PROJECT)
+                continue;
+            if (raw.layoutVersion !== layoutVersion)
+                v.pins = emptyLayouts();
+            return { view: v };
+        }
+        return { view: null };
+    }
+    catch (e) {
+        return { view: null, why: e instanceof Error ? e.message : String(e) };
+    }
+}
 export class Views {
     book;
     file;