[tannevaled]

Why

go-slides renders a deck one page per slide, and its bundled theme fonts (Lato, Roboto Mono, five faces) travelled in every page as @font-face data: URIs. Profiling its export against marp-cli showed most of each render going to fonts:

• paint.NewFonts parsed the seven bundled families on every render;
• each @font-face file was parsed twice per render (LoadFontFaces validates it, RegisterFontFaces parses it again);
• urlToken, formatHint and the !important check lowercased a copy of the whole value — for an inlined font or image, hundreds of kilobytes copied per declaration per render.

What

• paint: the bundled families are parsed once per process and shared. An *opentype.Font is read-only after Parse (checked: every field write in go-opentype is in the parse path); the per-registry state — the Face cache that caches glyphs, the named faces — stays per Fonts.
• paint: Fonts.RegisterFont registers an already-parsed font.
• engine: LoadFontFaces keeps the font it parsed to validate a file; RegisterFontFaces registers it instead of parsing again.
• engine: parsed font files are cached across renders, keyed by the SHA-256 of their bytes (never by URL, so a key only ever names the bytes it was parsed from), bounded to 64 files / 32 MiB, LRU. A file larger than the bound is used and not kept; a file that fails to parse is not kept.
• engine: Engine.FontFaces — typefaces the host installs for every render, like a browser's system fonts — and ParseFontFace to build one, parsed once. A family the page declares a face for keeps the page's.
• css: the three searches match in place (the existing indexFold / equalFoldASCII), which also keeps the index valid when a non-ASCII character changes length under ToLower (tested with Ⱥ).

Tests

• TestSharedFontsRenderConcurrently: 6 concurrent renders on one Engine sharing a cached data: URI face and the bundled fonts, under -race, byte-identical to a serial render.
• TestEngineFontFaces: a host face renders byte for byte like the same file declared by the page; the page's own face wins; an unparseable host face is skipped.
• TestFontCacheHitsAndBounds, TestFontCacheConcurrentMiss, TestRegisterFontFacesUsesParsedFont, TestNewFontsSharesBundledFonts, TestRegisterFont, TestParseFontFacesSrcCase, and new !important cases.
• Coverage: paint 100.0%, css 99.5% (floors unchanged).

Measured

BenchmarkRenderInlineFontFace (a 1280×720 page carrying its face as a data: URI), Apple M4 Max, 3 runs each, base = origin/main in a separate worktree:

	time/op	bytes/op	allocs/op
before	50–54 ms	36.6 MB	73,160
after	12–15 ms	6.2 MB	1,160

The machine was loaded (load average ~40 on 16 cores) while measuring: the allocation figures are exact, the times are indicative.

In go-slides (10-slide gaia deck, one worker): 1,211 MB → 65 MB allocated, with Engine.FontFaces in place of the data: URIs; output byte-identical.

🤖 Generated with Claude Code