@weasel-js/font 1.9.3 → 1.10.0

package/dist/{chunk-OYLAXZOV.js → chunk-NM6K6M4Y.js}

@@ -1,4 +1,4 @@
-import { createReflectable } from '@weasel-js/registry';
+import { createEmitter, createReflectable } from '@weasel-js/registry';
 
 // src/faceMetrics.ts
 var finite = (n) => typeof n === "number" && Number.isFinite(n);
@@ -97,6 +97,19 @@ function parseBmFont(raw) {
   if (!Array.isArray(r.chars)) throw new Error("parseBmFont: chars must be an array");
   const info = r.info;
   const common = r.common;
+  const positive = [
+    ["info.size", info.size],
+    ["common.scaleW", common.scaleW],
+    ["common.scaleH", common.scaleH]
+  ];
+  for (const [name, value] of positive) {
+    if (typeof value !== "number" || !(value > 0) || !Number.isFinite(value)) {
+      throw new Error(`parseBmFont: ${name} must be a positive number`);
+    }
+  }
+  if (typeof common.base !== "number" || !Number.isFinite(common.base)) {
+    throw new Error("parseBmFont: common.base must be a number");
+  }
   const chars = r.chars;
   const kernings = Array.isArray(r.kernings) ? r.kernings : [];
   const charMap = /* @__PURE__ */ new Map();
@@ -123,25 +136,29 @@ function parseBmFont(raw) {
     ...typeof range === "number" && range > 0 ? { distanceRange: range } : {}
   };
 }
-
-// src/glyphReady.ts
-var subscribers = /* @__PURE__ */ new Set();
+var ready = createEmitter();
 var generation = 0;
 function glyphGeneration() {
   return generation;
 }
 function subscribeGlyphReady(cb) {
-  subscribers.add(cb);
-  return () => {
-    subscribers.delete(cb);
-  };
+  return ready.subscribe(cb);
+}
+var faces = 0;
+function faceGeneration() {
+  return faces;
 }
 function notifyGlyphReady() {
   generation++;
-  for (const cb of subscribers) cb();
+  faces++;
+  ready.emit();
+}
+function notifyGlyphBaked() {
+  generation++;
+  ready.emit();
 }
 function _clearGlyphReadySubscribers() {
-  subscribers.clear();
+  ready = createEmitter();
 }
 
 // src/fallback.ts
@@ -169,6 +186,9 @@ function claimFallbackWarning(key) {
   warnedFallbacks.add(key);
   return true;
 }
+function fallbackWarningClaimed(key) {
+  return warnedFallbacks.has(key);
+}
 function _clearFallbackWarnings() {
   warnedFallbacks.clear();
 }
@@ -178,26 +198,115 @@ function _resetFallbackForTests() {
   warnedFallbacks.clear();
 }
 
-// src/cssFamily.ts
-function cssFamilyName(family) {
-  if (/[,"']/.test(family)) return family;
-  return GENERIC_FAMILIES.has(family.trim().toLowerCase()) ? family.trim() : JSON.stringify(family);
+// src/dynamic/dynamicPages.ts
+var PAGE_SIZE = 1024;
+var MAX_PAGES = 4;
+var PageSet = class {
+  constructor(format) {
+    this.format = format;
+  }
+  format;
+  pages = [];
+  // Per-GL-cache upload progress: last page version each cache has seen.
+  // WeakMap-keyed so disposed renderers don't pin anything.
+  uploaded = /* @__PURE__ */ new WeakMap();
+  textureId(page) {
+    return `${this.format.idPrefix}${page}`;
+  }
+  /** Copy a `w`×`h` block of texels into page `pageIndex` at `(x, y)`. */
+  blit(pageIndex, x, y, w, h, bytes) {
+    const n = this.format.channels;
+    while (this.pages.length <= pageIndex) {
+      this.pages.push({ data: new Uint8Array(PAGE_SIZE * PAGE_SIZE * n), version: 0, patches: [] });
+    }
+    const page = this.pages[pageIndex];
+    for (let row = 0; row < h; row++) {
+      page.data.set(bytes.subarray(row * w * n, (row + 1) * w * n), ((y + row) * PAGE_SIZE + x) * n);
+    }
+    page.version++;
+    page.patches.push({ seq: page.version, x, y, w, h });
+  }
+  /** Zero every page. One whole-page patch stands in for all the patches before it. */
+  clear() {
+    for (const page of this.pages) {
+      page.data.fill(0);
+      page.version++;
+      page.patches = [{ seq: page.version, x: 0, y: 0, w: PAGE_SIZE, h: PAGE_SIZE }];
+    }
+  }
+  /** Bring `cache`'s copy of page `pageIndex` up to date: a full upload the
+   *  first time, patches after. Returns false if the page doesn't exist yet. */
+  sync(cache, pageIndex) {
+    const page = this.pages[pageIndex];
+    if (!page) return false;
+    const n = this.format.channels;
+    const id = this.textureId(pageIndex);
+    let seen = this.uploaded.get(cache);
+    if (!seen) {
+      seen = /* @__PURE__ */ new Map();
+      this.uploaded.set(cache, seen);
+    }
+    if (!cache.has(id)) {
+      this.format.upload(cache, id, page.data);
+      seen.set(pageIndex, page.version);
+      return true;
+    }
+    const last = seen.get(pageIndex) ?? 0;
+    if (last >= page.version) return true;
+    for (const patch of page.patches) {
+      if (patch.seq <= last) continue;
+      const tight = new Uint8Array(patch.w * patch.h * n);
+      for (let row = 0; row < patch.h; row++) {
+        const src = ((patch.y + row) * PAGE_SIZE + patch.x) * n;
+        tight.set(page.data.subarray(src, src + patch.w * n), row * patch.w * n);
+      }
+      this.format.patch(cache, id, patch.x, patch.y, patch.w, patch.h, tight);
+    }
+    seen.set(pageIndex, page.version);
+    return true;
+  }
+};
+var fields = new PageSet({
+  channels: 1,
+  idPrefix: "weasel-dyn-sdf-page-",
+  upload: (cache, id, data) => cache.uploadR8(id, PAGE_SIZE, PAGE_SIZE, data),
+  patch: (cache, id, x, y, w, h, data) => cache.subImageR8(id, x, y, w, h, data)
+});
+var colors = new PageSet({
+  channels: 4,
+  idPrefix: "weasel-dyn-color-page-",
+  upload: (cache, id, data) => cache.uploadRGBA(id, PAGE_SIZE, PAGE_SIZE, data),
+  patch: (cache, id, x, y, w, h, data) => cache.subImageRGBA(id, x, y, w, h, data)
+});
+function blitToPage(pageIndex, x, y, w, h, bytes) {
+  fields.blit(pageIndex, x, y, w, h, bytes);
+}
+function blitToColorPage(pageIndex, x, y, w, h, rgba) {
+  colors.blit(pageIndex, x, y, w, h, rgba);
+}
+function clearPages() {
+  fields.clear();
+  colors.clear();
+}
+function dynamicPageTextureId(page) {
+  return fields.textureId(page);
+}
+function colorPageTextureId(page) {
+  return colors.textureId(page);
+}
+function syncDynamicPageTexture(cache, pageIndex) {
+  return fields.sync(cache, pageIndex);
+}
+function syncColorPageTexture(cache, pageIndex) {
+  return colors.sync(cache, pageIndex);
+}
+function _getPagesForTests() {
+  return fields.pages;
+}
+function _resetPagesForTests() {
+  fields.pages = [];
+  colors.pages = [];
 }
-var GENERIC_FAMILIES = /* @__PURE__ */ new Set([
-  "serif",
-  "sans-serif",
-  "monospace",
-  "cursive",
-  "fantasy",
-  "system-ui",
-  "ui-serif",
-  "ui-sans-serif",
-  "ui-monospace",
-  "ui-rounded",
-  "math",
-  "emoji",
-  "fangsong"
-]);
 
 // src/dynamic/shelfPack.ts
 var ShelfPacker = class {
@@ -208,13 +317,16 @@ var ShelfPacker = class {
   pageSize;
   maxPages;
   pages = [];
-  warned = false;
   get pageCount() {
     return this.pages.length;
   }
-  /** Allocate a w×h rect. Returns null (warning once) when capacity is out. */
+  /** Whether an empty page could hold a w×h rect. */
+  fits(w, h) {
+    return w <= this.pageSize && h <= this.pageSize;
+  }
+  /** Allocate a w×h rect. Returns null when capacity is out. */
   alloc(w, h) {
-    if (w > this.pageSize || h > this.pageSize) return this.fail();
+    if (!this.fits(w, h)) return null;
     for (let p = 0; p < this.pages.length; p++) {
       const spot = this.allocInPage(this.pages[p], w, h);
       if (spot) return { page: p, ...spot };
@@ -225,7 +337,7 @@ var ShelfPacker = class {
       const spot = this.allocInPage(page, w, h);
       if (spot) return { page: this.pages.length - 1, ...spot };
     }
-    return this.fail();
+    return null;
   }
   allocInPage(page, w, h) {
     for (const shelf of page.shelves) {
@@ -243,15 +355,6 @@ var ShelfPacker = class {
     }
     return null;
   }
-  fail() {
-    if (!this.warned) {
-      this.warned = true;
-      console.warn(
-        `weasel DynamicGlyphAtlas: glyph pages full (${this.maxPages} \xD7 ${this.pageSize}\xB2); further dynamic glyphs will not render.`
-      );
-    }
-    return null;
-  }
 };
 
 // src/dynamic/distanceTransform.ts
@@ -315,9 +418,179 @@ function alphaToSdf(alpha, width, height, radius, cutoff) {
   return out;
 }
 
+// src/dynamic/bakeQueue.ts
+var SDF_RADIUS = 8;
+var SDF_CUTOFF = 0.5;
+var DEFAULT_BAKE_BUDGET = 16;
+var newPacker = () => new ShelfPacker(PAGE_SIZE, MAX_PAGES);
+var fieldPacker = newPacker();
+var colorPacker = newPacker();
+var pending = [];
+var flushScheduled = false;
+var budget = DEFAULT_BAKE_BUDGET;
+var asked = 0;
+var settled = true;
+var reclaimScheduled = false;
+var forgetGlyphs = () => {
+};
+var warned = /* @__PURE__ */ new Set();
+function onPagesEmptied(forget) {
+  forgetGlyphs = forget;
+}
+function requestBake(char, raster) {
+  asked++;
+  if (raster.width === 0 || raster.height === 0) {
+    char.page = 0;
+    return;
+  }
+  if (budget > 0) {
+    budget--;
+    bake(char, raster);
+  } else {
+    pending.push({ char, raster });
+    scheduleFlush();
+  }
+}
+function dropBakes(chars) {
+  pending = pending.filter((job) => !chars.has(job.char));
+}
+function bake(char, raster) {
+  const color = "rgba" in raster;
+  const packer = color ? colorPacker : fieldPacker;
+  const spot = packer.alloc(raster.width, raster.height);
+  if (!spot) {
+    noRoom(packer, raster);
+    return;
+  }
+  if (color) {
+    blitToColorPage(spot.page, spot.x, spot.y, raster.width, raster.height, raster.rgba);
+  } else {
+    const sdf = alphaToSdf(raster.alpha, raster.width, raster.height, SDF_RADIUS, SDF_CUTOFF);
+    blitToPage(spot.page, spot.x, spot.y, raster.width, raster.height, sdf);
+  }
+  char.x = spot.x;
+  char.y = spot.y;
+  char.width = raster.width;
+  char.height = raster.height;
+  char.page = spot.page;
+}
+function noRoom(packer, raster) {
+  if (!packer.fits(raster.width, raster.height)) {
+    warnOnce("weasel DynamicGlyphAtlas: a glyph is larger than a page and will not render.");
+  } else if (!settled) {
+    warnOnce(
+      `weasel DynamicGlyphAtlas: more glyphs are in use at once than its pages hold (${MAX_PAGES} \xD7 ${PAGE_SIZE}\xB2); the rest will not render.`
+    );
+  } else if (!reclaimScheduled) {
+    reclaimScheduled = true;
+    setTimeout(reclaim, 0);
+  }
+}
+function warnOnce(message) {
+  if (warned.has(message)) return;
+  warned.add(message);
+  console.warn(message);
+}
+function reclaim() {
+  reclaimScheduled = false;
+  settled = false;
+  fieldPacker = newPacker();
+  colorPacker = newPacker();
+  pending = [];
+  clearPages();
+  forgetGlyphs();
+  notifyGlyphReady();
+}
+function scheduleFlush() {
+  if (flushScheduled) return;
+  flushScheduled = true;
+  setTimeout(flushPending, 0);
+}
+function flushPending() {
+  flushScheduled = false;
+  let n = 0;
+  while (pending.length > 0 && n < DEFAULT_BAKE_BUDGET) {
+    const job = pending.shift();
+    if (job.char.page !== -1) continue;
+    bake(job.char, job.raster);
+    n++;
+  }
+  if (pending.length > 0) scheduleFlush();
+  notifyGlyphBaked();
+}
+function resetBakeBudget(n = DEFAULT_BAKE_BUDGET) {
+  budget = n;
+  if (asked === 0 && pending.length === 0) settled = true;
+  asked = 0;
+}
+function _resetBakeQueueForTests() {
+  fieldPacker = newPacker();
+  colorPacker = newPacker();
+  pending = [];
+  flushScheduled = false;
+  asked = 0;
+  settled = true;
+  reclaimScheduled = false;
+  warned.clear();
+  budget = DEFAULT_BAKE_BUDGET;
+}
+
+// src/cssFamily.ts
+function cssFamilyName(family) {
+  if (/[,"']/.test(family)) return family;
+  return GENERIC_FAMILIES.has(family.trim().toLowerCase()) ? family.trim() : JSON.stringify(family);
+}
+var GENERIC_FAMILIES = /* @__PURE__ */ new Set([
+  "serif",
+  "sans-serif",
+  "monospace",
+  "cursive",
+  "fantasy",
+  "system-ui",
+  "ui-serif",
+  "ui-sans-serif",
+  "ui-monospace",
+  "ui-rounded",
+  "math",
+  "emoji",
+  "fangsong"
+]);
+
+// src/dynamic/fontLoads.ts
+function familyKey(family) {
+  return family.trim().replace(/^(["'])(.*)\1$/, "$2").toLowerCase();
+}
+function watchFontLoads(onLoaded) {
+  const fonts = typeof document === "undefined" ? void 0 : document.fonts;
+  if (!fonts?.addEventListener) return () => {
+  };
+  const listener = (event) => {
+    const faces4 = event.fontfaces ?? [];
+    if (faces4.length > 0) onLoaded(faces4.map((face) => face.family));
+  };
+  fonts.addEventListener("loadingdone", listener);
+  return () => fonts.removeEventListener("loadingdone", listener);
+}
+
 // src/dynamic/glyphRasterizer.ts
 var BAKE_SIZE = 48;
 var PAD = 8;
+var COLORED_BELOW = 240;
+function premultipliedColor(data) {
+  const out = new Uint8ClampedArray(data.length);
+  let colored = false;
+  for (let i = 0; i < data.length; i += 4) {
+    const a = data[i + 3];
+    if (a === 0) continue;
+    const r = data[i], g = data[i + 1], b = data[i + 2];
+    if (a >= 128 && Math.min(r, g, b) < COLORED_BELOW) colored = true;
+    out[i] = Math.round(r * a / 255);
+    out[i + 1] = Math.round(g * a / 255);
+    out[i + 2] = Math.round(b * a / 255);
+    out[i + 3] = a;
+  }
+  return colored ? out : null;
+}
 var METRICS_SIZE = 1e3;
 function cssFontString(weight, style, family, size = BAKE_SIZE) {
   return `${style === "italic" ? "italic " : ""}${weight} ${size}px ${cssFamilyName(family)}`;
@@ -340,6 +613,38 @@ function createCanvasRasterizer() {
     ctx.textBaseline = "alphabetic";
     ctx.textAlign = "left";
   }
+  function draw(family, weight, style, text) {
+    setFont(family, weight, style);
+    const m = ctx.measureText(text);
+    const advance = m.width;
+    const inkLeft = Math.ceil(m.actualBoundingBoxLeft ?? 0);
+    const inkRight = Math.ceil(m.actualBoundingBoxRight ?? advance);
+    const inkAscent = Math.ceil(m.actualBoundingBoxAscent ?? BAKE_SIZE * 0.8);
+    const inkDescent = Math.ceil(m.actualBoundingBoxDescent ?? BAKE_SIZE * 0.2);
+    const inkW = inkLeft + inkRight;
+    const inkH = inkAscent + inkDescent;
+    if (inkW <= 0 || inkH <= 0) {
+      return { data: new Uint8ClampedArray(0), width: 0, height: 0, left: 0, top: 0, advance };
+    }
+    const w = inkW + 2 * PAD;
+    const h = inkH + 2 * PAD;
+    if (canvas.width < w || canvas.height < h) {
+      canvas.width = Math.max(canvas.width, w);
+      canvas.height = Math.max(canvas.height, h);
+      setFont(family, weight, style);
+    }
+    ctx.clearRect(0, 0, w, h);
+    ctx.fillStyle = "#fff";
+    ctx.fillText(text, PAD + inkLeft, PAD + inkAscent);
+    return {
+      data: ctx.getImageData(0, 0, w, h).data,
+      width: w,
+      height: h,
+      left: -(inkLeft + PAD),
+      top: inkAscent + PAD,
+      advance
+    };
+  }
   return {
     faceMetrics(family, weight, style) {
       setFont(family, weight, style, METRICS_SIZE);
@@ -351,59 +656,33 @@ function createCanvasRasterizer() {
       };
     },
     rasterize(family, weight, style, codepoint) {
-      setFont(family, weight, style);
-      const chStr = String.fromCodePoint(codepoint);
-      const m = ctx.measureText(chStr);
-      const advance = m.width;
-      const inkLeft = Math.ceil(m.actualBoundingBoxLeft ?? 0);
-      const inkRight = Math.ceil(m.actualBoundingBoxRight ?? advance);
-      const inkAscent = Math.ceil(m.actualBoundingBoxAscent ?? BAKE_SIZE * 0.8);
-      const inkDescent = Math.ceil(m.actualBoundingBoxDescent ?? BAKE_SIZE * 0.2);
-      const inkW = inkLeft + inkRight;
-      const inkH = inkAscent + inkDescent;
-      if (inkW <= 0 || inkH <= 0) {
-        return { width: 0, height: 0, alpha: new Uint8ClampedArray(0), left: 0, top: 0, advance };
-      }
-      const w = inkW + 2 * PAD;
-      const h = inkH + 2 * PAD;
-      if (canvas.width < w || canvas.height < h) {
-        canvas.width = Math.max(canvas.width, w);
-        canvas.height = Math.max(canvas.height, h);
-        setFont(family, weight, style);
-      }
-      ctx.clearRect(0, 0, w, h);
-      ctx.fillStyle = "#fff";
-      ctx.fillText(chStr, PAD + inkLeft, PAD + inkAscent);
-      const img = ctx.getImageData(0, 0, w, h);
-      const alpha = new Uint8ClampedArray(w * h);
-      for (let i = 0; i < alpha.length; i++) alpha[i] = img.data[i * 4 + 3];
-      return {
-        width: w,
-        height: h,
-        alpha,
-        left: -(inkLeft + PAD),
-        top: inkAscent + PAD,
-        advance
-      };
+      const { data, ...box } = draw(family, weight, style, String.fromCodePoint(codepoint));
+      const alpha = new Uint8ClampedArray(box.width * box.height);
+      for (let i = 0; i < alpha.length; i++) alpha[i] = data[i * 4 + 3];
+      return { ...box, alpha };
+    },
+    rasterizeColor(family, weight, style, text) {
+      const { data, ...box } = draw(family, weight, style, text);
+      const rgba = premultipliedColor(data);
+      return rgba && { ...box, rgba };
     }
   };
 }
 
 // src/dynamic/dynamicAtlas.ts
-var PAGE_SIZE = 1024;
-var MAX_PAGES = 4;
-var SDF_RADIUS = 8;
-var SDF_CUTOFF = 0.5;
-var DEFAULT_BAKE_BUDGET = 16;
 var canvasFamilies = /* @__PURE__ */ new Set();
 var autoEnrolledFamilies = /* @__PURE__ */ new Set();
-var faces = /* @__PURE__ */ new Map();
-var pages = [];
-var packer = new ShelfPacker(PAGE_SIZE, MAX_PAGES);
-var pending = [];
-var flushScheduled = false;
-var budget = DEFAULT_BAKE_BUDGET;
+var faces2 = /* @__PURE__ */ new Map();
 var rasterizer = null;
+var stopWatchingLoads = null;
+function forgetGlyphs2(face) {
+  face.font.charMap.clear();
+  face.font.chars.length = 0;
+  face.clusters.clear();
+}
+onPagesEmptied(() => {
+  for (const face of faces2.values()) forgetGlyphs2(face);
+});
 function getRasterizer() {
   if (!rasterizer) rasterizer = createCanvasRasterizer();
   return rasterizer;
@@ -438,162 +717,105 @@ 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);
+  for (const key of [...faces2.keys()]) {
+    if (faces2.get(key).family === family) faces2.delete(key);
   }
   notifyGlyphReady();
 }
 function getDynamicFace(family, weight, style) {
   const key = `${family}|${weight}|${style}`;
-  const existing = faces.get(key);
+  const existing = faces2.get(key);
   if (existing) return existing;
   const r = getRasterizer();
-  const metrics = r.faceMetrics(family, weight, style);
-  const base = Math.round(metrics.ascent);
   const font = {
     info: { face: family, size: BAKE_SIZE },
-    common: {
-      lineHeight: Math.round(metrics.ascent + metrics.descent),
-      base,
-      scaleW: PAGE_SIZE,
-      scaleH: PAGE_SIZE
-    },
+    common: { lineHeight: 0, base: 0, scaleW: PAGE_SIZE, scaleH: PAGE_SIZE },
     chars: [],
     kernings: [],
     // no kerning in v1 (measured-pair kerning is future work)
     charMap: /* @__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 }
+    kerningMap: /* @__PURE__ */ new Map()
   };
+  const record = (id, raster) => ({
+    id,
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0,
+    xoffset: raster.left,
+    yoffset: font.common.base - raster.top,
+    xadvance: raster.advance,
+    page: -1
+  });
+  const clusters = /* @__PURE__ */ new Map();
   const face = {
     family,
     weight,
     style,
     font,
+    clusters,
     requestGlyph(cp) {
       const cached = font.charMap.get(cp);
       if (cached) return cached;
       const raster = r.rasterize(family, weight, style, cp);
-      const char = {
-        id: cp,
-        x: 0,
-        y: 0,
-        width: 0,
-        height: 0,
-        xoffset: raster.left,
-        yoffset: base - raster.top,
-        xadvance: raster.advance,
-        page: -1
-      };
+      const char = record(cp, raster);
       font.charMap.set(cp, char);
       font.chars.push(char);
-      if (raster.width === 0 || raster.height === 0) {
-        char.page = 0;
-        return char;
-      }
-      if (budget > 0) {
-        budget--;
-        bake(char, raster);
-      } else {
-        pending.push({ char, raster });
-        scheduleFlush();
-      }
+      requestBake(char, raster);
+      return char;
+    },
+    requestCluster(text) {
+      const cached = clusters.get(text);
+      if (cached !== void 0) return cached;
+      const raster = r.rasterizeColor?.(family, weight, style, text) ?? null;
+      const char = raster && { ...record(text.codePointAt(0), raster), color: true };
+      clusters.set(text, char);
+      if (char && raster) requestBake(char, raster);
       return char;
     }
   };
-  faces.set(key, face);
+  measureFace(face);
+  faces2.set(key, face);
+  stopWatchingLoads ??= watchFontLoads(refreshFamilies);
   return face;
 }
-function bake(char, raster) {
-  const spot = packer.alloc(raster.width, raster.height);
-  if (!spot) return;
-  const sdf = alphaToSdf(raster.alpha, raster.width, raster.height, SDF_RADIUS, SDF_CUTOFF);
-  while (pages.length <= spot.page) {
-    pages.push({ data: new Uint8Array(PAGE_SIZE * PAGE_SIZE), version: 0, patches: [] });
-  }
-  const page = pages[spot.page];
-  for (let row = 0; row < raster.height; row++) {
-    page.data.set(
-      sdf.subarray(row * raster.width, (row + 1) * raster.width),
-      (spot.y + row) * PAGE_SIZE + spot.x
-    );
-  }
-  page.version++;
-  page.patches.push({ seq: page.version, x: spot.x, y: spot.y, w: raster.width, h: raster.height });
-  char.x = spot.x;
-  char.y = spot.y;
-  char.width = raster.width;
-  char.height = raster.height;
-  char.page = spot.page;
-}
-function scheduleFlush() {
-  if (flushScheduled) return;
-  flushScheduled = true;
-  setTimeout(flushPending, 0);
-}
-function flushPending() {
-  flushScheduled = false;
-  let n = 0;
-  while (pending.length > 0 && n < DEFAULT_BAKE_BUDGET) {
-    const job = pending.shift();
-    if (job.char.page !== -1) continue;
-    bake(job.char, job.raster);
-    n++;
-  }
-  if (pending.length > 0) scheduleFlush();
+function measureFace(face) {
+  const { font } = face;
+  const metrics = getRasterizer().faceMetrics(face.family, face.weight, face.style);
+  font.common.lineHeight = Math.round(metrics.ascent + metrics.descent);
+  font.common.base = Math.round(metrics.ascent);
+  font.faceMetrics = { ascent: metrics.ascent / BAKE_SIZE, descent: metrics.descent / BAKE_SIZE };
+  forgetGlyphs2(face);
+}
+function refreshCanvasFont(family) {
+  refreshFamilies(family === void 0 ? null : [family]);
+}
+function refreshFamilies(families) {
+  const keys = families && new Set(families.map(familyKey));
+  const dropped = /* @__PURE__ */ new Set();
+  let measured = 0;
+  for (const face of faces2.values()) {
+    if (keys && !face.family.split(",").some((name) => keys.has(familyKey(name)))) continue;
+    for (const char of face.font.chars) dropped.add(char);
+    for (const char of face.clusters.values()) if (char) dropped.add(char);
+    measureFace(face);
+    measured++;
+  }
+  if (measured === 0) return;
+  dropBakes(dropped);
   notifyGlyphReady();
 }
-function resetBakeBudget(n = DEFAULT_BAKE_BUDGET) {
-  budget = n;
-}
-function dynamicPageTextureId(page) {
-  return `weasel-dyn-sdf-page-${page}`;
-}
-var uploadedVersions = /* @__PURE__ */ new WeakMap();
-function syncDynamicPageTexture(cache, pageIndex) {
-  const page = pages[pageIndex];
-  if (!page) return false;
-  const id = dynamicPageTextureId(pageIndex);
-  let seen = uploadedVersions.get(cache);
-  if (!seen) {
-    seen = /* @__PURE__ */ new Map();
-    uploadedVersions.set(cache, seen);
-  }
-  if (!cache.has(id)) {
-    cache.uploadR8(id, PAGE_SIZE, PAGE_SIZE, page.data);
-    seen.set(pageIndex, page.version);
-    return true;
-  }
-  const last = seen.get(pageIndex) ?? 0;
-  if (last >= page.version) return true;
-  for (const patch of page.patches) {
-    if (patch.seq <= last) continue;
-    const tight = new Uint8Array(patch.w * patch.h);
-    for (let row = 0; row < patch.h; row++) {
-      const src = (patch.y + row) * PAGE_SIZE + patch.x;
-      tight.set(page.data.subarray(src, src + patch.w), row * patch.w);
-    }
-    cache.subImageR8(id, patch.x, patch.y, patch.w, patch.h, tight);
-  }
-  seen.set(pageIndex, page.version);
-  return true;
-}
 function __setGlyphRasterizerForTests(r) {
   rasterizer = r;
 }
-function _getPagesForTests() {
-  return pages;
-}
 function _resetDynamicFontsForTests() {
   canvasFamilies.clear();
   autoEnrolledFamilies.clear();
-  faces = /* @__PURE__ */ new Map();
-  pages = [];
-  packer = new ShelfPacker(PAGE_SIZE, MAX_PAGES);
-  pending = [];
-  flushScheduled = false;
-  budget = DEFAULT_BAKE_BUDGET;
+  faces2 = /* @__PURE__ */ new Map();
+  _resetPagesForTests();
+  _resetBakeQueueForTests();
+  stopWatchingLoads?.();
+  stopWatchingLoads = null;
   _clearGlyphReadySubscribers();
   rasterizer = null;
 }
@@ -601,9 +823,7 @@ function _resetDynamicFontsForTests() {
 // src/outline/OutlineFace.ts
 var OUTLINE_PRECISION = 5;
 
-// src/outline/sfnt.ts
-var SFNT_HEADER_BYTES = 12;
-var TABLE_RECORD_BYTES = 16;
+// src/outline/tag.ts
 function tagAt(view, offset) {
   return String.fromCharCode(
     view.getUint8(offset),
@@ -612,10 +832,11 @@ function tagAt(view, offset) {
     view.getUint8(offset + 3)
   );
 }
-function isFontCollection(bytes) {
-  if (bytes.byteLength < 4) return false;
-  return tagAt(new DataView(bytes), 0) === "ttcf";
-}
+
+// src/outline/dataFork.ts
+var RESOURCE_HEADER_BYTES = 16;
+var TYPE_ENTRY_BYTES = 8;
+var REFERENCE_BYTES = 12;
 var FONT_SIGNATURES = /* @__PURE__ */ new Set([
   "\0
\0\0",
   "true",
@@ -625,7 +846,6 @@ var FONT_SIGNATURES = /* @__PURE__ */ new Set([
   "wOFF",
   "wOF2"
 ]);
-var RESOURCE_HEADER_BYTES = 16;
 function isDataForkFont(bytes) {
   if (bytes.byteLength < RESOURCE_HEADER_BYTES) return false;
   const view = new DataView(bytes);
@@ -636,6 +856,46 @@ function isDataForkFont(bytes) {
   const mapLength = view.getUint32(12);
   return dataOffset >= RESOURCE_HEADER_BYTES && dataOffset + dataLength === mapOffset && mapOffset + mapLength <= bytes.byteLength;
 }
+var truncated = () => new Error("Datafork TrueType (.dfont) is truncated: a resource runs past the end of its segment.");
+function sfntResources(bytes) {
+  const view = new DataView(bytes);
+  const dataOffset = view.getUint32(0);
+  const mapOffset = view.getUint32(4);
+  const dataLength = view.getUint32(8);
+  const mapEnd = mapOffset + view.getUint32(12);
+  const inMap = (at, count) => at >= mapOffset && at + count <= mapEnd;
+  if (!inMap(mapOffset + 24, 2)) return [];
+  const typeList = mapOffset + view.getUint16(mapOffset + 24);
+  if (!inMap(typeList, 2)) return [];
+  const typeCount = view.getUint16(typeList) + 1 & 65535;
+  const out = [];
+  for (let t = 0; t < typeCount; t++) {
+    const entry = typeList + 2 + t * TYPE_ENTRY_BYTES;
+    if (!inMap(entry, TYPE_ENTRY_BYTES)) throw truncated();
+    if (tagAt(view, entry) !== "sfnt") continue;
+    const count = view.getUint16(entry + 4) + 1;
+    const references = typeList + view.getUint16(entry + 6);
+    for (let i = 0; i < count; i++) {
+      const ref = references + i * REFERENCE_BYTES;
+      if (!inMap(ref, REFERENCE_BYTES)) throw truncated();
+      const offset = view.getUint32(ref + 4) & 16777215;
+      if (offset + 4 > dataLength) throw truncated();
+      const start = dataOffset + offset + 4;
+      const length = view.getUint32(start - 4);
+      if (offset + 4 + length > dataLength) throw truncated();
+      out.push(bytes.slice(start, start + length));
+    }
+  }
+  return out;
+}
+
+// src/outline/sfnt.ts
+var SFNT_HEADER_BYTES = 12;
+var TABLE_RECORD_BYTES = 16;
+function isFontCollection(bytes) {
+  if (bytes.byteLength < 4) return false;
+  return tagAt(new DataView(bytes), 0) === "ttcf";
+}
 function readTableDirectory(view, dirOffset) {
   const numTables = view.getUint16(dirOffset + 4);
   const records = [];
@@ -674,7 +934,12 @@ function extractFont(source, view, dirOffset) {
   const records = readTableDirectory(view, dirOffset);
   const padded = (n) => n + 3 & -4;
   let total = SFNT_HEADER_BYTES + records.length * TABLE_RECORD_BYTES;
-  for (const r of records) total += padded(r.length);
+  for (const r of records) {
+    if (r.offset + r.length > source.byteLength) {
+      throw new Error(`font collection is truncated: table "${r.tag}" runs past the end of the file`);
+    }
+    total += padded(r.length);
+  }
   const out = new ArrayBuffer(total);
   const dst = new DataView(out);
   const dstBytes = new Uint8Array(out);
@@ -699,26 +964,34 @@ function extractFont(source, view, dirOffset) {
   return out;
 }
 function sfntFromCollection(bytes, postScriptName) {
+  const members = membersOf(bytes);
+  if (!members) return { bytes, matched: true, names: [] };
+  const names2 = members.map((m) => m.name);
+  const at = postScriptName ? names2.indexOf(postScriptName) : 0;
+  return { bytes: members[Math.max(at, 0)].bytes(), matched: at >= 0, names: names2 };
+}
+function membersOf(bytes) {
   if (isDataForkFont(bytes)) {
-    throw new Error(
-      "Datafork TrueType (.dfont) is not supported \u2014 the outline tier reads sfnt tables and a .dfont holds them inside a Macintosh resource map."
-    );
+    const fonts = sfntResources(bytes);
+    if (fonts.length === 0) throw new Error("Datafork TrueType (.dfont) holds no sfnt resource.");
+    return fonts.map((font) => {
+      const view2 = new DataView(font);
+      return { name: postScriptNameAt(view2, readTableDirectory(view2, 0)), bytes: () => font };
+    });
   }
-  if (!isFontCollection(bytes)) return { bytes, matched: true };
+  if (!isFontCollection(bytes)) return null;
   const view = new DataView(bytes);
   const numFonts = view.getUint32(8);
   if (numFonts === 0) throw new Error("font collection contains no fonts");
-  const offsets = [];
-  for (let i = 0; i < numFonts; i++) offsets.push(view.getUint32(12 + i * 4));
-  if (postScriptName) {
-    for (const dirOffset of offsets) {
-      const records = readTableDirectory(view, dirOffset);
-      if (postScriptNameAt(view, records) === postScriptName) {
-        return { bytes: extractFont(bytes, view, dirOffset), matched: true };
-      }
-    }
+  const members = [];
+  for (let i = 0; i < numFonts; i++) {
+    const dirOffset = view.getUint32(12 + i * 4);
+    members.push({
+      name: postScriptNameAt(view, readTableDirectory(view, dirOffset)),
+      bytes: () => extractFont(bytes, view, dirOffset)
+    });
   }
-  return { bytes: extractFont(bytes, view, offsets[0]), matched: !postScriptName };
+  return members;
 }
 
 // src/outline/gposKerning.ts
@@ -919,7 +1192,12 @@ function faceFor(font, gpos) {
 function createOpenTypeParser(postScriptName) {
   return async (bytes) => {
     const parse = parserOf(await loadOpenType());
-    const { bytes: single } = sfntFromCollection(bytes, postScriptName);
+    const { bytes: single, matched, names: names2 } = sfntFromCollection(bytes, postScriptName);
+    if (!matched) {
+      throw new Error(
+        `no member of the font file is named "${postScriptName}" (it holds ${names2.join(", ")})`
+      );
+    }
     return faceFor(parse(single), gposPairKerning(single));
   };
 }
@@ -996,7 +1274,7 @@ function glyphOutline(family, weight, style, cp) {
     const raw = slot.face.glyphD(cp);
     d = raw === null ? null : closeContours(raw);
   } catch (err) {
-    warnOnce(
+    warnOnce2(
       `glyph|${slotKey(family, weight, style)}`,
       `weasel: outline face "${family}" (${weight}/${style}) could not produce a glyph for U+${cp.toString(16).toUpperCase().padStart(4, "0")} \u2014 ${err instanceof Error ? err.message : String(err)}. Falling back to the SDF tier.`
     );
@@ -1038,7 +1316,7 @@ async function runLoad(slot) {
     slot.status = "failed";
     slots.bump();
     notifyGlyphReady();
-    warnOnce(
+    warnOnce2(
       `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.`
     );
@@ -1074,15 +1352,15 @@ async function readSource(source) {
   if (resolved instanceof ArrayBuffer) return resolved;
   return resolved.arrayBuffer();
 }
-var warned = /* @__PURE__ */ new Set();
-function warnOnce(key, message) {
-  if (warned.has(key)) return;
-  warned.add(key);
+var warned2 = /* @__PURE__ */ new Set();
+function warnOnce2(key, message) {
+  if (warned2.has(key)) return;
+  warned2.add(key);
   console.warn(message);
 }
 function _resetFontOutlinesForTests() {
   slots.clear();
-  warned.clear();
+  warned2.clear();
 }
 var registry = createReflectable();
 var fontRegistry = registry.reflection;
@@ -1301,6 +1579,7 @@ function missResolveResult(family, weight, style, suppressWarn = false) {
       source: "outline"
     };
   }
+  if (fontPending(family, weight, style)) return pendingMiss(family, weight, style);
   const policy2 = getFontFallbackPolicy();
   if (policy2 === "canvas") {
     autoEnrollCanvasFont(family);
@@ -1506,8 +1785,8 @@ function resolveFontVariantInternal(family, weight, style, suppressWarn) {
 
 // src/domFace.ts
 var names = /* @__PURE__ */ new Map();
-var faces2 = /* @__PURE__ */ new Map();
-var warned2 = /* @__PURE__ */ new Set();
+var faces3 = /* @__PURE__ */ new Map();
+var warned3 = /* @__PURE__ */ new Set();
 function domFonts() {
   return typeof FontFace !== "undefined" && typeof document !== "undefined" && !!document.fonts;
 }
@@ -1531,8 +1810,8 @@ function privateFamily(family, variant) {
   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);
+    if (resolved.entry && !warned3.has(target)) {
+      warned3.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).`
       );
@@ -1556,7 +1835,7 @@ function cssFontFamilyLoading(family, variant = {}) {
   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);
+  const pending2 = (exact.length > 0 ? exact : priv.variants).map((v) => faces3.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(() => {
   });
 }
@@ -1564,7 +1843,7 @@ 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);
+  const have = faces3.get(key);
   if (have?.from === css.registration) return;
   if (have?.face) document.fonts.delete(have.face);
   let settle2;
@@ -1580,10 +1859,10 @@ function ensureFace(name, family, weight, style, bytes) {
     entry.settled = true;
     settle2();
   };
-  faces2.set(key, entry);
+  faces3.set(key, entry);
   const descriptors = { weight: String(weight), style, display: "swap" };
   const add = (face) => {
-    if (faces2.get(key) !== entry) return finish();
+    if (faces3.get(key) !== entry) return finish();
     entry.face = face;
     document.fonts.add(face);
     face.load().then(finish, () => {
@@ -1598,13 +1877,13 @@ function ensureFace(name, family, weight, style, bytes) {
 }
 function _resetDomFacesForTests() {
   if (typeof document !== "undefined" && document.fonts) {
-    for (const { face } of faces2.values()) if (face) document.fonts.delete(face);
+    for (const { face } of faces3.values()) if (face) document.fonts.delete(face);
   }
   names.clear();
-  faces2.clear();
-  warned2.clear();
+  faces3.clear();
+  warned3.clear();
 }
 
-export { DEFAULT_BAKE_BUDGET, FIXTURE_FONT, PAGE_SIZE, SDF_RADIUS, __setGlyphRasterizerForTests, _getPagesForTests, _resetDomFacesForTests, _resetDynamicFontsForTests, _resetFallbackForTests, _resetFontOutlinesForTests, _resetFontRegistryForTests, createOpenTypeParser, cssFamilyName, 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-OYLAXZOV.js.map
-//# sourceMappingURL=chunk-OYLAXZOV.js.map
+export { DEFAULT_BAKE_BUDGET, FIXTURE_FONT, PAGE_SIZE, SDF_RADIUS, __setGlyphRasterizerForTests, _getPagesForTests, _resetDomFacesForTests, _resetDynamicFontsForTests, _resetFallbackForTests, _resetFontOutlinesForTests, _resetFontRegistryForTests, claimFallbackWarning, colorPageTextureId, createOpenTypeParser, cssFamilyName, cssFontFamily, cssFontFamilyLoading, dynamicPageTextureId, ensureFontTexture, faceGeneration, faceMetricsFor, faceMetricsFromTables, faceMetricsOf, fallbackWarningClaimed, fontOutlineRegistry, fontPending, fontRegistry, getDefaultFontFamily, getFont, getFontFallbackPolicy, glyphGeneration, glyphOutline, hasFontOutlines, isCanvasFont, listCanvasFonts, listFontOutlines, listFontWeights, listFonts, loadFontOutlines, markAllFontsNotUploaded, outlineMetrics, outlineStatus, parseBmFont, refreshCanvasFont, registerCanvasFont, registerFont, registerFontOutlines, resetBakeBudget, resolveFontVariant, resolveGlyphFallback, setDefaultFontFamily, setFontFallbackPolicy, subscribeGlyphReady, syncColorPageTexture, syncDynamicPageTexture, textureCacheKey, unregisterCanvasFont, unregisterFontOutlines, verticalMetricsFromTables, warmFonts };
+//# sourceMappingURL=chunk-NM6K6M4Y.js.map
+//# sourceMappingURL=chunk-NM6K6M4Y.js.map