@openpresentation/opf-render 0.7.0 → 0.8.1

package/README.md

@@ -1,9 +1,45 @@
 # OPF Render
 
-Version 0.7.0 requires core 0.9.0 and renders accepted quote and code geometry without fitting it again. Code filename/language/body parts preserve source whitespace, literal tabs and metadata case and expose trace targets for editing. The [43 reviewed code raster changes](docs/evidence/shared-code/raster-review.json) retain the other 762 corpus hashes. Planned coordinated releases PPTX 0.7.0 and editor 0.6.0 will add native source recovery and editing. Glyph containment and separation do not establish native pixel equivalence.
+Version 0.8.1 requires core 0.10.1, including metric, quote and timeline layout placeholders and the corrected text-bullet contract. It retains the existing rendering APIs.
+
+Unfinished prepared shaping work is preserved in the [September 15 roadmap](docs/roadmap-shaping-20260915.md); it is not part of the published runtime.
+
+Version 0.8.0 and this checkout require Node 24 (`24.x`). Use `.nvmrc` for local development. Earlier published versions retain their original engine declarations. Browser entrypoints remain browser-safe; native application compatibility is verified separately.
+
+Version 0.8.0 adds optional font-registry vector outlines and shared heading/scalar/rich line placement. Pass identical `textMeasurement` and `textRasterPadding` options to preview, pagination and export; padding defaults to one scaled reference pixel. SVG consumes accepted origins without remeasuring. See the [source contract and limits](https://github.com/OpenPresentation/opf/blob/f94125a1ff95bf0974a055fe1c081d348dad54f2/docs/plans/text-placement.md). Native raster certification remains separate.
+
+Version 0.8.0 requires core 0.10.0 and renders accepted quote and code geometry without fitting it again. Code filename/language/body parts preserve source whitespace, literal tabs and metadata case and expose trace targets for editing. The [43 reviewed code raster changes](docs/evidence/shared-code/raster-review.json) retain the other 762 corpus hashes. Coordinated releases PPTX 0.8.0 and editor 0.7.0 add native source recovery and editing. Glyph containment and separation do not establish native pixel equivalence.
 
 Deterministic local renderer for Open Presentation Format documents. The shared SVG core implements validation, catalog resolution, placeholder binding and text layout. Node APIs additionally convert SVG to PNG and raster-backed PDF.
 
+In version 0.8.0, `design.contentBox` uses core's shared padded geometry. The card renders at `item.frameBox`; its payload uses `item.box` and accepted internals. Card padding participates in composition scoring, strict overflow and pagination. This requires core 0.10.0.
+
+Version 0.8.0 paints plain and rich text, titles, subtitles and tags using composition's accepted fits and resolved styles. Painting does not measure those payloads again. Supply a font registry during composition: reusing an estimated fit cannot correct spacing when the actual drawing font has different advances.
+
+Version 0.8.0 includes `prepareNodeFonts` in `/fonts-node`. It verifies all selected font files and license notices against the versioned `BUNDLED_FONT_MANIFEST`, including exact npm versions and SHA-256 hashes. The returned options configure layout, SVG, editing, PPTX, and Node raster output with the same font inputs:
+
+```js
+import { prepareNodeFonts } from '@openpresentation/opf-render/fonts-node';
+import { renderSvgDeck, svgToPng } from '@openpresentation/opf-render';
+import { paginatePresentation } from '@openpresentation/opf/pagination';
+import { toPptx } from '@openpresentation/opf-pptx';
+
+const { registry, options } = await prepareNodeFonts({
+  pack: 'office', substitutionPolicy: 'visual',
+});
+const { presentation } = paginatePresentation(opf, options);
+const slides = renderSvgDeck(presentation, options);
+const png = await svgToPng(slides[0], options);
+const pptx = await toPptx(presentation, options);
+console.log(registry.substitutions);
+```
+
+The default `pack: 'base'` contains nine Roboto/Roboto Mono faces and suits a document using `design.fontScheme: 'roboto'`. The Office pack includes 24 additional faces and defaults to metric substitution policy; visual substitution remains explicit. Neither helper changes the document's authored font scheme or installs system fonts. Missing resources, changed bytes/notices, and unexpected package versions fail with actionable font errors. Requested/resolved substitution records remain on `registry.substitutions`; source paths appear where the caller supplies them. Font coverage, variant naming, shaping, and native fidelity retain their documented limits.
+
+Default PNG/PDF raster loading now uses the same complete nine-face base pack, fixing omitted semibold and italic faces. Custom raster callers may still set `useBundledFonts: false`. Font files must stay available and unchanged for subsequent raster calls. `node scripts/update-font-manifest.mjs` is an explicit maintenance operation requiring review of font bytes, style metadata, licenses and raster changes; builds and installs never regenerate the expected hashes.
+
+Version 0.8.0 resolves OpenType preferred-family groups, so a Roboto request at 500, 600 or 800 selects the installed Medium, SemiBold or ExtraBold face. Explicit caller family renames keep their own namespace; ambiguous grouped faces reject. Resolved styles also carry optional `fontFace` metadata with the physical legacy family and its bold/italic style-link flags. Coordinated PPTX export consumes those flags independently of numeric weight. This prevents requesting a second bold style from an already named ExtraBold/SemiBold family. Browser CSS and native selectors retain their respective family names; no font is synthesized or installed by this lookup. See [exact-weight evidence and limits](docs/evidence/font-variants/README.md).
+
 Code strings that [XML 1.0 cannot represent](https://www.w3.org/TR/xml/#charsets) reject rendering with `invalid-code-text`, the OPF field path and UTF-16 offset. Input JSON stays unchanged. Tabs, line endings and valid supplementary Unicode remain accepted; schema validity and XML serialization do not certify font coverage or native fidelity.
 
 ## Scope
@@ -18,20 +54,36 @@ Code strings that [XML 1.0 cannot represent](https://www.w3.org/TR/xml/#charsets
 
 ```js
 import { renderSvgDeck } from "@openpresentation/opf-render";
+import { loadOfficeFontRegistry } from "@openpresentation/opf-render/fonts-node";
 
-const svgs = renderSvgDeck(opf, { trace: true });
+const fonts = await loadOfficeFontRegistry({ substitutionPolicy: "visual" });
+const svgs = renderSvgDeck(opf, {
+  trace: true,
+  textMeasurement: fonts.textMeasurement,
+  embeddedFonts: fonts.embeddedFonts,
+});
+console.log(fonts.substitutions);
 ```
 
 Set `trace: true` to stamp rendered SVG elements with `data-opf-path` values such as `slides.0.title`; omit it for smaller production SVG.
 
+The installed open font pack works offline. This example explicitly permits visual substitutes such as Carlito for Aptos; the substitution report identifies requested and resolved faces. A visual substitute is not a claim of metric or pixel equivalence. Omit `substitutionPolicy` to restrict the Office loader to its metric mappings, or supply your own licensed faces. Missing fonts/glyphs fail explicitly. Without `textMeasurement`, synchronous SVG APIs use estimated widths; named fonts alone do not make rich-run spacing reliable. Browser hosts should load the same bytes using the loader below.
+
+Unresolved images produce an `unresolved-asset` diagnostic through `onDiagnostic`, including the OPF path, reason and complete description. The fallback shows a bounded status label when it fits above the selected readability floor, otherwise an icon with the full accessible description. It preserves authored opacity, including faint decorative watermarks; a missing image is still missing even when its fallback fits. Use `strictAssets: true` to reject unresolved images. Supply embedded raster data URIs or a synchronous host `imageResolver` to resolve them; the renderer does not fetch URLs or read local paths. Caller descriptions and other metadata override referenced asset metadata through alias chains. These diagnostics identify unresolved sources, not malformed image bytes or native PowerPoint compatibility.
+
+Header/footer images and watermarks fit their complete artwork within their allocated regions. `design.imageFill: "crop"` continues to crop content picture placeholders; background images retain their own fit policy.
+
 PNG and PDF conversion APIs are async because they load the local raster/PDF engines on demand:
 
 ```js
 import { renderSvgDeck, svgToPdf, svgToPng } from "@openpresentation/opf-render";
+import { loadOfficeFontRegistry } from "@openpresentation/opf-render/fonts-node";
 
-const svgs = renderSvgDeck(opf);
-const png = await svgToPng(svgs[0], { scale: 1 });
-const pdf = await svgToPdf(svgs, { scale: 1 });
+const fonts = await loadOfficeFontRegistry({ substitutionPolicy: "visual" });
+const svgs = renderSvgDeck(opf, { textMeasurement: fonts.textMeasurement });
+const rasterOptions = { scale: 1, fontFiles: fonts.fontFiles, useBundledFonts: false, loadSystemFonts: false };
+const png = await svgToPng(svgs[0], rasterOptions);
+const pdf = await svgToPdf(svgs, rasterOptions);
 ```
 
 `svgToPng` returns PNG bytes for one SVG. `svgToPdf` accepts one SVG or an array of SVGs and returns PDF bytes with one slide per page. The SVG page `width`/`height` or `viewBox` determines the PDF page size; `scale` controls raster density only.
@@ -86,6 +138,8 @@ npm run validate
 npm test
 ```
 
+The accepted-text regression `npm run test:text` checks 24 combinations of dimensions, alignment, cards and formatting, including exact accepted positions/styles and strict overflow. `npm run test:rich-spacing-browser -- <new-output-directory>` compares two unchanged gallery slides with identical open font bytes. `npm run test:text-browser -- <new-output-directory>` also checks actual text paint: it currently exits 1 for four portrait/right title cases with one painted pixel beyond the 0.1-pixel cell tolerance in the recorded Windows Edge environment. Its advance/origin checks pass. Font text rectangles, painted-pixel containment, source whitespace and native fidelity are separate results; that historical plain fitting normalized whitespace. Later source-whitespace evidence below supersedes that behavior and has its own reviewed corpus checkpoint.
+
 When this repo is checked out beside `openpresentation/opf`, `npm test` also renders every `examples/**/*.opf.json` deck twice and asserts byte-identical SVG output. Golden PNG drift is checked on every run against all 805 slides from the installed core package, identified by a content digest. Changed or missing corpora fail; Git history cannot skip the gate. To generate a review candidate after an intentional visual change:
 
 ```sh
@@ -122,7 +176,7 @@ Version 0.1.1 adds rich-text line offsets and measured boxes to opt-in SVG traci
 
 PNG and PDF conversion now decode embedded WebP image data URIs to static PNG before rasterization. This preserves fit/crop, transparency, EXIF orientation and the first animation frame. The source SVG and OPF document remain unchanged; browser SVG output keeps the original embedded image. Both href and legacy xlink:href are supported, including base64 and percent-encoded data. This step does not resolve local filenames, download remote images or change the existing host imageResolver contract.
 
-The Node-only raster path lazily loads pinned Sharp 0.35.4, requiring Node 20.9 or later and normal installation of its optional platform binaries. Browser exports do not include the decoder. Malformed embedded WebP produces image-conversion-failed with its data-opf-path when present, otherwise svg.images.N. Decoding has a 40-megapixel limit. PNG/PDF are static outputs; animation beyond the first frame and original image metadata are not retained.
+The Node-only raster path lazily loads pinned Sharp 0.35.4, requiring Node 24 for this package and normal installation of its optional platform binaries. Browser exports do not include the decoder. Malformed embedded WebP produces image-conversion-failed with its data-opf-path when present, otherwise svg.images.N. Decoding has a 40-megapixel limit. PNG/PDF are static outputs; animation beyond the first frame and original image metadata are not retained.
 
 Regression checks compare six fixtures against independent Pillow pixels, verify fit/crop, inspect actual PDF image streams and transparency masks, and exercise input encodings and diagnostics. All 805 existing raster baselines remain unchanged. Test fixtures are project-authored and MIT licensed; the decoder and its bundled codecs retain their upstream licenses.
 
@@ -147,3 +201,5 @@ Renderer 0.5.0 requires core 0.7.0 and uses its shared styled-cell geometry. A c
 Every covered position is explicit `null`. Each merged anchor renders once; traced text uses its `.value` path for editing. Styles support RGB/RGBA fills and text colors, horizontal and vertical alignment, reference-pixel padding and per-edge solid/dashed/dotted borders. Rich-run colors override the cell text color. Columns remain equal width; rows grow from measured text, padding and span constraints. Pagination preserves connected vertical merge groups.
 
 The Node20/24 renderer suite retains all 805 existing raster baselines. Browser fixtures verify merged text containment and styled-cell typing, formatting, cancellation and undo with actual loaded fonts. Native PowerPoint appearance remains a separate converter verification boundary.
+
+Version 0.8.0 preserves scalar spaces, literal tabs and exact hard-line source ranges across core layout and SVG. Explicit tab positions and whitespace-preserving SVG text prevent source collapse. Its separate 805-slide checkpoint follows review of all 279 changed slides in 35 paired sheets and six full-size pairs; historical baselines remain retained. See [the review and bounds](docs/evidence/source-whitespace-corpus-review/README.md). Estimated wrapping/advances, multilingual shaping and native Office remain separate gates.

package/dist/font-manifest.js

@@ -0,0 +1,326 @@
+// Generated deliberately by scripts/update-font-manifest.mjs; never during build/install.
+const freeze=value=>{if(value&&typeof value==='object'){for(const child of Object.values(value))freeze(child);Object.freeze(value);}return value;};
+export const BUNDLED_FONT_MANIFEST=freeze({
+  "version": 1,
+  "packages": [
+    {
+      "name": "@expo-google-fonts/roboto",
+      "version": "0.4.3",
+      "pack": "base",
+      "source": "https://www.npmjs.com/package/@expo-google-fonts/roboto/v/0.4.3",
+      "license": "OFL-1.1",
+      "licenseFile": "LICENSE_FONT",
+      "licenseSha256": "061402327a96aadb0bfb694a960ed289ecd38d383e396243831ab81feb109c41",
+      "faces": [
+        {
+          "file": "400Regular/Roboto_400Regular.ttf",
+          "family": "Roboto",
+          "weight": 400,
+          "italic": false,
+          "sha256": "15256405ecb0d880678833a582760efad538ab2932318b52c8105b267d159459"
+        },
+        {
+          "file": "500Medium/Roboto_500Medium.ttf",
+          "family": "Roboto Medium",
+          "weight": 500,
+          "italic": false,
+          "sha256": "79343dc641a2e8d48a703a4667b71fc8dc6565cc8ce47dfc34fc52c12aadbf38"
+        },
+        {
+          "file": "600SemiBold/Roboto_600SemiBold.ttf",
+          "family": "Roboto SemiBold",
+          "weight": 600,
+          "italic": false,
+          "sha256": "32fe2086b0e54eca85a68eb74e3d89bb16a7ffe59085d6dc7d079f5b3c26d6ab"
+        },
+        {
+          "file": "700Bold/Roboto_700Bold.ttf",
+          "family": "Roboto",
+          "weight": 700,
+          "italic": false,
+          "sha256": "4aaf8c5b661a386998c2e70cf2b87e2440f5404e0b8fd81164f0413fb3435ec6"
+        },
+        {
+          "file": "800ExtraBold/Roboto_800ExtraBold.ttf",
+          "family": "Roboto ExtraBold",
+          "weight": 800,
+          "italic": false,
+          "sha256": "43d5ce98c58336045220fa1dac2bd22281b1aab3eca66785cb34eb3ad1dfe1a5"
+        },
+        {
+          "file": "400Regular_Italic/Roboto_400Regular_Italic.ttf",
+          "family": "Roboto",
+          "weight": 400,
+          "italic": true,
+          "sha256": "6a372c348dc20c246b92d60b9bda3c0a9ffedc129790ed3f31faf89daa99d793"
+        },
+        {
+          "file": "700Bold_Italic/Roboto_700Bold_Italic.ttf",
+          "family": "Roboto",
+          "weight": 700,
+          "italic": true,
+          "sha256": "c6a5e7c224d3bf6698e5d3c124f0f0220cad20d5d413920447a96f033a0292ee"
+        }
+      ]
+    },
+    {
+      "name": "@expo-google-fonts/roboto-mono",
+      "version": "0.4.2",
+      "pack": "base",
+      "source": "https://www.npmjs.com/package/@expo-google-fonts/roboto-mono/v/0.4.2",
+      "license": "OFL-1.1",
+      "licenseFile": "LICENSE_FONT",
+      "licenseSha256": "50ab8dd54680d3473f649c9db86fece88434d097c7834475c1c72d2f8c429215",
+      "faces": [
+        {
+          "file": "400Regular/RobotoMono_400Regular.ttf",
+          "family": "Roboto Mono",
+          "weight": 400,
+          "italic": false,
+          "sha256": "e4bf45837847d4abfa5a502b807a83393aa138727bdb9ea9c93fb17d53208d95"
+        },
+        {
+          "file": "700Bold/RobotoMono_700Bold.ttf",
+          "family": "Roboto Mono",
+          "weight": 700,
+          "italic": false,
+          "sha256": "92649d819cc4c20480b23a47aaa111769924eb31c66b6ecdcf6f573662558c83"
+        }
+      ]
+    },
+    {
+      "name": "@expo-google-fonts/carlito",
+      "version": "0.4.1",
+      "pack": "office",
+      "source": "https://www.npmjs.com/package/@expo-google-fonts/carlito/v/0.4.1",
+      "license": "OFL-1.1",
+      "licenseFile": "LICENSE_FONT",
+      "licenseSha256": "58402f82a7c332a700294988fe7554fbb0a63a8d27ccc1ee3bbc640311990a00",
+      "faces": [
+        {
+          "file": "400Regular/Carlito_400Regular.ttf",
+          "family": "Carlito",
+          "weight": 400,
+          "italic": false,
+          "sha256": "ca019755404c45627a8566915df99068949dc32ee2bce48d6aeee7542d2a0a89"
+        },
+        {
+          "file": "400Regular_Italic/Carlito_400Regular_Italic.ttf",
+          "family": "Carlito",
+          "weight": 400,
+          "italic": true,
+          "sha256": "074cd1b89d53765d90d0ed3b4bfe49523efaaf4f3f430c006bc3233778b0ebb5"
+        },
+        {
+          "file": "700Bold/Carlito_700Bold.ttf",
+          "family": "Carlito",
+          "weight": 700,
+          "italic": false,
+          "sha256": "51edbfa32d8af939913ae1f4ad0a5173e32083499218c133384638090295f0b0"
+        },
+        {
+          "file": "700Bold_Italic/Carlito_700Bold_Italic.ttf",
+          "family": "Carlito",
+          "weight": 700,
+          "italic": true,
+          "sha256": "25f5672c1985d168d6bc2973864fc5a7e374bb95fe8d0f91cff47ae17fa67691"
+        }
+      ]
+    },
+    {
+      "name": "@expo-google-fonts/caladea",
+      "version": "0.4.2",
+      "pack": "office",
+      "source": "https://www.npmjs.com/package/@expo-google-fonts/caladea/v/0.4.2",
+      "license": "OFL-1.1",
+      "licenseFile": "LICENSE_FONT",
+      "licenseSha256": "ccdab61d371d8c8683a128a92cd7d498dbdb1d37689f7cb21f1bf6b16658d213",
+      "faces": [
+        {
+          "file": "400Regular/Caladea_400Regular.ttf",
+          "family": "Caladea",
+          "weight": 400,
+          "italic": false,
+          "sha256": "59faf27a90dee5c1b7813b12b26c725ea88adc1bfe37b0ac8e0b8b32a5732c2a"
+        },
+        {
+          "file": "400Regular_Italic/Caladea_400Regular_Italic.ttf",
+          "family": "Caladea",
+          "weight": 400,
+          "italic": true,
+          "sha256": "669e65b265d40899b59d7f3531ca136b7e0fda80a3d1b5d47bbe7825be81fbe3"
+        },
+        {
+          "file": "700Bold/Caladea_700Bold.ttf",
+          "family": "Caladea",
+          "weight": 700,
+          "italic": false,
+          "sha256": "11d1e1dc461d1e491b6a396d91934c3bb09d06a77cc3d21ad0b10346c39c3ec2"
+        },
+        {
+          "file": "700Bold_Italic/Caladea_700Bold_Italic.ttf",
+          "family": "Caladea",
+          "weight": 700,
+          "italic": true,
+          "sha256": "93d7c2003fe3fd8381cbd518af6cc2f4b510a37c7741c49a95893b6da8edbbc7"
+        }
+      ]
+    },
+    {
+      "name": "@expo-google-fonts/arimo",
+      "version": "0.4.3",
+      "pack": "office",
+      "source": "https://www.npmjs.com/package/@expo-google-fonts/arimo/v/0.4.3",
+      "license": "OFL-1.1",
+      "licenseFile": "LICENSE_FONT",
+      "licenseSha256": "11cce536cd2f3864d767003af5dcd739e2e15818cf2279b6175edeadd3960992",
+      "faces": [
+        {
+          "file": "400Regular/Arimo_400Regular.ttf",
+          "family": "Arimo",
+          "weight": 400,
+          "italic": false,
+          "sha256": "88cc899855d30f9c779b73c3319d0e077b098f927187aafce11ca029add707a6"
+        },
+        {
+          "file": "400Regular_Italic/Arimo_400Regular_Italic.ttf",
+          "family": "Arimo",
+          "weight": 400,
+          "italic": true,
+          "sha256": "6bd2c6a6fa87f4566cf0a92c5834884597acbd7be9719e550837865ac4167a42"
+        },
+        {
+          "file": "700Bold/Arimo_700Bold.ttf",
+          "family": "Arimo",
+          "weight": 700,
+          "italic": false,
+          "sha256": "ec96ac9fdd94766f66f6140c1375bf011577558f88d43f76b3b59307d2a6bca3"
+        },
+        {
+          "file": "700Bold_Italic/Arimo_700Bold_Italic.ttf",
+          "family": "Arimo",
+          "weight": 700,
+          "italic": true,
+          "sha256": "b42b19c10bf5d526f00068303a643282c3df55a79c6fa2eea80b4a078a4a705a"
+        }
+      ]
+    },
+    {
+      "name": "@expo-google-fonts/tinos",
+      "version": "0.4.2",
+      "pack": "office",
+      "source": "https://www.npmjs.com/package/@expo-google-fonts/tinos/v/0.4.2",
+      "license": "OFL-1.1",
+      "licenseFile": "LICENSE_FONT",
+      "licenseSha256": "cb3382d4643e8b02c12e322c220a3c76a5020d667e4fd4e7c75e744cca6caa6b",
+      "faces": [
+        {
+          "file": "400Regular/Tinos_400Regular.ttf",
+          "family": "Tinos",
+          "weight": 400,
+          "italic": false,
+          "sha256": "924ef269e73da94c1803ff68877f5d998dd16605c5ffad82ee181034f8a1fffe"
+        },
+        {
+          "file": "400Regular_Italic/Tinos_400Regular_Italic.ttf",
+          "family": "Tinos",
+          "weight": 400,
+          "italic": true,
+          "sha256": "4a52de5bcf70e37bd71949f8a85302b75795a1943aedffbbee4f2db7744e1c81"
+        },
+        {
+          "file": "700Bold/Tinos_700Bold.ttf",
+          "family": "Tinos",
+          "weight": 700,
+          "italic": false,
+          "sha256": "576a19b5dc026cafe6ae8fde4c849588dae6475cf5d912cebdf2827388c43ad9"
+        },
+        {
+          "file": "700Bold_Italic/Tinos_700Bold_Italic.ttf",
+          "family": "Tinos",
+          "weight": 700,
+          "italic": true,
+          "sha256": "10c90ef7896d758923c06a1485d7824cdb457466da0bf7d42f81c5228931281b"
+        }
+      ]
+    },
+    {
+      "name": "@expo-google-fonts/cousine",
+      "version": "0.4.3",
+      "pack": "office",
+      "source": "https://www.npmjs.com/package/@expo-google-fonts/cousine/v/0.4.3",
+      "license": "OFL-1.1",
+      "licenseFile": "LICENSE_FONT",
+      "licenseSha256": "b81c4d4dc0a9f72c9155e78187316e016e2012a8102468804173dc61468b906d",
+      "faces": [
+        {
+          "file": "400Regular/Cousine_400Regular.ttf",
+          "family": "Cousine",
+          "weight": 400,
+          "italic": false,
+          "sha256": "ca2264d6750d6c47df703be4486361a37ab943d42de6ea2bf794b7c7af767799"
+        },
+        {
+          "file": "400Regular_Italic/Cousine_400Regular_Italic.ttf",
+          "family": "Cousine",
+          "weight": 400,
+          "italic": true,
+          "sha256": "f1626b7287db36af8ba2ff88840c82f121f4cbda8971fe3f717f975e9fd782a8"
+        },
+        {
+          "file": "700Bold/Cousine_700Bold.ttf",
+          "family": "Cousine",
+          "weight": 700,
+          "italic": false,
+          "sha256": "f03c46c4bc5c0a3af4a1f4fbe5e3e16954581cced05cea20b3bffe12740d99d3"
+        },
+        {
+          "file": "700Bold_Italic/Cousine_700Bold_Italic.ttf",
+          "family": "Cousine",
+          "weight": 700,
+          "italic": true,
+          "sha256": "acb798f3629cda0041fbd6234237cf549a1b932792f2a71b0986eb3e1382ed37"
+        }
+      ]
+    },
+    {
+      "name": "@expo-google-fonts/gelasio",
+      "version": "0.4.1",
+      "pack": "office",
+      "source": "https://www.npmjs.com/package/@expo-google-fonts/gelasio/v/0.4.1",
+      "license": "OFL-1.1",
+      "licenseFile": "LICENSE_FONT",
+      "licenseSha256": "b393cb01867c919b44381512120dc3e4c954c7b47e2035c405f3a324799a4d29",
+      "faces": [
+        {
+          "file": "400Regular/Gelasio_400Regular.ttf",
+          "family": "Gelasio",
+          "weight": 400,
+          "italic": false,
+          "sha256": "44aae47442ad39e623788930f38f1e702febcf094c284c5058bf49f7da23de9a"
+        },
+        {
+          "file": "400Regular_Italic/Gelasio_400Regular_Italic.ttf",
+          "family": "Gelasio",
+          "weight": 400,
+          "italic": true,
+          "sha256": "2b24b3d41c06d030a31db6610454595775e572a2992d73171cab783407d202a8"
+        },
+        {
+          "file": "700Bold/Gelasio_700Bold.ttf",
+          "family": "Gelasio",
+          "weight": 700,
+          "italic": false,
+          "sha256": "fade86eca52203e2ccaf9aee494aa4b0335589879738c47e9d92a53630696d10"
+        },
+        {
+          "file": "700Bold_Italic/Gelasio_700Bold_Italic.ttf",
+          "family": "Gelasio",
+          "weight": 700,
+          "italic": true,
+          "sha256": "24f1cb5cf5f765acc5d744a54a6c5dfe34723e58842f5b1b696716497e032852"
+        }
+      ]
+    }
+  ]
+});

package/dist/fonts-node.d.ts

@@ -1,4 +1,26 @@
-import type {FontRegistry,FontRegistryOptions} from "./fonts.js";
+import type {FontRegistry,FontRegistryOptions,EmbeddedFont} from "./fonts.js";
 export declare function loadBundledFontRegistry(options?: FontRegistryOptions): Promise<FontRegistry & {fontFiles:string[]}>;
 
 export declare function loadOfficeFontRegistry(options?: FontRegistryOptions & {includeBaseFonts?:boolean}): Promise<FontRegistry & {fontFiles:string[]}>;
+
+export interface BundledFontManifest {
+  readonly version: number;
+  readonly packages: readonly Readonly<{
+    name:string; version:string; pack:"base"|"office"; source:string;
+    license:string; licenseFile:string; licenseSha256:string;
+    faces:readonly Readonly<{file:string; family:string; weight:number; italic:boolean; sha256:string}>[];
+  }>[];
+}
+export declare const BUNDLED_FONT_MANIFEST: BundledFontManifest;
+export interface PreparedNodeFonts {
+  registry: FontRegistry & {fontFiles:string[]};
+  manifest: BundledFontManifest;
+  options: {
+    textMeasurement: FontRegistry["textMeasurement"];
+    embeddedFonts: EmbeddedFont[];
+    fontFiles: string[];
+    useBundledFonts: false;
+    loadSystemFonts: false;
+  };
+}
+export declare function prepareNodeFonts(options?: FontRegistryOptions & {pack?:"base"|"office"; includeBaseFonts?:boolean}): Promise<PreparedNodeFonts>;

package/dist/fonts-node.js

@@ -1,44 +1,74 @@
 import { readFile } from "node:fs/promises";
 import { createRequire } from "node:module";
-import { createFontRegistry } from "./fonts.js";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { createFontRegistry, OPFFontError } from "./fonts.js";
+import { BUNDLED_FONT_MANIFEST } from "./font-manifest.js";
+export { BUNDLED_FONT_MANIFEST } from "./font-manifest.js";
 const require = createRequire(import.meta.url);
+
+async function verifiedFile(file, expected, details) {
+  let bytes;
+  try { bytes = await readFile(file); }
+  catch (error) { throw new OPFFontError("font-resource-unavailable", "Reinstall the pinned font package: a required local resource is unavailable.", {...details, cause: error.code}); }
+  const actual = createHash("sha256").update(bytes).digest("hex");
+  if (actual !== expected) throw new OPFFontError("font-integrity-mismatch", "The local font resource differs from the reviewed font manifest; reinstall the pinned package.", {...details, expected, actual});
+  return bytes;
+}
+
+async function loadPack(pack) {
+  const entries = [], fontFiles = [];
+  for (const pkg of BUNDLED_FONT_MANIFEST.packages.filter(item => item.pack === pack)) {
+    let manifestPath, installed;
+    try {
+      manifestPath = require.resolve(`${pkg.name}/package.json`);
+      installed = JSON.parse(await readFile(manifestPath, "utf8"));
+    } catch (error) {
+      throw new OPFFontError("font-resource-unavailable", `Install ${pkg.name}@${pkg.version} to use this offline font pack.`, {package:pkg.name, cause:error.code});
+    }
+    if (installed.version !== pkg.version) throw new OPFFontError("font-version-mismatch", `Expected ${pkg.name}@${pkg.version}; reinstall the pinned package.`, {package:pkg.name, expected:pkg.version, actual:installed.version});
+    const directory = path.dirname(manifestPath);
+    const license = (await verifiedFile(path.join(directory, pkg.licenseFile), pkg.licenseSha256, {package:pkg.name, file:pkg.licenseFile})).toString("utf8");
+    for (const face of pkg.faces) {
+      const file = path.join(directory, face.file);
+      const data = await verifiedFile(file, face.sha256, {package:pkg.name, file:face.file});
+      fontFiles.push(file);
+      entries.push({data:new Uint8Array(data), family:face.family, weight:face.weight, italic:face.italic, license});
+    }
+  }
+  return {entries, fontFiles};
+}
+
 /** Bundled, openly licensed faces. No system font discovery or network requests. */
 export async function loadBundledFontRegistry(options = {}) {
-  const definitions = [
-    ["roboto","400Regular","Roboto_400Regular",400,false],
-    ["roboto","500Medium","Roboto_500Medium",500,false],
-    ["roboto","600SemiBold","Roboto_600SemiBold",600,false],
-    ["roboto","700Bold","Roboto_700Bold",700,false],
-    ["roboto","800ExtraBold","Roboto_800ExtraBold",800,false],
-    ["roboto","400Regular_Italic","Roboto_400Regular_Italic",400,true],
-    ["roboto","700Bold_Italic","Roboto_700Bold_Italic",700,true],
-    ["roboto-mono","400Regular","RobotoMono_400Regular",400,false],
-    ["roboto-mono","700Bold","RobotoMono_700Bold",700,false],
-  ];
-  const licenses = Object.fromEntries(await Promise.all(["roboto","roboto-mono"].map(async pkg=>[pkg,await readFile(require.resolve(`@expo-google-fonts/${pkg}/LICENSE_FONT`),"utf8")])));
-  const fontFiles = definitions.map(([pkg,directory,name])=>require.resolve(`@expo-google-fonts/${pkg}/${directory}/${name}.ttf`));
-  const entries = await Promise.all(definitions.map(async ([pkg,,,weight,italic],index)=>({license:licenses[pkg],data:new Uint8Array(await readFile(fontFiles[index])),weight,italic})));
+  const {entries, fontFiles} = await loadPack("base");
   return Object.assign(createFontRegistry(entries,options),{fontFiles});
 }
 
 /** Six pinned open-source Office substitutes, optionally alongside the base Roboto pack. */
 export async function loadOfficeFontRegistry(options = {}) {
-  const packages = ["carlito","caladea","arimo","tinos","cousine","gelasio"];
-  const styles = [["400Regular",400,false],["400Regular_Italic",400,true],["700Bold",700,false],["700Bold_Italic",700,true]];
-  const entries = [], fontFiles = [];
-  for (const pkg of packages) {
-    const name = pkg[0].toUpperCase()+pkg.slice(1);
-    const license = await readFile(require.resolve(`@expo-google-fonts/${pkg}/LICENSE_FONT`),"utf8");
-    for (const [directory,weight,italic] of styles) {
-      const path = require.resolve(`@expo-google-fonts/${pkg}/${directory}/${name}_${directory}.ttf`);
-      fontFiles.push(path);
-      entries.push({data:new Uint8Array(await readFile(path)),weight,italic,license});
-    }
-  }
+  const {entries, fontFiles} = await loadPack("office");
   if (options.includeBaseFonts !== false) {
-    const base = await loadBundledFontRegistry();
+    const base = await loadPack("base");
     fontFiles.push(...base.fontFiles);
-    for (const face of base.embeddedFonts) entries.push({...face,data:Uint8Array.from(Buffer.from(face.dataUrl.split(",")[1],"base64"))});
+    entries.push(...base.entries);
   }
   return Object.assign(createFontRegistry(entries,{substitutionPolicy:"metric",...options}),{fontFiles});
 }
+
+/** One set of verified font inputs for layout, SVG, editor, PPTX, and Node raster export. */
+export async function prepareNodeFonts({pack = "base", ...options} = {}) {
+  if (pack !== "base" && pack !== "office") throw new OPFFontError("invalid-font-pack", "Choose the base or office font pack.", {pack});
+  const registry = await (pack === "base" ? loadBundledFontRegistry(options) : loadOfficeFontRegistry(options));
+  return {
+    registry,
+    manifest:BUNDLED_FONT_MANIFEST,
+    options:{
+      textMeasurement:registry.textMeasurement,
+      embeddedFonts:registry.embeddedFonts,
+      fontFiles:[...registry.fontFiles],
+      useBundledFonts:false,
+      loadSystemFonts:false,
+    },
+  };
+}

package/dist/fonts.d.ts

@@ -2,7 +2,7 @@ import type { TextMeasurement, TextStyle } from "@openpresentation/opf/compositi
 export interface FontFaceInput { data: Uint8Array; family?: string; weight?: number; italic?: boolean; postscriptName?: string; license?: string }
 export interface EmbeddedFont { family: string; weight: number; italic?: boolean; dataUrl: string; license?: string }
 export type FontCompatibility = "exact" | "metric" | "visual" | "generic";
-export interface FontResolution { requestedFamily:string; sourceFamily:string; resolvedFamily:string; requestedWeight:number; resolvedWeight:number; italic:boolean; compatibility:FontCompatibility; path?:string; source?:string; note?:string }
+export interface FontResolution { requestedFamily:string; sourceFamily:string; resolvedFamily:string; requestedWeight:number; resolvedWeight:number; italic:boolean; compatibility:FontCompatibility; fontFace?:TextStyle['fontFace']; path?:string; source?:string; note?:string }
 export interface FontRegistryOptions {
   aliases?: Record<string,string>; fallbackFamily?: string; strictGlyphs?: boolean;
   substitutionPolicy?: "none" | "metric" | "visual";
@@ -11,7 +11,7 @@ export interface FontRegistryOptions {
 export declare const FONT_COMPATIBILITY: readonly Readonly<{requestedFamily:string;substitutes:readonly string[];compatibility:"metric"|"visual";weights?:readonly number[];source?:string;note:string}>[];
 export declare const EXPERIMENTAL_FONT_CANDIDATES: readonly Readonly<{requestedFamily:string;substitute:string;source:string;note:string}>[];
 export interface FontRegistry {
-  textMeasurement: TextMeasurement;
+  textMeasurement: TextMeasurement & {outlineBounds: NonNullable<TextMeasurement['outlineBounds']>};
   clearSubstitutions(): void;
   resolveFont(style: TextStyle): FontResolution;
   readonly embeddedFonts: EmbeddedFont[];