@weasel-js/font 1.6.1 → 1.7.1

package/dist/{chunk-QDTJ3CPE.js → chunk-RYN4NYX4.js}

@@ -1,3 +1,82 @@
+import { createReflectable } from '@weasel-js/registry';
+
+// src/faceMetrics.ts
+var finite = (n) => typeof n === "number" && Number.isFinite(n);
+var USE_TYPO_METRICS = 1 << 7;
+function verticalMetricsFromTables(t) {
+  const upem = t.unitsPerEm;
+  if (!finite(upem) || upem <= 0) return void 0;
+  const os2 = t.os2;
+  const pair = (a, d, down) => finite(a) && finite(d) && a + (down ? d : -d) > 0 ? { ascent: a / upem, descent: (down ? d : -d) / upem } : void 0;
+  const typo = pair(os2?.sTypoAscender, os2?.sTypoDescender, false);
+  const hhea = pair(t.hhea?.ascender, t.hhea?.descender, false);
+  const win = pair(os2?.usWinAscent, os2?.usWinDescent, true);
+  const useTypo = finite(os2?.fsSelection) && (os2.fsSelection & USE_TYPO_METRICS) !== 0;
+  return (useTypo ? typo : void 0) ?? hhea ?? typo ?? win;
+}
+function faceMetricsFromTables(t) {
+  const upem = t.unitsPerEm;
+  if (!finite(upem) || upem <= 0) return void 0;
+  const out = {};
+  const rule = (position, thickness) => finite(position) && finite(thickness) && thickness > 0 ? { offset: -position / upem, thickness: thickness / upem } : void 0;
+  const script = (size, shift) => finite(size) && finite(shift) && size > 0 ? { size: size / upem, shift: shift / upem } : void 0;
+  const underline = rule(t.post?.underlinePosition, t.post?.underlineThickness);
+  const strikethrough = rule(t.os2?.yStrikeoutPosition, t.os2?.yStrikeoutSize);
+  const superscript = script(t.os2?.ySuperscriptYSize, t.os2?.ySuperscriptYOffset);
+  const sub = t.os2?.ySubscriptYOffset;
+  const subscript = script(t.os2?.ySubscriptYSize, finite(sub) ? -sub : sub);
+  const vertical = verticalMetricsFromTables(t);
+  if (vertical) {
+    out.ascent = vertical.ascent;
+    out.descent = vertical.descent;
+  }
+  if (underline) out.underline = underline;
+  if (strikethrough) out.strikethrough = strikethrough;
+  if (superscript) out.superscript = superscript;
+  if (subscript) out.subscript = subscript;
+  const xHeight = t.os2?.sxHeight;
+  const capHeight = t.os2?.sCapHeight;
+  if (finite(xHeight) && xHeight > 0) out.xHeight = xHeight / upem;
+  if (finite(capHeight) && capHeight > 0) out.capHeight = capHeight / upem;
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function parseFaceMetrics(raw) {
+  if (raw === void 0) return void 0;
+  if (typeof raw !== "object" || raw === null) throw new Error("parseBmFont: faceMetrics must be an object");
+  const r = raw;
+  const out = {};
+  if (r.ascent !== void 0 || r.descent !== void 0) {
+    if (!finite(r.ascent) || !finite(r.descent) || r.ascent + r.descent <= 0) {
+      throw new Error("parseBmFont: malformed faceMetrics.ascent/descent");
+    }
+    out.ascent = r.ascent;
+    out.descent = r.descent;
+  }
+  const pair = (key, a, b, positive) => {
+    const v = r[key];
+    if (v === void 0) return;
+    const e = v;
+    if (typeof e !== "object" || e === null || !finite(e[a]) || !finite(e[b]) || e[positive] <= 0) {
+      throw new Error(`parseBmFont: malformed faceMetrics.${key}`);
+    }
+    out[key] = { [a]: e[a], [b]: e[b] };
+  };
+  pair("underline", "offset", "thickness", "thickness");
+  pair("strikethrough", "offset", "thickness", "thickness");
+  pair("superscript", "size", "shift", "size");
+  pair("subscript", "size", "shift", "size");
+  for (const key of ["xHeight", "capHeight"]) {
+    const v = r[key];
+    if (v === void 0) continue;
+    if (!finite(v) || v <= 0) throw new Error(`parseBmFont: malformed faceMetrics.${key}`);
+    out[key] = v;
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function faceMetricsOf(result) {
+  return result.outlineFace?.faceMetrics ?? result.entry?.font.faceMetrics;
+}
+
 // src/FontAtlas.ts
 var FIXTURE_FONT = {
   info: { face: "Inter", size: 32 },
@@ -31,7 +110,18 @@ function parseBmFont(raw) {
     }
     inner.set(k.second, k.amount);
   }
-  return { info, common, chars, kernings, charMap, kerningMap };
+  const faceMetrics = parseFaceMetrics(r.faceMetrics);
+  const range = r.distanceField?.distanceRange;
+  return {
+    info,
+    common,
+    chars,
+    kernings,
+    charMap,
+    kerningMap,
+    ...faceMetrics ? { faceMetrics } : {},
+    ...typeof range === "number" && range > 0 ? { distanceRange: range } : {}
+  };
 }
 
 // src/glyphReady.ts
@@ -58,13 +148,17 @@ function _clearGlyphReadySubscribers() {
 var policy = "substitute";
 var defaultFamily = null;
 function setFontFallbackPolicy(next) {
+  if (next === policy) return;
   policy = next;
+  notifyGlyphReady();
 }
 function getFontFallbackPolicy() {
   return policy;
 }
 function setDefaultFontFamily(family) {
+  if (family === defaultFamily) return;
   defaultFamily = family;
+  notifyGlyphReady();
 }
 function getDefaultFontFamily() {
   return defaultFamily;
@@ -203,8 +297,9 @@ function alphaToSdf(alpha, width, height, radius, cutoff) {
 // src/dynamic/glyphRasterizer.ts
 var BAKE_SIZE = 48;
 var PAD = 8;
-function cssFontString(weight, style, family) {
-  return `${style === "italic" ? "italic " : ""}${weight} ${BAKE_SIZE}px ${JSON.stringify(family)}`;
+var METRICS_SIZE = 1e3;
+function cssFontString(weight, style, family, size = BAKE_SIZE) {
+  return `${style === "italic" ? "italic " : ""}${weight} ${size}px ${JSON.stringify(family)}`;
 }
 function createCanvasRasterizer() {
   let canvas;
@@ -219,18 +314,19 @@ function createCanvasRasterizer() {
   }
   const ctx = canvas.getContext("2d", { willReadFrequently: true });
   if (!ctx) throw new Error("weasel DynamicGlyphAtlas: 2D context unavailable");
-  function setFont(family, weight, style) {
-    ctx.font = cssFontString(weight, style, family);
+  function setFont(family, weight, style, size = BAKE_SIZE) {
+    ctx.font = cssFontString(weight, style, family, size);
     ctx.textBaseline = "alphabetic";
     ctx.textAlign = "left";
   }
   return {
     faceMetrics(family, weight, style) {
-      setFont(family, weight, style);
+      setFont(family, weight, style, METRICS_SIZE);
       const m = ctx.measureText("Hg");
+      const k = BAKE_SIZE / METRICS_SIZE;
       return {
-        ascent: m.fontBoundingBoxAscent ?? BAKE_SIZE * 0.8,
-        descent: m.fontBoundingBoxDescent ?? BAKE_SIZE * 0.2
+        ascent: (m.fontBoundingBoxAscent ?? METRICS_SIZE * 0.8) * k,
+        descent: (m.fontBoundingBoxDescent ?? METRICS_SIZE * 0.2) * k
       };
     },
     rasterize(family, weight, style, codepoint) {
@@ -292,8 +388,10 @@ function getRasterizer() {
   return rasterizer;
 }
 function registerCanvasFont(family) {
+  if (isExplicitCanvasFont(family)) return;
   canvasFamilies.add(family);
   autoEnrolledFamilies.delete(family);
+  notifyGlyphReady();
 }
 function isCanvasFont(family) {
   if (!canvasFamilies.has(family)) return false;
@@ -316,11 +414,13 @@ function isExplicitCanvasFont(family) {
   return canvasFamilies.has(family) && !autoEnrolledFamilies.has(family);
 }
 function unregisterCanvasFont(family) {
+  if (!canvasFamilies.has(family)) return;
   canvasFamilies.delete(family);
   autoEnrolledFamilies.delete(family);
   for (const key of [...faces.keys()]) {
     if (faces.get(key).family === family) faces.delete(key);
   }
+  notifyGlyphReady();
 }
 function getDynamicFace(family, weight, style) {
   const key = `${family}|${weight}|${style}`;
@@ -341,7 +441,9 @@ function getDynamicFace(family, weight, style) {
     kernings: [],
     // no kerning in v1 (measured-pair kerning is future work)
     charMap: /* @__PURE__ */ new Map(),
-    kerningMap: /* @__PURE__ */ new Map()
+    kerningMap: /* @__PURE__ */ new Map(),
+    // Unrounded, unlike `common`: layout places the baseline from these.
+    faceMetrics: { ascent: metrics.ascent / BAKE_SIZE, descent: metrics.descent / BAKE_SIZE }
   };
   const face = {
     family,
@@ -598,6 +700,163 @@ function sfntFromCollection(bytes, postScriptName) {
   return { bytes: extractFont(bytes, view, offsets[0]), matched: !postScriptName };
 }
 
+// src/outline/gposKerning.ts
+function gposPairKerning(bytes) {
+  const v = new DataView(bytes);
+  const version = v.byteLength >= 12 ? tag(v, 0) : "";
+  if (version !== "\0
\0\0" && version !== "true" && version !== "OTTO") return null;
+  const gpos = tableOffset(v, "GPOS");
+  if (gpos === null) return null;
+  const featureList = gpos + v.getUint16(gpos + 6);
+  const lookupList = gpos + v.getUint16(gpos + 8);
+  const lookupIndexes = /* @__PURE__ */ new Set();
+  const featureCount = v.getUint16(featureList);
+  for (let i = 0; i < featureCount; i++) {
+    const rec = featureList + 2 + i * 6;
+    if (tag(v, rec) !== "kern") continue;
+    const feature = featureList + v.getUint16(rec + 4);
+    const count = v.getUint16(feature + 2);
+    for (let j = 0; j < count; j++) lookupIndexes.add(v.getUint16(feature + 4 + j * 2));
+  }
+  if (lookupIndexes.size === 0) return null;
+  const lookups = [];
+  for (const index of [...lookupIndexes].sort((a, b) => a - b)) {
+    const lookup = lookupList + v.getUint16(lookupList + 2 + index * 2);
+    const type = v.getUint16(lookup);
+    const subtables = [];
+    const count = v.getUint16(lookup + 4);
+    for (let j = 0; j < count; j++) {
+      let sub = lookup + v.getUint16(lookup + 6 + j * 2);
+      let subType = type;
+      if (type === 9) {
+        subType = v.getUint16(sub + 2);
+        sub += v.getUint32(sub + 4);
+      }
+      if (subType === 2) subtables.push(sub);
+    }
+    if (subtables.length > 0) lookups.push(subtables);
+  }
+  const memo = /* @__PURE__ */ new Map();
+  return (left, right) => {
+    const key = left * 65536 + right;
+    const hit = memo.get(key);
+    if (hit !== void 0) return hit;
+    let total = 0;
+    for (const subtables of lookups) {
+      for (const sub of subtables) {
+        const value = pairValue(v, sub, left, right);
+        if (value !== null) {
+          total += value;
+          break;
+        }
+      }
+    }
+    memo.set(key, total);
+    return total;
+  };
+}
+function tag(v, at) {
+  return String.fromCharCode(v.getUint8(at), v.getUint8(at + 1), v.getUint8(at + 2), v.getUint8(at + 3));
+}
+function tableOffset(v, name) {
+  const count = v.getUint16(4);
+  for (let i = 0; i < count; i++) {
+    const rec = 12 + i * 16;
+    if (tag(v, rec) === name) return v.getUint32(rec + 8);
+  }
+  return null;
+}
+function valueSize(format) {
+  let n = 0;
+  for (let f = format; f; f >>= 1) n += f & 1;
+  return n * 2;
+}
+function xAdvance(v, at, format) {
+  if (!(format & 4)) return 0;
+  return v.getInt16(at + (format & 1 ? 2 : 0) + (format & 2 ? 2 : 0));
+}
+function pairValue(v, sub, left, right) {
+  const format = v.getUint16(sub);
+  const covIndex = coverageIndex(v, sub + v.getUint16(sub + 2), left);
+  if (covIndex < 0) return null;
+  const vf1 = v.getUint16(sub + 4);
+  const vf2 = v.getUint16(sub + 6);
+  const recordSize = 2 + valueSize(vf1) + valueSize(vf2);
+  if (format === 1) {
+    const pairSet = sub + v.getUint16(sub + 10 + covIndex * 2);
+    let lo = 0;
+    let hi = v.getUint16(pairSet) - 1;
+    while (lo <= hi) {
+      const mid = lo + hi >> 1;
+      const rec = pairSet + 2 + mid * recordSize;
+      const second = v.getUint16(rec);
+      if (second === right) return xAdvance(v, rec + 2, vf1);
+      if (second < right) lo = mid + 1;
+      else hi = mid - 1;
+    }
+    return null;
+  }
+  if (format === 2) {
+    const class1 = classOf(v, sub + v.getUint16(sub + 8), left);
+    const class2 = classOf(v, sub + v.getUint16(sub + 10), right);
+    const class1Count = v.getUint16(sub + 12);
+    const class2Count = v.getUint16(sub + 14);
+    if (class1 >= class1Count || class2 >= class2Count) return null;
+    const rec = sub + 16 + (class1 * class2Count + class2) * (recordSize - 2);
+    return xAdvance(v, rec, vf1);
+  }
+  return null;
+}
+function coverageIndex(v, cov, glyph) {
+  const format = v.getUint16(cov);
+  const count = v.getUint16(cov + 2);
+  let lo = 0;
+  let hi = count - 1;
+  if (format === 1) {
+    while (lo <= hi) {
+      const mid = lo + hi >> 1;
+      const g = v.getUint16(cov + 4 + mid * 2);
+      if (g === glyph) return mid;
+      if (g < glyph) lo = mid + 1;
+      else hi = mid - 1;
+    }
+    return -1;
+  }
+  if (format === 2) {
+    while (lo <= hi) {
+      const mid = lo + hi >> 1;
+      const rec = cov + 4 + mid * 6;
+      const start = v.getUint16(rec);
+      const end = v.getUint16(rec + 2);
+      if (glyph < start) hi = mid - 1;
+      else if (glyph > end) lo = mid + 1;
+      else return v.getUint16(rec + 4) + glyph - start;
+    }
+  }
+  return -1;
+}
+function classOf(v, def, glyph) {
+  const format = v.getUint16(def);
+  if (format === 1) {
+    const start = v.getUint16(def + 2);
+    const count = v.getUint16(def + 4);
+    const i = glyph - start;
+    return i >= 0 && i < count ? v.getUint16(def + 6 + i * 2) : 0;
+  }
+  if (format === 2) {
+    let lo = 0;
+    let hi = v.getUint16(def + 2) - 1;
+    while (lo <= hi) {
+      const mid = lo + hi >> 1;
+      const rec = def + 4 + mid * 6;
+      if (glyph < v.getUint16(rec)) hi = mid - 1;
+      else if (glyph > v.getUint16(rec + 2)) lo = mid + 1;
+      else return v.getUint16(rec + 4);
+    }
+  }
+  return 0;
+}
+
 // src/outline/opentypeParser.ts
 var modulePromise = null;
 function loadOpenType() {
@@ -608,11 +867,14 @@ function parserOf(ns) {
   const interop = ns;
   return interop.default?.parse ?? ns.parse;
 }
-function faceFor(font) {
+function faceFor(font, gpos) {
   const upem = font.unitsPerEm;
+  const { hhea, post, os2 } = font.tables;
+  const faceMetrics = faceMetricsFromTables({ unitsPerEm: upem, hhea, post, os2 });
   return {
     unitsPerEm: upem,
-    ascender: font.ascender / upem,
+    ascender: faceMetrics?.ascent ?? font.ascender / upem,
+    ...faceMetrics ? { faceMetrics } : {},
     advanceOf(cp) {
       const index = font.charToGlyphIndex(String.fromCodePoint(cp));
       if (!index) return null;
@@ -622,6 +884,7 @@ function faceFor(font) {
       const l = font.charToGlyphIndex(String.fromCodePoint(left));
       const r = font.charToGlyphIndex(String.fromCodePoint(right));
       if (!l || !r) return 0;
+      if (gpos) return gpos(l, r) / upem;
       return font.getKerningValue(font.glyphs.get(l), font.glyphs.get(r)) / upem;
     },
     glyphD(cp) {
@@ -636,13 +899,14 @@ function createOpenTypeParser(postScriptName) {
   return async (bytes) => {
     const parse = parserOf(await loadOpenType());
     const { bytes: single } = sfntFromCollection(bytes, postScriptName);
-    return faceFor(parse(single));
+    return faceFor(parse(single), gposPairKerning(single));
   };
 }
 var openTypeParser = createOpenTypeParser();
 
 // src/outline/outlineRegistry.ts
-var slots = /* @__PURE__ */ new Map();
+var slots = createReflectable();
+var fontOutlineRegistry = slots.reflection;
 function slotKey(family, weight, style) {
   return `${family}|${weight}|${style}`;
 }
@@ -656,12 +920,15 @@ function registerFontOutlines(family, variant, source, opts = {}) {
     weight,
     style,
     source,
+    cssSrc: opts.cssSrc,
     parser: opts.parser ?? openTypeParser,
     status: "idle",
     face: null,
-    glyphs: /* @__PURE__ */ new Map()
+    glyphs: /* @__PURE__ */ new Map(),
+    load: null
   });
   notifyGlyphReady();
+  if (source instanceof ArrayBuffer) announceBytes(slots.get(slotKey(family, weight, style)), source);
 }
 function unregisterFontOutlines(family, variant = {}) {
   const { weight, style } = normalize(variant);
@@ -674,7 +941,7 @@ function outlineStatus(family, weight = 400, style = "normal") {
   return slots.get(slotKey(family, weight, style))?.status ?? null;
 }
 function listFontOutlines() {
-  return [...slots.values()].map(({ family, weight, style, status }) => ({ family, weight, style, status })).sort((a, b) => a.family.localeCompare(b.family) || a.weight - b.weight || a.style.localeCompare(b.style));
+  return slots.entries().map(({ value: { family, weight, style, status } }) => ({ family, weight, style, status })).sort((a, b) => a.family.localeCompare(b.family) || a.weight - b.weight || a.style.localeCompare(b.style));
 }
 function closeContours(d) {
   let out = "";
@@ -725,20 +992,57 @@ function outlineMetrics(family, weight, style) {
   }
   return slot.status === "ready" ? slot.face : null;
 }
-async function beginLoad(slot) {
+async function loadFontOutlines(family, variant = {}) {
+  const { weight, style } = normalize(variant);
+  const slot = slots.get(slotKey(family, weight, style));
+  if (!slot) return null;
+  await beginLoad(slot);
+  return slot.status;
+}
+function beginLoad(slot) {
+  slot.load ??= runLoad(slot);
+  return slot.load;
+}
+async function runLoad(slot) {
   slot.status = "loading";
+  slots.bump();
   try {
-    slot.face = await slot.parser(await readSource(slot.source));
+    const bytes = await readSource(slot.source);
+    announceBytes(slot, bytes);
+    slot.face = await slot.parser(bytes);
     slot.status = "ready";
+    slots.bump();
     notifyGlyphReady();
   } catch (err) {
     slot.status = "failed";
+    slots.bump();
+    notifyGlyphReady();
     warnOnce(
       `load|${slotKey(slot.family, slot.weight, slot.style)}`,
       `weasel registerFontOutlines("${slot.family}" ${slot.weight}/${slot.style}): ${err instanceof Error ? err.message : String(err)}. Large text in this face keeps rendering from the SDF tier.`
     );
   }
 }
+function outlineCssSource(family, weight, style) {
+  const slot = slots.get(slotKey(family, weight, style));
+  if (!slot) return null;
+  if (slot.cssSrc !== void 0) return { registration: slot, src: slot.cssSrc };
+  if (typeof slot.source === "string") {
+    return { registration: slot, url: `url(${JSON.stringify(slot.source)})` };
+  }
+  const source = slot.source;
+  return { registration: slot, bytes: () => readSource(source) };
+}
+var bytesListener = null;
+function onOutlineBytes(listener) {
+  bytesListener = listener;
+}
+function announceBytes(slot, bytes) {
+  try {
+    bytesListener?.(slot, bytes);
+  } catch {
+  }
+}
 async function readSource(source) {
   const resolved = typeof source === "function" ? await source() : source;
   if (typeof resolved === "string") {
@@ -756,12 +1060,11 @@ function warnOnce(key, message) {
   console.warn(message);
 }
 function _resetFontOutlinesForTests() {
-  slots = /* @__PURE__ */ new Map();
+  slots.clear();
   warned.clear();
 }
-
-// src/registerFont.ts
-var registry = /* @__PURE__ */ new Map();
+var registry = createReflectable();
+var fontRegistry = registry.reflection;
 function variantKey(weight, style) {
   return `${weight}|${style}`;
 }
@@ -771,17 +1074,33 @@ function normalizeVariant(v) {
     style: v.style ?? "normal"
   };
 }
+var inFlight = /* @__PURE__ */ new Map();
+var loads = /* @__PURE__ */ new Map();
+var declared = /* @__PURE__ */ new Map();
+var registeredFamilies = /* @__PURE__ */ new Set();
 function _resetFontRegistryForTests() {
-  registry = /* @__PURE__ */ new Map();
+  registry.clear();
+  inFlight.clear();
+  loads.clear();
+  declared.clear();
+  registeredFamilies.clear();
   _clearFallbackWarnings();
 }
 function getFont(family, weight = 400, style = "normal") {
   return registry.get(family)?.get(variantKey(weight, style)) ?? null;
 }
+function faceMetricsFor(family, weight = 400, style = "normal") {
+  return getFont(family, weight, style)?.font.faceMetrics ?? outlineMetrics(family, weight, style === "italic" ? "italic" : "normal")?.faceMetrics;
+}
 function listFonts() {
   const out = [];
-  for (const [family, variantMap] of registry) {
-    const variants = [...variantMap.keys()].map((key) => {
+  for (const family of registeredFamilies) {
+    const keys = /* @__PURE__ */ new Set([
+      ...registry.get(family)?.keys() ?? [],
+      ...declared.get(family)?.keys() ?? []
+    ]);
+    if (keys.size === 0) continue;
+    const variants = [...keys].map((key) => {
       const [w, s] = key.split("|");
       return { weight: Number(w), style: s };
     }).sort((a, b) => a.weight - b.weight || a.style.localeCompare(b.style));
@@ -789,10 +1108,60 @@ function listFonts() {
   }
   return out;
 }
-async function registerFont(family, variant, metricsUrl, atlasUrl) {
+function listFontWeights(family) {
+  const weights = /* @__PURE__ */ new Set();
+  for (const key of registry.get(family)?.keys() ?? []) weights.add(Number(key.split("|")[0]));
+  for (const key of declared.get(family)?.keys() ?? []) weights.add(Number(key.split("|")[0]));
+  for (const face of listFontOutlines()) {
+    if (face.family === family && face.status !== "failed") weights.add(face.weight);
+  }
+  return [...weights].sort((a, b) => a - b);
+}
+function registerFont(family, variant, metricsUrl, atlasUrl, opts = {}) {
   const { weight, style } = normalizeVariant(variant);
   const key = variantKey(weight, style);
-  if (registry.get(family)?.has(key)) return;
+  registeredFamilies.add(family);
+  if (registry.get(family)?.has(key)) return Promise.resolve();
+  if (!opts.lazy) return loadVariant(family, key, metricsUrl, atlasUrl);
+  const running = loads.get(`${family}|${key}`);
+  if (running) return running;
+  const existing = declared.get(family)?.get(key);
+  if (existing) return existing.promise;
+  let settle2;
+  const promise = new Promise((resolve, reject) => {
+    settle2 = (load) => {
+      load.then(resolve, reject);
+    };
+  });
+  const variants = declared.get(family) ?? /* @__PURE__ */ new Map();
+  declared.set(family, variants.set(key, { metricsUrl, atlasUrl, promise, settle: settle2 }));
+  notifyGlyphReady();
+  return promise;
+}
+function loadVariant(family, key, metricsUrl, atlasUrl) {
+  const id = `${family}|${key}`;
+  const running = loads.get(id);
+  if (running) return running;
+  const load = fetchVariant(family, key, metricsUrl, atlasUrl);
+  loads.set(id, load);
+  const settleLoad = () => {
+    if (loads.get(id) === load) loads.delete(id);
+  };
+  load.then(settleLoad, settleLoad);
+  const pendingLazy = declared.get(family)?.get(key);
+  if (pendingLazy) {
+    const variants = declared.get(family);
+    variants.delete(key);
+    if (variants.size === 0) declared.delete(family);
+    pendingLazy.settle(load);
+  }
+  return load;
+}
+async function fetchVariant(family, key, metricsUrl, atlasUrl) {
+  const [weight, style] = key.split("|");
+  const token = {};
+  const tokens = inFlight.get(family) ?? /* @__PURE__ */ new Set();
+  inFlight.set(family, tokens.add(token));
   try {
     const [metricsRes, atlasRes] = await Promise.all([
       fetch(metricsUrl),
@@ -810,19 +1179,76 @@ async function registerFont(family, variant, metricsUrl, atlasUrl) {
     ]);
     const font = parseBmFont(rawJson);
     const bitmap = await createImageBitmap(blob);
-    let familyMap = registry.get(family);
-    if (!familyMap) {
-      familyMap = /* @__PURE__ */ new Map();
-      registry.set(family, familyMap);
-    }
-    familyMap.set(key, { font, bitmap });
+    registry.set(family, new Map(registry.get(family)).set(key, { font, bitmap }));
+    settle(family, token);
     notifyGlyphReady();
   } catch (err) {
+    settle(family, token);
+    notifyGlyphReady();
     throw new Error(
       `weasel registerFont("${family}" ${weight}/${style}): ${err instanceof Error ? err.message : String(err)}`
     );
   }
 }
+function wakeDeclared(family, weight, style) {
+  const variants = declared.get(family);
+  if (!variants) return;
+  const exact = variantKey(weight, style);
+  const keys = variants.has(exact) ? [exact] : [...variants.keys()];
+  for (const key of keys) {
+    const { metricsUrl, atlasUrl } = variants.get(key);
+    loadVariant(family, key, metricsUrl, atlasUrl).catch(() => {
+    });
+  }
+}
+function warmFonts(fonts) {
+  const pending2 = [];
+  for (const font of fonts ?? [...registeredFamilies]) {
+    if (typeof font !== "string") {
+      const { weight, style } = normalizeVariant(font);
+      pending2.push(...variantLoads(font.family, weight, style));
+      continue;
+    }
+    if (!registeredFamilies.has(font)) {
+      return Promise.reject(new Error(`weasel warmFonts: "${font}" was never registered.`));
+    }
+    for (const [key, { metricsUrl, atlasUrl }] of [...declared.get(font) ?? []]) {
+      loadVariant(font, key, metricsUrl, atlasUrl);
+    }
+    pending2.push(...familyLoads(font));
+  }
+  return Promise.all(pending2).then(() => void 0);
+}
+function familyLoads(family) {
+  return [...loads].filter(([id]) => id.startsWith(`${family}|`)).map(([, load]) => load);
+}
+function variantLoads(family, weight, style) {
+  const out = [];
+  const outlines = hasFontOutlines(family, weight, style);
+  if (outlines) out.push(loadFontOutlines(family, { weight, style }));
+  const key = variantKey(weight, style);
+  if (registry.get(family)?.has(key)) return out;
+  wakeDeclared(family, weight, style);
+  const exact = loads.get(`${family}|${key}`);
+  if (exact) return [...out, exact];
+  if (registry.has(family) || atlasPending(family)) return [...out, ...familyLoads(family)];
+  if (outlines || isExplicitCanvasFont(family) || getFontFallbackPolicy() !== "substitute") return out;
+  const fallback = getDefaultFontFamily() ?? firstRegisteredFamily();
+  return fallback !== null && fallback !== family ? [...out, ...variantLoads(fallback, weight, style)] : out;
+}
+function atlasPending(family) {
+  return inFlight.has(family) || declared.has(family);
+}
+function settle(family, token) {
+  const tokens = inFlight.get(family);
+  if (!tokens?.delete(token)) return;
+  if (tokens.size === 0) inFlight.delete(family);
+}
+function fontPending(family, weight = 400, style = "normal") {
+  if (atlasPending(family)) return true;
+  const outline = outlineStatus(family, weight, style === "italic" ? "italic" : "normal");
+  return outline === "idle" || outline === "loading";
+}
 function ensureFontTexture(family, weight, style, textureCache) {
   const entry = getFont(family, weight, style);
   if (!entry) return false;
@@ -868,12 +1294,13 @@ function missResolveResult(family, weight, style, suppressWarn = false) {
   if (policy2 === "substitute") {
     const fallback = getDefaultFontFamily() ?? firstRegisteredFamily();
     if (fallback !== null && fallback !== family) {
-      if (registry.has(fallback) || isCanvasFont(fallback)) {
+      if (registry.has(fallback) || isCanvasFont(fallback) || atlasPending(fallback)) {
         const result = resolveFontVariantInternal(fallback, weight, style, true);
         if (result.entry !== null || result.dynamicFace !== void 0) {
           if (!suppressWarn) warnMissingFamilyOnce(family, weight, style, fallback);
           return { ...result, substituted: { requested: family, resolved: fallback } };
         }
+        if (atlasPending(fallback)) return pendingMiss(family, weight, style);
       }
       if (!suppressWarn) warnUnusableDefaultOnce(family, weight, style, fallback);
     } else if (fallback === family && !suppressWarn) {
@@ -892,9 +1319,19 @@ function missResolveResult(family, weight, style, suppressWarn = false) {
   };
 }
 function firstRegisteredFamily() {
-  for (const family of registry.keys()) return family;
+  for (const family of registeredFamilies) {
+    if (registry.has(family) || atlasPending(family)) return family;
+  }
   return null;
 }
+function pendingMiss(family, weight, style) {
+  return {
+    entry: null,
+    resolved: { family, weight, style },
+    synthetic: { bold: false, italic: false },
+    source: "atlas"
+  };
+}
 function warnMissingFamilyOnce(family, weight, style, resolved) {
   if (!claimFallbackWarning(`substituted|${family}|${weight}|${style}`)) return;
   const cause = registry.has(family) ? `has no variant matching ${weight}/${style}, and none of its registered variants are close enough for the within-family chain to substitute \u2014 rendering with "${resolved}" instead. Bake that variant with registerFont("${family}", { weight: ${weight}, style: '${style}' }, \u2026)` : `is not registered \u2014 rendering with "${resolved}" instead. Call registerFont("${family}", \u2026)`;
@@ -946,11 +1383,17 @@ function resolveGlyphFallback(family, weight, style) {
   }
 }
 function resolveFontVariantInternal(family, weight, style, suppressWarn) {
+  wakeDeclared(family, weight, style);
+  const exactKey = variantKey(weight, style);
+  if (loads.has(`${family}|${exactKey}`) && !registry.get(family)?.has(exactKey)) {
+    return pendingMiss(family, weight, style);
+  }
   const familyMap = registry.get(family);
   if (!familyMap || familyMap.size === 0) {
+    if (atlasPending(family)) return pendingMiss(family, weight, style);
     return missResolveResult(family, weight, style, suppressWarn);
   }
-  const exact = familyMap.get(variantKey(weight, style));
+  const exact = familyMap.get(exactKey);
   if (exact) {
     return {
       entry: exact,
@@ -1040,6 +1483,107 @@ function resolveFontVariantInternal(family, weight, style, suppressWarn) {
   return missResolveResult(family, weight, style, suppressWarn);
 }
 
-export { DEFAULT_BAKE_BUDGET, FIXTURE_FONT, __setGlyphRasterizerForTests, _getPagesForTests, _resetDynamicFontsForTests, _resetFallbackForTests, _resetFontOutlinesForTests, _resetFontRegistryForTests, createOpenTypeParser, dynamicPageTextureId, ensureFontTexture, getDefaultFontFamily, getFont, getFontFallbackPolicy, glyphGeneration, glyphOutline, hasFontOutlines, isCanvasFont, listCanvasFonts, listFontOutlines, listFonts, markAllFontsNotUploaded, outlineMetrics, outlineStatus, parseBmFont, registerCanvasFont, registerFont, registerFontOutlines, resetBakeBudget, resolveFontVariant, resolveGlyphFallback, setDefaultFontFamily, setFontFallbackPolicy, subscribeGlyphReady, syncDynamicPageTexture, textureCacheKey, unregisterCanvasFont, unregisterFontOutlines };
-//# sourceMappingURL=chunk-QDTJ3CPE.js.map
-//# sourceMappingURL=chunk-QDTJ3CPE.js.map
+// src/domFace.ts
+var names = /* @__PURE__ */ new Map();
+var faces2 = /* @__PURE__ */ new Map();
+var warned2 = /* @__PURE__ */ new Set();
+function domFonts() {
+  return typeof FontFace !== "undefined" && typeof document !== "undefined" && !!document.fonts;
+}
+function nameFor(family) {
+  let name = names.get(family);
+  if (!name) {
+    name = `weasel-face-${names.size}`;
+    names.set(family, name);
+  }
+  return name;
+}
+onOutlineBytes((registration, bytes) => {
+  if (!domFonts()) return;
+  const { family, weight, style } = registration;
+  ensureFace(nameFor(family), family, weight, style, bytes);
+});
+function privateFamily(family, variant) {
+  if (!domFonts()) return null;
+  const resolved = resolveFontVariant(family, variant.weight ?? 400, variant.style ?? "normal");
+  if (resolved.source === "canvas") return null;
+  const target = resolved.resolved.family;
+  const variants = listFontOutlines().filter((f) => f.family === target && f.status !== "failed");
+  if (variants.length === 0) {
+    if (resolved.entry && !warned2.has(target)) {
+      warned2.add(target);
+      console.warn(
+        `weasel: "${target}" draws from a baked atlas with no font file registered, so DOM text in it (the text edit overlay) uses the browser's own "${family}" and will not match the canvas. Register the file the atlas was baked from: registerFontOutlines("${target}", \u2026).`
+      );
+    }
+    return null;
+  }
+  return { target, variants };
+}
+function cssFontFamily(family, variant = {}) {
+  const priv = privateFamily(family, variant);
+  if (!priv) return family;
+  const name = nameFor(priv.target);
+  for (const v of priv.variants) ensureFace(name, v.family, v.weight, v.style);
+  return `${JSON.stringify(name)}, ${family}`;
+}
+function cssFontFamilyLoading(family, variant = {}) {
+  const priv = privateFamily(family, variant);
+  if (!priv) return null;
+  const name = nameFor(priv.target);
+  for (const v of priv.variants) ensureFace(name, v.family, v.weight, v.style);
+  const weight = variant.weight ?? 400;
+  const style = variant.style ?? "normal";
+  const exact = priv.variants.filter((v) => v.weight === weight && v.style === style);
+  const pending2 = (exact.length > 0 ? exact : priv.variants).map((v) => faces2.get(`${v.family}|${v.weight}|${v.style}`)).filter((l) => l !== void 0 && !l.settled).map((l) => l.done);
+  return pending2.length === 0 ? null : Promise.all(pending2).then(() => {
+  });
+}
+function ensureFace(name, family, weight, style, bytes) {
+  const key = `${family}|${weight}|${style}`;
+  const css = outlineCssSource(family, weight, style);
+  if (!css) return;
+  const have = faces2.get(key);
+  if (have?.from === css.registration) return;
+  if (have?.face) document.fonts.delete(have.face);
+  let settle2;
+  const entry = {
+    from: css.registration,
+    face: null,
+    settled: false,
+    done: new Promise((r) => {
+      settle2 = r;
+    })
+  };
+  const finish = () => {
+    entry.settled = true;
+    settle2();
+  };
+  faces2.set(key, entry);
+  const descriptors = { weight: String(weight), style, display: "swap" };
+  const add = (face) => {
+    if (faces2.get(key) !== entry) return finish();
+    entry.face = face;
+    document.fonts.add(face);
+    face.load().then(finish, () => {
+      finish();
+      console.warn(`weasel: could not load "${family}" (${weight}/${style}) for DOM text; the text edit overlay falls back to the browser's own face.`);
+    });
+  };
+  if ("src" in css) add(new FontFace(name, css.src, descriptors));
+  else if (bytes !== void 0) add(new FontFace(name, bytes, descriptors));
+  else if ("url" in css) add(new FontFace(name, css.url, descriptors));
+  else css.bytes().then((buf) => add(new FontFace(name, buf, descriptors)), finish);
+}
+function _resetDomFacesForTests() {
+  if (typeof document !== "undefined" && document.fonts) {
+    for (const { face } of faces2.values()) if (face) document.fonts.delete(face);
+  }
+  names.clear();
+  faces2.clear();
+  warned2.clear();
+}
+
+export { DEFAULT_BAKE_BUDGET, FIXTURE_FONT, PAGE_SIZE, SDF_RADIUS, __setGlyphRasterizerForTests, _getPagesForTests, _resetDomFacesForTests, _resetDynamicFontsForTests, _resetFallbackForTests, _resetFontOutlinesForTests, _resetFontRegistryForTests, createOpenTypeParser, cssFontFamily, cssFontFamilyLoading, dynamicPageTextureId, ensureFontTexture, faceMetricsFor, faceMetricsFromTables, faceMetricsOf, fontOutlineRegistry, fontPending, fontRegistry, getDefaultFontFamily, getFont, getFontFallbackPolicy, glyphGeneration, glyphOutline, hasFontOutlines, isCanvasFont, listCanvasFonts, listFontOutlines, listFontWeights, listFonts, loadFontOutlines, markAllFontsNotUploaded, outlineMetrics, outlineStatus, parseBmFont, registerCanvasFont, registerFont, registerFontOutlines, resetBakeBudget, resolveFontVariant, resolveGlyphFallback, setDefaultFontFamily, setFontFallbackPolicy, subscribeGlyphReady, syncDynamicPageTexture, textureCacheKey, unregisterCanvasFont, unregisterFontOutlines, verticalMetricsFromTables, warmFonts };
+//# sourceMappingURL=chunk-RYN4NYX4.js.map
+//# sourceMappingURL=chunk-RYN4NYX4.js.map