Batch Apply Latin Filter Across Multi-Weight Font Families

Globs every weight, keeps the Latin codepoints plus .notdef, rebuilds a fresh TTF per weight. Output behaviour matches the in-browser Latin Filter exactly: TTF out, kerning/layout dropped.

// subset-latin.mjs  —  node subset-latin.mjs ./src/fonts
import fs from "node:fs";
import path from "node:path";
import opentype from "opentype.js";

const keep = new Set();
for (let c = 0x20; c <= 0x7e; c++) keep.add(c);
for (let c = 0xa0; c <= 0xff; c++) keep.add(c);

const dir = process.argv[2] ?? "./src/fonts";
for (const f of fs.readdirSync(dir).filter(n => /\.ttf$/i.test(n))) {
  const font = opentype.loadSync(path.join(dir, f));
  const glyphs = [font.glyphs.get(0)];          // .notdef
  for (let i = 1; i < font.glyphs.length; i++) {
    const g = font.glyphs.get(i);
    const us = g.unicodes?.length ? g.unicodes : [g.unicode];
    if (us.some(u => u != null && keep.has(u))) glyphs.push(g);
  }
  const out = new opentype.Font({
    familyName: font.getEnglishName("fontFamily") || f,
    styleName:  font.getEnglishName("fontSubfamily") || "Regular",
    unitsPerEm: font.unitsPerEm,
    ascender:   font.ascender,
    descender:  font.descender,
    glyphs,
  });
  const dst = path.join(dir, f.replace(/\.ttf$/i, ".latin.ttf"));
  fs.writeFileSync(dst, Buffer.from(out.toArrayBuffer()));
  console.log(`${f} -> ${path.basename(dst)}  (${glyphs.length} glyphs)`);
}

Same Latin charset, but harfbuzz keeps GSUB/GPOS so kerning and ligatures survive — and writes WOFF2 directly. Use this when the in-browser tool's dropped layout tables aren't acceptable.

#!/usr/bin/env bash
for f in ./src/fonts/*.ttf; do
  pyftsubset "$f" \
    --unicodes=U+0020-007E,U+00A0-00FF \
    --layout-features='*' \
    --flavor=woff2 \
    --output-file="${f%.ttf}.latin.woff2"
  echo "subset $f -> ${f%.ttf}.latin.woff2"
done
# Layout tables preserved; output is web-ready WOFF2.

The opentype.js path emits TTF, so add a WOFF2 step. This wraps the same wasm encoder the ttf-to-woff2 tool uses.

// after subset-latin.mjs
import { compress } from "wawoff2";   // wasm WOFF2 encoder
import fs from "node:fs";

for (const f of fs.readdirSync("./src/fonts")
                  .filter(n => /\.latin\.ttf$/i.test(n))) {
  const ttf = fs.readFileSync(`./src/fonts/${f}`);
  const woff2 = await compress(new Uint8Array(ttf));
  fs.writeFileSync(`./src/fonts/${f.replace(/\.ttf$/, ".woff2")}`, woff2);
}

One rule per weight, all sharing the family name, with the Latin unicode-range so the browser skips the file on non-Latin pages.

const weights = { 400: "Regular", 500: "Medium", 700: "Bold" };
let css = "";
for (const [w, name] of Object.entries(weights)) {
  css += `@font-face{font-family:"Brand";font-weight:${w};` +
         `font-display:swap;` +
         `src:url(/f/Brand-${name}.latin.woff2) format("woff2");` +
         `unicode-range:U+0000-00FF;}\n`;
}
fs.writeFileSync("./dist/fonts.css", css);

Prefer one HTTP call per font over installing toolchains? Pair the runner once; it executes the latin-filter job on your machine. The schema is option-free (the Latin preset is fixed).

# 1. Inspect the (option-free) schema
curl -H "Authorization: Bearer $JAD_API_KEY" \
  https://jadapps.example/api/v1/tools/latin-filter

# 2. Dispatch to your paired local runner (font stays local)
#    POST the file to the runner endpoint per the API docs:
#    127.0.0.1:9789/v1/tools/latin-filter/run
# The runner uses a layout-preserving engine where available;
# for byte-for-byte browser parity, use the opentype.js script.

If a weight has CFF (PostScript) outlines — common in .otf families — font.toArrayBuffer() can throw, exactly like the in-browser tool's message about the opentype.js writer. In a batch, wrap each file in try/catch and either skip-and-log or route that weight to pyftsubset, which handles CFF natively. Mixed TTF/OTF families are the usual trigger.

If a source file covers a non-Latin script only, the kept-glyph count is zero. The browser tool throws 'Subset would be empty'; your script should detect glyphs.length === 1 (just .notdef) and skip with a warning rather than write a degenerate font. Confirm coverage first with character-coverage-map.

Every weight built with the opentype.js script loses GPOS/GSUB. If your design system relies on kerning at display sizes, the whole family ships un-kerned and nobody notices until a headline looks off. If that's unacceptable, the entire build should use pyftsubset --layout-features='*' instead. Decide per design system, not per file.

If your 'family' is actually one variable font, the opentype.js rebuild flattens it to the default instance — you won't get distinct weights. Freeze each named instance to a static font with variable-font-freezer first, then run the batch over the frozen statics. pyftsubset can keep variations with --instancer, but that's a different workflow.

opentype.loadSync doesn't read WOFF2; decompress to TTF first (wawoff2) or feed TTF/OTF sources. Either way the opentype.js path writes TTF — add the WOFF2 compression step. This mirrors the browser tool, which accepts WOFF2 input but always returns TTF.

The script copies fontFamily/fontSubfamily from each source's name table. If a source font has a non-standard or missing name record, the rebuilt font may fall back to the filename, breaking your @font-face matching. Verify with font-metadata-extractor and override familyName/styleName explicitly if needed.

Like the browser tool, the opentype.js rebuild doesn't carry fpgm/prep/cvt, so TrueType hinting is gone. Modern macOS/iOS/Windows 10+ render outline-only and look identical; only legacy Windows GDI users see a difference. pyftsubset preserves hinting by default (--no-hinting to drop it) if you need it.

If you parallelise the batch and rely on glyph IDs being stable, note that subset glyph ordering follows source iteration order — deterministic per file but not comparable across different source fonts. For reproducible CI artifacts, sort inputs and run single-threaded, or hash outputs to detect real changes.

Each .latin.ttf is uncompressed with table padding, so a 191-glyph subset can still be 30–60 KB. Judge the family's total weight on the compressed WOFF2 artifacts, not the intermediate TTFs. The pyftsubset path skips this by writing WOFF2 directly.

A real family folder may mix .ttf, .otf, .woff, and .woff2. The opentype.js path needs TTF/OTF (and OTF may fail the writer); WOFF/WOFF2 must be decompressed first. Normalise inputs to TTF up front, or branch the glob so WOFF/WOFF2 go through a decompression step before subsetting.