Automate Name Table Cleanup in Your Build Pipeline

This reproduces the tool's behaviour in Python: keep only (3, 1, 0x409) records for nameIDs 1, 2, 4, 5, 6, 13, 14, output a TTF, and raise if nothing survives.

from fontTools.ttLib import TTFont

KEEP_IDS = {1, 2, 4, 5, 6, 13, 14}

def clean_name_table(in_path, out_path):
    f = TTFont(in_path)            # handles .ttf/.otf; for woff set flavor None on save
    name = f["name"]
    kept = [r for r in name.names
            if r.platformID == 3 and r.platEncID == 1
            and r.langID == 0x409 and r.nameID in KEEP_IDS]
    if not kept:
        raise SystemExit("No Windows English name records to keep")
    name.names = kept
    f.flavor = None               # output uncompressed sfnt (TTF)
    f.save(out_path)

clean_name_table("Brand-Regular.ttf", "Brand-Regular.cleaned.ttf")

After cleaning, re-open and assert the identity records survived. Use this as a CI gate.

// node, using fontkit
const fontkit = require('fontkit');
const font = fontkit.openSync('Brand-Regular.cleaned.ttf');

if (!font.familyName) throw new Error('family (nameID 1) missing');
if (!font.fullName)   throw new Error('full name (nameID 4) missing');
console.log('OK:', font.familyName, '/', font.fullName);

Walk every weight, clean, then WOFF2-compress. Mirrors the tool's TTF-only output plus a separate compression step.

#!/usr/bin/env bash
set -euo pipefail
for f in src/fonts/*.ttf; do
  stem=$(basename "$f" .ttf)
  python clean_name_table.py "$f" "build/${stem}.cleaned.ttf"
  # compress last
  python -c "from fontTools.ttLib import woff2; \
    woff2.compress('build/${stem}.cleaned.ttf', 'public/fonts/${stem}.woff2')"
done

Skip fonts already reduced to the 7 keep-list records so re-runs are no-ops and CI stays fast.

from fontTools.ttLib import TTFont
KEEP_IDS = {1, 2, 4, 5, 6, 13, 14}

def already_clean(path):
    name = TTFont(path)["name"].names
    return all(r.platformID == 3 and r.platEncID == 1
               and r.langID == 0x409 and r.nameID in KEEP_IDS
               for r in name) and len(name) <= len(KEEP_IDS)

# in the loop: if already_clean(f): continue

Confirm the tool takes a file and no options before wiring the runner payload. Useful as a one-time check in setup.

curl -s -H "Authorization: Bearer $JAD_API_KEY" \
  https://jadapps.example/api/v1/tools/name-table-cleaner | jq '.input.options'

# -> []  (empty: the tool has no configurable fields)
# Execution is runner-backed; POST /run returns 400 + pairing steps.

The /api/v1/tools/name-table-cleaner/run endpoint is upload-free. JAD's API/MCP layer never receives file content — every font tool executes through your paired @jadapps/runner locally. A POST with content returns 400 with pairing instructions. Build your CI around the runner, not around uploading bytes to JAD.

Whether you feed it a WOFF2 or a TTF, the output is an uncompressed .cleaned.ttf. There is no compression step inside the tool. In CI you must add WOFF2 compression afterwards (fontTools woff2.compress or the ttf-to-woff2 runner step), or you'll ship a larger file than you started with.

If a source font carries only Mac-platform or non-English records, filtering leaves zero records and the tool raises No Windows English name records to keep. Your CI should treat this as a hard failure, not a skip — silently shipping the original would leave the bloat, and silently shipping a nameless font would break matching. Fix the source font (add a (3, 1, 0x409) record) and re-run.

The live tool decompresses WOFF/WOFF2 automatically. A naive fontTools port that opens a .woff2 directly works (fontTools reads it) but you must set font.flavor = None before saving to emit a TTF rather than re-wrapping as WOFF2. Forgetting this produces a WOFF2 output, not the TTF the tool would give you.

The live tool does not recompute head.checkSumAdjustment after editing. fontTools' save() does recompute it. So a byte-diff between the tool's output and your fontTools port will show a different head checksum even when the name table is identical. Both render fine; if you assert byte-equality in tests, exclude the head checksum or normalise both through a validator.

nameIDs 256+ (variable-font axis and instance labels) are not in the keep-list, so cleaning a variable font drops them. The fvar axes still work, but design tools that read the labels show blanks. If your CI ships variable fonts meant to be edited downstream, exclude them from the name-table-clean step or add 256+ to your port's keep-list deliberately.

On the free tier the font batch limit is 1 file at a time and 5 MB per file. For a multi-weight CI run you'll want Pro (20 files, 50 MB) or higher. A faithful local fontTools port has no such limit — it runs on your machine — which is another reason teams often port the logic for unattended builds.

Running the clean step twice on the same font is safe: the second pass finds the same 7 records, keeps them, and drops nothing. The metrics show Records dropped == 0 and ~0% size reduction. Use the idempotency guard above to skip the work entirely and keep CI fast.