visualproof 0.2.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, 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,7 +18,7 @@ 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 { 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";
@@ -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 */
@@ -976,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)
@@ -1294,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);
@@ -1307,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 });
@@ -1401,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

@@ -373,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>)"),
@@ -387,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/pipeline.js

@@ -41,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). 10: the project's git source and commit (server/history.ts, gitSource). */
-const VIEW_VERSION = 10;
+ *  (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"));
@@ -63,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");
@@ -72,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);
@@ -87,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

@@ -12,7 +12,7 @@ export function readOnlyAllows(method, path) {
         // 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

@@ -4,11 +4,19 @@ import { readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { gunzipSync, gzipSync } from "node:zlib";
 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,6 +36,7 @@ export function writeSnapshot(project, prep, out, label, review, views) {
         }
     }
     const b64 = (buf) => buf.toString("base64");
+    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, "");
@@ -35,7 +44,7 @@ export function writeSnapshot(project, prep, out, label, review, views) {
     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/view.js

@@ -3,7 +3,6 @@
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { LAYOUT_VERSION } from "../shared/graph.js";
-import { gitSource } from "./history.js";
 import { layOutHere, layOutOffThread } from "./layoutthread.js";
 import { compiledTextHash } from "./status.js";
 import { versionBase, versions } from "./versions.js";
@@ -75,11 +74,6 @@ function viewParts(p, ex) {
     });
     return { nodes, edges };
 }
-/** The project's git source and commit as it is read, where it is a git repository. */
-function gitOf(root) {
-    const git = gitSource(root);
-    return git ? { git } : {};
-}
 function assemble(p, ex, nodes, edges, layouts) {
     const g = ex.graph;
     const meta = {
@@ -93,7 +87,6 @@ function assemble(p, ex, nodes, edges, layouts) {
             toolchain: p.toolchain,
             extractedAt: ex.at,
             extractMs: g.stats.ms,
-            ...gitOf(p.root),
         },
         modules: g.modules.map((m) => {
             const file = p.files.get(m.name) ?? null;

package/dist/server/views.js

@@ -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;

package/dist/shared/artfonts.js

@@ -0,0 +1,81 @@
+// Text measured as an artwork's fonts draw it, without a browser (ExportSpec decision 21): the
+// advance widths of the faces the package ships (assets/webfonts/metrics.json, made by
+// scripts/artfonts.py), for a CSS font as a canvas takes it. A face stands for its family at the
+// nearest weight it is made at; a character it has not is measured in the faces that stand in for
+// it (Noto Sans, Noto Sans Math), as the renderer draws it from them. No kerning: the renderer the
+// command draws with is given none either.
+/** the families an artwork's fonts name that the package has not, and the face drawn for them: the
+ *  system's own for the board's names (web/src/canvas.ts FONT), and the generic ones */
+const STANDS_FOR = {
+    "-apple-system": "Source Sans 3",
+    "blinkmacsystemfont": "Source Sans 3",
+    "sf pro text": "Source Sans 3",
+    "inter": "Source Sans 3",
+    "segoe ui": "Source Sans 3",
+    "sans-serif": "Source Sans 3",
+    "system-ui": "Source Sans 3",
+    "georgia": "Source Serif 4",
+    "times new roman": "Source Serif 4",
+    "serif": "Source Serif 4",
+};
+/** A CSS font as a 2D context takes it ("italic 600 12px \"Jost\", sans-serif"): its slant, weight,
+ *  size in pixels, and families in order. */
+export function parseFont(font) {
+    const m = /^\s*((?:(?:italic|oblique|normal|bold|bolder|lighter|\d{3})\s+)*)([\d.]+)px(?:\/[^\s]+)?\s+(.+)$/i.exec(font);
+    if (!m)
+        return { style: "normal", weight: 400, px: 10, families: ["sans-serif"] };
+    const words = m[1].trim().toLowerCase().split(/\s+/).filter(Boolean);
+    const style = words.includes("italic") || words.includes("oblique") ? "italic" : "normal";
+    const num = words.find((w) => /^\d{3}$/.test(w));
+    const weight = num ? Number(num) : words.includes("bold") ? 700 : 400;
+    const families = m[3].split(",").map((f) => f.trim().replace(/^["']|["']$/g, "")).filter(Boolean);
+    return { style, weight, px: Number(m[2]), families };
+}
+/** How wide `text` is in `font`, in pixels, as the package's faces draw it. */
+export function textMeasurer(metrics) {
+    const families = new Map();
+    for (const f of metrics.faces)
+        families.set(f.family.toLowerCase(), [...(families.get(f.family.toLowerCase()) ?? []), f]);
+    const chosen = new Map();
+    /** the face a font is drawn in: its first family the package has (or stands one in for), at the
+     *  slant asked where it is made in it, at the nearest weight */
+    const faceOf = (font) => {
+        const hit = chosen.get(font);
+        if (hit)
+            return hit;
+        const f = parseFont(font);
+        let set;
+        for (const fam of f.families) {
+            const k = fam.toLowerCase();
+            set = families.get(k) ?? families.get(STANDS_FOR[k]?.toLowerCase() ?? "");
+            if (set)
+                break;
+        }
+        set ??= families.get("source sans 3") ?? metrics.faces;
+        const slanted = set.filter((x) => x.style === f.style);
+        const pool = slanted.length ? slanted : set;
+        const face = pool.reduce((a, b) => (Math.abs(b.weight - f.weight) < Math.abs(a.weight - f.weight) ? b : a));
+        const out = { face, px: f.px };
+        chosen.set(font, out);
+        return out;
+    };
+    return (text, font) => {
+        const { face, px } = faceOf(font);
+        let w = 0;
+        for (const ch of text) {
+            const cp = String(ch.codePointAt(0));
+            let units = face.widths[cp];
+            let upm = face.unitsPerEm;
+            if (units === undefined)
+                for (const fb of metrics.fallback)
+                    if (fb.widths[cp] !== undefined) {
+                        units = fb.widths[cp];
+                        upm = fb.unitsPerEm;
+                        break;
+                    }
+            // a character no face has: about an en, as a renderer's missing glyph is drawn
+            w += ((units ?? face.unitsPerEm * 0.55) / upm) * px;
+        }
+        return w;
+    };
+}