Automate SVG Font Generation for PDF Build Pipelines

A standalone Node script using opentype.js. Same glyph walk, same 5,000 cap, same codepoint rule, same 2-decimal path precision as the browser tool.

// svg-font.mjs — node svg-font.mjs MyFont.ttf
import fs from 'node:fs';
import opentype from 'opentype.js';

const esc = s => s.replace(/[&<>"']/g, c =>
  ({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&apos;'}[c]));

const path = process.argv[2];
const font = opentype.parse(fs.readFileSync(path).buffer);
const upm = font.unitsPerEm;
const ascent  = font.ascender  ?? upm * 0.8;
const descent = font.descender ?? upm * -0.2;
const family  = font.getEnglishName('fontFamily') || 'font';
const sub     = font.getEnglishName('fontSubfamily') || 'Regular';

let body = '';
const limit = Math.min(font.glyphs.length, 5000);
for (let i = 0; i < limit; i++) {
  const g = font.glyphs.get(i);
  if (g.unicode == null && i !== 0) continue;
  const adv = g.advanceWidth ?? upm;
  const d = g.getPath(0, 0, upm).toPathData(2);
  body += i === 0
    ? `\n    <missing-glyph horiz-adv-x="${adv}" d="${d}"/>`
    : `\n    <glyph unicode="${esc(String.fromCodePoint(g.unicode))}"` +
      `${g.name ? ` glyph-name="${esc(g.name)}"` : ''}` +
      ` horiz-adv-x="${adv}" d="${d}"/>`;
}

const weight = sub.toLowerCase().includes('bold') ? 'bold' : 'normal';
fs.writeFileSync(path.replace(/\.[^.]+$/, '.svg'),
`<?xml version="1.0" standalone="no"?>
<svg xmlns="http://www.w3.org/2000/svg"><defs>
  <font id="${esc(family)}" horiz-adv-x="${upm}">
    <font-face font-family="${esc(family)}" font-weight="${weight}"
               units-per-em="${upm}" ascent="${ascent}" descent="${descent}"/>${body}
  </font>
</defs></svg>\n`);

Loop the converter over every TTF/OTF in a folder, emitting one SVG per font. Keep TTF masters in the repo so you don't need a WOFF2 decompress step in CI.

import { glob } from 'glob';
import { execFileSync } from 'node:child_process';

const fonts = await glob('src/fonts/*.{ttf,otf}');
for (const f of fonts) {
  execFileSync('node', ['svg-font.mjs', f], { stdio: 'inherit' });
}
console.log(`Converted ${fonts.length} fonts → SVG.`);

On Pro/Developer, run the exact JAD handler locally over HTTP. The font is sent only to 127.0.0.1, never to JAD's servers.

curl -sS -X POST http://127.0.0.1:9789/v1/tools/font-to-svg-font/run \
  -F 'file=@dist/fonts/Brand-Regular.subset.ttf' \
  -o dist/fonts/Brand-Regular.svg

# Inspect the no-options schema first:
curl -sS http://localhost:3000/api/v1/tools/font-to-svg-font | jq '.options'
# → []

Fail the build if a font lost glyphs (missing codepoints) or wasn't subset (oversized SVG). Cheap checks that catch the two most common PDF font defects before render.

import fs from 'node:fs';

const EXPECTED_GLYPHS = 80;   // your locked charset size
const MAX_BYTES = 60_000;     // size budget per SVG

for (const svg of fs.readdirSync('dist/fonts').filter(f => f.endsWith('.svg'))) {
  const xml = fs.readFileSync(`dist/fonts/${svg}`, 'utf8');
  const glyphs = (xml.match(/<glyph /g) || []).length;
  const bytes = Buffer.byteLength(xml);
  if (glyphs < EXPECTED_GLYPHS)
    throw new Error(`${svg}: only ${glyphs} glyphs (missing codepoints?)`);
  if (bytes > MAX_BYTES)
    throw new Error(`${svg}: ${bytes}B over budget — subset it`);
}

Skip regeneration when nothing changed. Conversion is deterministic for a fixed source + opentype.js version, so a content hash is a safe cache key.

import { createHash } from 'node:crypto';
import fs from 'node:fs';

function cacheKey(fontPath, charset) {
  const h = createHash('sha256');
  h.update(fs.readFileSync(fontPath));
  h.update(charset);
  return h.digest('hex').slice(0, 16);
}
// Store dist/fonts/<stem>.<key>.svg and reuse if the key matches.
// Pin opentype.js in package.json so path bytes don't drift.

Path output comes from opentype.js toPathData(2). An unpinned dependency can change rounding or command emission across versions, producing different SVG bytes and busting your cache. Pin the exact opentype.js version in package.json and treat a deliberate bump as a content change you re-baseline.

If a full font reaches the converter, the SVG can be hundreds of KB of uncompressed XML, and a large CJK font silently truncates at 5,000 glyphs. The size-budget CI guard catches the bloat; the glyph-count guard catches the truncation. Always subset to the document charset upstream of the converter.

Conversion exports only codepointed glyphs. If your charset relies on glyphs reached via ligature/substitution (no unicode), those won't appear and Glyphs-exported drops below the expected count. The count CI guard fails the build; fix by relying on codepointed glyphs or embedding the TTF natively for true ligatures.

The browser tool decompresses WOFF/WOFF2 transparently; a minimal Node script using only opentype.parse expects an sfnt. Either keep TTF masters in the repo, add wawoff2 (WOFF2) / pako-inflate (WOFF) to decompress first, or use the runner API which handles all four formats. The simplest CI is TTF-in.

On the free tier, files over 5 MB are rejected (Pro 50 MB, Developer 1 GB). A large unsubset source font trips this. Subset before conversion, or run on a paid tier. The pure-Node script has no such limit — it's your own opentype.js call — but you still want to subset for size and the 5,000-glyph cap.

The conversion drops kerning, ligatures, and all GPOS/GSUB. PDFs rendered from the SVG Font show raw advances and unsubstituted glyphs. If the PDF needs real shaping, embed the original TTF/OTF natively in your PDF engine instead — see the PDF pipeline integration guide.

The glyph walk uses default-axis master outlines; it does not flatten a chosen weight/width. A variable font yields one static SVG Font at its defaults. Freeze the instance you want first with the Variable Font Freezer (mind its gvar caveat) or instance with fontTools varLib.instancer in CI, then convert.

The converter walks glyphs by index 0..N, so glyph order in the SVG is the source font's glyph order, which is stable for a fixed font. Don't write CI checks that assume codepoint-sorted order — sort yourself if you need it. The order is deterministic but follows glyph index, not Unicode value.