@overpunch/vf-clamp 2.1.4

package/README.md

@@ -0,0 +1,372 @@
+# vf-clamp
+
+[![npm](https://img.shields.io/npm/v/%40overpunch%2Fvf-clamp.svg)](https://www.npmjs.com/package/@overpunch/vf-clamp) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![part of liiift type-tools](https://img.shields.io/badge/liiift-type--tools-blueviolet)](https://github.com/over-punch/type-tools)
+
+The delivery layer for per-purchase micro-VFs. Restrict a variable font's axis ranges to exactly the named instances a customer bought — like CSS `clamp()` for design space.
+
+```
+npm install @overpunch/vf-clamp
+```
+
+**[Interactive demo at vfclamp.com →](https://vfclamp.com)**
+
+![Clamp to the styles a customer bought: a weight axis showing a full family's nine named instances (Thin–Black), and a clamped output that keeps only Light–Bold (wght 300–700) as a variable range while the masters outside the purchase are removed](https://raw.githubusercontent.com/over-punch/vf-clamp/main/assets/design-space.png?v=2)
+
+---
+
+## What it does
+
+Takes a variable font (TTF, OTF, WOFF, or WOFF2) and produces one restricted variant per configured output. Each variant is a valid variable font with unused axis ranges trimmed, gvar deltas pruned, and the name table updated to reflect the restricted instance range. No Python required — powered by [fonttools](https://github.com/fonttools/fonttools) compiled to WASM via [Pyodide](https://pyodide.org).
+
+---
+
+## For foundries
+
+A variable font is usually all-or-nothing: customers buy the whole family to get one, or they buy statics and lose interpolation. vf-clamp adds the tier in between — a variable font scoped to exactly the named instances a customer purchased, generated and delivered at checkout.
+
+**Purchase → Clamp → Deliver.** A customer buys two or more adjacent styles; your store POSTs the order to the [REST API](#rest-api); a scoped VF comes back in seconds with its name table rewritten to the purchased range, in the format the licence calls for.
+
+Why it matters:
+
+- **A new revenue tier** — two adjacent styles become a variable purchase, not just two statics. Price a ladder: two-style VF → subfamily → full family.
+- **Licence containment** — a full VF ships every master, so customers can reach weights they never paid for. A clamped VF physically contains only the purchased range — nothing outside the licence is left in the file to leak.
+- **Branded, traceable files** — the name table (family, full name, PostScript name) is rewritten to the purchased range, so every delivered file is identifiable as that specific order.
+- **Lighter files for the web** — a site that uses only Medium–Black shouldn't ship Thin–Light deadweight. Clamping prunes masters outside the licensed range: variation across what they bought, at a smaller download.
+- **Sell bespoke cuts** — pin an axis to a coordinate that was never a named instance (a custom optical size or width) and sell that exact cut, without shipping it in the retail family.
+- **Ready for `opsz` demand** — browsers drive the optical-size axis automatically via `font-optical-sizing: auto`, keyed off the rendered point size. Delivering `opsz` clamped to a usable range keeps files small as that axis matters more.
+
+The npm package, CLI, and editor plugins all share the same axis-constraint model, so the same delivery logic runs in your build pipeline, your storefront, or a designer's font editor.
+
+**Real numbers** — Inter (wght 100–900) clamped to a Text weight range (400–700), same WOFF2 format so the delta is pure clamping:
+
+| Font | Source TTF | Full WOFF2 | Text-clamped WOFF2 |
+|---|---|---|---|
+| Inter | 843 KB | 337 KB | **243 KB** — −28% vs full WOFF2 |
+
+Pinning an axis outright (e.g. a fixed width or optical size) removes its masters entirely and saves more.
+
+---
+
+## Usage
+
+### Inspect a font first
+
+```ts
+import { getInstances } from '@overpunch/vf-clamp'
+import { readFile } from 'fs/promises'
+
+const font = await readFile('MyFont-VF.ttf')
+const { axes, instances } = await getInstances(font)
+
+// axes:     [{ tag: 'wght', minimum: 100, default: 400, maximum: 900, name: 'Weight' }, ...]
+// instances:[{ name: 'Regular', coordinates: { wght: 400 } }, ...]
+```
+
+Use the named instances to figure out what to clamp — adjacent instances naturally define the bounds for each output.
+
+### Clamp from named instances
+
+```ts
+import { clampFont } from '@overpunch/vf-clamp'
+import { readFile, writeFile } from 'fs/promises'
+
+const source = await readFile('Omnes-VF.ttf')
+
+const results = await clampFont(source, {
+  outputs: [
+    // one VF spanning the full weight range for Condensed
+    {
+      name: 'Condensed',
+      instances: ['Condensed Thin', 'Condensed Black'],
+    },
+    // one VF for a narrower weight slice of SemiCondensed
+    {
+      name: 'SemiCondensed Text',
+      instances: ['SemiCondensed Light', 'SemiCondensed Bold'],
+    },
+  ],
+})
+
+for (const result of results) {
+  await writeFile(`Omnes-${result.name}-VF.ttf`, result.buffer)
+}
+```
+
+### Clamp with explicit axis constraints
+
+```ts
+const results = await clampFont(source, {
+  outputs: [
+    // Pin wdth to 75 — axis is removed from the output font
+    { name: 'Condensed', axes: { wdth: 75 } },
+
+    // Restrict wdth to a range — axis stays variable within [87.5, 100]
+    { name: 'SemiCondensed', axes: { wdth: { min: 87.5, max: 100 } } },
+  ],
+})
+```
+
+### Mix instances and explicit axes
+
+```ts
+const results = await clampFont(source, {
+  format: 'woff2',
+  outputs: [
+    {
+      name: 'Condensed Text',
+      instances: ['Condensed Light', 'Condensed Bold'],
+      // Clamp opsz independently of the named instance range
+      axes: { opsz: { min: 8, max: 24 } },
+    },
+  ],
+})
+
+// result.buffer is a valid WOFF2 file — Brotli-compressed
+await writeFile('Omnes-Condensed-Text-VF.woff2', results[0].buffer)
+```
+
+---
+
+## Axis value types
+
+| Value | Effect |
+|---|---|
+| `number` | Pin the axis to that value — axis is locked and removed from the output |
+| `{ min, max }` | Restrict to a range — axis stays variable within those bounds |
+| `null` | Keep the full original range — same as omitting the axis entirely |
+| *(omitted)* | Keep the full original range — axis is unchanged |
+
+---
+
+## Verifying output
+
+Clamping is inspectable — read the result back with `getInstances` and the fvar table reflects the restricted range. Clamping Inter (wght 100–900, 9 instances) to a Text weight range:
+
+```ts
+const [text] = await clampFont(source, {
+  outputs: [{ name: 'Text', axes: { wght: { min: 400, max: 700 } } }],
+})
+
+const { axes, instances } = await getInstances(text.buffer)
+// axes:      wght 400 → 700          (was 100 → 900)
+// instances: Regular, Medium, SemiBold, Bold   (the 5 outside the range are gone)
+```
+
+The output is a valid variable font you can drop into a build or hand to a customer: masters outside the range are physically removed, so nothing past the licence is reachable in the file.
+
+---
+
+## API
+
+### `getInstances(input)`
+
+```ts
+async function getInstances(
+  input: ArrayBuffer | Uint8Array | Buffer
+): Promise<FontInstancesResult>
+
+interface FontInstancesResult {
+  axes: AxisDefinition[]
+  instances: FontInstance[]
+}
+```
+
+Reads the fvar table and returns every axis and named instance defined in the font. Use this to discover what can be clamped before building an output config.
+
+### `clampFont(input, options)`
+
+```ts
+async function clampFont(
+  input: ArrayBuffer | Uint8Array | Buffer,
+  options: ClampOptions
+): Promise<ClampResult[]>
+```
+
+**Parameters**
+
+- `input` — Source variable font binary (TTF, OTF, WOFF, or WOFF2).
+- `options.outputs` — Array of `OutputConfig` entries, one per output variant.
+- `options.format` — `'ttf'` (default), `'otf'`, `'woff'`, or `'woff2'`.
+- `options.normalizeWeightAxis` — When `true`, remaps the wght axis minimum to 100 so that CSS `font-weight: 100` reaches the lightest weight. Useful for fonts whose design space starts above wght 100 (e.g. 250). Defaults to `false`.
+
+**Returns**
+
+Array of `ClampResult` in the same order as `options.outputs`:
+
+```ts
+interface ClampResult {
+  name: string       // matches OutputConfig.name (or auto-derived instance range)
+  buffer: Uint8Array // restricted font binary
+  format: OutputFormat
+}
+```
+
+### `convertToWoff2(input)`
+
+```ts
+async function convertToWoff2(
+  input: Uint8Array | Buffer
+): Promise<Uint8Array>
+```
+
+Standalone WOFF2 encoder. Wraps the same Brotli-based pipeline used internally by `clampFont`. Useful for converting any TTF/OTF to WOFF2 without clamping.
+
+### `convertToWoff(input)`
+
+```ts
+async function convertToWoff(
+  input: Uint8Array | Buffer
+): Promise<Uint8Array>
+```
+
+Standalone WOFF encoder. Wraps the same zlib-based pipeline used internally by `clampFont`. Useful for converting any TTF/OTF to WOFF without clamping.
+
+### `compactName(first, last)`
+
+```ts
+function compactName(first: string, last: string): string
+```
+
+Produces a compact display name from the first and last selected instance names. Strips shared leading prefix and trailing suffix tokens, joins differing parts with a hyphen.
+
+```ts
+compactName('Inter Light', 'Inter Bold')         // → 'Inter Light-Bold'
+compactName('Condensed Thin', 'Condensed Black') // → 'Condensed Thin-Black'
+compactName('Regular', 'Regular')                // → 'Regular'
+```
+
+---
+
+## Types
+
+```ts
+type AxisValue = number | AxisRange | null
+
+interface AxisRange {
+  min: number
+  max: number
+}
+
+interface OutputConfig {
+  name?: string           // label for this output — written into the name table
+  instances?: string[]    // named instances to hull; hull derived automatically
+  axes?: Record<string, AxisValue>  // explicit axis constraints; override hull per-tag
+}
+
+interface ClampOptions {
+  outputs: OutputConfig[]
+  format?: 'ttf' | 'otf' | 'woff' | 'woff2'  // defaults to 'ttf'
+  normalizeWeightAxis?: boolean                 // remap wght min to 100 for CSS compatibility
+}
+
+interface ClampResult {
+  name: string
+  buffer: Uint8Array
+  format: OutputFormat
+}
+
+interface AxisDefinition {
+  tag: string
+  name: string
+  minimum: number
+  default: number
+  maximum: number
+}
+
+interface FontInstance {
+  name: string
+  coordinates: Record<string, number>
+}
+
+interface FontInstancesResult {
+  axes: AxisDefinition[]
+  instances: FontInstance[]
+}
+
+// Deprecated alias — use OutputConfig
+type SubfamilyConfig = OutputConfig
+```
+
+---
+
+## Notes
+
+- **Pyodide cold start**: first call initialises the Python WASM runtime (~10–20 s on first use per process). Subsequent calls in the same process reuse the singleton — warm calls are fast (~1–2 s).
+- **Input format**: TTF, OTF, WOFF, and WOFF2 are all accepted as input.
+- **Outputs are processed sequentially** — Pyodide is single-threaded.
+- **Name table patching**: each output font's family name, full name, and PostScript name are updated to reflect the output's name.
+- **Next.js**: add `@overpunch/vf-clamp` to `serverExternalPackages` in `next.config.ts` to prevent webpack bundling the Pyodide runtime.
+- **Vite / other bundlers**: externalise `@overpunch/vf-clamp` and run it server-side or at build time, so the multi-MB Pyodide runtime isn't shipped to the browser.
+
+---
+
+## REST API
+
+The delivery layer: wire vf-clamp into a storefront so a purchase event becomes a delivered file. vfclamp.com exposes hosted endpoints — one to read a font's instances, one to clamp and return scoped fonts by URL. Useful for server-side workflows where the font is fetched by URL. Contact [hello@liiift.studio](mailto:hello@liiift.studio) to request an API key.
+
+```
+POST https://vfclamp.com/api/clamp
+X-API-Key: <your-key>
+Content-Type: application/json
+
+{
+  "fontUrl": "https://cdn.example.com/MyFont-VF.ttf",
+  "format": "woff2",
+  "outputs": [
+    { "name": "Text", "instances": ["Light", "Bold"] },
+    { "name": "Condensed", "axes": { "wdth": 75 } }
+  ]
+}
+// → { results: [{ name, data, format, size }] }
+
+POST https://vfclamp.com/api/instances
+X-API-Key: <your-key>
+
+{ "fontUrl": "https://cdn.example.com/MyFont-VF.ttf" }
+// → { axes: [...], instances: [...] }
+```
+
+**Performance & limits.** The hosted endpoints keep the runtime warm, so a typical clamp returns in ~1–2 s (a cold instance adds the one-time ~10–20 s Pyodide init). Rate limits, concurrency, and uptime depend on your API plan — ask when you request a key.
+
+---
+
+## Running at scale
+
+Pyodide is single-threaded and warms up once per process (~10–20 s cold, then ~1–2 s per call). In a storefront, **don't clamp inside the request handler** and don't drive one instance from parallel requests — serialise through a warm worker, and scale out with a pool of processes:
+
+```ts
+import PQueue from 'p-queue'
+import { clampFont } from '@overpunch/vf-clamp'
+
+// one warm engine, requests queued — the checkout response isn't blocked on the clamp
+const queue = new PQueue({ concurrency: 1 }) // the engine is single-threaded
+
+export function enqueueClamp(source, options) {
+  return queue.add(() => clampFont(source, options))
+}
+```
+
+For higher throughput, run **N worker processes** (each with its own warm Pyodide) behind a job queue or round-robin — concurrency scales with processes, not threads — or offload entirely to the [hosted REST API](#rest-api).
+
+---
+
+## Integrations
+
+vf-clamp is available as a CLI and as native plugins for Glyphs.app, RoboFont, and VS Code — all using the same axis-constraint model as the npm package.
+
+| Integration | Distribution |
+|---|---|
+| [vf-clamp-cli](https://github.com/over-punch/vf-clamp-cli) | `npm install -g @overpunch/vf-clamp-cli` |
+| [vf-clamp-glyphs](https://github.com/over-punch/vf-clamp-glyphs) | `.glyphsPlugin` download |
+| [vf-clamp-robofont](https://github.com/over-punch/vf-clamp-robofont) | `.roboFontExt` download |
+| [vf-clamp-vscode](https://github.com/over-punch/vf-clamp-vscode) | `.vsix` download / VS Code Marketplace |
+
+The CLI in action — inspect a font, then clamp it:
+
+![vf-clamp CLI: inspecting Inter's axes and 9 named instances, then clamping Regular–Bold to a Text WOFF2](https://raw.githubusercontent.com/over-punch/vf-clamp-cli/main/assets/demo.gif?v=1)
+
+---
+
+## License
+
+MIT — [Liiift Studio](https://liiift.studio)

package/dist/index.cjs

@@ -0,0 +1,287 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const N=require("node:module");var g=typeof document<"u"?document.currentScript:null;const O=N.createRequire(typeof document>"u"?require("url").pathToFileURL(__filename).href:g&&g.tagName.toUpperCase()==="SCRIPT"&&g.src||new URL("index.cjs",document.baseURI).href),{preparePyodide:l,PyodideFile:u}=O("@web-alchemy/fonttools/src/pyodide.js");let h=null;async function j(){return h||(h=l().then(e=>e.runPythonAsync(`
+from fontTools.ttLib import TTFont
+
+def vf_convert_flavor(file_options):
+    font = TTFont(file_options['input-file'])
+    font.flavor = file_options['flavor']
+    font.save(file_options['output-file'])
+
+vf_convert_flavor
+`))),h}async function V(e,o){const a=await l(),t=new u({pyodide:a}),n=new u({pyodide:a});try{await t.upload(e);const i=new Map([["input-file",t.filename],["output-file",n.filename],["flavor",o]]);return(await j())(i),n.download()}finally{try{t.delete()}catch{}try{n.delete()}catch{}}}async function I(e){return V(e,"woff")}async function D(e){return V(e,"woff2")}let w=null;async function L(){return w||(w=l().then(e=>e.runPythonAsync(`
+import json
+from fontTools.ttLib import TTFont
+
+def get_instances_fn(input_file):
+    font = TTFont(input_file)
+
+    if 'fvar' not in font:
+        return json.dumps({'axes': [], 'instances': []})
+
+    fvar = font['fvar']
+    name_table = font['name']
+
+    axes = [
+        {
+            'tag': ax.axisTag,
+            'name': name_table.getDebugName(ax.axisNameID) or ax.axisTag,
+            'minimum': ax.minValue,
+            'default': ax.defaultValue,
+            'maximum': ax.maxValue,
+        }
+        for ax in fvar.axes
+    ]
+
+    instances = [
+        {
+            'name': name_table.getDebugName(inst.subfamilyNameID) or f'Instance {i}',
+            'coordinates': dict(inst.coordinates),
+        }
+        for i, inst in enumerate(fvar.instances)
+    ]
+
+    return json.dumps({'axes': axes, 'instances': instances})
+
+get_instances_fn
+`))),w}async function R(e){const o=await l(),a=e instanceof ArrayBuffer?new Uint8Array(e):e,t=new u({pyodide:o});try{await t.upload(a);const i=(await L())(t.filename);return JSON.parse(i)}finally{try{t.delete()}catch{}}}let v=null,y=null,A=null,T=null,b=null;async function M(){return v||(v=l().then(e=>e.runPythonAsync(`
+from fontTools import ttLib
+
+def patch_font_names_fn(file_options):
+    font = ttLib.TTFont(file_options['input-file'])
+    name_table = font['name']
+    family_name  = file_options['family-name']
+    ps_name      = file_options['postscript-name']
+
+    existing_ids = {r.nameID for r in name_table.names}
+
+    # nameID 1 = Family, 4 = Full name, 6 = PostScript name
+    # nameID 2 = Subfamily — reset to 'Regular' so the restricted file does not
+    #            collide with the source font's Subfamily in OS font caches.
+    # nameID 3 = Unique ID — regenerate so it is distinct from the source font.
+    # nameID 16 = Preferred family (update only if present)
+    # nameID 25 = Variations PS Name Prefix (update only if present)
+    #
+    # head.fontRevision is a Fixed value (e.g. 1.000). Fall back to '1.000' if
+    # the head table is unreadable.
+    try:
+        version = '%.3f' % font['head'].fontRevision
+    except Exception:
+        version = '1.000'
+    unique_id = '%s;%s;%s' % (version, ps_name, family_name)
+
+    updates = {
+        1: family_name,
+        2: 'Regular',
+        3: unique_id,
+        4: family_name,
+        6: ps_name,
+    }
+    if 16 in existing_ids:
+        updates[16] = family_name
+    if 25 in existing_ids:
+        updates[25] = ps_name
+
+    for record in name_table.names:
+        if record.nameID not in updates:
+            continue
+        value = updates[record.nameID]
+        if record.platformID == 3:
+            record.string = value.encode('utf-16-be')
+        elif record.platformID == 1:
+            try:
+                record.string = value.encode('mac_roman')
+            except Exception:
+                record.string = value.encode('ascii', errors='replace')
+
+    font.save(file_options['output-file'])
+
+patch_font_names_fn
+`))),v}async function U(){return y||(y=l().then(e=>e.runPythonAsync(`
+from fontTools.ttLib import TTFont
+from fontTools.varLib import instancer
+import json
+
+def vf_clamp_instantiate(file_options, axes_json):
+    font = TTFont(file_options['input-file'])
+    axes_spec = json.loads(axes_json)
+
+    limits = {}
+    axes_by_tag = {ax.axisTag: ax for ax in font['fvar'].axes}
+
+    for tag, spec in axes_spec.items():
+        if spec is None:
+            continue
+        ax = axes_by_tag.get(tag)
+        if isinstance(spec, list):
+            mn = float(spec[0])
+            mx = float(spec[1])
+            default = ax.defaultValue if ax else (mn + mx) / 2
+            default = max(mn, min(mx, default))
+            limits[tag] = instancer.AxisTriple(mn, default, mx)
+        else:
+            limits[tag] = float(spec)
+
+    partial = instancer.instantiateVariableFont(font, limits)
+    partial.save(file_options['output-file'])
+
+vf_clamp_instantiate
+`))),y}async function k(){return A||(A=l().then(e=>e.runPythonAsync(`
+from fontTools.ttLib import TTFont
+
+def vf_clamp_normalize_wght(file_options, new_min_str):
+    new_min = float(new_min_str)
+    font = TTFont(file_options['input-file'])
+
+    if 'fvar' not in font:
+        font.save(file_options['output-file'])
+        return
+
+    wght_axis = next((ax for ax in font['fvar'].axes if ax.axisTag == 'wght'), None)
+
+    # Only normalize when the font's minimum is above the target (e.g. 251 > 100)
+    if wght_axis is None or wght_axis.minValue <= new_min:
+        font.save(file_options['output-file'])
+        return
+
+    old_min = wght_axis.minValue
+    default = wght_axis.defaultValue
+    scale = (default - new_min) / (default - old_min)
+
+    def remap(v):
+        return (default + (v - default) * scale) if v < default else v
+
+    # Update fvar axis minimum
+    wght_axis.minValue = new_min
+
+    # Update named instance wght coordinates
+    for inst in font['fvar'].instances:
+        if 'wght' in inst.coordinates:
+            inst.coordinates['wght'] = remap(inst.coordinates['wght'])
+
+    # Update STAT axis values that reference wght
+    if 'STAT' in font and font['STAT'].table.AxisValueArray:
+        stat = font['STAT'].table
+        wght_idx = None
+        if hasattr(stat, 'DesignAxisRecord') and stat.DesignAxisRecord:
+            for i, ax in enumerate(stat.DesignAxisRecord.Axis):
+                if ax.AxisTag == 'wght':
+                    wght_idx = i
+                    break
+        if wght_idx is not None:
+            for av in stat.AxisValueArray.AxisValue:
+                fmt = av.Format
+                if fmt in (1, 3) and av.AxisIndex == wght_idx:
+                    av.Value = remap(av.Value)
+                    if fmt == 3:
+                        av.LinkedValue = remap(av.LinkedValue)
+                elif fmt == 2 and av.AxisIndex == wght_idx:
+                    av.NominalValue = remap(av.NominalValue)
+                    av.RangeMinValue = remap(av.RangeMinValue)
+                    av.RangeMaxValue = remap(av.RangeMaxValue)
+
+    font.save(file_options['output-file'])
+
+vf_clamp_normalize_wght
+`))),A}async function C(){return T||(T=l().then(e=>e.runPythonAsync(`
+from fontTools.ttLib import TTFont
+
+def vf_clamp_prune_stat(file_options):
+    font = TTFont(file_options['input-file'])
+
+    if 'STAT' not in font or 'fvar' not in font:
+        font.save(file_options['output-file'])
+        return
+
+    stat = font['STAT'].table
+    if not getattr(stat, 'DesignAxisRecord', None) or not stat.DesignAxisRecord.Axis:
+        font.save(file_options['output-file'])
+        return
+
+    fvar_tags = {ax.axisTag for ax in font['fvar'].axes}
+    stat_axes = list(stat.DesignAxisRecord.Axis)
+
+    # Map old STAT AxisIndex -> new index after pruning STAT axes that vanish from fvar.
+    surviving_indices = [i for i, ax in enumerate(stat_axes) if ax.AxisTag in fvar_tags]
+    if len(surviving_indices) == len(stat_axes):
+        # No axes removed — nothing to prune.
+        font.save(file_options['output-file'])
+        return
+    old_to_new = {old: new for new, old in enumerate(surviving_indices)}
+
+    # Rewrite the DesignAxisRecord.Axis list to surviving axes only.
+    stat.DesignAxisRecord.Axis = [stat_axes[i] for i in surviving_indices]
+    if hasattr(stat, 'DesignAxisCount'):
+        stat.DesignAxisCount = len(stat.DesignAxisRecord.Axis)
+
+    # Prune AxisValueArray entries that reference removed axes.
+    if stat.AxisValueArray and stat.AxisValueArray.AxisValue:
+        kept = []
+        for av in stat.AxisValueArray.AxisValue:
+            fmt = av.Format
+            if fmt in (1, 2, 3):
+                if av.AxisIndex not in old_to_new:
+                    continue  # references a removed axis
+                av.AxisIndex = old_to_new[av.AxisIndex]
+                kept.append(av)
+            elif fmt == 4:
+                inner = list(getattr(av, 'AxisValueRecord', []) or [])
+                if any(rec.AxisIndex not in old_to_new for rec in inner):
+                    continue  # whole record dies if any inner ref is dead
+                for rec in inner:
+                    rec.AxisIndex = old_to_new[rec.AxisIndex]
+                kept.append(av)
+            else:
+                # Unknown format — keep as-is to be safe.
+                kept.append(av)
+        stat.AxisValueArray.AxisValue = kept
+        if hasattr(stat, 'AxisValueCount'):
+            stat.AxisValueCount = len(kept)
+
+    font.save(file_options['output-file'])
+
+vf_clamp_prune_stat
+`))),T}async function $(){return b||(b=l().then(e=>e.runPythonAsync(`
+from fontTools.ttLib import TTFont
+
+def vf_clamp_update_os2(file_options):
+    font = TTFont(file_options['input-file'])
+
+    if 'fvar' not in font:
+        font.save(file_options['output-file'])
+        return
+
+    wght_axis = next((ax for ax in font['fvar'].axes if ax.axisTag == 'wght'), None)
+    if wght_axis is None:
+        font.save(file_options['output-file'])
+        return
+
+    new_default = wght_axis.defaultValue
+    # OS/2.usWeightClass valid range is 1..1000.
+    weight_class = int(round(max(1, min(1000, new_default))))
+
+    if 'OS/2' in font:
+        os2 = font['OS/2']
+        os2.usWeightClass = weight_class
+        # fsSelection bits: 0x20 = BOLD, 0x40 = REGULAR.
+        # Mirror the convention: REGULAR when usWeightClass < 600, BOLD when >= 700.
+        fs = os2.fsSelection
+        fs &= ~(0x20 | 0x40)
+        if weight_class >= 700:
+            fs |= 0x20  # BOLD
+        elif weight_class < 600:
+            fs |= 0x40  # REGULAR
+        os2.fsSelection = fs
+
+    if 'head' in font:
+        head = font['head']
+        # macStyle bit 0 = bold.
+        ms = head.macStyle
+        if weight_class >= 700:
+            ms |= 0x01
+        else:
+            ms &= ~0x01
+        head.macStyle = ms
+
+    font.save(file_options['output-file'])
+
+vf_clamp_update_os2
+`))),b}function z(e){return e.replace(/[^A-Za-z0-9 -]/g,"").trim().split(/\s+/).join("-").replace(/^-+|-+$/g,"").slice(0,63)}async function W(e,o){if(!o)return e;const a=await l(),t=new u({pyodide:a}),n=new u({pyodide:a});try{const i=z(o);await t.upload(e);const r=new Map([["input-file",t.filename],["output-file",n.filename],["family-name",o],["postscript-name",i]]);return(await M())(r),n.download()}catch(i){return console.warn(`vf-clamp: name table patching failed for "${o}" — returning unpatched buffer`,i),e}finally{try{t.delete()}catch{}try{n.delete()}catch{}}}function q(e){return typeof e=="number"?e:e===null?null:[e.min,e.max]}async function B(e,o){const a=await l(),t=new u({pyodide:a}),n=new u({pyodide:a});try{await t.upload(e);const i=new Map([["input-file",t.filename],["output-file",n.filename]]);return(await U())(i,JSON.stringify(o)),n.download()}finally{try{t.delete()}catch{}try{n.delete()}catch{}}}async function E(e){const o=await l(),a=new u({pyodide:o}),t=new u({pyodide:o});try{await a.upload(e);const n=new Map([["input-file",a.filename],["output-file",t.filename]]);return(await C())(n),t.download()}catch(n){return console.warn("vf-clamp: STAT prune failed — returning unpruned buffer",n),e}finally{try{a.delete()}catch{}try{t.delete()}catch{}}}async function G(e){const o=await l(),a=new u({pyodide:o}),t=new u({pyodide:o});try{await a.upload(e);const n=new Map([["input-file",a.filename],["output-file",t.filename]]);return(await $())(n),t.download()}catch(n){return console.warn("vf-clamp: OS/2 + macStyle update failed — returning original buffer",n),e}finally{try{a.delete()}catch{}try{t.delete()}catch{}}}async function J(e,o){const a=await l(),t=new u({pyodide:a}),n=new u({pyodide:a});try{await t.upload(e);const i=new Map([["input-file",t.filename],["output-file",n.filename]]);return(await k())(i,String(o)),n.download()}catch(i){return console.warn("vf-clamp: wght normalisation failed — returning unnormalised buffer",i),e}finally{try{t.delete()}catch{}try{n.delete()}catch{}}}function H(e,o){const a=new Map(o.map(i=>[i.name,i])),t={};for(const i of e){const r=a.get(i);if(!r)throw new Error(`Named instance "${i}" not found in font`);for(const[s,m]of Object.entries(r.coordinates))t[s]?(t[s].min=Math.min(t[s].min,m),t[s].max=Math.max(t[s].max,m)):t[s]={min:m,max:m}}const n={};for(const[i,{min:r,max:s}]of Object.entries(t))n[i]=r===s?r:{min:r,max:s};return n}async function Z(e,o){var s,m;if(o.outputs.length===0)return[];const a=e instanceof ArrayBuffer?new Uint8Array(e):e,t=o.format??"ttf";let n=[],i=[];if(o.outputs.some(f=>{var p;return(p=f.instances)==null?void 0:p.length})){const f=await R(a);n=f.instances,i=f.axes}const r=[];for(const f of o.outputs){let p={};(s=f.instances)!=null&&s.length&&(p=H(f.instances,n)),f.axes&&(p={...p,...f.axes});for(const d of i){const x=p[d.tag];if(x!=null&&typeof x=="object"){const _=x;if(d.default<_.min||d.default>_.max){const P=Math.max(_.min,Math.min(_.max,d.default));console.warn(`vf-clamp: axis "${d.tag}" default (${d.default}) is outside restricted range [${_.min}, ${_.max}] — will be clamped to ${P}`)}}}const F={};for(const[d,x]of Object.entries(p))x!==null&&(F[d]=q(x));const S=f.name??((m=f.instances)!=null&&m.length?f.instances.length===1?f.instances[0]:`${f.instances[0]}-${f.instances[f.instances.length-1]}`:"output");let c=await B(a,F);c=await E(c),o.normalizeWeightAxis&&(c=await J(c,100)),c=await G(c),c=await W(c,S),t==="woff2"?c=await D(c):t==="woff"&&(c=await I(c)),r.push({name:S,buffer:c,format:t})}return r}function K(e,o){if(e===o)return e;const a=e.split(" "),t=o.split(" ");let n=0;for(;n<a.length&&n<t.length&&a[n]===t[n];)n++;let i=0;for(;i<a.length-n&&i<t.length-n&&a[a.length-1-i]===t[t.length-1-i];)i++;const r=a.slice(0,n).join(" "),s=a.slice(n,a.length-(i||0)).join(" "),m=t.slice(n,t.length-(i||0)).join(" "),f=i>0?a.slice(a.length-i).join(" "):"",p=s&&m?`${s}-${m}`:s||m;return[r,p,f].filter(Boolean).join(" ")}exports.clampFont=Z;exports.compactName=K;exports.convertToWoff=I;exports.convertToWoff2=D;exports.getInstances=R;