@weasel-js/font 1.0.2 → 1.0.3

package/dist/test-seams-DLNsXb8P.d.ts

@@ -0,0 +1,562 @@
+/**
+ * BmFont JSON types and parser for the MSDF atlas format produced by
+ * msdf-bmfont-xml. The parser builds accelerator maps (charMap, kerningMap)
+ * for O(1) glyph and kerning lookup during layout.
+ */
+interface BmFontInfo {
+    face: string;
+    size: number;
+}
+/** Font-wide vertical metrics and the atlas page dimensions, in pixels. */
+interface BmFontCommon {
+    lineHeight: number;
+    base: number;
+    scaleW: number;
+    scaleH: number;
+}
+/** One glyph: where it sits in the atlas page (`x`/`y`/`width`/`height`),
+ *  where to draw it relative to the pen (`xoffset`/`yoffset`), and how far the
+ *  pen then advances. */
+interface BmFontChar {
+    id: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    xoffset: number;
+    yoffset: number;
+    xadvance: number;
+    page: number;
+}
+/** A kerning pair: `amount` px to add to the advance when `second` follows
+ *  `first`. Codepoints, not glyph indices. */
+interface BmFontKerning {
+    first: number;
+    second: number;
+    amount: number;
+}
+/** A parsed MSDF atlas: the BmFont record plus the `charMap` / `kerningMap`
+ *  accelerators layout reads per glyph. */
+interface BmFont {
+    info: BmFontInfo;
+    common: BmFontCommon;
+    chars: BmFontChar[];
+    kernings: BmFontKerning[];
+    charMap: Map<number, BmFontChar>;
+    kerningMap: Map<number, Map<number, number>>;
+}
+/** Two-glyph fixture for unit tests. */
+declare const FIXTURE_FONT: {
+    info: {
+        face: string;
+        size: number;
+    };
+    common: {
+        lineHeight: number;
+        base: number;
+        scaleW: number;
+        scaleH: number;
+    };
+    chars: {
+        id: number;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        xoffset: number;
+        yoffset: number;
+        xadvance: number;
+        page: number;
+    }[];
+    kernings: {
+        first: number;
+        second: number;
+        amount: number;
+    }[];
+};
+/** Validate a BmFont JSON document and build its lookup maps. Throws with the
+ *  missing or malformed field named. */
+declare function parseBmFont(raw: unknown): BmFont;
+
+/**
+ * The only thing the glyph tier needs from a GL texture cache. Core's
+ * `GLTextureCache` satisfies this structurally — there is no adapter and no
+ * registration step, because the type *is* the seam.
+ *
+ * Declared here rather than imported so this package has zero reach-back into
+ * core. If core's cache ever drops one of these methods, the failure surfaces
+ * as a type error at the call site in `renderer/draw.ts`, which is where it
+ * belongs.
+ */
+/** Anything WebGL can upload as a texture. */
+type TexSource = HTMLImageElement | ImageBitmap | ImageData | HTMLCanvasElement;
+/** The texture-upload surface the glyph tier needs. Core's `GLTextureCache`
+ *  satisfies it structurally, so nothing registers or adapts. */
+interface GlyphTextureSink {
+    has(id: string): boolean;
+    upload(id: string, source: TexSource): string;
+    uploadR8(id: string, width: number, height: number, data: Uint8Array): void;
+    subImageR8(id: string, x: number, y: number, w: number, h: number, data: Uint8Array): void;
+}
+
+interface FaceMetrics {
+    ascent: number;
+    descent: number;
+}
+interface RasterizedGlyph {
+    width: number;
+    height: number;
+    alpha: Uint8ClampedArray;
+    left: number;
+    top: number;
+    advance: number;
+}
+interface GlyphRasterizer {
+    faceMetrics(family: string, weight: number, style: 'normal' | 'italic'): FaceMetrics;
+    rasterize(family: string, weight: number, style: 'normal' | 'italic', codepoint: number): RasterizedGlyph;
+}
+
+/**
+ * DynamicGlyphAtlas — runtime single-channel SDF glyphs for canvas-sourced
+ * (installed machine) fonts. TinySDF technique: canvas fillText at 48 px →
+ * Euclidean distance transform → shelf-packed R8 pages (1024², max 4).
+ *
+ * Baked MSDF atlases always win: this tier only serves families registered
+ * via `registerCanvasFont` that have no baked entry (see resolveFontVariant).
+ *
+ * Faces expose a BmFont-shaped `font` whose charMap grows as glyphs are
+ * requested, so `layoutRuns` consumes them through the same code path as
+ * baked atlases. A char's advance is valid immediately (measureText); its
+ * atlas rect fills in when the bake lands (width 0 / page -1 until then, so
+ * layout advances the pen but emits no quad).
+ */
+
+/** How many glyphs the dynamic atlas will rasterize synchronously before
+ *  deferring the rest to a later flush. Caps the frame cost of text that
+ *  suddenly needs many new glyphs; the leftovers arrive a tick later and
+ *  notify through `onGlyphReady`. */
+declare const DEFAULT_BAKE_BUDGET = 16;
+interface DynamicFace {
+    family: string;
+    weight: number;
+    style: 'normal' | 'italic';
+    /** BmFont-shaped view consumed by layoutRuns; charMap grows lazily. */
+    font: BmFont;
+    /** Char record for `cp`, measured on first request (advance always valid
+     *  immediately; atlas rect fills in when the bake lands). */
+    requestGlyph(cp: number): BmFontChar;
+}
+interface DynamicPage {
+    data: Uint8Array;
+    /** Bumps on every glyph blit; each blit appends a patch with seq = version. */
+    version: number;
+    patches: {
+        seq: number;
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    }[];
+}
+/** One family served by the dynamic canvas-SDF tier. See `listCanvasFonts`. */
+interface CanvasFontEntry {
+    family: string;
+    /** `'explicit'` — a `registerCanvasFont` call; `'auto'` — the `'canvas'`
+     *  fallback policy enrolled it on a miss, and the enrollment lapses if
+     *  that policy changes. */
+    enrollment: 'explicit' | 'auto';
+}
+/** Mark `family` as canvas-sourced: when no baked atlas covers it,
+ *  resolveFontVariant serves it from this dynamic atlas. */
+declare function registerCanvasFont(family: string): void;
+/**
+ * Will `family` be served by the dynamic canvas-SDF tier *right now*?
+ *
+ * Service, not membership — the answer depends on the fallback policy in
+ * force and can change without any enrollment call:
+ *   - explicitly enrolled via `registerCanvasFont` → `true` under every
+ *     policy; a consumer naming a family outranks the policy.
+ *   - auto-enrolled by the `'canvas'` policy → `true` only while that policy
+ *     is still in force. The enrollment lapses rather than being discarded,
+ *     so returning to `'canvas'` makes it `true` again.
+ *   - never enrolled → `false`, including under `'canvas'` (that policy
+ *     enrolls lazily, on the first miss).
+ *
+ * The membership reading would answer `true` for an auto-enrolled family
+ * under `'substitute'` / `'none'`, where nothing routes to this tier — a
+ * caller predicting what renders would be told the opposite of the truth.
+ * Mirrors `listFonts`, which reports the baked registry alone for the same
+ * reason: "enrolled" is not "will render".
+ */
+declare function isCanvasFont(family: string): boolean;
+/**
+ * Every family the dynamic canvas-SDF tier will serve *right now* — the
+ * enumeration companion to `isCanvasFont`, which answers one family at a
+ * time. Same "service, not membership" rule: an auto-enrolled family appears
+ * only while the `'canvas'` policy is in force.
+ *
+ * Exists so a consumer can offer these families in a font picker.
+ * `listFonts` reports the baked registry alone, so without this the only
+ * ways to present canvas-served families were to hard-code a list beside the
+ * `registerCanvasFont` calls or to omit them — a UI inventing its own answer
+ * about what will render.
+ *
+ * `enrollment` distinguishes a consumer's explicit `registerCanvasFont` from
+ * a lazy enrollment the policy made on a miss; both render identically, but
+ * only the explicit one survives a policy change.
+ */
+declare function listCanvasFonts(): readonly CanvasFontEntry[];
+/** Remove a canvas family. Its faces are dropped; already-baked glyph
+ *  pixels stay in their pages (no eviction in v1). */
+declare function unregisterCanvasFont(family: string): void;
+/** Reset the per-frame synchronous bake budget. Called by
+ *  `WeaselRenderer.render()` at frame start; the headless
+ *  `renderSceneToPixels` path passes Infinity so print never defers. */
+declare function resetBakeBudget(n?: number): void;
+/** Texture-cache key for a dynamic page (parallel to `textureCacheKey`). */
+declare function dynamicPageTextureId(page: number): string;
+/** Bring `cache`'s copy of page `pageIndex` up to date: full R8 upload the
+ *  first time, `texSubImage2D` patches after. Returns false if the page
+ *  doesn't exist yet. */
+declare function syncDynamicPageTexture(cache: GlyphTextureSink, pageIndex: number): boolean;
+/** @internal test seam — inject a fake rasterizer (jsdom has no canvas
+ *  metrics). Pass null to restore the lazy default. */
+declare function __setGlyphRasterizerForTests(r: GlyphRasterizer | null): void;
+/** @internal test seam — inspect CPU-side pages. */
+declare function _getPagesForTests(): readonly DynamicPage[];
+/** @internal test seam — clear all dynamic-font state. */
+declare function _resetDynamicFontsForTests(): void;
+
+/**
+ * FontRegistry and registerFont() public API.
+ *
+ * Variants are keyed by (family, weight, style). registerFont() takes a
+ * FontVariant alongside the family and the two URLs; the registry stores
+ * entries in a two-level Map so resolveFontVariant() can iterate a family's
+ * variants for the fallback chain.
+ */
+
+/** A registered face: its parsed metrics and the atlas image to sample. */
+interface FontEntry {
+    font: BmFont;
+    bitmap: ImageBitmap;
+}
+/** Which face within a family. Defaults to weight 400, style `'normal'`. */
+interface FontVariant {
+    weight?: number;
+    style?: 'normal' | 'italic';
+}
+type FontStyle = 'normal' | 'italic';
+/** Test helper. Do not call from product code. */
+declare function _resetFontRegistryForTests(): void;
+/** Exact lookup — does NOT walk the fallback chain. Use `resolveFontVariant` for that. */
+declare function getFont(family: string, weight?: number, style?: FontStyle): FontEntry | null;
+/** One family in the registry and the variants registered for it — what a
+ *  font picker can honestly offer. */
+interface RegisteredFont {
+    family: string;
+    variants: readonly {
+        weight: number;
+        style: FontStyle;
+    }[];
+}
+/**
+ * Enumerate the registry — what a font picker can honestly offer. Families
+ * come back in registration order; variants sorted by weight, then style, so
+ * the output is stable enough to assert against.
+ */
+declare function listFonts(): readonly RegisteredFont[];
+/**
+ * Fetch a baked MSDF atlas and its metrics, and register them as one variant
+ * of `family`. Resolves once the face is usable; re-registering a variant that
+ * is already present is a no-op.
+ */
+declare function registerFont(family: string, variant: FontVariant, metricsUrl: string, atlasUrl: string): Promise<void>;
+/**
+ * Ensure the atlas for `(family, weight, style)` is uploaded to
+ * `textureCache`. Cache key is `${family}|${weight}|${style}` so each
+ * variant occupies its own texture slot.
+ */
+declare function ensureFontTexture(family: string, weight: number, style: FontStyle, textureCache: GlyphTextureSink): boolean;
+/** The texture cache key used by `ensureFontTexture` for a given variant. */
+declare function textureCacheKey(family: string, weight: number, style: FontStyle): string;
+/** Kept as a no-op for context-restore call sites; per-cache dedup handles it now. */
+declare function markAllFontsNotUploaded(): void;
+/** What `resolveFontVariant` found: the atlas to draw with, the face it
+ *  actually landed on after walking the fallback chain, and what has to be
+ *  synthesized to cover the difference. */
+interface ResolveResult {
+    entry: FontEntry | null;
+    /**
+     * The (family, weight, style) triple that was actually matched. May differ
+     * from the requested values when the resolver walked the fallback chain —
+     * including `family`, when the cross-family policy substituted a default.
+     *
+     * This is the atlas identity: pass all three to `getFont` /
+     * `textureCacheKey` and the lookup hits. Describing only weight and style
+     * here once let a caller key its draw on the *requested* family, which
+     * resolves to no atlas at all and paints nothing.
+     *
+     * The synthetic flags describe the gap between requested and resolved for
+     * shader-side compensation. When `entry` is null, these mirror the
+     * requested values.
+     */
+    resolved: {
+        family: string;
+        weight: number;
+        style: FontStyle;
+    };
+    synthetic: {
+        bold: boolean;
+        italic: boolean;
+    };
+    /** Which tier resolved: a baked MSDF atlas, or the runtime canvas-SDF
+     *  dynamic atlas. Misses report 'atlas' (the default tier). */
+    source: 'atlas' | 'canvas';
+    /** Set only when source === 'canvas': the dynamic face whose BmFont-shaped
+     *  `font` layoutRuns consumes in place of `entry.font`. */
+    dynamicFace?: DynamicFace;
+    /**
+     * Set when the requested family was not registered and the fallback policy
+     * substituted a different one. Reported structurally so a UI can say
+     * "Inter — not loaded, showing Roboto" instead of leaving the user to
+     * wonder why the family control did nothing.
+     */
+    substituted?: {
+        requested: string;
+        resolved: string;
+    };
+}
+/**
+ * Resolve a `(family, weight, style)` request to a registered font entry,
+ * walking the fallback chain when an exact match isn't available. Returns
+ * synthetic flags describing the gap between requested and resolved so the
+ * renderer can apply SDF-thicken / vertex-skew fakes.
+ */
+declare function resolveFontVariant(family: string, weight: number, style: FontStyle): ResolveResult;
+/**
+ * Escalate a *single codepoint* to the dynamic tier when the atlas that
+ * resolved for the run has no glyph for it.
+ *
+ * `resolveFontVariant` answers at family granularity: it picks one tier for a
+ * whole run. But a baked MSDF atlas covers a fixed charset, so a run served by
+ * a perfectly good atlas can still contain a character that atlas never baked
+ * — an em dash, a curly quote, anything outside the subset. The dynamic tier
+ * rasterizes on demand from installed fonts and can serve exactly those.
+ *
+ * Returns a canvas-tier `ResolveResult` whose `dynamicFace` the caller drives
+ * with `requestGlyph(cp)`, or `null` when escalation isn't available:
+ *
+ *   - Policy `'none'` documents a miss as a *hard* miss. Quietly reaching for
+ *     another tier per codepoint would undo that, so it doesn't.
+ *   - No canvas to rasterize into (SSR, a jsdom test without one) makes the
+ *     dynamic tier constructible-but-broken; `getDynamicFace` throws and this
+ *     reports the miss instead of taking the caller down with it.
+ *
+ * Cheap to call per missing codepoint: faces are cached by variant and glyphs
+ * by codepoint, so a repeat is two map lookups.
+ */
+declare function resolveGlyphFallback(family: string, weight: number, style: FontStyle): ResolveResult | null;
+
+/**
+ * Cross-family fallback policy. The per-family chain in `resolveFontVariant`
+ * (weight → style → synthetic) has always been rich; what was missing is what
+ * happens when the family itself was never registered. That case used to
+ * render nothing at all, which is the single most common cause of "my text is
+ * invisible".
+ */
+/**
+ * What happens when a requested family has no baked atlas:
+ *   - `'substitute'` — render with the default family (see
+ *     `setDefaultFontFamily`), reporting the swap on `ResolveResult.substituted`.
+ *   - `'canvas'` — auto-enroll the family with the dynamic canvas-SDF
+ *     rasterizer. The consumer gets the *real* typeface if the browser has it,
+ *     at canvas-SDF quality rather than baked-MSDF quality.
+ *   - `'none'` — hard miss; the run renders nothing.
+ */
+type FontFallbackPolicy = 'substitute' | 'canvas' | 'none';
+/** Set what happens when text asks for a family that was never registered.
+ *  Process-wide; defaults to `'substitute'`. */
+declare function setFontFallbackPolicy(next: FontFallbackPolicy): void;
+/** The cross-family fallback policy currently in force. */
+declare function getFontFallbackPolicy(): FontFallbackPolicy;
+/** Explicit default family for `'substitute'`. When unset, the first
+ *  registered family wins — the right answer for the common case of an app
+ *  that registers exactly one. */
+declare function setDefaultFontFamily(family: string): void;
+/** The family `setDefaultFontFamily` named, or `null` if none was set — in
+ *  which case `'substitute'` falls back to the first registered family. */
+declare function getDefaultFontFamily(): string | null;
+/** Test helper. Do not call from product code. */
+declare function _resetFallbackForTests(): void;
+
+/**
+ * The parsed-font seam for the outline tier.
+ *
+ * A face answers exactly one question — "what does codepoint N look like?" —
+ * and answers it as **SVG path data in em space**: one unit is one em, y
+ * grows downward, and the origin sits on the baseline at the glyph's pen
+ * position. That is a complete description of the glyph independent of size,
+ * zoom, and position, which is the whole reason the tier exists: tessellate
+ * once, transform per instance.
+ *
+ * ### Why `d` and not a command stream
+ *
+ * `@weasel-js/font` is a Tier A leaf — `@weasel-js/core` depends on it and
+ * never the reverse (see `leaf-purity.test.ts`), so this package cannot name
+ * core's `PolygonPath`. The alternative to a string would be re-declaring
+ * core's `PATH_M`/`PATH_L`/… opcodes over here and trusting two packages to
+ * keep the same numbering forever. SVG `d` is the kit's documented language
+ * for geometry crossing a boundary (`docs/conventions.md`), core already
+ * ships `pathFromD`, and a glyph outline is exactly the case it describes.
+ *
+ * The string is also a natural cache key and costs nothing to hold: the
+ * parse happens once per glyph, and core caches the *tessellation*, not the
+ * text.
+ */
+/** Weight/style pair identifying one face within a family. */
+type OutlineFontStyle = 'normal' | 'italic';
+/** A parsed font face, viewed only as a source of glyph outlines. See the
+ *  module comment for the em-space contract `glyphD` returns. */
+interface OutlineFace {
+    /** Font design units per em. Reported for diagnostics; `glyphD` has already
+     *  divided by it, so callers never need to. */
+    unitsPerEm: number;
+    /**
+     * Em-space SVG path data for `cp`, or `null` when this face has no glyph
+     * for the codepoint *or* the glyph has no contours (a space). Both answers
+     * mean the same thing to a caller: there is nothing here to tessellate, so
+     * fall through to whatever tier would have drawn it.
+     */
+    glyphD(cp: number): string | null;
+}
+/**
+ * Turn font file bytes into a face. Async because the default implementation
+ * dynamically imports its parser — see `opentypeParser.ts` for why that
+ * matters — and because a caller may want to hand back a face that finishes
+ * initializing off-thread.
+ */
+type OutlineParser = (bytes: ArrayBuffer) => OutlineFace | Promise<OutlineFace>;
+
+/**
+ * The outline tier's registry: which faces have real font bytes behind them,
+ * and what a given glyph looks like.
+ *
+ * ### What this tier is for
+ *
+ * A distance field is a *sampled* representation. The baked MSDF atlas is
+ * generated from outlines and holds up well; the dynamic canvas-SDF tier
+ * (`../dynamic/`) reconstructs its field from a 48px raster, so magnifying it
+ * past a few times the bake size exposes the raster as contour wobble — bumps
+ * one bake-texel apart, ±2–3px at 8×. No bake size fixes that, it only moves
+ * the size at which it appears (`glyphRasterizer.ts` measures the tradeoff:
+ * error is *minimized at* the bake size, so raising it spoils the 12–32px
+ * range where most text lives).
+ *
+ * Above a size threshold the answer is to stop sampling: parse the font, take
+ * the glyph's outline, and hand it to the path renderer the kit already has.
+ * Exact at every zoom, and — because a glyph becomes an ordinary path — it
+ * takes strokes and non-solid fills for free.
+ *
+ * Below the threshold the atlas still wins, and not narrowly: outlines carry
+ * no hinting and no stem darkening, so body text at 12–16px rendered from
+ * them looks *worse* than a platform rasterizer that puts stems on the pixel
+ * grid. Two tiers with a size threshold is the standard hybrid, not a
+ * compromise.
+ *
+ * ### Metric neutrality (the load-bearing invariant)
+ *
+ * This tier replaces how a glyph is *painted*, never where it sits. Advances,
+ * kerning, line breaking and baselines all keep coming from whichever tier
+ * resolved the run — the baked atlas or the canvas face. That is what lets
+ * the threshold be a rendering decision: zooming past it swaps glyph geometry
+ * with the layout untouched, so text cannot reflow under the user's cursor,
+ * and `measureTextBounds` / `textLineBoxes` need to know nothing about
+ * outlines at all.
+ *
+ * The cost is that a face whose real advances disagree with the atlas's
+ * inherits the atlas's. For the bundled Inter that is exact (the subset ships
+ * from the same source the atlas was baked from), and for a machine font the
+ * outline bytes and the canvas metrics come from the same file.
+ *
+ * ### Availability
+ *
+ * Everything here degrades rather than blocks. Bytes arrive over `fetch` or
+ * `queryLocalFonts` — asynchronous, and in the local case gated behind a
+ * permission the user can refuse — so `glyphOutline` answers `null` until a
+ * face is loaded and forever if it failed, and the caller falls back down the
+ * ladder to SDF. A family must never render *nothing* because the outline
+ * tier could not get bytes.
+ */
+
+/**
+ * Where a face's bytes come from. A URL is fetched; a buffer or blob is used
+ * as-is; a thunk is called at first use, which is what lets `queryLocalFonts`
+ * results be registered eagerly and read lazily — the permission prompt and
+ * the (potentially many megabytes of) blob only happen for a family the
+ * document actually sets text in.
+ */
+type OutlineSource = string | ArrayBuffer | Blob | (() => ArrayBuffer | Blob | Promise<ArrayBuffer | Blob>);
+/** Which face within a family to register outlines for. Defaults to weight
+ *  400, style `'normal'`. */
+interface OutlineVariant {
+    weight?: number;
+    style?: OutlineFontStyle;
+}
+/** Options for registering an outline font. */
+interface OutlineFontOptions {
+    /** Override the default opentype.js parser. Mostly a test seam; also the
+     *  hook for a consumer who already has a font parser in their bundle. */
+    parser?: OutlineParser;
+}
+/** Load state of one registered face. */
+type OutlineStatus = 'idle' | 'loading' | 'ready' | 'failed';
+/**
+ * Register font file bytes for one face, so text set in it can render from
+ * outlines above the size threshold.
+ *
+ * Registration is cheap and synchronous: nothing is fetched, and the parser
+ * is not even imported, until a frame actually asks for a glyph from this
+ * face. Registering a face that is never drawn large costs one map entry.
+ *
+ * The variant must match exactly what the layout tier resolved — this is
+ * deliberately *not* a fallback chain. Painting 400-weight outlines at
+ * 700-weight advances, or upright outlines where the shader was going to
+ * fake an oblique, looks worse than the SDF it replaced; a miss here falls
+ * back down the ladder instead, which is always safe.
+ */
+declare function registerFontOutlines(family: string, variant: OutlineVariant, source: OutlineSource, opts?: OutlineFontOptions): void;
+/** Drop a registration. Glyphs already handed out stay valid — they are
+ *  plain path data — but nothing further resolves from this face. */
+declare function unregisterFontOutlines(family: string, variant?: OutlineVariant): void;
+/**
+ * Is an outline face registered for this exact variant? Answers `true` while
+ * the bytes are still loading — the question is "could this face serve
+ * outlines", which is what a caller deciding whether to *ask* wants; use
+ * `outlineStatus` for the narrower "can it right now".
+ */
+declare function hasFontOutlines(family: string, weight?: number, style?: OutlineFontStyle): boolean;
+/** Load state of a registered face; `null` when nothing is registered. */
+declare function outlineStatus(family: string, weight?: number, style?: OutlineFontStyle): OutlineStatus | null;
+/** Every registered outline face and its load state — the enumeration a
+ *  debug overlay or font picker needs, mirroring `listFonts`. */
+declare function listFontOutlines(): readonly {
+    family: string;
+    weight: number;
+    style: OutlineFontStyle;
+    status: OutlineStatus;
+}[];
+/**
+ * Em-space SVG path data for one glyph of a registered outline face, or `null`
+ * when there is nothing to draw.
+ *
+ * Synchronous and non-throwing by design: a face that has not been parsed yet
+ * starts loading and answers `null` for now, so a renderer can call this every
+ * frame and simply fall through to another text tier until the outline
+ * arrives. Results are cached per codepoint.
+ */
+declare function glyphOutline(family: string, weight: number, style: OutlineFontStyle, cp: number): string | null;
+/** @internal Test seam — registry and warn-once keys are module state. */
+declare function _resetFontOutlinesForTests(): void;
+
+export { _resetFontRegistryForTests as $, outlineStatus as A, type BmFont as B, type CanvasFontEntry as C, DEFAULT_BAKE_BUDGET as D, parseBmFont as E, FIXTURE_FONT as F, type GlyphTextureSink as G, registerCanvasFont as H, registerFont as I, registerFontOutlines as J, resetBakeBudget as K, resolveFontVariant as L, resolveGlyphFallback as M, setDefaultFontFamily as N, type OutlineFontStyle as O, setFontFallbackPolicy as P, syncDynamicPageTexture as Q, type RegisteredFont as R, textureCacheKey as S, type TexSource as T, unregisterCanvasFont as U, unregisterFontOutlines as V, _getPagesForTests as W, _resetDynamicFontsForTests as X, _resetFallbackForTests as Y, _resetFontOutlinesForTests as Z, __setGlyphRasterizerForTests as _, type BmFontChar as a, type BmFontCommon as b, type BmFontInfo as c, type BmFontKerning as d, type FontEntry as e, type FontFallbackPolicy as f, type FontVariant as g, type OutlineFace as h, type OutlineFontOptions as i, type OutlineParser as j, type OutlineSource as k, type OutlineStatus as l, type OutlineVariant as m, type ResolveResult as n, dynamicPageTextureId as o, ensureFontTexture as p, getDefaultFontFamily as q, getFont as r, getFontFallbackPolicy as s, glyphOutline as t, hasFontOutlines as u, isCanvasFont as v, listCanvasFonts as w, listFontOutlines as x, listFonts as y, markAllFontsNotUploaded as z };

package/dist/test-seams.d.ts

@@ -0,0 +1 @@
+export { _ as __setGlyphRasterizerForTests, W as _getPagesForTests, X as _resetDynamicFontsForTests, Y as _resetFallbackForTests, Z as _resetFontOutlinesForTests, $ as _resetFontRegistryForTests } from './test-seams-DLNsXb8P.js';

package/dist/test-seams.js

@@ -0,0 +1,3 @@
+export { __setGlyphRasterizerForTests, _getPagesForTests, _resetDynamicFontsForTests, _resetFallbackForTests, _resetFontOutlinesForTests, _resetFontRegistryForTests } from './chunk-3RSTZDXH.js';
+//# sourceMappingURL=test-seams.js.map
+//# sourceMappingURL=test-seams.js.map

package/dist/test-seams.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"test-seams.js"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weasel-js/font",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "MSDF font atlases, glyph metrics, and runtime glyph rasterization for @weasel-js/core. Registry, kerning-aware glyph layout, and the SDF text shader source.",
   "license": "MIT",
   "type": "module",
@@ -13,6 +13,10 @@
       "import": "./dist/index.js",
       "types": "./dist/index.d.ts"
     },
+    "./test-seams": {
+      "import": "./dist/test-seams.js",
+      "types": "./dist/test-seams.d.ts"
+    },
     "./package.json": "./package.json"
   },
   "scripts": {