hb-subset-wasm 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kyosuke Nakamura
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,168 @@
+# hb-subset-wasm
+
+HarfBuzz font subsetting compiled to WebAssembly. Optimized for Cloudflare Workers.
+
+This is an **unofficial** package that wraps HarfBuzz's subset API in a minimal, standalone WebAssembly module. It is designed to be easy to use for common font subsetting tasks.
+
+## Why this exists
+
+- **Not harfbuzzjs** — harfbuzzjs exposes a large, low-level HarfBuzz API. This package exposes only subsetting, with a small high-level API.
+- **Cloudflare Workers first** — standalone wasm with no JS glue code, no WASI, no filesystem access, no Node.js-specific imports. Works everywhere.
+- **Variable font support** — supports pinning variation axes and narrowing axis ranges.
+- **Composable** — output is a standard `Uint8Array` that can be piped into [woff2-encode-wasm](https://www.npmjs.com/package/woff2-encode-wasm) or any other tool.
+
+## Install
+
+```bash
+npm install hb-subset-wasm
+```
+
+> **Note:** This package is ESM-only.
+
+## Quick start
+
+### Cloudflare Workers
+
+```ts
+import { init, subset } from 'hb-subset-wasm';
+import wasmModule from 'hb-subset-wasm/wasm';
+
+const ready = init(wasmModule);
+
+export default {
+  async fetch(request) {
+    await ready;
+
+    const fontData = new Uint8Array(/* fetch from R2, KV, or origin */);
+    const result = await subset(fontData, {
+      text: 'The characters you need',
+    });
+
+    return new Response(result, {
+      headers: { 'Content-Type': 'font/sfnt' },
+    });
+  },
+};
+```
+
+### Node.js
+
+```ts
+import { readFileSync } from 'node:fs';
+import { init, subset } from 'hb-subset-wasm';
+
+await init(readFileSync('node_modules/hb-subset-wasm/dist/hb-subset.wasm'));
+
+const fontData = new Uint8Array(/* ... your .ttf or .otf bytes ... */);
+const result = await subset(fontData, { text: 'Hello, world!' });
+```
+
+### Browser
+
+```ts
+import { init, subset } from 'hb-subset-wasm';
+
+await init(fetch('/hb-subset.wasm'));
+
+const result = await subset(fontData, { text: 'Hello, world!' });
+```
+
+## Safety limits for untrusted input
+
+When subsetting user-supplied fonts in a service:
+
+- Enforce a request/body size limit before calling `subset()`.
+- Keep memory growth bounded. `scripts/build-wasm.sh` uses `MAXIMUM_MEMORY_BYTES` (default: `268435456`, i.e. 256MiB).
+- Apply normal service safeguards (timeouts, rate limits, concurrency limits).
+
+The Worker E2E example includes a 10MiB request-body limit and returns `413` for oversized payloads.
+
+## API
+
+### `init(source): Promise<void>`
+
+Initialize the WebAssembly module. Call once before using `subset()`.
+
+`source` accepts:
+
+| Type | Use case |
+|---|---|
+| `WebAssembly.Module` | Cloudflare Workers (pre-compiled, fastest startup) |
+| `BufferSource` | Node.js / Deno (raw .wasm bytes via `readFileSync`) |
+| `Response \| Promise<Response>` | Browser (`fetch()` response, supports streaming compilation) |
+
+### `subset(fontData, options): Promise<Uint8Array>`
+
+Subset a font. Returns the subsetted font as a `Uint8Array`.
+
+| Option | Type | Description |
+|---|---|---|
+| `text` | `string` | Characters to retain (easiest option) |
+| `unicodes` | `number[]` | Unicode codepoints to retain |
+| `glyphIds` | `number[]` | Glyph IDs to retain |
+| `retainGids` | `boolean` | Preserve original glyph IDs (don't renumber) |
+| `noHinting` | `boolean` | Remove hinting instructions (smaller output) |
+| `variationAxes` | `Record<string, number \| {min?, max?, default?}>` | Pin or narrow variation axes |
+| `passthroughTables` | `string[]` | Table tags to pass through without subsetting |
+| `dropTables` | `string[]` | Table tags to drop entirely |
+
+At least one of `text`, `unicodes`, or `glyphIds` must be provided.
+
+## Variable fonts
+
+Pin a variation axis to a fixed value (removes variability, smaller output):
+
+```ts
+const result = await subset(fontData, {
+  text: 'Hello',
+  variationAxes: { wght: 400 },
+});
+```
+
+Narrow a variation axis range:
+
+```ts
+const result = await subset(fontData, {
+  text: 'Hello',
+  variationAxes: {
+    wght: { min: 300, max: 700 },
+    wdth: { min: 75, max: 100, default: 100 },
+  },
+});
+```
+
+## Composing with WOFF2 encoding
+
+This package outputs standard TrueType/OpenType font bytes. To convert to WOFF2, pipe the output into a WOFF2 encoder:
+
+```ts
+import { readFileSync } from 'node:fs';
+import { init as initSubset, subset } from 'hb-subset-wasm';
+import { init as initWoff2, encode } from 'woff2-encode-wasm';
+
+await initSubset(readFileSync('node_modules/hb-subset-wasm/dist/hb-subset.wasm'));
+await initWoff2(readFileSync('node_modules/woff2-encode-wasm/dist/encoder.wasm'));
+
+const subsetFont = await subset(fontData, { text: 'Hello' });
+const woff2Font = await encode(subsetFont);
+```
+
+## Performance
+
+On a test machine (Apple Silicon), subsetting a small font takes approximately **0.05ms per operation**. The wasm binary is ~577KB (standalone, no JS glue).
+
+## Limitations
+
+- **WOFF2 encoding is out of scope** — use a separate package like `woff2-encode-wasm`.
+- **Single face only** — font collections (TTC) are not supported; only the first face is used.
+- **No shaping** — this package only performs subsetting, not text shaping.
+- **Axis range narrowing** — fully supported via HarfBuzz's `hb_subset_input_set_axis_range`. Behavior depends on the font's variation data.
+- **AAT features** — Apple Advanced Typography tables are not included in the build to reduce binary size.
+
+## HarfBuzz version
+
+Built against HarfBuzz 10.4.0. The HarfBuzz source is included as a git submodule under `deps/harfbuzz`.
+
+## License
+
+MIT (this package). HarfBuzz itself is licensed under the [Old MIT license](https://github.com/harfbuzz/harfbuzz/blob/main/COPYING). See [THIRD_PARTY_NOTICES](./THIRD_PARTY_NOTICES) for full details.

package/THIRD_PARTY_NOTICES

@@ -0,0 +1,48 @@
+This package includes HarfBuzz, compiled into the WebAssembly binary (dist/hb-subset.wasm).
+
+HarfBuzz is licensed under the "Old MIT" license:
+
+--------------------------------------------------------------------------------
+
+HarfBuzz is licensed under the so-called "Old MIT" license.  Details follow.
+For parts of HarfBuzz that are licensed under different licenses see individual
+files names COPYING in subdirectories where applicable.
+
+Copyright © 2010-2022  Google, Inc.
+Copyright © 2015-2020  Ebrahim Byagowi
+Copyright © 2019,2020  Facebook, Inc.
+Copyright © 2012,2015  Mozilla Foundation
+Copyright © 2011  Codethink Limited
+Copyright © 2008,2010  Nokia Corporation and/or its subsidiary(-ies)
+Copyright © 2009  Keith Stribley
+Copyright © 2011  Martin Hosken and SIL International
+Copyright © 2007  Chris Wilson
+Copyright © 2005,2006,2020,2021,2022,2023  Behdad Esfahbod
+Copyright © 2004,2007,2008,2009,2010,2013,2021,2022,2023  Red Hat, Inc.
+Copyright © 1998-2005  David Turner and Werner Lemberg
+Copyright © 2016  Igalia S.L.
+Copyright © 2022  Matthias Clasen
+Copyright © 2018,2021  Khaled Hosny
+Copyright © 2018,2019,2020  Adobe, Inc
+Copyright © 2013-2015  Alexei Podtelezhnikov
+
+For full copyright notices consult the individual files in the package.
+
+
+Permission is hereby granted, without written agreement and without
+license or royalty fees, to use, copy, modify, and distribute this
+software and its documentation for any purpose, provided that the
+above copyright notice and the following two paragraphs appear in
+all copies of this software.
+
+IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
+DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
+ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
+IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGE.
+
+THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
+BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
+ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
+PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.

package/dist/api.d.ts

@@ -0,0 +1,28 @@
+import type { SubsetOptions, WasmSource } from './types.js';
+/**
+ * Initialize the wasm module.
+ *
+ * Call once before using `subset()`. Accepts various source types:
+ *
+ * ```ts
+ * // Cloudflare Workers — pre-compiled module (fastest)
+ * import wasmModule from 'hb-subset-wasm/wasm';
+ * await init(wasmModule);
+ *
+ * // Node.js — raw bytes
+ * import { readFileSync } from 'node:fs';
+ * await init(readFileSync('node_modules/hb-subset-wasm/dist/hb-subset.wasm'));
+ *
+ * // Browser — fetch
+ * await init(fetch('/hb-subset.wasm'));
+ * ```
+ */
+export declare function init(source: WasmSource): Promise<void>;
+/**
+ * Subset a font, returning the subsetted font bytes.
+ *
+ * ```ts
+ * const result = await subset(fontBytes, { text: 'Hello, world!' });
+ * ```
+ */
+export declare function subset(fontData: Uint8Array | ArrayBuffer, options: SubsetOptions): Promise<Uint8Array>;

package/dist/api.js

@@ -0,0 +1,371 @@
+// HarfBuzz subset flag constants (from hb-subset.h)
+const HB_SUBSET_FLAGS_NO_HINTING = 0x00000001;
+const HB_SUBSET_FLAGS_RETAIN_GIDS = 0x00000002;
+const HB_SUBSET_FLAGS_NOTDEF_OUTLINE = 0x00000040;
+const ERROR_MESSAGES = {
+    1: 'Failed to create font blob',
+    2: 'Failed to create font face',
+    3: 'Font has no glyphs — invalid or corrupted font data',
+    4: 'Failed to create subset input — out of memory',
+    5: 'Subset operation failed',
+    6: 'Failed to serialize subset result',
+    7: 'Subset result is empty',
+    8: 'Failed to allocate output buffer — out of memory',
+    9: 'Failed to pin variation axis — invalid axis tag for this font',
+    10: 'Failed to set variation axis range — invalid axis tag or range',
+};
+const MAX_UNICODE_CODEPOINT = 0x10FFFF;
+const MAX_UINT32 = 0xFFFFFFFF;
+const TAG_PATTERN = /^[\x20-\x7E]{4}$/;
+let ex = null;
+let initPromise = null;
+function getRuntimeWebAssembly() {
+    const wasm = globalThis.WebAssembly;
+    if (!wasm) {
+        throw new Error('WebAssembly is not available in this runtime');
+    }
+    return wasm;
+}
+/** Wasm import stubs — the standalone module needs only these two. */
+function buildImportObject() {
+    return {
+        env: {
+            emscripten_notify_memory_growth: () => { },
+        },
+        wasi_snapshot_preview1: {
+            proc_exit(code) {
+                throw new Error(`hb-subset wasm called proc_exit(${code})`);
+            },
+        },
+    };
+}
+function isBinarySource(source) {
+    return source instanceof ArrayBuffer || ArrayBuffer.isView(source);
+}
+function isWasmModule(source, wasm) {
+    return source instanceof wasm.Module;
+}
+function hasInstance(result) {
+    return typeof result === 'object' && result !== null && 'instance' in result;
+}
+function getInstance(result) {
+    return hasInstance(result) ? result.instance : result;
+}
+function assertResponseLike(value) {
+    if (!value || typeof value !== 'object' || typeof value.arrayBuffer !== 'function') {
+        throw new TypeError('init(source) expects a WebAssembly.Module, ArrayBuffer, ArrayBufferView, Response, or Promise<Response>');
+    }
+}
+function finiteNumber(name, value) {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        throw new TypeError(`${name} must be a finite number`);
+    }
+    return value;
+}
+function integerInRange(name, value, min, max) {
+    if (typeof value !== 'number' || !Number.isInteger(value) || value < min || value > max) {
+        throw new RangeError(`${name} must be an integer in [${min}, ${max}]`);
+    }
+    return value;
+}
+function validateTag(tag, field) {
+    if (typeof tag !== 'string' || !TAG_PATTERN.test(tag)) {
+        throw new TypeError(`${field} must be exactly 4 printable ASCII characters`);
+    }
+    return tag;
+}
+/**
+ * Initialize the wasm module.
+ *
+ * Call once before using `subset()`. Accepts various source types:
+ *
+ * ```ts
+ * // Cloudflare Workers — pre-compiled module (fastest)
+ * import wasmModule from 'hb-subset-wasm/wasm';
+ * await init(wasmModule);
+ *
+ * // Node.js — raw bytes
+ * import { readFileSync } from 'node:fs';
+ * await init(readFileSync('node_modules/hb-subset-wasm/dist/hb-subset.wasm'));
+ *
+ * // Browser — fetch
+ * await init(fetch('/hb-subset.wasm'));
+ * ```
+ */
+export async function init(source) {
+    if (ex)
+        return;
+    if (initPromise)
+        return initPromise;
+    initPromise = (async () => {
+        const wasm = getRuntimeWebAssembly();
+        const imports = buildImportObject();
+        let instance;
+        if (isWasmModule(source, wasm)) {
+            // Pre-compiled module (Cloudflare Workers)
+            const instantiated = await wasm.instantiate(source, imports);
+            instance = getInstance(instantiated);
+        }
+        else if (isBinarySource(source)) {
+            // Raw bytes (Node.js, Deno)
+            const bytes = source instanceof ArrayBuffer
+                ? source
+                : source.buffer.slice(source.byteOffset, source.byteOffset + source.byteLength);
+            const instantiated = await wasm.instantiate(bytes, imports);
+            instance = getInstance(instantiated);
+        }
+        else {
+            // Response or Promise<Response> (browser fetch)
+            const response = await source;
+            assertResponseLike(response);
+            if (typeof wasm.instantiateStreaming === 'function' && typeof response.clone === 'function') {
+                try {
+                    const instantiated = await wasm.instantiateStreaming(response, imports);
+                    instance = getInstance(instantiated);
+                }
+                catch {
+                    // Fallback if content-type isn't application/wasm
+                    const buf = await response.clone().arrayBuffer();
+                    const instantiated = await wasm.instantiate(buf, imports);
+                    instance = getInstance(instantiated);
+                }
+            }
+            else {
+                const buf = await response.arrayBuffer();
+                const instantiated = await wasm.instantiate(buf, imports);
+                instance = getInstance(instantiated);
+            }
+        }
+        ex = instance.exports;
+        // STANDALONE_WASM reactors need _initialize called once
+        if (typeof ex._initialize === 'function') {
+            ex._initialize();
+        }
+    })();
+    try {
+        await initPromise;
+    }
+    catch (error) {
+        initPromise = null;
+        throw error;
+    }
+}
+function getWasm() {
+    if (!ex) {
+        throw new Error('hb-subset-wasm not initialized. Call init() first.');
+    }
+    return ex;
+}
+/** Get the current wasm memory buffer (may change after growth). */
+function buf() {
+    return getWasm().memory.buffer;
+}
+/**
+ * Encode a 4-character OpenType tag string to bytes.
+ */
+function encodeTag(tag) {
+    validateTag(tag, 'tag');
+    return [
+        tag.charCodeAt(0),
+        tag.charCodeAt(1),
+        tag.charCodeAt(2),
+        tag.charCodeAt(3),
+    ];
+}
+/**
+ * Subset a font, returning the subsetted font bytes.
+ *
+ * ```ts
+ * const result = await subset(fontBytes, { text: 'Hello, world!' });
+ * ```
+ */
+export async function subset(fontData, options) {
+    if (!options || typeof options !== 'object') {
+        throw new TypeError('options must be an object');
+    }
+    if (options.text !== undefined && typeof options.text !== 'string') {
+        throw new TypeError('text must be a string');
+    }
+    if (options.unicodes !== undefined && !Array.isArray(options.unicodes)) {
+        throw new TypeError('unicodes must be an array of integers');
+    }
+    if (options.glyphIds !== undefined && !Array.isArray(options.glyphIds)) {
+        throw new TypeError('glyphIds must be an array of integers');
+    }
+    if (options.retainGids !== undefined && typeof options.retainGids !== 'boolean') {
+        throw new TypeError('retainGids must be a boolean');
+    }
+    if (options.noHinting !== undefined && typeof options.noHinting !== 'boolean') {
+        throw new TypeError('noHinting must be a boolean');
+    }
+    if (options.passthroughTables !== undefined && !Array.isArray(options.passthroughTables)) {
+        throw new TypeError('passthroughTables must be an array of OpenType tags');
+    }
+    if (options.dropTables !== undefined && !Array.isArray(options.dropTables)) {
+        throw new TypeError('dropTables must be an array of OpenType tags');
+    }
+    if (options.variationAxes !== undefined
+        && (typeof options.variationAxes !== 'object' || options.variationAxes === null || Array.isArray(options.variationAxes))) {
+        throw new TypeError('variationAxes must be an object mapping axis tags to numbers or ranges');
+    }
+    const m = getWasm();
+    const font = fontData instanceof Uint8Array ? fontData : new Uint8Array(fontData);
+    if (font.length === 0) {
+        throw new RangeError('fontData must not be empty');
+    }
+    // Collect all unicode codepoints
+    const unicodes = [];
+    if (options.text) {
+        for (const char of options.text) {
+            const cp = char.codePointAt(0);
+            if (cp !== undefined)
+                unicodes.push(cp);
+        }
+    }
+    if (options.unicodes) {
+        options.unicodes.forEach((cp, index) => {
+            unicodes.push(integerInRange(`unicodes[${index}]`, cp, 0, MAX_UNICODE_CODEPOINT));
+        });
+    }
+    const glyphIds = (options.glyphIds ?? []).map((gid, index) => integerInRange(`glyphIds[${index}]`, gid, 0, MAX_UINT32));
+    if (unicodes.length === 0 && glyphIds.length === 0) {
+        throw new Error('At least one of text, unicodes, or glyphIds must be provided');
+    }
+    // Build flags
+    let flags = HB_SUBSET_FLAGS_NOTDEF_OUTLINE; // keep .notdef outline by default
+    if (options.retainGids)
+        flags |= HB_SUBSET_FLAGS_RETAIN_GIDS;
+    if (options.noHinting)
+        flags |= HB_SUBSET_FLAGS_NO_HINTING;
+    // Prepare variation axes
+    const pinTags = [];
+    const pinValues = [];
+    const rangeTags = [];
+    const rangeMins = [];
+    const rangeMaxs = [];
+    const rangeDefs = [];
+    if (options.variationAxes) {
+        for (const [rawTag, rawValue] of Object.entries(options.variationAxes)) {
+            const tag = validateTag(rawTag, `variationAxes key "${rawTag}"`);
+            const encoded = encodeTag(tag);
+            if (typeof rawValue === 'number') {
+                pinTags.push(encoded);
+                pinValues.push(finiteNumber(`variationAxes.${tag}`, rawValue));
+                continue;
+            }
+            if (!rawValue || typeof rawValue !== 'object' || Array.isArray(rawValue)) {
+                throw new TypeError(`variationAxes.${tag} must be a finite number or { min?, max?, default? }`);
+            }
+            const hasMin = rawValue.min !== undefined;
+            const hasMax = rawValue.max !== undefined;
+            const hasDefault = rawValue.default !== undefined;
+            if (!hasMin && !hasMax && !hasDefault) {
+                throw new TypeError(`variationAxes.${tag} must specify at least one of min, max, or default`);
+            }
+            const min = hasMin ? finiteNumber(`variationAxes.${tag}.min`, rawValue.min) : Number.NaN;
+            const max = hasMax ? finiteNumber(`variationAxes.${tag}.max`, rawValue.max) : Number.NaN;
+            const def = hasDefault ? finiteNumber(`variationAxes.${tag}.default`, rawValue.default) : Number.NaN;
+            if (!Number.isNaN(min) && !Number.isNaN(max) && min > max) {
+                throw new RangeError(`variationAxes.${tag}.min must be <= variationAxes.${tag}.max`);
+            }
+            if (!Number.isNaN(def) && !Number.isNaN(min) && def < min) {
+                throw new RangeError(`variationAxes.${tag}.default must be >= variationAxes.${tag}.min`);
+            }
+            if (!Number.isNaN(def) && !Number.isNaN(max) && def > max) {
+                throw new RangeError(`variationAxes.${tag}.default must be <= variationAxes.${tag}.max`);
+            }
+            rangeTags.push(encoded);
+            rangeMins.push(min);
+            rangeMaxs.push(max);
+            rangeDefs.push(def);
+        }
+    }
+    // Prepare tag arrays
+    const passthroughTags = (options.passthroughTables ?? []).map((tag, index) => encodeTag(validateTag(tag, `passthroughTables[${index}]`)));
+    const dropTags = (options.dropTables ?? []).map((tag, index) => encodeTag(validateTag(tag, `dropTables[${index}]`)));
+    // --- Allocate wasm memory ---
+    const allocations = [];
+    function walloc(size) {
+        if (size === 0)
+            return 0;
+        const ptr = m.malloc(size);
+        if (!ptr)
+            throw new Error('wasm malloc failed');
+        allocations.push(ptr);
+        return ptr;
+    }
+    function writeTags(tags, ptr) {
+        const view = new Uint8Array(buf(), ptr, tags.length * 4);
+        for (let i = 0; i < tags.length; i++) {
+            view[i * 4] = tags[i][0];
+            view[i * 4 + 1] = tags[i][1];
+            view[i * 4 + 2] = tags[i][2];
+            view[i * 4 + 3] = tags[i][3];
+        }
+    }
+    try {
+        // Font data
+        const fontPtr = walloc(font.length);
+        new Uint8Array(buf()).set(font, fontPtr);
+        // Unicodes array (uint32)
+        const unicodesPtr = walloc(unicodes.length * 4);
+        new Uint32Array(buf(), unicodesPtr, unicodes.length).set(unicodes);
+        // Glyph IDs array (uint32)
+        const glyphIdsPtr = walloc(glyphIds.length * 4);
+        if (glyphIds.length > 0) {
+            new Uint32Array(buf(), glyphIdsPtr, glyphIds.length).set(glyphIds);
+        }
+        // Passthrough tags (4 bytes each)
+        const passthroughPtr = walloc(passthroughTags.length * 4);
+        if (passthroughTags.length > 0)
+            writeTags(passthroughTags, passthroughPtr);
+        // Drop tags
+        const dropPtr = walloc(dropTags.length * 4);
+        if (dropTags.length > 0)
+            writeTags(dropTags, dropPtr);
+        // Pin axis tags + values
+        const pinTagsPtr = walloc(pinTags.length * 4);
+        const pinValuesPtr = walloc(pinTags.length * 4);
+        if (pinTags.length > 0) {
+            writeTags(pinTags, pinTagsPtr);
+            new Float32Array(buf(), pinValuesPtr, pinTags.length).set(pinValues);
+        }
+        // Range axis tags + min/max/def
+        const rangeTagsPtr = walloc(rangeTags.length * 4);
+        const rangeMinsPtr = walloc(rangeTags.length * 4);
+        const rangeMaxsPtr = walloc(rangeTags.length * 4);
+        const rangeDefsPtr = walloc(rangeTags.length * 4);
+        if (rangeTags.length > 0) {
+            writeTags(rangeTags, rangeTagsPtr);
+            new Float32Array(buf(), rangeMinsPtr, rangeTags.length).set(rangeMins);
+            new Float32Array(buf(), rangeMaxsPtr, rangeTags.length).set(rangeMaxs);
+            new Float32Array(buf(), rangeDefsPtr, rangeTags.length).set(rangeDefs);
+        }
+        // Output pointers (pointer to pointer + size)
+        const outDataPtrPtr = walloc(4);
+        const outSizePtr = walloc(4);
+        // Call subset
+        const result = m.hb_wrapper_subset(fontPtr, font.length, unicodesPtr, unicodes.length, glyphIdsPtr, glyphIds.length, flags, passthroughPtr, passthroughTags.length, dropPtr, dropTags.length, pinTagsPtr, pinValuesPtr, pinTags.length, rangeTagsPtr, rangeMinsPtr, rangeMaxsPtr, rangeDefsPtr, rangeTags.length, outDataPtrPtr, outSizePtr);
+        if (result !== 0) {
+            const msg = ERROR_MESSAGES[result] || `Unknown error (code ${result})`;
+            throw new Error(`Subset failed: ${msg}`);
+        }
+        // Read output — re-read buffer in case memory grew during subset
+        const outDataPtr = new Uint32Array(buf(), outDataPtrPtr, 1)[0];
+        const outSize = new Uint32Array(buf(), outSizePtr, 1)[0];
+        if (!outDataPtr || !outSize) {
+            throw new Error('Subset produced empty output');
+        }
+        // Copy result to a new Uint8Array before freeing
+        const output = new Uint8Array(outSize);
+        output.set(new Uint8Array(buf(), outDataPtr, outSize));
+        // Free the output buffer allocated by C
+        m.hb_wrapper_free(outDataPtr);
+        return output;
+    }
+    finally {
+        for (const ptr of allocations) {
+            m.free(ptr);
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { init, subset } from './api.js';
+export type { WasmSource, SubsetOptions } from './types.js';

package/dist/index.js

@@ -0,0 +1 @@
+export { init, subset } from './api.js';

package/dist/types.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Wasm source for initialization.
+ *
+ * - `WebAssembly.Module` — pre-compiled module (Cloudflare Workers)
+ * - `ArrayBuffer | ArrayBufferView` — raw .wasm bytes (Node.js, Deno)
+ * - `Response | Promise<Response>` — fetch() response (browser)
+ */
+export interface ResponseLike {
+    arrayBuffer(): Promise<ArrayBuffer>;
+    clone?(): ResponseLike;
+}
+type RuntimeWebAssemblyModule = typeof globalThis extends {
+    WebAssembly: {
+        Module: infer ModuleType;
+    };
+} ? ModuleType : never;
+type RuntimeResponse = typeof globalThis extends {
+    Response: infer ResponseType;
+} ? ResponseType : ResponseLike;
+export type WasmSource = RuntimeWebAssemblyModule | ArrayBuffer | ArrayBufferView | RuntimeResponse | Promise<RuntimeResponse>;
+/**
+ * Options for subsetting a font.
+ *
+ * At least one of `text`, `unicodes`, or `glyphIds` must be provided.
+ */
+export interface SubsetOptions {
+    /** Characters to retain — the simplest way to subset. */
+    text?: string;
+    /** Unicode codepoints to retain. */
+    unicodes?: number[];
+    /** Glyph IDs to retain. */
+    glyphIds?: number[];
+    /** If true, glyph IDs in the output font are preserved (not renumbered). */
+    retainGids?: boolean;
+    /** If true, hinting instructions are removed (smaller output). */
+    noHinting?: boolean;
+    /**
+     * Variation axes to pin or constrain.
+     *
+     * - A number pins the axis to a fixed value (removes variability).
+     * - An object `{ min?, max?, default? }` narrows the axis range.
+     *
+     * Example:
+     * ```ts
+     * variationAxes: {
+     *   wght: 400,                    // pin weight to 400
+     *   wdth: { min: 75, max: 100 }   // narrow width range
+     * }
+     * ```
+     */
+    variationAxes?: Record<string, number | {
+        min?: number;
+        max?: number;
+        default?: number;
+    }>;
+    /**
+     * Table tags to pass through without subsetting.
+     * Example: `['GSUB', 'GPOS']`
+     */
+    passthroughTables?: string[];
+    /**
+     * Table tags to drop entirely from the output.
+     * Example: `['DSIG']`
+     */
+    dropTables?: string[];
+}
+export {};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/wasm.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Pre-compiled WebAssembly module for hb-subset.
+ *
+ * In Cloudflare Workers, import this directly:
+ * ```ts
+ * import wasmModule from 'hb-subset-wasm/wasm';
+ * await init(wasmModule);
+ * ```
+ */
+type RuntimeWasmModule =
+  typeof globalThis extends { WebAssembly: { Module: infer ModuleType } }
+    ? ModuleType
+    : unknown;
+
+declare const wasmModule: RuntimeWasmModule;
+export default wasmModule;

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "hb-subset-wasm",
+  "version": "0.2.0",
+  "description": "HarfBuzz font subsetting compiled to WebAssembly — optimized for Cloudflare Workers",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./wasm": {
+      "types": "./dist/wasm.d.ts",
+      "default": "./dist/hb-subset.wasm"
+    }
+  },
+  "files": [
+    "dist",
+    "THIRD_PARTY_NOTICES"
+  ],
+  "scripts": {
+    "build:wasm": "bash scripts/build-wasm.sh",
+    "build:ts": "tsc && cp src/wasm.d.ts dist/wasm.d.ts",
+    "build": "rm -rf dist && npm run build:wasm && npm run build:ts",
+    "test": "node --test test/*.test.js",
+    "pretest": "npm run build",
+    "prepublishOnly": "npm test",
+    "bench": "node bench/bench.js"
+  },
+  "keywords": [
+    "harfbuzz",
+    "font",
+    "subset",
+    "wasm",
+    "webassembly",
+    "cloudflare-workers",
+    "font-subsetting",
+    "variable-fonts",
+    "opentype"
+  ],
+  "author": "Kyosuke Nakamura",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kyosuke/hb-subset-wasm.git"
+  },
+  "bugs": {
+    "url": "https://github.com/kyosuke/hb-subset-wasm/issues"
+  },
+  "homepage": "https://github.com/kyosuke/hb-subset-wasm#readme",
+  "devDependencies": {
+    "typescript": "^6.0.2"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}