@glissade/core 0.11.0 → 0.12.0-pre.0

package/dist/font-ingest.js

@@ -0,0 +1,282 @@
+import { t as parseCmap } from "./cmap.js";
+//#region src/fontIngest.ts
+/**
+* @glissade/core/font-ingest — the font INGESTION front door (DESIGN.md §3.6).
+*
+* This is the heavy, EXPORT/prepare-path-only sibling of the light, embed-safe
+* `fontRegistry.ts`. It owns the byte work that must never reach the runtime
+* document or the browser bundle:
+*
+*   - magic-byte sniffing (ttf / otf / ttc → straight to Skia; woff/woff2 →
+*     decoded in-process to a plain sfnt),
+*   - STATIC variable-axis instancing (a fixed axis tuple → ONE static sfnt,
+*     content-hashed so identical inputs yield byte-identical output), and
+*   - eager `parseCmap` so `registerFont` returns the covered code points and a
+*     build-time `covers(text)` predicate.
+*
+* The single heavy dependency — `subset-font` (a wasm hb-subset wrapper that
+* also decodes woff2 via `fontverter`) — is reached ONLY through a dynamic
+* `import()` inside this module, which lives on its own tsdown entry
+* (`@glissade/core/font-ingest`). `core/index.ts` never imports it, so the
+* decoder + instancer tree-shake completely out of the embed (asserted by the
+* §4.4 leak-guard in scripts/check-size.mjs).
+*
+* Determinism: woff2 → sfnt and axis instancing run ONCE here, at ingest time,
+* never inside evaluate(); the result is a content-hashed static sfnt with a
+* stable identity. No new field flows through FontSpec/DisplayList, so the
+* evaluate() byte output is unchanged.
+*/
+const MAGIC = {
+	/** 0x00010000 (TrueType) */ ttf1: 65536,
+	/** 'true' */ trueTag: 1953658213,
+	/** 'OTTO' */ otto: 1330926671,
+	/** 'ttcf' */ ttcf: 1953784678,
+	/** 'wOFF' */ woff: 2001684038,
+	/** 'wOF2' */ woff2: 2001684018
+};
+function asUint8(src) {
+	return src instanceof Uint8Array ? src : new Uint8Array(src);
+}
+/** Sniff the leading 4 bytes; throws on input that is not a recognized font. */
+function sniffFontFormat(src) {
+	const u8 = asUint8(src);
+	if (u8.byteLength < 4) throw new FontIngestError("input is too short to be a font (need ≥ 4 magic bytes)");
+	const t = (u8[0] << 24 | u8[1] << 16 | u8[2] << 8 | u8[3]) >>> 0;
+	switch (t) {
+		case MAGIC.ttf1:
+		case MAGIC.trueTag: return "truetype";
+		case MAGIC.otto: return "opentype";
+		case MAGIC.ttcf: return "collection";
+		case MAGIC.woff: return "woff";
+		case MAGIC.woff2: return "woff2";
+		default: throw new FontIngestError(`unrecognized font magic 0x${t.toString(16).padStart(8, "0")} — expected ttf/otf/ttc/woff/woff2`);
+	}
+}
+var FontIngestError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "FontIngestError";
+	}
+};
+/** FNV-1a (32-bit) over the bytes → 8-hex-char content hash (DESIGN §3.5 family). */
+function fnv1a(bytes) {
+	let h = 2166136261;
+	for (let i = 0; i < bytes.length; i++) {
+		h ^= bytes[i];
+		h = h + ((h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24)) >>> 0;
+	}
+	return h.toString(16).padStart(8, "0");
+}
+function codePointsOf(text) {
+	const out = [];
+	for (const ch of text) {
+		const cp = ch.codePointAt(0);
+		if (cp !== void 0) out.push(cp);
+	}
+	return out;
+}
+let subsetFontPromise;
+async function loadSubsetFont() {
+	subsetFontPromise ??= import("subset-font").then((m) => m.default ?? m, (err) => {
+		throw new FontIngestError(`font ingestion needs the optional 'subset-font' dependency for woff2 decode / axis instancing — install it. (${String(err?.message ?? err)})`);
+	});
+	return subsetFontPromise;
+}
+/**
+* Build the "retain every code point" string from a font's own cmap — used to
+* run hb-subset purely as a woff2 DECODER / variable-axis INSTANCER without
+* dropping a single glyph (subsetting is the DEFERRED feature). We feed back
+* exactly the code points the source already covers.
+*/
+function retainAllText(coverage) {
+	let s = "";
+	for (const cp of coverage) s += String.fromCodePoint(cp);
+	return s;
+}
+/**
+* Ingest one face: sniff → (woff2 decode) → (instance at `axes`) → a static
+* sfnt + content hash + coverage. The heavy path (woff2 / instancing) runs
+* hb-subset; a plain ttf/otf with no axes skips it entirely (zero-dep fast
+* path), keeping the common case off the wasm boundary.
+*/
+async function ingestFont(init) {
+	const sourceFormat = sniffFontFormat(init.src);
+	const input = asUint8(init.src);
+	const weight = init.weight ?? 400;
+	const style = init.style ?? "normal";
+	const fallback = init.fallback ? [...init.fallback] : [];
+	const needsDecode = sourceFormat === "woff" || sourceFormat === "woff2";
+	const needsInstance = init.axes !== void 0 && Object.keys(init.axes).length > 0;
+	let bytes;
+	if (!needsDecode && !needsInstance) bytes = input;
+	else {
+		const subsetFont = await loadSubsetFont();
+		let decoded = input;
+		if (needsDecode) decoded = await subsetFont(input, retainAllText(parseCmap(input)), { targetFormat: "sfnt" });
+		if (needsInstance) {
+			const coverage = parseCmap(decoded);
+			decoded = await subsetFont(decoded, retainAllText(coverage), {
+				targetFormat: "sfnt",
+				variationAxes: init.axes
+			});
+		}
+		bytes = decoded;
+	}
+	const coverage = parseCmap(bytes);
+	const hash = fnv1a(bytes);
+	return {
+		family: init.family,
+		weight,
+		style,
+		bytes,
+		sourceFormat,
+		hash,
+		coverage,
+		fallback,
+		covers(text) {
+			return codePointsOf(text).every((cp) => coverage.has(cp));
+		},
+		missing(text) {
+			const miss = /* @__PURE__ */ new Set();
+			for (const cp of codePointsOf(text)) if (!coverage.has(cp)) miss.add(cp);
+			return [...miss].sort((a, b) => a - b);
+		}
+	};
+}
+/**
+* `registerFont(...)` — the merged front door. Ingests `init` and records it in
+* `store` (the in-process registry the render path consumes). Returns the
+* ingested face (bytes + coverage + `covers()`); the caller decides whether to
+* persist the static sfnt to disk (content-hashed url) and/or feed Skia.
+*/
+async function registerFont(init, store) {
+	const result = await ingestFont(init);
+	const face = {
+		...result,
+		faceRef(url) {
+			return {
+				url,
+				...result.weight !== 400 ? { weight: result.weight } : {},
+				...result.style !== "normal" ? { style: result.style } : {}
+			};
+		}
+	};
+	store?.add(face);
+	return face;
+}
+/**
+* A tiny in-process store the export/prepare path fills via `registerFont` and
+* the renderer drains. Groups faces by family and remembers each family's
+* declared fallback chain — the same shape `buildFontRegistry` consumes, so the
+* programmatic and document-driven paths converge on one registry.
+*/
+var FontStore = class {
+	byFamily = /* @__PURE__ */ new Map();
+	fallbacks = /* @__PURE__ */ new Map();
+	add(face) {
+		const list = this.byFamily.get(face.family) ?? [];
+		list.push(face);
+		this.byFamily.set(face.family, list);
+		if (face.fallback.length > 0) this.fallbacks.set(face.family, [...face.fallback]);
+	}
+	families() {
+		return [...this.byFamily.keys()];
+	}
+	facesOf(family) {
+		return this.byFamily.get(family) ?? [];
+	}
+	fallbackOf(family) {
+		return this.fallbacks.get(family) ?? [];
+	}
+	/** Every ingested face across every family (the renderer registers these). */
+	all() {
+		const out = [];
+		for (const list of this.byFamily.values()) out.push(...list);
+		return out;
+	}
+};
+function font(family) {
+	const sources = [];
+	const fallback = [];
+	let weightList;
+	let axes;
+	let variable = false;
+	const api = {
+		src(path, opts) {
+			sources.push({
+				path,
+				...opts?.weight !== void 0 ? { weight: opts.weight } : {},
+				...opts?.style !== void 0 ? { style: opts.style } : {}
+			});
+			return api;
+		},
+		bytes(data, opts) {
+			sources.push({
+				bytes: data,
+				...opts?.weight !== void 0 ? { weight: opts.weight } : {},
+				...opts?.style !== void 0 ? { style: opts.style } : {}
+			});
+			return api;
+		},
+		weights(ws) {
+			weightList = [...ws];
+			return api;
+		},
+		fallback(families) {
+			fallback.push(...families);
+			return api;
+		},
+		variable() {
+			variable = true;
+			return api;
+		},
+		axis(tag, value) {
+			(axes ??= {})[tag] = value;
+			return api;
+		},
+		build() {
+			let resolved = sources;
+			if (weightList && sources.length === 1 && sources[0].weight === void 0) {
+				const base = sources[0];
+				resolved = weightList.map((w) => ({
+					...base,
+					weight: w
+				}));
+			}
+			return {
+				family,
+				sources: resolved,
+				fallback,
+				variable,
+				...axes !== void 0 ? { axes } : {}
+			};
+		}
+	};
+	return api;
+}
+/**
+* Ingest a whole `FontPlan` into `store`. `read` resolves a source path to bytes
+* (the I/O seam — the CLI reads files, a bundler plugin could fetch). Every
+* source becomes one ingested face under the plan's family; the family fallback
+* is attached to the first face so the store records it once.
+*/
+async function buildFontPlan(plan, read, store) {
+	const out = [];
+	for (let i = 0; i < plan.sources.length; i++) {
+		const entry = plan.sources[i];
+		const src = entry.bytes ?? (entry.path !== void 0 ? await read(entry.path) : void 0);
+		if (src === void 0) throw new FontIngestError(`font('${plan.family}') source #${i} has neither a path nor bytes`);
+		const face = await registerFont({
+			family: plan.family,
+			src,
+			...entry.weight !== void 0 ? { weight: entry.weight } : {},
+			...entry.style !== void 0 ? { style: entry.style } : {},
+			...plan.axes !== void 0 ? { axes: plan.axes } : {},
+			...i === 0 && plan.fallback.length > 0 ? { fallback: plan.fallback } : {}
+		}, store);
+		out.push(face);
+	}
+	return out;
+}
+//#endregion
+export { FontIngestError, FontStore, buildFontPlan, font, ingestFont, registerFont, sniffFontFormat };

package/dist/index.d.ts

@@ -1,4 +1,7 @@
-import { $ as validateTrack, A as GainEnvelope, At as getValueType, B as emitDevWarning, C as resolveTweenTarget, Ct as UnknownValueTypeError, D as ChildEntry, Dt as Vec2, E as AudioClip, Et as ValueTypeInferenceError, F as TimelineValidationError, Ft as registerValueType, G as TrackValidationError, H as Key, I as audioOffsetSamples, It as stringType, J as resolveEaseDerivative, K as key, L as compileTimeline, Lt as vec2ArcType, M as Marker, Mt as numberType, N as Timeline, Nt as paintType, O as CompiledTimeline, Ot as booleanType, P as TimelineInit, Pt as pathType, Q as track, R as isDurationEditable, Rt as vec2Equals, S as isEditableNodeId, St as PathValue, T as AssetRef, Tt as ValueTypeId, U as KeyOpts, V as setDevWarning, W as Track, X as springTo, Y as sampleTrack, Z as stagger, _ as setSidecarTrack, _t as ColorStop, a as SidecarOrphan, at as springEasing, b as TweenTarget, bt as Paint, c as SidecarVersionError, ct as DEFAULT_EASE, d as emptySidecar, dt as UnknownEasingError, et as velocityAt, f as hashKeys, ft as cubicBezier, g as normalizeEditedKeys, gt as namedEasing, h as migrateSidecar, ht as easings, i as SidecarDocV1, it as spring, j as Json, jt as inferValueType, k as FontFaceRef, kt as colorType, l as assignKeyIds, lt as EaseSpec, m as mergeSidecarDetailed, mt as easingDerivatives, n as OrphanReason, nt as SpringConfig, o as SidecarTimelineEntry, ot as springEasingDerivative, p as mergeSidecar, pt as cubicBezierDerivative, q as resolveEase, r as SidecarDoc, rt as SpringEase, s as SidecarTrackEntry, st as springPresets, t as MergeResult, tt as RetargetSpring, u as deleteSidecarTrack, ut as EasingFn, v as TARGET_PATH, vt as GradientInterpolation, w as targetNodeId, wt as ValueType, x as UnresolvableTargetError, xt as PathContour, y as TargetCarrier, yt as HandoffKind, z as DevWarning, zt as vec2Type } from "./sidecar.js";
+import { $ as easingDerivatives, A as getValueType, B as RetargetSpring, C as UnknownValueTypeError, D as Vec2, E as ValueTypeInferenceError, F as registerValueType, G as springEasingDerivative, H as SpringEase, I as stringType, J as EaseSpec, K as springPresets, L as vec2ArcType, M as numberType, N as paintType, O as booleanType, P as pathType, Q as cubicBezierDerivative, R as vec2Equals, S as PathValue, T as ValueTypeId, U as spring, V as SpringConfig, W as springEasing, X as UnknownEasingError, Y as EasingFn, Z as cubicBezier, _ as MeshInterpolation, a as key, b as Paint, c as sampleTrack, d as track, et as easings, f as validateTrack, g as HandoffKind, h as GradientInterpolation, i as TrackValidationError, j as inferValueType, k as colorType, l as springTo, m as ColorStop, n as KeyOpts, o as resolveEase, p as velocityAt, q as DEFAULT_EASE, r as Track, s as resolveEaseDerivative, t as Key, tt as namedEasing, u as stagger, v as MeshPaint, w as ValueType, x as PathContour, y as MeshPoint, z as vec2Type } from "./track.js";
+import { a as isEditableNodeId, i as UnresolvableTargetError, n as TargetCarrier, o as resolveTweenTarget, r as TweenTarget, s as targetNodeId, t as TARGET_PATH } from "./targetRef.js";
+import { _ as setDevWarning, a as FontFaceRef, c as Marker, d as TimelineValidationError, f as audioOffsetSamples, g as emitDevWarning, h as DevWarning, i as CompiledTimeline, l as Timeline, m as isDurationEditable, n as AudioClip, o as GainEnvelope, p as compileTimeline, r as ChildEntry, s as Json, t as AssetRef, u as TimelineInit } from "./timeline.js";
+import { _ as setSidecarTrack, a as SidecarOrphan, c as SidecarVersionError, d as emptySidecar, f as hashKeys, g as normalizeEditedKeys, h as migrateSidecar, i as SidecarDocV1, l as assignKeyIds, m as mergeSidecarDetailed, n as OrphanReason, o as SidecarTimelineEntry, p as mergeSidecar, r as SidecarDoc, s as SidecarTrackEntry, t as MergeResult, u as deleteSidecarTrack } from "./sidecar.js";
 
 //#region src/signal.d.ts
 
@@ -357,4 +360,4 @@ interface CheckpointedSim {
 }
 declare function bakeCheckpointed<W, S = W>(cfg: CheckpointedBakeConfig<W, S>): CheckpointedSim;
 //#endregion
-export { type AssetRef, type AudioClip, type BakeConfig, BakeError, type BindTarget, type BindableSignal, type BoundTimeline, type CheckpointedBakeConfig, type CheckpointedSim, type ChildEntry, CircularDependencyError, ColorParseError, type ColorStop, type CompiledTimeline, type CoverageReport, type CurveSampler, DEFAULT_EASE, type DevWarning, type EaseSpec, type EasingFn, type Equals, type FontFaceRef, type FontMode, type FontRegistry, type FontUsage, FontValidationError, type GainEnvelope, type GradientInterpolation, type HandoffKind, type Json, type Key, type KeyOpts, type Marker, type MergeResult, type MissingGlyphs, type OkLab, type OrphanReason, type Paint, type PathContour, type PathValue, type Playhead, type Position, PositionError, type ReadonlySignal, type ResolvedFace, type RetargetSpring, type Rgba, type Rng, type Scheduler, type SidecarDoc, type SidecarDocV1, type SidecarOrphan, type SidecarTimelineEntry, type SidecarTrackEntry, SidecarVersionError, type Signal, type SignalOptions, type SpringConfig, type SpringEase, TARGET_PATH, type TargetCarrier, type Timeline, type TimelineBuilder, type TimelineInit, TimelineValidationError, type Track, TrackValidationError, type TweenOpts, type TweenTarget, UnboundTargetError, UnknownEasingError, UnknownValueTypeError, UnresolvableTargetError, type ValidateFontsOptions, type ValueType, type ValueTypeId, ValueTypeInferenceError, type Vec2, type Vec2Signal, WriteDuringEvaluationError, assignKeyIds, audioOffsetSamples, bake, bakeCheckpointed, batch, beginReadPhase, bindTimeline, booleanType, buildFontRegistry, buildTimeline, colorType, compileTimeline, computed, createPlayhead, cubicBezier, cubicBezierDerivative, deleteSidecarTrack, easingDerivatives, easings, emitDevWarning, emptySidecar, endReadPhase, evaluateAt, formatColor, getTimelineCallbacks, getValueType, hashKeys, inReadPhase, inferValueType, isDurationEditable, isEditableNodeId, isExemptFamily, key, lerpColor, mergeSidecar, mergeSidecarDetailed, migrateSidecar, namedEasing, normalizeEditedKeys, numberType, oklabToRgba, paintType, parseCmap, parseColor, pathType, random, registerValueType, resolveEase, resolveEaseDerivative, resolveTweenTarget, rgbaToOklab, sampleTrack, setDevWarning, setScheduler, setSidecarTrack, signal, spring, springEasing, springEasingDerivative, springPresets, springTo, stagger, stringType, synchronousScheduler, targetNodeId, timeline, track, untracked, validateFonts, validateTrack, vec2ArcType, vec2Equals, vec2Signal, vec2Type, velocityAt };
+export { type AssetRef, type AudioClip, type BakeConfig, BakeError, type BindTarget, type BindableSignal, type BoundTimeline, type CheckpointedBakeConfig, type CheckpointedSim, type ChildEntry, CircularDependencyError, ColorParseError, type ColorStop, type CompiledTimeline, type CoverageReport, type CurveSampler, DEFAULT_EASE, type DevWarning, type EaseSpec, type EasingFn, type Equals, type FontFaceRef, type FontMode, type FontRegistry, type FontUsage, FontValidationError, type GainEnvelope, type GradientInterpolation, type HandoffKind, type Json, type Key, type KeyOpts, type Marker, type MergeResult, type MeshInterpolation, type MeshPaint, type MeshPoint, type MissingGlyphs, type OkLab, type OrphanReason, type Paint, type PathContour, type PathValue, type Playhead, type Position, PositionError, type ReadonlySignal, type ResolvedFace, type RetargetSpring, type Rgba, type Rng, type Scheduler, type SidecarDoc, type SidecarDocV1, type SidecarOrphan, type SidecarTimelineEntry, type SidecarTrackEntry, SidecarVersionError, type Signal, type SignalOptions, type SpringConfig, type SpringEase, TARGET_PATH, type TargetCarrier, type Timeline, type TimelineBuilder, type TimelineInit, TimelineValidationError, type Track, TrackValidationError, type TweenOpts, type TweenTarget, UnboundTargetError, UnknownEasingError, UnknownValueTypeError, UnresolvableTargetError, type ValidateFontsOptions, type ValueType, type ValueTypeId, ValueTypeInferenceError, type Vec2, type Vec2Signal, WriteDuringEvaluationError, assignKeyIds, audioOffsetSamples, bake, bakeCheckpointed, batch, beginReadPhase, bindTimeline, booleanType, buildFontRegistry, buildTimeline, colorType, compileTimeline, computed, createPlayhead, cubicBezier, cubicBezierDerivative, deleteSidecarTrack, easingDerivatives, easings, emitDevWarning, emptySidecar, endReadPhase, evaluateAt, formatColor, getTimelineCallbacks, getValueType, hashKeys, inReadPhase, inferValueType, isDurationEditable, isEditableNodeId, isExemptFamily, key, lerpColor, mergeSidecar, mergeSidecarDetailed, migrateSidecar, namedEasing, normalizeEditedKeys, numberType, oklabToRgba, paintType, parseCmap, parseColor, pathType, random, registerValueType, resolveEase, resolveEaseDerivative, resolveTweenTarget, rgbaToOklab, sampleTrack, setDevWarning, setScheduler, setSidecarTrack, signal, spring, springEasing, springEasingDerivative, springPresets, springTo, stagger, stringType, synchronousScheduler, targetNodeId, timeline, track, untracked, validateFonts, validateTrack, vec2ArcType, vec2Equals, vec2Signal, vec2Type, velocityAt };

package/dist/index.js

@@ -1,4 +1,6 @@
-import { $ as vec2ArcType, A as velocityAt, B as easings, C as resolveEase, D as stagger, E as springTo, F as DEFAULT_EASE, G as colorType, H as UnknownValueTypeError, I as UnknownEasingError, J as numberType, K as getValueType, L as cubicBezier, M as springEasing, N as springEasingDerivative, O as track, P as springPresets, Q as stringType, R as cubicBezierDerivative, S as key, T as sampleTrack, U as ValueTypeInferenceError, V as namedEasing, W as booleanType, X as pathType, Y as paintType, Z as registerValueType, _ as audioOffsetSamples, a as hashKeys, at as formatColor, b as timeline$1, c as migrateSidecar, ct as parseColor, d as TARGET_PATH, et as vec2Equals, f as UnresolvableTargetError, g as TimelineValidationError, h as targetNodeId, i as emptySidecar, it as ColorParseError, j as spring, k as validateTrack, l as normalizeEditedKeys, lt as rgbaToOklab, m as resolveTweenTarget, n as assignKeyIds, nt as emitDevWarning, o as mergeSidecar, ot as lerpColor, p as isEditableNodeId, q as inferValueType, r as deleteSidecarTrack, rt as setDevWarning, s as mergeSidecarDetailed, st as oklabToRgba, t as SidecarVersionError, tt as vec2Type, u as setSidecarTrack, v as compileTimeline, w as resolveEaseDerivative, x as TrackValidationError, y as isDurationEditable, z as easingDerivatives } from "./sidecar.js";
+import { A as ColorParseError, B as springEasingDerivative, C as paintType, D as vec2ArcType, E as stringType, F as rgbaToOklab, G as cubicBezierDerivative, H as DEFAULT_EASE, I as emitDevWarning, J as namedEasing, K as easingDerivatives, L as setDevWarning, M as lerpColor, N as oklabToRgba, O as vec2Equals, P as parseColor, R as spring, S as numberType, T as registerValueType, U as UnknownEasingError, V as springPresets, W as cubicBezier, _ as ValueTypeInferenceError, a as targetNodeId, b as getValueType, c as resolveEase, d as springTo, f as stagger, g as UnknownValueTypeError, h as velocityAt, i as resolveTweenTarget, j as formatColor, k as vec2Type, l as resolveEaseDerivative, m as validateTrack, n as UnresolvableTargetError, o as TrackValidationError, p as track, q as easings, r as isEditableNodeId, s as key, t as TARGET_PATH, u as sampleTrack, v as booleanType, w as pathType, x as inferValueType, y as colorType, z as springEasing } from "./targetRef.js";
+import { t as parseCmap } from "./cmap.js";
+import { a as hashKeys, c as migrateSidecar, d as TimelineValidationError, f as audioOffsetSamples, h as timeline$1, i as emptySidecar, l as normalizeEditedKeys, m as isDurationEditable, n as assignKeyIds, o as mergeSidecar, p as compileTimeline, r as deleteSidecarTrack, s as mergeSidecarDetailed, t as SidecarVersionError, u as setSidecarTrack } from "./sidecar.js";
 //#region src/ticker.ts
 /** The default scheduler: flush synchronously, preserving pre-ticker timing. */
 const synchronousScheduler = (flush) => flush();
@@ -448,117 +450,6 @@ function buildFontRegistry(assets) {
 	};
 }
 //#endregion
-//#region src/cmap.ts
-/**
-* Minimal sfnt `cmap` reader (DESIGN.md §3.6 glyph-coverage check) — pure,
-* byte-only, ZERO DOM / ZERO Node. Given the raw bytes of a TrueType/OpenType
-* (or the first table of a TTC) font, returns the set of Unicode code points
-* the font claims to cover. I/O (reading the file / fetching the URL) happens
-* at the call site; this function only parses bytes.
-*
-* Hand-rolled (no font-parsing dependency) to keep core zero-dep and in budget.
-* It covers the two cmap subtable formats that matter in practice:
-*   - format 4  (segment mapping to delta values — the BMP workhorse)
-*   - format 12 (segmented coverage — astral planes, e.g. emoji)
-* Malformed or unsupported input yields an empty set; it never throws or hangs.
-*/
-const PLATFORM_UNICODE = 0;
-const PLATFORM_WINDOWS = 3;
-/** Read a big-endian u16 with bounds checking (0 when out of range). */
-function u16(dv, off) {
-	return off + 2 <= dv.byteLength ? dv.getUint16(off) : 0;
-}
-function u32(dv, off) {
-	return off + 4 <= dv.byteLength ? dv.getUint32(off) : 0;
-}
-/** Rank a (platform, encoding) cmap subtable: higher = better Unicode coverage. */
-function encodingScore(platform, encoding) {
-	if (platform === PLATFORM_WINDOWS && encoding === 10) return 5;
-	if (platform === PLATFORM_UNICODE && encoding >= 4) return 5;
-	if (platform === PLATFORM_WINDOWS && encoding === 1) return 3;
-	if (platform === PLATFORM_UNICODE) return 3;
-	return 0;
-}
-function parseFormat4(dv, base, into) {
-	const segCountX2 = u16(dv, base + 6);
-	const segCount = segCountX2 >> 1;
-	const endOff = base + 14;
-	const startOff = endOff + segCountX2 + 2;
-	const deltaOff = startOff + segCountX2;
-	const rangeOff = deltaOff + segCountX2;
-	for (let i = 0; i < segCount; i++) {
-		const end = u16(dv, endOff + i * 2);
-		const start = u16(dv, startOff + i * 2);
-		if (start > end) continue;
-		const idDelta = u16(dv, deltaOff + i * 2);
-		const idRangeOffset = u16(dv, rangeOff + i * 2);
-		for (let c = start; c <= end; c++) {
-			if (c === 65535) continue;
-			let glyph;
-			if (idRangeOffset === 0) glyph = c + idDelta & 65535;
-			else {
-				const g = u16(dv, rangeOff + i * 2 + idRangeOffset + (c - start) * 2);
-				glyph = g === 0 ? 0 : g + idDelta & 65535;
-			}
-			if (glyph !== 0) into.add(c);
-		}
-	}
-}
-function parseFormat12(dv, base, into) {
-	const declared = u32(dv, base + 12);
-	const maxGroups = Math.max(0, Math.floor((dv.byteLength - (base + 16)) / 12));
-	const nGroups = Math.min(declared, maxGroups);
-	let off = base + 16;
-	for (let i = 0; i < nGroups; i++, off += 12) {
-		const startChar = u32(dv, off);
-		const endChar = u32(dv, off + 4);
-		const startGlyph = u32(dv, off + 8);
-		if (startChar > endChar) continue;
-		if (endChar - startChar > 2097152) continue;
-		for (let c = startChar; c <= endChar; c++) if (startGlyph + (c - startChar) !== 0) into.add(c);
-	}
-}
-function parseCmap(bytes) {
-	const out = /* @__PURE__ */ new Set();
-	try {
-		const dv = ArrayBuffer.isView(bytes) ? new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength) : new DataView(bytes);
-		if (dv.byteLength < 12) return out;
-		let sfntOff = 0;
-		if (u32(dv, 0) === 1953784678) sfntOff = u32(dv, 12);
-		const numTables = u16(dv, sfntOff + 4);
-		let cmapOff = 0;
-		for (let i = 0; i < numTables; i++) {
-			const rec = sfntOff + 12 + i * 16;
-			if (u32(dv, rec) === 1668112752) {
-				cmapOff = u32(dv, rec + 8);
-				break;
-			}
-		}
-		if (cmapOff === 0) return out;
-		const nSub = u16(dv, cmapOff + 2);
-		let bestOff = 0;
-		let bestScore = -1;
-		for (let i = 0; i < nSub; i++) {
-			const rec = cmapOff + 4 + i * 8;
-			const platform = u16(dv, rec);
-			const encoding = u16(dv, rec + 2);
-			const subOff = cmapOff + u32(dv, rec + 4);
-			const score = encodingScore(platform, encoding);
-			if (score > bestScore && subOff + 2 <= dv.byteLength) {
-				bestScore = score;
-				bestOff = subOff;
-			}
-		}
-		if (bestScore < 0) return out;
-		const format = u16(dv, bestOff);
-		if (format === 4) parseFormat4(dv, bestOff, out);
-		else if (format === 12) parseFormat12(dv, bestOff, out);
-	} catch {
-		return out;
-	}
-	return out;
-}
-//#endregion
 //#region src/fontValidation.ts
 /**
 * Font validation (DESIGN.md §3.6) — the family-level + glyph-coverage check.