@itsthecsguy/linework 0.1.3 → 0.1.4

package/README.md

@@ -159,6 +159,8 @@ Linework sizes every box from the real width of its text in the font it renders
 
 Linework needs Node 20+ and a Chromium-based browser, which it uses headless to measure text and render. It tries Playwright's Chromium, then Chrome, then Edge. If none is found, run `linework install-browser`, or set `LINEWORK_CHROME` to a browser binary. If a browser is found but crashes on launch, an agent's sandbox is usually blocking it. Linework then retries Playwright's Chromium in single-process mode, which starts inside Codex's sandbox.
 
+Linework keeps the font subsets it embeds in your cache folder (`~/Library/Caches/linework` on macOS, `~/.cache/linework` on Linux, `%LOCALAPPDATA%\linework` on Windows), so rebuilding a diagram doesn't compress the same fonts again. Set `LINEWORK_NO_CACHE=1` to turn that off.
+
 ## Connect over MCP
 
 The MCP server is for chat apps and agents that can't run shell commands. Agents with a shell do better with the skill, since they can run the CLI and see its output directly.

package/dist/api.js

@@ -97,19 +97,22 @@ export async function build(specText, opts) {
         }
         else
             xml = await straightenDetours(b, toMxfile(diagram, l), detourEdges(diagram, l));
-        xml = (await fixLabels(b, xml)).xml;
+        const fixed = await fixLabels(b, xml);
+        xml = fixed.xml;
         xml = stampEdgeRoutes(xml);
-        return finish(b, xml, { mode, warnings, direction: mode === 'merge' ? (old.meta.aiviz_direction ?? l.direction) : l.direction, edits, old, stats });
+        // Stamping routes changes attributes, not geometry: the cells fixLabels read still hold.
+        return finish(b, xml, { mode, warnings, direction: mode === 'merge' ? (old.meta.aiviz_direction ?? l.direction) : l.direction, edits, old, stats, cells: fixed.cells });
     });
     async function finish(b, xml, r) {
         fs.mkdirSync(path.dirname(path.resolve(opts.out)), { recursive: true });
-        fs.writeFileSync(opts.out, kind === 'svg' ? await b.renderSvg(xml) : xml);
-        if (opts.png)
-            await b.renderPng(xml, opts.png);
+        // Issued together: the browser renders the preview and lays out the lint pass
+        // while node subsets the fonts for the SVG.
+        const [file, , cells] = await Promise.all([kind === 'svg' ? b.renderSvg(xml) : xml, opts.png ? b.renderPng(xml, opts.png) : undefined, r.cells ?? b.inspect(xml)]);
+        fs.writeFileSync(opts.out, file);
         return {
             out: opts.out,
             warnings: r.warnings,
-            check: check(await b.inspect(xml)),
+            check: check(cells),
             direction: r.direction,
             mode: r.mode,
             merge: r.stats,

package/dist/cli.js

@@ -1,11 +1,8 @@
 #!/usr/bin/env node
 import fs from 'node:fs';
+import module from 'node:module';
 import path from 'node:path';
 import { parseArgs } from 'node:util';
-import { build, checkFile, listIcons, render, show, tidy } from './api.js';
-import { SpecError, jsonSchema } from './spec/parse.js';
-import { KINDS, DIAGRAM_TYPES } from './spec/model.js';
-import { buildLines, checkLines } from './report.js';
 const USAGE = `linework: AI-written, hand-editable diagrams (YAML spec -> .drawio.svg)
 
 Usage:
@@ -53,43 +50,89 @@ Usage:
       Download the headless Chromium build that matches this version. Needed only
       when no Chrome or Edge is installed, or to run inside an agent's sandbox.
 `;
+// Node 22.1+ can keep compiled bytecode for linework's modules on disk, which
+// takes about a quarter off loading them on every run after the first. Older
+// Node has no such call. NODE_DISABLE_COMPILE_CACHE=1 turns it off.
+module.enableCompileCache?.();
 async function main(argv) {
     const [cmd, ...rest] = argv;
-    const { values, positionals } = parseArgs({
-        args: rest,
-        allowPositionals: true,
-        options: {
-            out: { type: 'string', short: 'o' },
-            png: { type: 'string' },
-            force: { type: 'boolean', default: false },
-            relayout: { type: 'boolean', default: false },
-            geometry: { type: 'boolean', default: false },
-            quiet: { type: 'boolean', short: 'q', default: false },
-            block: { type: 'string' },
-            scale: { type: 'string' },
-            'no-open': { type: 'boolean', default: false },
-            port: { type: 'string' },
-            root: { type: 'string' },
-            to: { type: 'string' },
-            pull: { type: 'boolean', default: false },
-            help: { type: 'boolean', short: 'h' },
-        },
-    });
+    const { values, positionals } = parseArgs({ args: rest, allowPositionals: true, options: OPTIONS });
     if (!cmd || cmd === 'help' || cmd === '--help' || cmd === '-h' || values.help)
         return void process.stdout.write(USAGE);
+    // Commands that draw start Chromium first and load the rest of linework while it
+    // boots and loads draw.io: the two take about the same time, so they overlap.
+    const needsBrowser = ['build', 'render', 'check', 'tidy', 'icons'].includes(cmd) || (cmd === 'import' && !!values.out);
+    const launching = needsBrowser ? import('./render/browser.js').then((m) => m.DrawioBrowser.launch({ scale: cmd === 'render' && values.scale ? Number(values.scale) : 2 })) : undefined;
+    // A failure here surfaces where the browser is awaited; don't report it twice.
+    launching?.catch(() => { });
+    try {
+        await run(cmd, values, positionals, launching);
+    }
+    finally {
+        if (launching)
+            await (await launching.catch(() => undefined))?.close();
+    }
+    // The font subsetter's WebAssembly keeps node alive for ~100ms after the work
+    // is done, with nothing left to run. A drawing command is finished here.
+    if (launching)
+        await exitWhenFlushed();
+}
+/** A small spec with a group, labels and a cycle: enough to exercise ELK's main paths. */
+const WARM_SPEC = 'type: architecture\ngroups: { g: G }\nnodes:\n  a: { in: g }\n  b: { in: g }\n  c: {}\nedges:\n  - a -> b: x\n  - b -> c: y\n  - c -> a\n';
+async function warmUp() {
+    const [{ parseSpecText }, { layout }] = await Promise.all([import('./spec/parse.js'), import('./layout/layout.js')]);
+    await layout(parseSpecText(WARM_SPEC).diagram);
+}
+function exitWhenFlushed() {
+    return new Promise(() => {
+        let pending = 2;
+        const done = () => --pending === 0 && process.exit();
+        process.stdout.write('', done);
+        process.stderr.write('', done);
+    });
+}
+const OPTIONS = {
+    out: { type: 'string', short: 'o' },
+    png: { type: 'string' },
+    force: { type: 'boolean', default: false },
+    relayout: { type: 'boolean', default: false },
+    geometry: { type: 'boolean', default: false },
+    quiet: { type: 'boolean', short: 'q', default: false },
+    block: { type: 'string' },
+    scale: { type: 'string' },
+    'no-open': { type: 'boolean', default: false },
+    port: { type: 'string' },
+    root: { type: 'string' },
+    to: { type: 'string' },
+    pull: { type: 'boolean', default: false },
+    help: { type: 'boolean', short: 'h' },
+};
+async function run(cmd, values, positionals, launching) {
+    const browser = async () => {
+        // ELK compiles its code on first use. Laying out a tiny graph while Chromium
+        // is still starting takes that cost off the real layout.
+        if (launching && ['build', 'import'].includes(cmd))
+            await warmUp();
+        return launching;
+    };
+    const { buildLines } = await import('./report.js');
     switch (cmd) {
         case 'build': {
             const src = positionals[0];
             if (!src || !values.out)
                 fail('usage: linework build <spec.yaml|-> -o <out.drawio.svg>');
             const text = src === '-' ? fs.readFileSync(0, 'utf8') : fs.readFileSync(src, 'utf8');
-            const res = await build(text, { out: values.out, png: values.png, force: values.force, relayout: values.relayout });
+            const { build } = await import('./api.js');
+            // Spec errors first: they shouldn't wait on, or hide behind, a browser problem.
+            (await import('./spec/parse.js')).parseSpecText(text);
+            const res = await build(text, { out: values.out, png: values.png, force: values.force, relayout: values.relayout, browser: await browser() });
             for (const line of buildLines(res, values.png))
                 console.log(line);
             return;
         }
         case 'show': {
             const file = positionals[0] ?? fail('usage: linework show <file.drawio.svg>');
+            const { show } = await import('./api.js');
             const res = show(file, { geometry: values.geometry });
             process.stdout.write(res.yaml);
             if (values.quiet)
@@ -107,30 +150,26 @@ async function main(argv) {
             const file = positionals[0];
             if (!file || !values.out)
                 fail('usage: linework render <file.drawio.svg> -o <out.png>');
-            const { DrawioBrowser } = await import('./render/browser.js');
-            const b = await DrawioBrowser.launch({ scale: values.scale ? Number(values.scale) : 2 });
-            try {
-                await render(file, values.out, b);
-            }
-            finally {
-                await b.close();
-            }
+            const { render } = await import('./api.js');
+            await render(file, values.out, await browser());
             console.log(`wrote ${values.out}`);
             return;
         }
         case 'check': {
             const file = positionals[0] ?? fail('usage: linework check <file.drawio.svg>');
-            const res = await checkFile(file);
-            printCheck(res);
+            const { checkFile } = await import('./api.js');
+            const res = await checkFile(file, await browser());
+            await printCheck(res);
             if (res.findings.some((f) => f.level === 'error'))
                 process.exitCode = 1;
             return;
         }
         case 'tidy': {
             const file = positionals[0] ?? fail('usage: linework tidy <file.drawio.svg>');
-            const res = await tidy(file);
+            const { tidy } = await import('./api.js');
+            const res = await tidy(file, await browser());
             console.log(res.fixed ? `rerouted ${res.fixed} edges in ${file}` : 'nothing to fix');
-            printCheck(res.check);
+            await printCheck(res.check);
             return;
         }
         case 'edit': {
@@ -169,16 +208,18 @@ async function main(argv) {
             const yaml = toYaml(res.diagram, 'imported from Mermaid');
             if (!values.out)
                 return void process.stdout.write(yaml);
-            const built = await build(yaml, { out: values.out, png: values.png, relayout: values.relayout, force: values.force });
+            const { build } = await import('./api.js');
+            const built = await build(yaml, { out: values.out, png: values.png, relayout: values.relayout, force: values.force, browser: await browser() });
             console.log(`wrote ${built.out} (${built.check.stats.nodes} nodes, ${built.check.stats.edges} edges, ${built.direction})`);
-            printCheck(built.check);
+            await printCheck(built.check);
             return;
         }
         case 'icons': {
             const provider = positionals[0];
             if (!provider || !['aws', 'gcp', 'k8s', 'azure'].includes(provider))
                 fail('usage: linework icons <aws|gcp|k8s|azure> [filter]');
-            const names = await listIcons(provider, positionals[1]);
+            const { listIcons } = await import('./api.js');
+            const names = await listIcons(provider, positionals[1], await browser());
             console.log(names.map((n) => `${provider}.${n}`).join('\n') || 'no matches');
             return;
         }
@@ -229,6 +270,7 @@ async function main(argv) {
             return;
         }
         case 'kinds': {
+            const { KINDS, DIAGRAM_TYPES } = await import('./spec/model.js');
             const types = (positionals.length ? positionals : DIAGRAM_TYPES);
             for (const t of types) {
                 if (!KINDS[t])
@@ -239,9 +281,11 @@ async function main(argv) {
             }
             return;
         }
-        case 'schema':
+        case 'schema': {
+            const { jsonSchema } = await import('./spec/parse.js');
             console.log(JSON.stringify(jsonSchema(), null, 2));
             return;
+        }
         case 'install-browser': {
             const { browserInstallCommand } = await import('./render/browser.js');
             const { spawnSync } = await import('node:child_process');
@@ -255,7 +299,8 @@ async function main(argv) {
             fail(`unknown command "${cmd}"\n\n${USAGE}`);
     }
 }
-function printCheck(res) {
+async function printCheck(res) {
+    const { checkLines } = await import('./report.js');
     for (const line of checkLines(res))
         console.log(line);
 }
@@ -264,7 +309,7 @@ function fail(msg) {
     process.exit(2);
 }
 main(process.argv.slice(2)).catch((e) => {
-    if (e instanceof SpecError) {
+    if (e?.name === 'SpecError') {
         console.error('spec error:');
         for (const i of e.issues)
             console.error(`  ${i.path ? i.path + ': ' : ''}${i.message}`);

package/dist/lint/fixlabels.js

@@ -42,14 +42,19 @@ export function runSpots(pts, label) {
 function labelEdges(findings) {
     return [...new Set(findings.filter((f) => LABEL_RULES.has(f.rule) && f.labelEdges).flatMap((f) => f.labelEdges))];
 }
+/**
+ * Returns the fixed XML and its cells. Only label backgrounds change after the
+ * cells are read, and those don't move anything, so the cells stay valid for it.
+ */
 export async function fixLabels(b, xml, maxRounds = 6) {
     let cur = xml;
-    let score = check(await b.inspect(cur)).findings.filter((f) => LABEL_RULES.has(f.rule)).length;
+    const labelScore = (cells) => check(cells).findings.filter((f) => LABEL_RULES.has(f.rule)).length;
+    let score = labelScore(await b.inspect(cur));
     let moved = 0;
     for (let round = 0; round < maxRounds && score > 0; round++) {
+        // The cells of `cur`, kept current as labels move: a move changes only that label's box.
         const cells = await b.inspect(cur);
-        const res = check(cells);
-        const targets = labelEdges(res.findings);
+        const targets = labelEdges(check(cells).findings);
         let improved = false;
         for (const id of targets) {
             const doc = new DOMParser().parseFromString(cur, 'text/xml');
@@ -59,19 +64,21 @@ export async function fixLabels(b, xml, maxRounds = 6) {
             const base = Number(g.getAttribute('x') ?? 0);
             const cell = cells.find((c) => c.id === id);
             const spots = cell?.points && cell.textBox ? runSpots(cell.points, cell.textBox) : [];
-            const tries = [...spots, ...OFFSETS.map((off) => Math.max(-0.9, Math.min(0.9, base + off)))];
+            const tries = [...spots, ...OFFSETS.map((off) => Math.max(-0.9, Math.min(0.9, base + off)))].map((x) => Number(x.toFixed(3)));
+            const boxes = await b.labelBoxes(cur, id, tries);
             let best;
-            for (const x of tries) {
-                g.setAttribute('x', x.toFixed(3));
-                const candidate = new XMLSerializer().serializeToString(doc);
-                const s = check(await b.inspect(candidate)).findings.filter((f) => LABEL_RULES.has(f.rule)).length;
+            for (let i = 0; i < tries.length; i++) {
+                const s = labelScore(cells.map((c) => (c.id === id ? { ...c, textBox: boxes[i] } : c)));
                 if (s < (best?.score ?? score))
-                    best = { xml: candidate, score: s };
+                    best = { x: tries[i], score: s, box: boxes[i] };
                 if (s === 0)
                     break;
             }
             if (best) {
-                cur = best.xml;
+                g.setAttribute('x', best.x.toFixed(3));
+                cur = new XMLSerializer().serializeToString(doc);
+                if (cell)
+                    cell.textBox = best.box;
                 score = best.score;
                 moved++;
                 improved = true;
@@ -82,16 +89,17 @@ export async function fixLabels(b, xml, maxRounds = 6) {
         if (!improved)
             break;
     }
-    cur = await matchLabelBackgrounds(b, cur);
-    return { xml: cur, moved };
+    const cells = await b.inspect(cur);
+    cur = await matchLabelBackgrounds(b, cur, cells);
+    return { xml: cur, moved, cells };
 }
 /**
  * A label's backing has to match what it sits on: the fill of the smallest group
  * under it, or the canvas. Run after labels move, since a move can carry a label
  * from the canvas onto a group or back.
  */
-export async function matchLabelBackgrounds(b, xml) {
-    const cells = await b.inspect(xml);
+export async function matchLabelBackgrounds(b, xml, known) {
+    const cells = known ?? (await b.inspect(xml));
     const doc = new DOMParser().parseFromString(xml, 'text/xml');
     const canvas = doc.getElementsByTagName('mxGraphModel')[0]?.getAttribute('background') ?? '#FFFFFF';
     const styleOf = new Map();

package/dist/render/browser.js

@@ -5,10 +5,10 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { createRequire } from 'node:module';
+import http from 'node:http';
 import { chromium } from 'playwright-core';
 import { FONT_STACK } from '../drawio/theme.js';
 import { FACES, embedFonts, fontFaceCss, fontsDir } from './fonts.js';
-const ORIGIN = 'http://aiviz.local';
 export function assetsDir() {
     // dist/render/browser.js or src/render/browser.ts -> <pkg>/assets/drawio
     let dir = path.dirname(fileURLToPath(import.meta.url));
@@ -90,6 +90,23 @@ window.aiviz = {
   hasStencil: function (name) {
     return mxStencilRegistry.getStencil(name) != null;
   },
+  // Where an edge's label lands at each of several positions along the edge
+  // (draw.io's -1..1 x). Moving a label changes nothing else in the diagram, so
+  // one decode serves every candidate instead of one full inspect per try.
+  labelBoxes: function (xml, id, xs) {
+    return withGraph(xml, function (graph) {
+      var model = graph.getModel(), cell = model.getCell(id);
+      if (!cell) return xs.map(function () { return null; });
+      return xs.map(function (x) {
+        var g = cell.geometry.clone();
+        g.x = x;
+        model.setGeometry(cell, g);
+        var st = graph.view.getState(cell);
+        var tb = st && st.text && st.text.boundingBox;
+        return tb ? { x: tb.x, y: tb.y, w: tb.width, h: tb.height } : null;
+      });
+    });
+  },
   inspect: function (xml) {
     return withGraph(xml, function (graph) {
       var model = graph.getModel(), out = [];
@@ -127,38 +144,34 @@ const TYPES = { '.js': 'text/javascript', '.css': 'text/css', '.html': 'text/htm
 export class DrawioBrowser {
     browser;
     page;
-    constructor(browser, page) {
+    server;
+    constructor(browser, page, server) {
         this.browser = browser;
         this.page = page;
+        this.server = server;
     }
     static async launch(opts = {}) {
-        const browser = await launchChromium();
-        const page = await browser.newPage({ deviceScaleFactor: opts.scale ?? 2 });
-        const dir = assetsDir();
-        const fonts = fontsDir();
-        const html = host();
-        await page.route(`${ORIGIN}/**`, async (route) => {
-            const url = new URL(route.request().url());
-            if (url.pathname === '/' || url.pathname === '/host.html')
-                return route.fulfill({ status: 200, contentType: 'text/html', body: html });
-            if (url.pathname.startsWith('/aiviz-fonts/')) {
-                const f = FACES.find((x) => `/aiviz-fonts/${x.file}` === url.pathname);
-                return f ? route.fulfill({ status: 200, contentType: 'font/woff2', body: fs.readFileSync(path.join(fonts, f.file)) }) : route.fulfill({ status: 404, body: '' });
-            }
-            const file = path.join(dir, path.normalize(url.pathname));
-            if (!file.startsWith(dir) || !fs.existsSync(file))
-                return route.fulfill({ status: 404, body: '' });
-            return route.fulfill({ status: 200, contentType: TYPES[path.extname(file)] ?? 'application/octet-stream', body: fs.readFileSync(file) });
-        });
-        // Nothing else may load: keeps rendering offline and deterministic.
-        await page.route(/^(?!http:\/\/aiviz\.local\/).*/, (route) => route.abort());
-        await page.goto(`${ORIGIN}/host.html`);
-        await page.waitForFunction(() => window.ready === true, null, { timeout: 30000 });
-        // Measuring before a font loads would size every box for the fallback font.
-        const ok = await page.evaluate((faces) => Promise.all(faces.map((f) => document.fonts.load(`${f.weight} 16px "${f.family}"`).then((r) => r.length > 0))), FACES.map(({ family, weight }) => ({ family, weight })));
-        if (ok.includes(false))
-            throw new Error('linework: bundled fonts failed to load (assets/fonts). Reinstall linework.');
-        return new DrawioBrowser(browser, page);
+        // Chromium starts while the asset server binds.
+        const [browser, server] = await Promise.all([launchChromium(), serveAssets()]);
+        const origin = `http://127.0.0.1:${server.address().port}`;
+        try {
+            const page = await browser.newPage({ deviceScaleFactor: opts.scale ?? 2 });
+            // Nothing else may load: keeps rendering offline and deterministic.
+            const own = new RegExp(`^${origin.replace(/[.]/g, '\\.')}/`);
+            await page.route((url) => !own.test(url.href), (route) => route.abort());
+            await page.goto(`${origin}/host.html`);
+            await page.waitForFunction(() => window.ready === true, null, { timeout: 30000 });
+            // Measuring before a font loads would size every box for the fallback font.
+            const ok = await page.evaluate((faces) => Promise.all(faces.map((f) => document.fonts.load(`${f.weight} 16px "${f.family}"`).then((r) => r.length > 0))), FACES.map(({ family, weight }) => ({ family, weight })));
+            if (ok.includes(false))
+                throw new Error('linework: bundled fonts failed to load (assets/fonts). Reinstall linework.');
+            return new DrawioBrowser(browser, page, server);
+        }
+        catch (e) {
+            await browser.close().catch(() => { });
+            server.close();
+            throw e;
+        }
     }
     measure(reqs) {
         return this.page.evaluate((r) => window.aiviz.measure(r), reqs);
@@ -182,12 +195,63 @@ export class DrawioBrowser {
     hasStencil(name) {
         return this.page.evaluate((n) => window.aiviz.hasStencil(n), name);
     }
+    // inspect is a pure function of the XML, and a build asks about the same XML
+    // more than once (lint, label fixing, the final check).
+    seen = new Map();
     inspect(xml) {
-        return this.page.evaluate((x) => window.aiviz.inspect(x), xml);
+        let hit = this.seen.get(xml);
+        if (!hit) {
+            hit = this.page.evaluate((x) => window.aiviz.inspect(x), xml);
+            hit.catch(() => this.seen.delete(xml));
+            if (this.seen.size >= 8)
+                this.seen.delete(this.seen.keys().next().value);
+            this.seen.set(xml, hit);
+        }
+        // Callers may change the cells; each gets its own copy.
+        return hit.then((cells) => structuredClone(cells));
     }
-    close() {
-        return this.browser.close();
+    /** Label boxes for edge `id` with its label at each draw.io position in `xs`. */
+    labelBoxes(xml, id, xs) {
+        return this.page.evaluate(([x, i, p]) => window.aiviz.labelBoxes(x, i, p), [xml, id, xs]);
     }
+    async close() {
+        await this.browser.close();
+        this.server.closeAllConnections();
+        this.server.close();
+    }
+}
+/**
+ * The draw.io runtime is 16MB of script. Served from a local port, Chromium reads
+ * it straight off the socket; through Playwright's request interception every
+ * byte would cross the DevTools protocol first.
+ */
+function serveAssets() {
+    const dir = assetsDir();
+    const fonts = fontsDir();
+    const html = host();
+    const send = (res, status, type, body) => {
+        res.writeHead(status, { 'content-type': type, 'cache-control': 'no-store' });
+        res.end(body);
+    };
+    const server = http.createServer((req, res) => {
+        const pathname = new URL(req.url ?? '/', 'http://x').pathname;
+        if (pathname === '/' || pathname === '/host.html')
+            return send(res, 200, 'text/html', html);
+        if (pathname.startsWith('/aiviz-fonts/')) {
+            const f = FACES.find((x) => `/aiviz-fonts/${x.file}` === pathname);
+            return f ? send(res, 200, 'font/woff2', fs.readFileSync(path.join(fonts, f.file))) : send(res, 404, 'text/plain', '');
+        }
+        const file = path.join(dir, path.normalize(decodeURIComponent(pathname)));
+        if (!file.startsWith(dir + path.sep) || !fs.existsSync(file) || !fs.statSync(file).isFile())
+            return send(res, 404, 'text/plain', '');
+        send(res, 200, TYPES[path.extname(file)] ?? 'application/octet-stream', fs.readFileSync(file));
+    });
+    // A server that's only waiting on a browser that already exited shouldn't keep node alive.
+    server.unref();
+    return new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(0, '127.0.0.1', () => resolve(server));
+    });
 }
 /** Playwright-core's own installer, so the Chromium build always matches the version we run. */
 export function browserInstallCommand() {

package/dist/render/fonts.js

@@ -2,7 +2,9 @@
 // SVG gets a subset of the faces it uses (only the glyphs in its text), so a
 // diagram looks the same on GitHub, in a browser and in a doc, and text that fit
 // when linework sized the boxes still fits wherever it is shown.
+import crypto from 'node:crypto';
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import subsetFont from 'subset-font';
 import { assetsDir } from './browser.js';
@@ -54,7 +56,7 @@ export async function embedFonts(svg) {
     text = [...new Set(text + text.toUpperCase() + ' ')].join('');
     const rules = [];
     for (const f of FACES.filter((x) => families.includes(x.family))) {
-        const sub = await subsetFont(read(f), text, { targetFormat: 'woff2' });
+        const sub = await subset(f, text);
         rules.push(`@font-face{font-family:"${f.family}";font-weight:${f.weight};font-style:normal;src:url(data:font/woff2;base64,${sub.toString('base64')}) format("woff2");}`);
     }
     const style = `<style id="aiviz-fonts" type="text/css">${rules.join('')}</style>`;
@@ -64,3 +66,65 @@ export async function embedFonts(svg) {
         return svg.replace(/<defs[^>]*>/, (m) => m + style);
     return svg.replace(/<svg\b[^>]*>/, (m) => `${m}<defs>${style}</defs>`);
 }
+// ---------- subset cache ----------
+//
+// Compressing a subset to WOFF2 is most of embedFonts' time, and rebuilding a
+// diagram after a small edit usually needs the same characters again. A subset
+// depends only on the font file and the set of characters (not their order), so
+// that pair is the key. Kept in memory and in the user's own cache folder, never
+// a shared temp dir: whatever is there ends up inside the SVGs.
+const memo = new Map();
+const fileHash = new Map();
+/** Drop the in-memory copies, so the next lookup reads the disk cache. For tests. */
+export function forgetSubsets() {
+    memo.clear();
+}
+function cacheDir() {
+    if (process.env.LINEWORK_NO_CACHE)
+        return undefined;
+    const home = os.homedir();
+    const base = process.env.XDG_CACHE_HOME ||
+        (process.platform === 'darwin' ? path.join(home, 'Library', 'Caches') : process.platform === 'win32' ? process.env.LOCALAPPDATA || path.join(home, 'AppData', 'Local') : path.join(home, '.cache'));
+    return path.join(base, 'linework', 'fonts');
+}
+async function subset(f, text) {
+    const font = read(f);
+    let fh = fileHash.get(f.file);
+    if (!fh)
+        fileHash.set(f.file, (fh = crypto.createHash('sha256').update(font).digest('hex')));
+    const chars = [...new Set(text)].sort().join('');
+    const key = crypto.createHash('sha256').update(`${fh}\0${chars}`).digest('hex').slice(0, 32);
+    const hit = memo.get(key);
+    if (hit)
+        return hit;
+    const dir = cacheDir();
+    const file = dir && path.join(dir, `${key}.woff2`);
+    let out;
+    try {
+        const b = file ? fs.readFileSync(file) : undefined;
+        // A WOFF2 file starts with its signature; anything else is a broken write.
+        if (b && b.subarray(0, 4).toString('latin1') === 'wOF2')
+            out = b;
+    }
+    catch {
+        // not cached yet
+    }
+    if (!out) {
+        out = await subsetFont(font, text, { targetFormat: 'woff2' });
+        if (file) {
+            try {
+                fs.mkdirSync(dir, { recursive: true });
+                const tmp = `${file}.${process.pid}.tmp`;
+                fs.writeFileSync(tmp, out);
+                fs.renameSync(tmp, file);
+            }
+            catch {
+                // A read-only or full disk only costs the cache.
+            }
+        }
+    }
+    if (memo.size >= 64)
+        memo.delete(memo.keys().next().value);
+    memo.set(key, out);
+    return out;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@itsthecsguy/linework",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Software diagrams an AI can write and a person can edit. YAML spec in, .drawio.svg out, editable in draw.io.",
   "keywords": [
     "diagram",