@onceworlds/cli 0.9.4 → 0.9.5

package/dist/cli.js

@@ -2,10 +2,10 @@
 
 // src/index.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
-import { createHash as createHash3 } from "node:crypto";
-import { existsSync as existsSync8, watch } from "node:fs";
+import { createHash as createHash4 } from "node:crypto";
+import { existsSync as existsSync9, watch } from "node:fs";
 import { mkdir as mkdir4, readdir as readdir3, readFile as readFile5, stat as stat2, writeFile as writeFile4 } from "node:fs/promises";
-import { basename as basename4, dirname as dirname8, join as join12, resolve as resolve9, sep as sep2 } from "node:path";
+import { basename as basename5, dirname as dirname9, join as join13, resolve as resolve10, sep as sep3 } from "node:path";
 import { parseArgs } from "node:util";
 
 // src/check.ts
@@ -1151,6 +1151,9 @@ function missingControls(listed, wanted) {
 }
 
 // src/glyphs.ts
+function unionCoverage(parts, unchecked = []) {
+  return { has: (code) => parts.some((p) => p.coverage.has(code)), names: parts.map((p) => p.name), unchecked };
+}
 var SORA_RANGES = "U+0000-00FF,U+0131,U+0152-0153,U+02BB-02BC,U+02C6,U+02DA,U+02DC,U+0304,U+0308,U+0329,U+2000-206F,U+20AC,U+2122,U+2191,U+2193,U+2212,U+2215,U+FEFF,U+FFFD,U+0100-02BA,U+02BD-02C5,U+02C7-02CC,U+02CE-02D7,U+02DD-02FF,U+1D00-1DBF,U+1E00-1E9F,U+1EF2-1EFF,U+2020,U+20A0-20AB,U+20AD-20C0,U+2113,U+2C60-2C7F,U+A720-A7FF";
 function rangeCoverage(ranges = SORA_RANGES) {
   const spans = ranges.split(",").map((part) => {
@@ -1174,9 +1177,12 @@ function missingGlyphs(texts, font, max = 12) {
   }
   return out;
 }
-function glyphNote(missing) {
+function glyphNote(missing, fonts = {}) {
   const codes = missing.map((ch) => `U+${ch.codePointAt(0).toString(16).toUpperCase().padStart(4, "0")}`);
-  return `text uses characters the engine's font (Sora) can't draw: ${missing.join(" ")} (${codes.join(", ")}). A browser draws them in whatever font the device has, so they look different on every phone or come out as boxes (shot draws boxes). Draw them as shapes (Shape2D, ui.draw.circle and polygon, UI.custom), or load a font that has them (loadFont, the theme's font) and draw the text in it`;
+  const names = fonts.names && fonts.names.length > 0 ? fonts.names : ["Sora"];
+  const which = names.length > 1 ? `its fonts (${names.join(", ")})` : names[0] === "Sora" ? "the engine's font (Sora)" : `its font (${names[0]})`;
+  const unchecked = fonts.unchecked && fonts.unchecked.length > 0 ? ` (${fonts.unchecked.join(", ")} could not be had to look in)` : "";
+  return `text uses characters ${which} can't draw: ${missing.join(" ")} (${codes.join(", ")})${unchecked}. A browser draws them in whatever font the device has, so they look different on every phone or come out as boxes (shot draws boxes). Draw them as shapes (Shape2D, ui.draw.circle and polygon, UI.custom), or load a font that has them (loadFont, the theme's font) and draw the text in it`;
 }
 
 // src/check.ts
@@ -1641,8 +1647,9 @@ async function checkEngineGame(options) {
     );
   }
   lines.push(...budgetLines(smoke.budget));
-  const missing = smoke.budget?.chars ? missingGlyphs([smoke.budget.chars], options.font ?? rangeCoverage()) : [];
-  if (missing.length > 0) lines.push(`! The ${glyphNote(missing)}.`);
+  const coverage2 = options.font ?? rangeCoverage();
+  const missing = smoke.budget?.chars ? missingGlyphs([smoke.budget.chars], coverage2) : [];
+  if (missing.length > 0) lines.push(`! The ${glyphNote(missing, coverage2)}.`);
   if (smoke.dump) lines.push("\xB7 The end of the first match (game.debug.text()):", ...smoke.dump.split("\n").slice(0, 24).map((l) => `    ${l}`));
   const problems = smoke.problems ?? [];
   if (problems.length > 0) {
@@ -2607,8 +2614,8 @@ function gitignoreText() {
 }
 function missingIgnores(existing) {
   const norm = (line2) => line2.trim().replace(/^\//, "").replace(/\/$/, "");
-  const have = new Set(existing.split(/\r?\n/).map(norm).filter((line2) => line2 && !line2.startsWith("#")));
-  return IGNORED.filter(({ line: line2, needed }) => needed && !have.has(norm(line2))).map(({ line: line2 }) => line2);
+  const have2 = new Set(existing.split(/\r?\n/).map(norm).filter((line2) => line2 && !line2.startsWith("#")));
+  return IGNORED.filter(({ line: line2, needed }) => needed && !have2.has(norm(line2))).map(({ line: line2 }) => line2);
 }
 
 // src/init.ts
@@ -2751,7 +2758,7 @@ import { fileURLToPath } from "node:url";
 // ../engine/package.json
 var package_default = {
   name: "@onceworlds/engine",
-  version: "1.3.2",
+  version: "1.4.0",
   description: "The Onceworlds game engine: entities, components, systems, fixed-step time, and the platform's rooms, matches and saves built in.",
   homepage: "https://onceworlds.com/docs",
   type: "module",
@@ -3381,7 +3388,7 @@ import { spawn as spawn2 } from "node:child_process";
 import { existsSync as existsSync3, mkdirSync, mkdtempSync, readdirSync as readdirSync2, rmSync, writeFileSync } from "node:fs";
 import { homedir as homedir2, tmpdir } from "node:os";
 import { dirname as dirname5, join as join5 } from "node:path";
-var sleep = (ms) => new Promise((resolve10) => setTimeout(resolve10, ms));
+var sleep = (ms) => new Promise((resolve11) => setTimeout(resolve11, ms));
 var ARROWS = { ArrowLeft: 37, ArrowUp: 38, ArrowRight: 39, ArrowDown: 40 };
 function keyInfo(key) {
   if (key in ARROWS) return { key, code: key, windowsVirtualKeyCode: ARROWS[key] };
@@ -3475,8 +3482,8 @@ async function launch(options) {
     throw new Error(`The browser (${binary}) did not start.`);
   }
   const ws = new WebSocket(version.webSocketDebuggerUrl);
-  await new Promise((resolve10, reject) => {
-    ws.onopen = () => resolve10();
+  await new Promise((resolve11, reject) => {
+    ws.onopen = () => resolve11();
     ws.onerror = () => reject(new Error("Could not talk to the browser."));
   });
   let nextId = 1;
@@ -3497,10 +3504,10 @@ async function launch(options) {
     for (const waiting of pending.values()) waiting.reject(new Error("the browser is gone"));
     pending.clear();
   };
-  const send2 = (method, params = {}, sessionId) => new Promise((resolve10, reject) => {
+  const send2 = (method, params = {}, sessionId) => new Promise((resolve11, reject) => {
     const id = nextId++;
     const timer = setTimeout(() => (pending.delete(id), reject(new Error(`${method}: the browser did not answer in 90 s`))), 9e4);
-    pending.set(id, { resolve: (value) => (clearTimeout(timer), resolve10(value)), reject: (error) => (clearTimeout(timer), reject(error)) });
+    pending.set(id, { resolve: (value) => (clearTimeout(timer), resolve11(value)), reject: (error) => (clearTimeout(timer), reject(error)) });
     if (ws.readyState !== 1) return pending.get(id).reject(new Error(`${method}: the browser is gone`));
     ws.send(JSON.stringify({ id, method, params, sessionId }));
   });
@@ -3646,7 +3653,7 @@ function saveFile(file, bytes) {
 }
 
 // src/posters.ts
-var sleep2 = (ms) => new Promise((resolve10) => setTimeout(resolve10, ms));
+var sleep2 = (ms) => new Promise((resolve11) => setTimeout(resolve11, ms));
 function defaultPosterSize(name) {
   if (/icon/i.test(name)) return { width: 512, height: 512 };
   if (/badge/i.test(name)) return { width: 256, height: 256 };
@@ -3778,7 +3785,7 @@ function openBrowser(url) {
   } catch {
   }
 }
-var sleep3 = (ms) => new Promise((resolve10) => setTimeout(resolve10, ms));
+var sleep3 = (ms) => new Promise((resolve11) => setTimeout(resolve11, ms));
 async function login(api2) {
   const started = await post(`${api2}/api/cli/device`, { label: deviceLabel() });
   if (started.status !== 200) throw new Error(String(started.data.message ?? `Login failed (${started.status}).`));
@@ -3822,7 +3829,7 @@ async function logout(api2) {
 import { join as join7 } from "node:path";
 var QUICK = ["join", "start", "reload-guest", "reload-host", "drop-host", "phone"];
 var ALL = ["join", "start", "reload-guest", "reload-host", "drop-guest", "drop-host", "two-away", "spectator", "second-match", "rapid-ready", "phone"];
-var sleep4 = (ms) => new Promise((resolve10) => setTimeout(resolve10, ms));
+var sleep4 = (ms) => new Promise((resolve11) => setTimeout(resolve11, ms));
 async function until(fn, ms = 15e3, step = 250) {
   const end = Date.now() + ms;
   for (; ; ) {
@@ -4862,7 +4869,7 @@ var TOOLS = [
   {
     name: "screenshot",
     title: "See the game",
-    description: 'A picture of the game to look at: the first player\'s screen `at` seconds into a simulated match with bots (default 8), the title screen (phase: "title") or the lobby (phase: "lobby": Play pressed, nobody ready), or a poster (poster: "cover", "icon"...). story: true is the first minute as a new player lives it, frame by frame on one contact sheet, with the questions to ask of it. 2D draws without a browser; 3D (or browser: true) needs Chrome. Engine games, after npm install.',
+    description: 'A picture of the game to look at: the first player\'s screen `at` seconds into a simulated match with bots (default 8), the title screen (phase: "title") or the lobby (phase: "lobby": Play pressed, nobody ready), or a poster (poster: "cover", "icon"...). story: true is the first minute as a new player lives it, frame by frame on one contact sheet, with the questions to ask of it. 2D draws without a browser, text in the game\'s own fonts (not the HTML overlay: browser: true draws it); 3D (or browser: true) needs Chrome. Engine games, after npm install.',
     inputSchema: {
       type: "object",
       properties: {
@@ -5255,13 +5262,13 @@ function formatStatus(raw) {
 }
 
 // src/shot.ts
-import { existsSync as existsSync6, mkdtempSync as mkdtempSync2, readFileSync as readFileSync5, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "node:fs";
-import { tmpdir as tmpdir3 } from "node:os";
-import { join as join10, resolve as resolve7 } from "node:path";
+import { existsSync as existsSync7, mkdtempSync as mkdtempSync2, readFileSync as readFileSync6, rmSync as rmSync2, writeFileSync as writeFileSync4 } from "node:fs";
+import { tmpdir as tmpdir4 } from "node:os";
+import { join as join11, resolve as resolve8 } from "node:path";
 import { fileURLToPath as fileURLToPath3, pathToFileURL as pathToFileURL3 } from "node:url";
 
 // src/font.ts
-import { brotliDecompressSync } from "node:zlib";
+import { brotliDecompressSync, inflateSync as inflateSync2 } from "node:zlib";
 var KNOWN_TAGS = [
   "cmap",
   "head",
@@ -5564,7 +5571,8 @@ function plainGlyphs(glyf, loca, numGlyphs, longOffsets) {
       continue;
     }
     const ends = Array.from({ length: count }, () => r.u16());
-    r.at += r.u16();
+    const instructions = r.u16();
+    r.at += instructions;
     const total = count ? ends[count - 1] + 1 : 0;
     const fl = [];
     while (fl.length < total) {
@@ -5649,10 +5657,35 @@ function readCmap(data) {
     return 0;
   };
 }
+function woffTables(bytes) {
+  const r = new Reader(bytes);
+  r.at = 12;
+  const numTables = r.u16();
+  r.at = 44;
+  const tables = /* @__PURE__ */ new Map();
+  for (let i = 0; i < numTables; i++) {
+    const tag = tagOf(r);
+    const offset = r.u32();
+    const compLength = r.u32();
+    const origLength = r.u32();
+    r.u32();
+    if (offset + compLength > bytes.length) throw new Error("the font ends early");
+    const stored = bytes.subarray(offset, offset + compLength);
+    const data = compLength < origLength ? new Uint8Array(inflateSync2(stored)) : stored;
+    tables.set(tag, { data, transformed: false });
+  }
+  return tables;
+}
+var tagAt = (bytes, at) => String.fromCharCode(bytes[at], bytes[at + 1], bytes[at + 2], bytes[at + 3]);
 function readFont(bytes) {
+  if (bytes.length < 12) throw new Error("not a font");
   let tables;
-  const magic = String.fromCharCode(bytes[0], bytes[1], bytes[2], bytes[3]);
+  const magic = tagAt(bytes, 0);
+  const flavor = magic === "wOF2" || magic === "wOFF" ? tagAt(bytes, 4) : magic;
+  if (flavor === "OTTO") throw new Error("CFF outlines (an OpenType font with PostScript outlines) are not read");
+  if (flavor !== "\0
\0\0" && flavor !== "true") throw new Error(magic === "ttcf" ? "a font collection is not read" : "not a font");
   if (magic === "wOF2") tables = woff2Tables(bytes).tables;
+  else if (magic === "wOFF") tables = woffTables(bytes);
   else {
     tables = /* @__PURE__ */ new Map();
     const r = new Reader(bytes);
@@ -5699,6 +5732,12 @@ function readFont(bytes) {
   const raw = glyf.transformed ? transformedGlyphs(glyf.data) : plainGlyphs(glyf.data, table("loca").data, numGlyphs, longOffsets);
   const toGlyph = readCmap(table("cmap").data);
   let weight = 400;
+  const os2 = tables.get("OS/2");
+  if (os2 && os2.data.length >= 6) {
+    const declared = os2.data[4] << 8 | os2.data[5];
+    const w = declared > 0 && declared < 10 ? declared * 100 : declared;
+    if (w >= 100 && w <= 1e3) weight = w;
+  }
   const fvar = tables.get("fvar");
   if (fvar) {
     const r = new Reader(fvar.data);
@@ -5764,6 +5803,591 @@ function fontStackOf(fonts) {
     has: (code) => fonts.some((f) => f.has(code))
   };
 }
+var FONT_FAMILY_LIST = /(?:^|\s)[+-]?(?:\d+\.?\d*|\.\d+)(?:px|pt|pc|em|rem|ex|ch|%|vh|vw|vmin|vmax|mm|cm|in|q)(?:\s*\/\s*\S+)?\s+(\S.*)$/i;
+function familiesOf(css) {
+  const list = FONT_FAMILY_LIST.exec(css)?.[1] ?? css;
+  return list.split(",").map((f) => f.trim().replace(/^(['"])(.*)\1$/, "$2").trim().toLowerCase()).filter(Boolean);
+}
+var picked = /* @__PURE__ */ new WeakMap();
+function pickFont(book, css) {
+  let known = picked.get(book);
+  if (!known) picked.set(book, known = /* @__PURE__ */ new Map());
+  const seen = known.get(css);
+  if (seen !== void 0) return seen;
+  let font = book.fallback;
+  for (const family of familiesOf(css)) {
+    const found = book.families.get(family);
+    if (found) {
+      font = found;
+      break;
+    }
+  }
+  if (known.size < 500) known.set(css, font);
+  return font;
+}
+
+// src/game-fonts.ts
+import { createHash as createHash3 } from "node:crypto";
+import { existsSync as existsSync5, mkdirSync as mkdirSync2, readdirSync as readdirSync3, readFileSync as readFileSync4, statSync as statSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { tmpdir as tmpdir3 } from "node:os";
+import { basename as basename4, dirname as dirname7, extname, join as join9, relative as relative3, resolve as resolve6, sep } from "node:path";
+var MAX_FAMILIES = 8;
+var NOT_HAD = /* @__PURE__ */ new Set([
+  "serif",
+  "sans-serif",
+  "monospace",
+  "cursive",
+  "fantasy",
+  "system-ui",
+  "ui-serif",
+  "ui-sans-serif",
+  "ui-monospace",
+  "ui-rounded",
+  "math",
+  "emoji",
+  "fangsong",
+  "-apple-system",
+  "blinkmacsystemfont",
+  "arial",
+  "arial black",
+  "helvetica",
+  "helvetica neue",
+  "segoe ui",
+  "segoe ui emoji",
+  "segoe ui symbol",
+  "times",
+  "times new roman",
+  "courier",
+  "courier new",
+  "georgia",
+  "verdana",
+  "tahoma",
+  "trebuchet ms",
+  "impact",
+  "comic sans ms",
+  "lucida grande",
+  "lucida console",
+  "menlo",
+  "monaco",
+  "consolas",
+  "sf pro",
+  "sf pro display",
+  "sf pro text",
+  "sf mono",
+  "apple color emoji",
+  "noto color emoji",
+  "palatino",
+  "palatino linotype",
+  // Words that aren't families: CSS keywords and values a `font`-named setting may hold.
+  "inherit",
+  "initial",
+  "unset",
+  "revert",
+  "revert-layer",
+  "none",
+  "auto",
+  "default",
+  "normal",
+  "bold",
+  "bolder",
+  "lighter",
+  "italic",
+  "oblique",
+  "small-caps",
+  "caption",
+  "icon",
+  "menu",
+  "message-box",
+  "small-caption",
+  "status-bar",
+  "swap",
+  "block",
+  "fallback",
+  "optional",
+  "true",
+  "false",
+  "null",
+  "undefined"
+]);
+var FONT_FILE = /\.(?:woff2?|ttf|otf)(?:[?#].*)?$/i;
+var GOOGLE_CSS = /fonts\.googleapis\.com\/css2?\?([^"'`\s)<>\\]+)/gi;
+var GOOGLE_HOST = /fonts\.googleapis\.com\/css/i;
+var FAMILY_NAME = /^[A-Za-z][A-Za-z0-9 _.-]{0,63}$/;
+var FONT_KEY = /font|family/i;
+var NOT_FONT_KEY = /(?:size|weight|style|variant|kerning|stretch|scale|features?|smoothing|optical|generation|loaded|ready|px|height|colou?r|count|index|id)s?$/i;
+function fileFamily(path) {
+  const name = basename4(path.split(/[?#]/)[0]);
+  let decoded = name;
+  try {
+    decoded = decodeURIComponent(name);
+  } catch {
+  }
+  return decoded.slice(0, decoded.length - extname(decoded).length).trim();
+}
+function familyOf(value) {
+  const v = value.replace(/!important\s*$/i, "").trim();
+  if (v === "" || v.length > 400 || GOOGLE_HOST.test(v)) return null;
+  if (FONT_FILE.test(v) && !/^data:/i.test(v)) {
+    const family = fileFamily(v);
+    return /^[^.${}<>"'`\\][^${}<>"'`\\]{0,63}$/.test(family) ? { family, source: v } : null;
+  }
+  if (/^(?:[a-z][\w+.-]*:|\/\/)/i.test(v)) return null;
+  const list = FONT_FAMILY_LIST.exec(v)?.[1] ?? v;
+  const first = list.split(",")[0].trim().replace(/^(['"])(.*)\1$/, "$2").trim();
+  if (!FAMILY_NAME.test(first) || NOT_HAD.has(first.toLowerCase())) return null;
+  return { family: first };
+}
+function googleFamilies(text2) {
+  const out = [];
+  for (const m of text2.matchAll(GOOGLE_CSS)) {
+    for (const part of m[1].replace(/&amp;/g, "&").split("&")) {
+      const [key, value] = part.split("=");
+      if (key !== "family" || !value) continue;
+      let decoded = value.replace(/\+/g, " ");
+      try {
+        decoded = decodeURIComponent(decoded);
+      } catch {
+      }
+      for (const family of decoded.split("|")) {
+        const name = family.split(":")[0].trim();
+        if (name) out.push(name);
+      }
+    }
+  }
+  return out;
+}
+function literalAt(text2, code, at) {
+  const quote = text2[at];
+  if (quote === "`") {
+    let value = "";
+    let dynamic = false;
+    let i = at + 1;
+    while (i < text2.length) {
+      const c = text2[i];
+      if (c === "\\") {
+        value += text2[i + 1] ?? "";
+        i += 2;
+      } else if (c === "`") return { value, end: i, dynamic };
+      else if (c === "$" && text2[i + 1] === "{") {
+        const end2 = closing(code, i + 1);
+        if (end2 < 0) return null;
+        value += "0";
+        dynamic = true;
+        i = end2 + 1;
+      } else {
+        value += c;
+        i++;
+      }
+    }
+    return null;
+  }
+  const end = code.indexOf(quote, at + 1);
+  if (end < 0) return null;
+  const raw = text2.slice(at + 1, end);
+  return raw.includes("\n") ? null : { value: raw.replace(/\\(.)/g, "$1"), end, dynamic: false };
+}
+function objectAround(code, at) {
+  let depth = 0;
+  for (let i = at; i >= 0 && at - i < 4e3; i--) {
+    if (code[i] === "}") depth++;
+    else if (code[i] === "{") {
+      if (depth === 0) {
+        const end = closing(code, i);
+        return end < 0 ? null : [i, end];
+      }
+      depth--;
+    }
+  }
+  return null;
+}
+var SETTING = /(?<![\w$])([A-Za-z_$][\w$]*)\s*(?::|=(?![=>]))\s*(['"`])/g;
+var FONT_FILE_LITERAL = /(['"`])([^'"`\n]*?\.(?:woff2?|ttf|otf)(?:[?#][^'"`\n]*)?)\1/gi;
+var FACE_KEYS = /(?<![\w$])(?:weights?|src|url|file|style|display|unicodeRange)\s*:/;
+function fromScript(text2, addFont) {
+  const code = blank(text2);
+  const named = [];
+  const add = (at, value, source, dynamic = false) => {
+    if (!(dynamic && FONT_FILE.test(value))) named.push({ at, value, source });
+  };
+  const files = /* @__PURE__ */ new Map();
+  for (const m of text2.matchAll(FONT_FILE_LITERAL)) if (code[m.index] === m[1]) files.set(m.index, m[2]);
+  const taken = /* @__PURE__ */ new Set();
+  const lists = [];
+  for (const m of code.matchAll(/(?<![\w$])([\w$]*fonts)\s*(?::|=(?![=>]))\s*\[/gi)) {
+    const open = m.index + m[0].length - 1;
+    const end = closing(code, open);
+    if (end < 0) continue;
+    lists.push([open, end]);
+    for (let i = open + 1; i < end; i++) {
+      const c = code[i];
+      if (c !== "'" && c !== '"' && c !== "`") continue;
+      const literal = literalAt(text2, code, i);
+      if (!literal) break;
+      const before = code.slice(open, i).trimEnd();
+      if ((before.endsWith("[") || before.endsWith(",")) && !files.has(i)) add(i, literal.value, void 0, literal.dynamic);
+      i = literal.end;
+    }
+  }
+  for (const m of code.matchAll(SETTING)) {
+    const key = m[1];
+    if (!FONT_KEY.test(key) || NOT_FONT_KEY.test(key)) continue;
+    const at = m.index + m[0].length - 1;
+    const literal = literalAt(text2, code, at);
+    if (!literal) continue;
+    let source;
+    if (/family/i.test(key)) {
+      const object = objectAround(code, m.index);
+      const inside = (pos) => object !== null && pos > object[0] && pos < object[1];
+      const own = [...files.keys()].filter(inside);
+      const listed = lists.some(([a, b]) => m.index > a && m.index < b);
+      const face = own.length > 0 || object !== null && FACE_KEYS.test(code.slice(object[0], object[1]));
+      if (/^family$/i.test(key) && !listed && !face) continue;
+      for (const pos of own) taken.add(pos);
+      source = own.length > 0 ? files.get(own[0]) : void 0;
+    }
+    if (files.has(at)) taken.add(at);
+    add(at, literal.value, source, literal.dynamic);
+  }
+  for (const m of code.matchAll(/(?<![\w$])loadFont\s*\(\s*(['"`])/g)) {
+    const at = m.index + m[0].length - 1;
+    const literal = literalAt(text2, code, at);
+    if (literal && !files.has(at)) add(at, literal.value, void 0, literal.dynamic);
+  }
+  for (const m of code.matchAll(/(?<![\w$])FontFace\s*\(\s*(['"`])/g)) {
+    const at = m.index + m[0].length - 1;
+    const family = literalAt(text2, code, at);
+    if (!family) continue;
+    const comma = /^\s*,\s*(['"`])/.exec(code.slice(family.end + 1));
+    const src = comma ? literalAt(text2, code, family.end + comma[0].length) : null;
+    const url = src && !src.dynamic ? /url\(\s*(['"]?)(.*?)\1\s*\)/i.exec(src.value)?.[2] ?? src.value : void 0;
+    add(at, family.value, url && (FONT_FILE.test(url) || /^data:/i.test(url)) ? url : void 0, family.dynamic);
+  }
+  for (const [pos, file] of files) if (!taken.has(pos)) add(pos, file);
+  for (const n of named.sort((a, b) => a.at - b.at)) addFont(n.value, n.source);
+  return /(?<![\w$])overlay\s*\.\s*(?:el|mount)\s*\(|\{[^{}]*\b(?:el|mount)\b[^{}]*\}\s*=\s*[\w$.]*overlay\b/.test(code);
+}
+function fromCss(text2, add) {
+  const css = text2.replace(/\/\*[\s\S]*?\*\//g, " ");
+  for (const m of css.matchAll(/@font-face\s*\{([^}]*)\}/gi)) {
+    const family = /font-family\s*:\s*([^;]+)/i.exec(m[1])?.[1];
+    if (!family) continue;
+    const src = /(?:^|[;\s])src\s*:\s*([^;]+)/i.exec(m[1])?.[1] ?? "";
+    const urls = [...src.matchAll(/url\(\s*(['"]?)(.*?)\1\s*\)/gi)].map((u) => u[2].trim());
+    add(family, urls.find((u) => FONT_FILE.test(u) || /^data:/i.test(u)) ?? urls[0]);
+  }
+  const rest = css.replace(/@font-face\s*\{[^}]*\}/gi, " ");
+  for (const m of rest.matchAll(/(?<![\w-])font-family\s*:\s*([^;{}]+)/gi)) add(m[1]);
+  for (const m of rest.matchAll(/(?<![\w-])font\s*:\s*([^;{}]+)/gi)) add(m[1]);
+}
+function fromHtml(text2, addScript, addStyle) {
+  let overlay = false;
+  for (const m of text2.matchAll(/<script\b[^>]*>([\s\S]*?)<\/script\s*>/gi)) overlay = fromScript(m[1], addScript) || overlay;
+  for (const m of text2.matchAll(/<style\b[^>]*>([\s\S]*?)<\/style\s*>/gi)) fromCss(m[1], addStyle);
+  for (const m of text2.matchAll(/\sstyle\s*=\s*(?:"([^"]*)"|'([^']*)')/gi)) fromCss(m[1] ?? m[2] ?? "", addStyle);
+  return overlay;
+}
+function fromJson(text2, add) {
+  let data;
+  try {
+    data = JSON.parse(text2);
+  } catch {
+    return;
+  }
+  let budget = 2e5;
+  const visit = (value, depth, inFonts) => {
+    if (budget-- <= 0 || depth > 40 || !value || typeof value !== "object") return;
+    if (Array.isArray(value)) {
+      for (const v of value) visit(v, depth + 1, inFonts);
+      return;
+    }
+    const entries = Object.entries(value);
+    const file = entries.find(([, v]) => typeof v === "string" && FONT_FILE.test(v))?.[1];
+    const face = inFonts || file !== void 0 || entries.some(([k]) => /^(?:weights?|src|url|file|style|display|unicodeRange)$/.test(k));
+    for (const [key, v] of entries) {
+      const list = /fonts$/i.test(key);
+      if (typeof v === "string" && FONT_KEY.test(key) && !NOT_FONT_KEY.test(key) && (face || !/^family$/i.test(key))) add(v, /family/i.test(key) ? file : void 0);
+      else if (Array.isArray(v) && list) {
+        for (const item of v) if (typeof item === "string") add(item);
+      }
+      visit(v, depth + 1, list && Array.isArray(v));
+    }
+  };
+  visit(data, 0, false);
+}
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  "dist",
+  "vendor",
+  "vendors",
+  "third_party",
+  "third-party",
+  "bower_components",
+  "jspm_packages",
+  "web_modules",
+  "coverage",
+  "test",
+  "tests",
+  "__tests__"
+]);
+var SOURCE_FILE = /\.(?:[cm]?[jt]sx?|html?|css|json)$/i;
+var NOT_SOURCE = /(?:\.min\.[cm]?js|\.bundle\.[cm]?js|\.d\.[cm]?ts|\.(?:test|spec)\.[cm]?[jt]sx?|^package(?:-lock)?\.json|^tsconfig\.json|^jsconfig\.json)$/i;
+function discoverFonts(dir) {
+  const root = resolve6(dir);
+  const seen = /* @__PURE__ */ new Map();
+  const pages = [];
+  let overlay = false;
+  let files = 0;
+  const adder = (from) => (value, source) => {
+    const found = familyOf(value);
+    if (!found) return;
+    const key = found.family.toLowerCase();
+    if (key === "sora") return;
+    let entry = seen.get(key);
+    if (!entry) seen.set(key, entry = { ref: { family: found.family }, uses: 0, order: seen.size });
+    entry.uses++;
+    if (entry.ref.family === entry.ref.family.toLowerCase() && found.family !== key) entry.ref.family = found.family;
+    const file = source ?? found.source;
+    if (file && !entry.ref.source) {
+      entry.ref.source = file;
+      entry.ref.from = from;
+    }
+  };
+  const walk = (folder, depth) => {
+    if (depth > 10 || files > 4e3) return;
+    let entries;
+    try {
+      entries = readdirSync3(folder, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+      if (entry.name.startsWith(".")) continue;
+      const abs = join9(folder, entry.name);
+      if (entry.isDirectory()) {
+        if (!SKIP_DIRS.has(entry.name)) walk(abs, depth + 1);
+        continue;
+      }
+      if (!entry.isFile() || !SOURCE_FILE.test(entry.name) || NOT_SOURCE.test(entry.name)) continue;
+      const rel = relative3(root, abs);
+      if (/^index\.html?$/i.test(entry.name)) pages.push(relative3(root, folder));
+      let text2;
+      try {
+        if (statSync3(abs).size > 15e5) continue;
+        text2 = readFileSync4(abs, "utf8");
+      } catch {
+        continue;
+      }
+      files++;
+      const add = adder(rel);
+      for (const family of googleFamilies(text2)) add(family);
+      const ext = extname(entry.name).toLowerCase();
+      if (ext === ".css") fromCss(text2, add);
+      else if (ext === ".html" || ext === ".htm") overlay = fromHtml(text2, add, add) || overlay;
+      else if (ext === ".json") fromJson(text2, add);
+      else overlay = fromScript(text2, add) || overlay;
+    }
+  };
+  walk(root, 0);
+  const families = [...seen.values()].sort((a, b) => b.uses - a.uses || a.order - b.order).slice(0, MAX_FAMILIES).map((e) => e.ref);
+  return { families, overlay, pages };
+}
+var NO_GAME_FONTS = { fonts: [], unavailable: [], overlay: false };
+var FONT_HOSTS = /* @__PURE__ */ new Set(["cdn.jsdelivr.net", "cdnjs.cloudflare.com", "unpkg.com", "esm.sh", "ga.jspm.io", "fonts.gstatic.com"]);
+var GOOGLE_WEIGHTS = ["800", "700", "600", "regular"];
+function parse(bytes) {
+  try {
+    return { font: readFont(bytes) };
+  } catch (error) {
+    return { why: /CFF/.test(String(error.message)) ? "CFF outlines, not read here" : "not a font file read here" };
+  }
+}
+function cacheOf(options) {
+  const dir = options.cacheDir ?? join9(tmpdir3(), "onceworlds-fonts");
+  try {
+    mkdirSync2(dir, { recursive: true });
+    return dir;
+  } catch {
+    return null;
+  }
+}
+async function download2(url, options) {
+  const fetcher = options.fetch ?? fetch;
+  try {
+    const res = await fetcher(url, { signal: AbortSignal.timeout(options.timeoutMs ?? 1e4) });
+    if (!res.ok) return { why: `${new URL(url).host} answered ${res.status}` };
+    const bytes = new Uint8Array(await res.arrayBuffer());
+    return bytes.length > 0 && bytes.length < 3e7 ? bytes : { why: "an empty file" };
+  } catch {
+    return { why: "offline" };
+  }
+}
+function cached2(cache, key) {
+  if (!cache) return null;
+  const fonts = [];
+  for (let i = 0; i < 8; i++) {
+    const file = join9(cache, `${key}.${i}.font`);
+    if (!existsSync5(file)) break;
+    try {
+      fonts.push(readFont(readFileSync4(file)));
+    } catch {
+      return null;
+    }
+  }
+  return fonts.length > 0 ? fontStackOf(fonts) : null;
+}
+function keep(cache, key, files) {
+  if (!cache) return;
+  try {
+    files.forEach((bytes, i) => writeFileSync3(join9(cache, `${key}.${i}.font`), bytes));
+  } catch {
+  }
+}
+async function googleFont(family, options = {}) {
+  const cache = cacheOf(options);
+  const slug = `google-${family.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "")}`;
+  for (const weight of GOOGLE_WEIGHTS) {
+    const font = cached2(cache, `${slug}-${weight}`);
+    if (font) return { font };
+  }
+  const fetcher = options.fetch ?? fetch;
+  const name = encodeURIComponent(family).replace(/%20/g, "+");
+  for (const weight of GOOGLE_WEIGHTS) {
+    const url = `https://fonts.googleapis.com/css2?family=${name}${weight === "regular" ? "" : `:wght@${weight}`}`;
+    let css;
+    try {
+      const res = await fetcher(url, { signal: AbortSignal.timeout(options.timeoutMs ?? 1e4) });
+      if (res.status === 400 || res.status === 404) continue;
+      if (!res.ok) return { why: `Google Fonts answered ${res.status}` };
+      css = await res.text();
+    } catch {
+      return { why: "offline" };
+    }
+    const urls = [...css.matchAll(/url\(\s*(['"]?)(https:[^'")\s]+)\1\s*\)/gi)].map((m) => m[2]).slice(0, 8);
+    if (urls.length === 0) return { why: "no file on Google Fonts" };
+    const files = [];
+    const fonts = [];
+    for (const url2 of urls) {
+      const got = await download2(url2, options);
+      if (!(got instanceof Uint8Array)) return got;
+      const had = parse(got);
+      if ("font" in had) {
+        files.push(got);
+        fonts.push(had.font);
+      }
+    }
+    if (fonts.length === 0) return { why: "not a font file read here" };
+    keep(cache, `${slug}-${weight}`, files);
+    return { font: fontStackOf(fonts) };
+  }
+  return { why: "not on Google Fonts" };
+}
+async function remoteFont(url, options) {
+  let host;
+  try {
+    host = new URL(url).host;
+  } catch {
+    return { why: "not an address" };
+  }
+  if (!FONT_HOSTS.has(host)) return { why: `${host} isn't a host the platform loads fonts from` };
+  const cache = cacheOf(options);
+  const key = `url-${createHash3("sha1").update(url).digest("hex").slice(0, 16)}`;
+  const known = cached2(cache, key);
+  if (known) return { font: known };
+  const got = await download2(url, options);
+  if (!(got instanceof Uint8Array)) return got;
+  const had = parse(got);
+  if ("font" in had) keep(cache, key, [got]);
+  return had;
+}
+function gameFile(source, from, dir, pages) {
+  let path = source.split(/[?#]/)[0];
+  try {
+    path = decodeURIComponent(path);
+  } catch {
+  }
+  const rooted = path.startsWith("/");
+  const rel = path.replace(/^\/+/, "");
+  const bases = [...from && !rooted ? [dirname7(join9(dir, from))] : [], ...pages.map((p) => join9(dir, p)), dir];
+  for (const base of bases) {
+    const file = resolve6(base, rel);
+    if (file !== dir && !file.startsWith(dir + sep)) continue;
+    try {
+      if (statSync3(file).isFile()) return file;
+    } catch {
+    }
+  }
+  return null;
+}
+async function have(ref, dir, pages, options) {
+  const source = ref.source;
+  if (!source) {
+    const had = await googleFont(ref.family, options);
+    const plain3 = ref.family.replace(/\s+Variable$/i, "");
+    return "why" in had && had.why === "not on Google Fonts" && plain3 !== ref.family ? googleFont(plain3, options) : had;
+  }
+  if (/^data:/i.test(source)) {
+    const m = /^data:[^,]*?(;base64)?,(.*)$/is.exec(source);
+    if (!m) return { why: "not a font file read here" };
+    let bytes;
+    try {
+      bytes = m[1] ? Buffer.from(m[2], "base64") : Buffer.from(decodeURIComponent(m[2]), "latin1");
+    } catch {
+      return { why: "not a font file read here" };
+    }
+    return parse(bytes);
+  }
+  if (/^(?:https?:)?\/\//i.test(source)) return remoteFont(source.startsWith("//") ? `https:${source}` : source, options);
+  if (/^[a-z][\w+.-]*:/i.test(source)) return { why: "not a file" };
+  const file = gameFile(source, ref.from, resolve6(dir), pages);
+  if (!file) return { why: `no file ${source}` };
+  try {
+    return parse(readFileSync4(file));
+  } catch {
+    return { why: `no file ${source}` };
+  }
+}
+async function loadGameFonts(dir, options = {}) {
+  let found;
+  try {
+    found = discoverFonts(dir);
+  } catch {
+    return NO_GAME_FONTS;
+  }
+  const had = await Promise.all(found.families.map((ref) => have(ref, dir, found.pages, options).catch(() => ({ why: "not a font file read here" }))));
+  const out = { fonts: [], unavailable: [], overlay: found.overlay };
+  found.families.forEach((ref, i) => {
+    const result = had[i];
+    if ("font" in result) {
+      const aliases = ref.source && !/^data:/i.test(ref.source) ? [.../* @__PURE__ */ new Set([ref.source, ref.source.split(/[?#]/)[0]])] : [];
+      out.fonts.push({ family: ref.family, font: result.font, aliases });
+    } else out.unavailable.push({ family: ref.family, why: result.why });
+  });
+  return out;
+}
+function fontBook(game, sora) {
+  const families = /* @__PURE__ */ new Map();
+  for (const { family, font, aliases } of game.fonts) {
+    const drawn = sora ? fontStackOf([font, sora]) : font;
+    for (const name of [family, ...aliases]) families.set(name.toLowerCase(), drawn);
+  }
+  return { fallback: sora, families };
+}
+function fontCoverage(game, sora) {
+  return unionCoverage(
+    [...game.fonts.map((f) => ({ name: f.family, coverage: f.font })), { name: "Sora", coverage: sora ?? rangeCoverage() }],
+    game.unavailable.map((u) => u.family)
+  );
+}
+var listOf = (items) => items.length < 2 ? items.join("") : `${items.slice(0, -1).join(", ")} and ${items[items.length - 1]}`;
+function fontNotes(game) {
+  const notes = [];
+  const lost = game.unavailable;
+  if (lost.length > 0) {
+    notes.push(`${listOf(lost.map((u) => `${u.family} (${u.why})`))} could not be had: ${lost.length === 1 ? "its" : "their"} text is drawn in Sora`);
+  }
+  if (game.overlay) notes.push("the game's HTML overlay (ui.overlay) isn't in a headless picture: --browser draws it");
+  return notes;
+}
 
 // src/raster.ts
 var NAMED = {
@@ -5836,16 +6460,20 @@ var Surface = class {
   height;
   /** Premultiplied RGBA, 0 to 1. */
   data;
+  /** What text is drawn in when the state's font names no family of `book` (the engine's font). */
   font;
+  /** The game's fonts by family: text is drawn in the first family of the state's font the book has. */
+  book;
   state;
   stack = [];
   paths = [];
   current = null;
-  constructor(width, height, font = null) {
+  constructor(width, height, fonts = null) {
     this.width = Math.max(1, Math.min(8192, Math.round(width) || 1));
     this.height = Math.max(1, Math.min(8192, Math.round(height) || 1));
     this.data = new Float32Array(this.width * this.height * 4);
-    this.font = font;
+    this.book = fonts && "families" in fonts ? fonts : null;
+    this.font = fonts && "families" in fonts ? fonts.fallback : fonts;
     this.state = {
       t: [1, 0, 0, 1, 0, 0],
       fill: [0, 0, 0, 1],
@@ -6121,8 +6749,8 @@ var Surface = class {
         const k = mask.data[j * mask.w + i];
         if (k <= 0) continue;
         const p = (mask.y0 + j) * this.width + mask.x0 + i;
-        const keep = 1 - k * (clip ? clip[p] : 1);
-        for (let c = 0; c < 4; c++) this.data[p * 4 + c] *= keep;
+        const keep2 = 1 - k * (clip ? clip[p] : 1);
+        for (let c = 0; c < 4; c++) this.data[p * 4 + c] *= keep2;
       }
     }
   }
@@ -6255,8 +6883,12 @@ var Surface = class {
     const weight = Number(/(?:^|\s)([1-9]00)(?:\s|$)/.exec(f)?.[1] ?? named);
     return { size, weight };
   }
+  /** The font the state's font string draws in. */
+  typeface() {
+    return this.book ? pickFont(this.book, this.state.font) : this.font;
+  }
   measureText(text2) {
-    return { width: measure(this.font, String(text2), this.fontOf().size) };
+    return { width: measure(this.typeface(), String(text2), this.fontOf().size) };
   }
   fillText(text2, x, y) {
     this.text(String(text2), x, y, false);
@@ -6265,7 +6897,7 @@ var Surface = class {
     this.text(String(text2), x, y, true);
   }
   text(text2, x, y, outline) {
-    const font = this.font;
+    const font = this.typeface();
     const { size, weight } = this.fontOf();
     if (!(size > 0) || text2 === "") return;
     const width = measure(font, text2, size);
@@ -6492,7 +7124,7 @@ function circle(cx, cy, r) {
   const n = Math.max(8, Math.min(64, Math.ceil(r * 1.5)));
   return Array.from({ length: n }, (_, i) => [cx + r * Math.cos(i / n * Math.PI * 2), cy + r * Math.sin(i / n * Math.PI * 2)]);
 }
-function strokePolygons(pts, closed, half, cap, join13, miterLimit) {
+function strokePolygons(pts, closed, half, cap, join14, miterLimit) {
   const points = pts.filter((p, i) => i === 0 || Math.hypot(p[0] - pts[i - 1][0], p[1] - pts[i - 1][1]) > 1e-6);
   if (closed && points.length > 2 && Math.hypot(points[0][0] - points[points.length - 1][0], points[0][1] - points[points.length - 1][1]) < 1e-6) points.pop();
   const out = [];
@@ -6524,7 +7156,7 @@ function strokePolygons(pts, closed, half, cap, join13, miterLimit) {
     const v = points[i];
     const n1 = normals[(i - 1 + segs) % segs];
     const n2 = normals[i % segs];
-    if (join13 === "round") {
+    if (join14 === "round") {
       out.push(circle(v[0], v[1], half));
       continue;
     }
@@ -6532,7 +7164,7 @@ function strokePolygons(pts, closed, half, cap, join13, miterLimit) {
       const p1 = [v[0] + n1[0] * half * side, v[1] + n1[1] * half * side];
       const p2 = [v[0] + n2[0] * half * side, v[1] + n2[1] * half * side];
       const poly = [v, p1, p2];
-      if (join13 === "miter") {
+      if (join14 === "miter") {
         const mx = n1[0] + n2[0];
         const my = n1[1] + n2[1];
         const ml = Math.hypot(mx, my);
@@ -6696,9 +7328,9 @@ function boxBlur(src, w, h, r, horizontal) {
 
 // src/serve.ts
 import { createServer } from "node:http";
-import { existsSync as existsSync5, readFileSync as readFileSync4, statSync as statSync3 } from "node:fs";
+import { existsSync as existsSync6, readFileSync as readFileSync5, statSync as statSync4 } from "node:fs";
 import { readFile as readFile4 } from "node:fs/promises";
-import { dirname as dirname7, extname, join as join9, resolve as resolve6, sep } from "node:path";
+import { dirname as dirname8, extname as extname2, join as join10, resolve as resolve7, sep as sep2 } from "node:path";
 var TYPES = {
   ".html": "text/html; charset=utf-8",
   ".js": "text/javascript",
@@ -6732,18 +7364,18 @@ var TYPES = {
   ".map": "application/json"
 };
 function engineFiles(dir, api2, version) {
-  for (let here = resolve6(dir); ; here = dirname7(here)) {
-    const pkg = join9(here, "node_modules", "@onceworlds", "engine");
-    for (const files of [join9(pkg, "dist"), pkg]) {
-      if (!existsSync5(join9(files, "index.js")) || !existsSync5(join9(files, "modules.js"))) continue;
+  for (let here = resolve7(dir); ; here = dirname8(here)) {
+    const pkg = join10(here, "node_modules", "@onceworlds", "engine");
+    for (const files of [join10(pkg, "dist"), pkg]) {
+      if (!existsSync6(join10(files, "index.js")) || !existsSync6(join10(files, "modules.js"))) continue;
       let installed = null;
       try {
-        installed = String(JSON.parse(readFileSync4(join9(pkg, "package.json"), "utf8")).version ?? "") || null;
+        installed = String(JSON.parse(readFileSync5(join10(pkg, "package.json"), "utf8")).version ?? "") || null;
       } catch {
       }
       return { local: files, installed, remote: "" };
     }
-    if (dirname7(here) === here) break;
+    if (dirname8(here) === here) break;
   }
   return { local: null, installed: null, remote: `${api2}/engine/${version}/` };
 }
@@ -6756,7 +7388,7 @@ function atLeast(version, least) {
   return true;
 }
 async function serveFolder(options) {
-  const dir = resolve6(options.dir);
+  const dir = resolve7(options.dir);
   const engine = engineFiles(dir, options.api, options.version);
   const map = engine.local ? { "@onceworlds/engine": "/__engine/index.js", "@onceworlds/engine/modules": "/__engine/modules.js" } : { "@onceworlds/engine": `${engine.remote}engine.js`, "@onceworlds/engine/modules": `${engine.remote}modules.js` };
   const server = createServer(async (req, res) => {
@@ -6764,16 +7396,16 @@ async function serveFolder(options) {
       const path = decodeURIComponent(new URL(req.url ?? "/", "http://localhost").pathname);
       const fromEngine = path.startsWith("/__engine/") && engine.local !== null;
       const base = fromEngine ? engine.local : dir;
-      let file = fromEngine ? join9(base, path.slice("/__engine/".length)) : join9(dir, path);
-      if (resolve6(file) !== base && !resolve6(file).startsWith(base + sep)) throw new Error("outside");
-      if (path.endsWith("/") || existsSync5(file) && statSync3(file).isDirectory()) file = join9(file, "index.html");
+      let file = fromEngine ? join10(base, path.slice("/__engine/".length)) : join10(dir, path);
+      if (resolve7(file) !== base && !resolve7(file).startsWith(base + sep2)) throw new Error("outside");
+      if (path.endsWith("/") || existsSync6(file) && statSync4(file).isDirectory()) file = join10(file, "index.html");
       let body = await readFile4(file);
       if (file.endsWith(".html")) {
         const tag = `<script type="importmap">${JSON.stringify({ imports: map })}</script>`;
         const html = body.toString("utf8");
         body = /<head[^>]*>/i.test(html) ? html.replace(/<head[^>]*>/i, (m) => `${m}${tag}`) : `${tag}${html}`;
       }
-      res.writeHead(200, { "Content-Type": TYPES[extname(file).toLowerCase()] ?? "application/octet-stream", "Cache-Control": "no-store" });
+      res.writeHead(200, { "Content-Type": TYPES[extname2(file).toLowerCase()] ?? "application/octet-stream", "Cache-Control": "no-store" });
       res.end(body);
     } catch {
       res.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" });
@@ -6903,9 +7535,9 @@ async function fontFile(file, api2, fetcher, versions) {
       return null;
     }
   };
-  if (existsSync6(join10(LOCAL_FONTS, file))) return read(readFileSync5(join10(LOCAL_FONTS, file)));
-  const cached2 = join10(tmpdir3(), `onceworlds-${file}`);
-  if (existsSync6(cached2)) return read(readFileSync5(cached2));
+  if (existsSync7(join11(LOCAL_FONTS, file))) return read(readFileSync6(join11(LOCAL_FONTS, file)));
+  const cached3 = join11(tmpdir4(), `onceworlds-${file}`);
+  if (existsSync7(cached3)) return read(readFileSync6(cached3));
   for (const version of [...versions, "1.1.0"]) {
     try {
       const res = await fetcher(`${api2}/engine/${version}/fonts/${file}`, { signal: AbortSignal.timeout(1e4) });
@@ -6914,7 +7546,7 @@ async function fontFile(file, api2, fetcher, versions) {
       const font = read(bytes);
       if (font) {
         try {
-          writeFileSync3(cached2, bytes);
+          writeFileSync4(cached3, bytes);
         } catch {
         }
         return font;
@@ -6930,6 +7562,30 @@ async function engineFont(api2, fetcher = fetch, versions = []) {
   const extended = await fontFile(FONT_FILES[1], api2, fetcher, versions);
   return extended ? fontStackOf([latin, extended]) : latin;
 }
+async function textFonts(options) {
+  const [sora, game] = await Promise.all([
+    engineFont(options.api, options.fetch, options.version ? [options.version] : []).catch(() => null),
+    loadGameFonts(options.dir, { fetch: options.fetch, cacheDir: options.fontCache }).catch(() => NO_GAME_FONTS)
+  ]);
+  return { sora, game, book: fontBook(game, sora), coverage: fontCoverage(game, sora) };
+}
+async function textCoverage(dir, api2, fetcher = fetch) {
+  const fonts = await textFonts({ dir, api: api2, fetch: fetcher });
+  return fonts.coverage;
+}
+function metricsTable(book) {
+  const table = { def: metricsOf(book.fallback), fam: {}, list: [] };
+  const index = /* @__PURE__ */ new Map();
+  for (const [family, font] of book.families) {
+    let at = index.get(font);
+    if (at === void 0) {
+      at = table.list.push(metricsOf(font)) - 1;
+      index.set(font, at);
+    }
+    table.fam[family] = at;
+  }
+  return table;
+}
 function metricsOf(font) {
   if (!font) return { upm: 1e3, asc: 800, desc: -200, adv: {}, avg: 550 };
   const adv = {};
@@ -6952,8 +7608,10 @@ function posterSize(name, width, height) {
 function recorderScript(options) {
   return `
 const OUT = ${JSON.stringify(options.out)};
-const DIR = ${JSON.stringify(resolve7(options.dir))};
+const DIR = ${JSON.stringify(resolve8(options.dir))};
 const M = ${JSON.stringify(options.metrics)};
+// A CSS font's family list (font.ts's FONT_FAMILY_LIST): text is measured in its first family this process draws with, else in Sora.
+const FAMILIES = new RegExp(${JSON.stringify(FONT_FAMILY_LIST.source)}, 'i');
 const MODE = ${JSON.stringify({ poster: options.poster ?? null, phase: options.phase ?? "play", story: options.story === true, at: options.at, width: options.width, height: options.height })};
 const { writeFileSync, readFileSync } = await import('node:fs');
 const { resolve: resolvePath, sep } = await import('node:path');
@@ -6971,11 +7629,25 @@ function record(canvas, op, args) {
   log.push([canvas.id, seq++, op, ...args.map(round)]);
 }
 const sizeOf = (font) => Number(/(\\d+(?:\\.\\d+)?)px/.exec(String(font))?.[1] ?? 10);
+const picked = new Map();
+function metricsOf(font) {
+  const css = String(font);
+  let m = picked.get(css);
+  if (m) return m;
+  m = M.def;
+  for (const part of (FAMILIES.exec(css)?.[1] ?? css).split(',')) {
+    const name = part.trim().replace(/^(['"])(.*)\\1$/, '$2').trim().toLowerCase();
+    if (Object.hasOwn(M.fam, name)) { m = M.list[M.fam[name]]; break; }
+  }
+  if (picked.size < 500) picked.set(css, m);
+  return m;
+}
 function measure(font, text) {
+  const m = metricsOf(font);
   const size = sizeOf(font);
   let units = 0;
-  for (const ch of String(text)) units += M.adv[ch.codePointAt(0)] ?? M.avg;
-  return (units * size) / M.upm;
+  for (const ch of String(text)) units += m.adv[ch.codePointAt(0)] ?? m.avg;
+  return (units * size) / m.upm;
 }
 class RecCanvas {
   constructor(w, h) { this.id = nextId++; this._w = Math.max(0, w | 0); this._h = Math.max(0, h | 0); this.style = {}; canvases[this.id] = [this._w, this._h]; this._ctx = null; }
@@ -7017,7 +7689,8 @@ class RecContext {
   getLineDash() { return [...this._dash]; }
   measureText(text) {
     const size = sizeOf(this._state.font);
-    return { width: measure(this._state.font, text), actualBoundingBoxAscent: (M.asc / M.upm) * size, actualBoundingBoxDescent: (-M.desc / M.upm) * size, fontBoundingBoxAscent: (M.asc / M.upm) * size, fontBoundingBoxDescent: (-M.desc / M.upm) * size, actualBoundingBoxLeft: 0, actualBoundingBoxRight: measure(this._state.font, text) };
+    const m = metricsOf(this._state.font);
+    return { width: measure(this._state.font, text), actualBoundingBoxAscent: (m.asc / m.upm) * size, actualBoundingBoxDescent: (-m.desc / m.upm) * size, fontBoundingBoxAscent: (m.asc / m.upm) * size, fontBoundingBoxDescent: (-m.desc / m.upm) * size, actualBoundingBoxLeft: 0, actualBoundingBoxRight: measure(this._state.font, text) };
   }
   /** Everything before a call that covers the whole canvas is gone from it: kept logs stay one frame long. */
   _covers(x, y, w, h) {
@@ -7285,9 +7958,13 @@ function replay(record, font) {
   }
   return { surface: surfaceOf(record.root), problems: [...problems], texts: [...texts] };
 }
-function glyphProblems(texts, font) {
-  const missing = font ? missingGlyphs(texts, font) : [];
-  return missing.length > 0 ? [glyphNote(missing)] : [];
+function glyphProblems(texts, coverage2) {
+  const missing = missingGlyphs(texts, coverage2);
+  return missing.length > 0 ? [glyphNote(missing, coverage2)] : [];
+}
+function textNotes(fonts, texts, overlay) {
+  const bars = fonts.sora ? [] : [`${fonts.game.fonts.length > 0 ? "text in Sora" : "text"} is drawn as bars: the engine's font could not be had`];
+  return [...fontNotes({ ...fonts.game, overlay: overlay && fonts.game.overlay }), ...glyphProblems(texts, fonts.coverage), ...bars];
 }
 function applySet(s, prop, value) {
   const v = value;
@@ -7303,8 +7980,8 @@ function greyBox(s, args) {
   s.fillRect(dx, dy, dw, dh);
   s.restore();
 }
-async function shootHeadless(options, font) {
-  const dir = resolve7(options.dir);
+async function shootHeadless(options, fonts) {
+  const dir = resolve8(options.dir);
   const config = findConfigModule(dir);
   const project = config ? null : findProject(dir);
   if (!config && !project) throw new Error("No game.config.js (export const config = {...}) or project.json here: shot plays the game from its config, as check does.");
@@ -7312,56 +7989,56 @@ async function shootHeadless(options, font) {
   const size = options.poster ? posterSize(options.poster, options.width, options.height) : { width: options.width ?? 1280, height: options.height ?? 720 };
   const phase = options.poster ? void 0 : options.phase ?? "play";
   const at = options.at ?? defaultAt(phase);
-  const temp = mkdtempSync2(join10(tmpdir3(), "onceworlds-shot-"));
+  const temp = mkdtempSync2(join11(tmpdir4(), "onceworlds-shot-"));
   try {
-    const out = join10(temp, "record.json");
-    const script = recorderScript({ config: config ?? void 0, project: project ?? void 0, out, poster: options.poster, phase, at, ...size, metrics: metricsOf(font), dir });
+    const out = join11(temp, "record.json");
+    const script = recorderScript({ config: config ?? void 0, project: project ?? void 0, out, poster: options.poster, phase, at, ...size, metrics: metricsTable(fonts.book), dir });
     const ran = await runProgram(process.execPath, ["--input-type=module", "--eval", script], dir, 3 * 6e4);
-    if (!existsSync6(out)) {
+    if (!existsSync7(out)) {
       const tail = ran.output.trimEnd().split("\n").slice(-12).join("\n");
       throw new Error(ran.timedOut ? "The game did not finish its frames in 3 minutes." : `The game could not be played headless:
 ${tail}`);
     }
-    const record = JSON.parse(readFileSync5(out, "utf8"));
+    const record = JSON.parse(readFileSync6(out, "utf8"));
     if (record.error && !record.three) throw new Error(`The game could not be drawn: ${record.error.split("\n").slice(0, 4).join(" ")}`);
-    const { surface, problems, texts } = replay(record, font);
+    const { surface, problems, texts } = replay(record, fonts.book);
     const png = encodePng(surface.width, surface.height, surface.rgba());
     const what = options.poster ? `the "${options.poster}" poster` : headlessMoment(phase ?? "play", record.seconds ?? at, record.phase);
-    const notes = [...problems, ...glyphProblems(texts, font), ...font ? [] : ["text is drawn as bars: the engine's font could not be had"], ...record.errors.map((e) => `the game reported: ${e}`)];
+    const notes = [...problems, ...textNotes(fonts, texts, !options.poster), ...record.errors.map((e) => `the game reported: ${e}`)];
     return { png, width: surface.width, height: surface.height, caption: [what, ...notes].join("; "), three: record.three };
   } finally {
     rmSync2(temp, { recursive: true, force: true });
   }
 }
-async function storyHeadless(options, font) {
-  const dir = resolve7(options.dir);
+async function storyHeadless(options, fonts) {
+  const dir = resolve8(options.dir);
   const config = findConfigModule(dir);
   const project = config ? null : findProject(dir);
   if (!config && !project) throw new Error("No game.config.js (export const config = {...}) or project.json here: shot plays the game from its config, as check does.");
   if (!hasNodeModules(dir)) throw new Error('@onceworlds/engine is not installed here: run "npm install" in the game folder first.');
   const size = { width: options.width ?? 960, height: options.height ?? 540 };
-  const temp = mkdtempSync2(join10(tmpdir3(), "onceworlds-story-"));
+  const temp = mkdtempSync2(join11(tmpdir4(), "onceworlds-story-"));
   try {
-    const out = join10(temp, "record.json");
-    const script = recorderScript({ config: config ?? void 0, project: project ?? void 0, out, story: true, at: options.at ?? STORY_SECONDS, ...size, metrics: metricsOf(font), dir });
+    const out = join11(temp, "record.json");
+    const script = recorderScript({ config: config ?? void 0, project: project ?? void 0, out, story: true, at: options.at ?? STORY_SECONDS, ...size, metrics: metricsTable(fonts.book), dir });
     const ran = await runProgram(process.execPath, ["--input-type=module", "--eval", script], dir, 5 * 6e4);
-    if (!existsSync6(out)) {
+    if (!existsSync7(out)) {
       const tail = ran.output.trimEnd().split("\n").slice(-12).join("\n");
       throw new Error(ran.timedOut ? "The game did not finish its first minute in 5 minutes." : `The game could not be played headless:
 ${tail}`);
     }
-    const record = JSON.parse(readFileSync5(out, "utf8"));
+    const record = JSON.parse(readFileSync6(out, "utf8"));
     if (record.three) return { frames: [], notes: [], three: true };
     if (record.error) throw new Error(`The game could not be drawn: ${record.error.split("\n").slice(0, 4).join(" ")}`);
     const problems = /* @__PURE__ */ new Set();
     const texts = /* @__PURE__ */ new Set();
     const frames = (record.frames ?? []).map((f) => {
-      const { surface, problems: p, texts: drawn } = replay({ ops: f.ops, canvases: f.canvases, root: record.root, images: record.images }, font);
+      const { surface, problems: p, texts: drawn } = replay({ ops: f.ops, canvases: f.canvases, root: record.root, images: record.images }, fonts.book);
       for (const x of p) problems.add(x);
       for (const t of drawn) texts.add(t);
       return { label: f.label, seconds: f.seconds, image: surface };
     });
-    const notes = [...problems, ...glyphProblems(texts, font), ...font ? [] : ["text is drawn as bars: the engine's font could not be had"], ...record.errors.map((e) => `the game reported: ${e}`)];
+    const notes = [...problems, ...textNotes(fonts, texts, true), ...record.errors.map((e) => `the game reported: ${e}`)];
     return { frames, notes, three: false };
   } finally {
     rmSync2(temp, { recursive: true, force: true });
@@ -7529,15 +8206,16 @@ async function storyBrowser(options, version) {
 }
 async function shootStory(options) {
   const version = options.version ?? ENGINE_VERSION;
-  const font = await engineFont(options.api, options.fetch, options.version ? [options.version] : []);
+  const fonts = options.browser ? null : await textFonts(options);
   let story;
-  if (options.browser) story = await storyBrowser(options, version);
+  if (!fonts) story = await storyBrowser(options, version);
   else {
-    const headless = await storyHeadless(options, font);
+    const headless = await storyHeadless(options, fonts);
     story = headless.three ? await storyBrowser(options, version) : headless;
   }
   if (story.frames.length === 0) throw new Error("The game drew nothing to look at in its first minute.");
-  const sheet = contactSheet(story.frames, font);
+  const sora = fonts ? fonts.sora : await engineFont(options.api, options.fetch, options.version ? [options.version] : []).catch(() => null);
+  const sheet = contactSheet(story.frames, sora);
   const frames = story.frames.map((f, i) => {
     const surface = f.image instanceof Surface ? f.image : null;
     const png = surface ? encodePng(surface.width, surface.height, surface.rgba()) : encodePng(f.image.width, f.image.height, toRgba(f.image.data));
@@ -7560,16 +8238,15 @@ function toRgba(data) {
 async function shoot(options) {
   const version = options.version ?? ENGINE_VERSION;
   if (options.browser) return shootBrowser(options, version);
-  const font = await engineFont(options.api, options.fetch, options.version ? [options.version] : []);
-  const headless = await shootHeadless(options, font);
+  const headless = await shootHeadless(options, await textFonts(options));
   if (!headless.three) return headless;
   return shootBrowser(options, version);
 }
 
 // src/assets.ts
-import { mkdtempSync as mkdtempSync3, readFileSync as readFileSync6, rmSync as rmSync3, existsSync as existsSync7 } from "node:fs";
-import { tmpdir as tmpdir4 } from "node:os";
-import { join as join11, resolve as resolve8 } from "node:path";
+import { mkdtempSync as mkdtempSync3, readFileSync as readFileSync7, rmSync as rmSync3, existsSync as existsSync8 } from "node:fs";
+import { tmpdir as tmpdir5 } from "node:os";
+import { join as join12, resolve as resolve9 } from "node:path";
 var LIBRARY_EXPORTS = ["assetLibrary", "library", "Library", "assetIndex", "libraryIndex", "ASSET_LIBRARY", "searchAssets"];
 function normalizeAsset(raw) {
   if (!raw || typeof raw !== "object") return null;
@@ -7627,14 +8304,14 @@ writeFileSync(${JSON.stringify(out)}, JSON.stringify(result, (k, v) => (typeof v
 `;
 }
 async function searchAssets(dir, api2, query, options = {}, fetcher = fetch) {
-  const folder = resolve8(dir);
+  const folder = resolve9(dir);
   if (hasNodeModules(folder)) {
-    const temp = mkdtempSync3(join11(tmpdir4(), "onceworlds-assets-"));
+    const temp = mkdtempSync3(join12(tmpdir5(), "onceworlds-assets-"));
     try {
-      const out = join11(temp, "catalog.json");
+      const out = join12(temp, "catalog.json");
       await runProgram(process.execPath, ["--input-type=module", "--eval", catalogScript(out, query, options)], folder, 6e4);
-      if (existsSync7(out)) {
-        const result = JSON.parse(readFileSync6(out, "utf8"));
+      if (existsSync8(out)) {
+        const result = JSON.parse(readFileSync7(out, "utf8"));
         if (Array.isArray(result.searched)) return result.searched.map(normalizeAsset).filter((a) => a !== null).slice(0, options.limit ?? 8);
         if (Array.isArray(result.entries)) return rankAssets(result.entries.map(normalizeAsset).filter((a) => a !== null), query, options);
       }
@@ -7746,7 +8423,7 @@ function checkProjectConfig(config) {
 }
 
 // src/index.ts
-var CLI_VERSION = "0.9.4";
+var CLI_VERSION = "0.9.5";
 var PRODUCTION_API = "https://onceworlds.com";
 var LOCAL_API = "http://localhost:8787";
 var USAGE = `Usage:
@@ -7873,7 +8550,7 @@ async function main() {
     console.log(USAGE);
     return;
   }
-  const projectDir = resolve9(projectArg ?? ".");
+  const projectDir = resolve10(projectArg ?? ".");
   const api2 = (values.api ?? process.env.ONCEWORLDS_API ?? (command === "dev" ? LOCAL_API : PRODUCTION_API)).replace(/\/+$/, "");
   if (command === "api" || command === "recipe" || command === "guide") {
     const words3 = positionals.slice(1).join(" ").trim();
@@ -7995,7 +8672,7 @@ async function dev(projectDir, api2, tokenArg, players = 1) {
   for (let n = 2; n <= players; n++) console.log(`  Player ${n}: ${first.playUrl}?player=${n}&watch`);
   console.log(`  Watching ${root}. Press Ctrl+C to stop.
 `);
-  const projectSignature = async () => signature((await collectFiles(root)).files) + await readFile5(join12(projectDir, "onceworlds.json"), "utf8").catch(() => "");
+  const projectSignature = async () => signature((await collectFiles(root)).files) + await readFile5(join13(projectDir, "onceworlds.json"), "utf8").catch(() => "");
   let lastSignature = await projectSignature();
   let timer;
   let running = false;
@@ -8028,17 +8705,17 @@ async function dev(projectDir, api2, tokenArg, players = 1) {
     timer = setTimeout(run, 250);
   };
   watch(root, { recursive: true }, (_event, filename) => {
-    if (filename && filename.split(sep2).some((part) => part.startsWith(".") || part === "node_modules")) return;
+    if (filename && filename.split(sep3).some((part) => part.startsWith(".") || part === "node_modules")) return;
     trigger();
   });
   await new Promise(() => {
   });
 }
 async function designDoc(projectDir) {
-  return readFile5(join12(projectDir, "DESIGN.md"), "utf8").catch(() => null);
+  return readFile5(join13(projectDir, "DESIGN.md"), "utf8").catch(() => null);
 }
 async function kitPrintOf(projectDir) {
-  return readKitPrint(await readFile5(join12(projectDir, KIT_PRINT_PATH), "utf8").catch(() => null));
+  return readKitPrint(await readFile5(join13(projectDir, KIT_PRINT_PATH), "utf8").catch(() => null));
 }
 async function readSources(files) {
   const sources = [];
@@ -8130,7 +8807,7 @@ async function writeControls(projectDir, config, hints) {
   } catch (err) {
     throw new CliError(`The action map gives controls the platform won't take: ${err.message}.`);
   }
-  const file = join12(projectDir, "onceworlds.json");
+  const file = join13(projectDir, "onceworlds.json");
   const written = JSON.parse(await readFile5(file, "utf8"));
   written.controls = controls;
   await writeFile4(file, `${JSON.stringify(written, null, 2)}
@@ -8145,7 +8822,7 @@ async function check(projectDir, options) {
   const sources = await readSources(files);
   const engine = await isEngineGame(projectDir, config);
   if (engine) console.log("Playing the game headless (its tests, then simulated matches with chaos)...");
-  const result = engine ? await checkEngineGame({ dir: projectDir, configFile: options.config, font: await engineFont(options.api).catch(() => null) }) : null;
+  const result = engine ? await checkEngineGame({ dir: projectDir, configFile: options.config, font: await textCoverage(projectDir, options.api).catch(() => null) }) : null;
   const findings = projectFindings(config, sources, result?.controls, await assetsOf(files), await configProblems(projectDir, config), await designDoc(projectDir), await kitPrintOf(projectDir));
   console.log(`
 Checked ${sources.length} file${sources.length === 1 ? "" : "s"} in ${root}.`);
@@ -8186,8 +8863,8 @@ ${formatBuildTemplates(scenes)}
   if (values.space !== void 0 && !SPACES.includes(values.space)) throw new CliError(`--space is ${SPACES.join(" or ")}.`);
   const folder = dirArg ?? values.slug;
   if (!folder) throw new CliError("Say which folder to make: onceworlds new <folder> (blank), or add --kit <name> to start from a kit (--list shows them).");
-  const dir = resolve9(folder);
-  const source = basename4(dir);
+  const dir = resolve10(folder);
+  const source = basename5(dir);
   const slug = values.slug ?? slugFrom(source);
   if (!slug) throw new CliError(`"${source}" can't be a game's link: pass --slug (lowercase letters, digits and dashes).`);
   const made = await newGame({ api: api2, dir, slug, name: values.name ?? titleFrom(source), description: values.description, kit: values.kit, template: values.template, space: values.space });
@@ -8215,14 +8892,14 @@ Next:
   Read AGENTS.md: the guide for you and your AI tool. Look the engine up with onceworlds api <name> and onceworlds recipe.`);
 }
 function publishRoot(projectDir, config) {
-  const root = resolve9(projectDir, config.dir ?? ".");
-  if (root !== projectDir && !root.startsWith(projectDir + sep2)) {
+  const root = resolve10(projectDir, config.dir ?? ".");
+  if (root !== projectDir && !root.startsWith(projectDir + sep3)) {
     throw new CliError(`"dir" in onceworlds.json (${config.dir}) must be a folder inside the project.`);
   }
   return root;
 }
 async function loadConfig(projectDir, options = {}) {
-  const file = join12(projectDir, "onceworlds.json");
+  const file = join13(projectDir, "onceworlds.json");
   let config;
   try {
     config = JSON.parse(await readFile5(file, "utf8"));
@@ -8263,8 +8940,8 @@ function storeImages(config) {
 }
 async function readStoreImage(projectDir, value, slot, field2) {
   if (typeof value !== "string" || !value.trim()) return { problem: `"${field2}" in onceworlds.json must be the path of an image, like "store/icon.png".` };
-  const abs = resolve9(projectDir, value);
-  if (!abs.startsWith(projectDir + sep2)) return { problem: `"${field2}" in onceworlds.json (${value}) must be inside the project folder.` };
+  const abs = resolve10(projectDir, value);
+  if (!abs.startsWith(projectDir + sep3)) return { problem: `"${field2}" in onceworlds.json (${value}) must be inside the project folder.` };
   let data;
   try {
     data = await readFile5(abs);
@@ -8276,7 +8953,7 @@ async function readStoreImage(projectDir, value, slot, field2) {
   if (!info) return { problem: `${value} ("${field2}") must be a PNG, JPEG, WebP or GIF.` };
   const problem = imageSizeProblem(slot, info.width, info.height);
   if (problem) return { problem: `${value} ("${field2}") is ${info.width}\xD7${info.height}. ${problem}` };
-  return { file: { path: value, abs, hash: createHash3("sha256").update(data).digest("hex"), size: data.byteLength } };
+  return { file: { path: value, abs, hash: createHash4("sha256").update(data).digest("hex"), size: data.byteLength } };
 }
 async function loadStore(projectDir, config) {
   const images = /* @__PURE__ */ new Map();
@@ -8319,7 +8996,7 @@ async function collectFiles(root) {
     for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
       if (entry.name.startsWith(".") || QUIET_SKIPS.has(entry.name) || TEST_FILE.test(entry.name)) continue;
       if (entry.isDirectory() && (prefix === "" ? DEV_FOLDERS.has(entry.name) : entry.name === "__tests__")) continue;
-      const abs = join12(dir, entry.name);
+      const abs = join13(dir, entry.name);
       const path = prefix + entry.name;
       if (entry.isDirectory()) {
         await walk(abs, `${path}/`);
@@ -8332,7 +9009,7 @@ async function collectFiles(root) {
         if (data.byteLength > LIMITS.deployFileBytes) {
           throw new CliError(`${path} is ${formatBytes(data.byteLength)}; files can be at most ${formatBytes(LIMITS.deployFileBytes)}.`);
         }
-        files.push({ path, abs, hash: createHash3("sha256").update(data).digest("hex"), size: data.byteLength });
+        files.push({ path, abs, hash: createHash4("sha256").update(data).digest("hex"), size: data.byteLength });
       }
     }
   }
@@ -8388,7 +9065,7 @@ async function whoami(api2) {
 }
 async function runPlaytest(projectDir, api2, options) {
   const { url, draft, chrome } = await draftToPlay(projectDir, api2, "Playtesting");
-  const pictures = options.pictures ? join12(projectDir, "store") : void 0;
+  const pictures = options.pictures ? join13(projectDir, "store") : void 0;
   const result = await playtest({
     chrome,
     url,
@@ -8417,12 +9094,12 @@ async function runPosters(projectDir, api2, only) {
   const result = await capturePosters({
     chrome,
     url,
-    dir: join12(projectDir, "store"),
+    dir: join13(projectDir, "store"),
     only: only ? only.split(",").map((name) => name.trim()).filter(Boolean) : void 0,
     log: (name) => console.error(`  posters: ${name}`)
   });
   const lines = [formatPosters(result)];
-  const file = join12(projectDir, "onceworlds.json");
+  const file = join13(projectDir, "onceworlds.json");
   const config = JSON.parse(await readFile5(file, "utf8"));
   const named = listingFrom(result.saved, config);
   if (named.icon || named.thumbnails) {
@@ -8449,11 +9126,11 @@ async function runShot(projectDir, api2, values) {
     const story = await shootStory({ dir: projectDir, api: api2, at, ...sizeArg(values.size), browser: values.browser === true }).catch((err) => {
       throw new CliError(err.message);
     });
-    const folder = resolve9(projectDir, "store", "story");
+    const folder = resolve10(projectDir, "store", "story");
     await mkdir4(folder, { recursive: true });
-    for (const frame of story.frames) await writeFile4(join12(folder, frame.file), frame.png);
-    const sheet = resolve9(projectDir, values.out ?? join12("store", "story.png"));
-    await mkdir4(dirname8(sheet), { recursive: true });
+    for (const frame of story.frames) await writeFile4(join13(folder, frame.file), frame.png);
+    const sheet = resolve10(projectDir, values.out ?? join13("store", "story.png"));
+    await mkdir4(dirname9(sheet), { recursive: true });
     await writeFile4(sheet, story.sheet.png);
     console.log(`Saved ${sheet} (${story.sheet.width}x${story.sheet.height}) and ${story.frames.length} frames in ${folder}: ${story.sheet.caption}.`);
     console.log(`
@@ -8468,13 +9145,13 @@ ${STORY_CHECKLIST.map((q) => `  - ${q}`).join("\n")}`);
   const shot = await shoot({ dir: projectDir, api: api2, poster: values.poster, phase, at, ...sizeArg(values.size), browser: values.browser === true }).catch((err) => {
     throw new CliError(err.message);
   });
-  const file = resolve9(projectDir, values.out ?? join12("store", values.poster ? `shot-${values.poster}.png` : phase && phase !== "play" ? `shot-${phase}.png` : "shot.png"));
-  await mkdir4(dirname8(file), { recursive: true });
+  const file = resolve10(projectDir, values.out ?? join13("store", values.poster ? `shot-${values.poster}.png` : phase && phase !== "play" ? `shot-${phase}.png` : "shot.png"));
+  await mkdir4(dirname9(file), { recursive: true });
   await writeFile4(file, shot.png);
   console.log(`Saved ${file} (${shot.width}x${shot.height}): ${shot.caption}.`);
 }
 async function servedRoot(projectDir) {
-  if (!existsSync8(join12(projectDir, "onceworlds.json"))) return { root: projectDir };
+  if (!existsSync9(join13(projectDir, "onceworlds.json"))) return { root: projectDir };
   const config = await loadConfig(projectDir, { strict: false });
   return { root: publishRoot(projectDir, config), name: config.name };
 }
@@ -8489,7 +9166,7 @@ async function runServe(projectDir, api2, values) {
   if (!Number.isInteger(port) || port < 0 || port > 65535) throw new CliError("--port is a port number (0 for any free one).");
   if (!(await stat2(projectDir).catch(() => null))?.isDirectory()) throw new CliError(`${projectDir} isn't a folder.`);
   const { root, name } = await servedRoot(projectDir);
-  if (!existsSync8(join12(root, "index.html"))) throw new CliError(`No index.html in ${root}: serve plays the page a game starts from.`);
+  if (!existsSync9(join13(root, "index.html"))) throw new CliError(`No index.html in ${root}: serve plays the page a game starts from.`);
   const served = await serveFolder({ dir: root, api: api2, version: ENGINE_VERSION, port });
   const { lines } = servedNotes(served, { bots, name });
   console.log(`${lines.join("\n")}
@@ -8498,7 +9175,7 @@ async function runServe(projectDir, api2, values) {
   });
 }
 async function namePictures(projectDir) {
-  const file = join12(projectDir, "onceworlds.json");
+  const file = join13(projectDir, "onceworlds.json");
   const config = JSON.parse(await readFile5(file, "utf8"));
   let changed = false;
   if (!config.icon) {
@@ -8525,7 +9202,7 @@ function mcpHost(api2) {
     },
     engineCheck: async (dir) => {
       const config = await loadConfig(dir);
-      return await isEngineGame(dir, config) ? checkEngineGame({ dir, font: await engineFont(api2).catch(() => null) }) : null;
+      return await isEngineGame(dir, config) ? checkEngineGame({ dir, font: await textCoverage(dir, api2).catch(() => null) }) : null;
     },
     playtest: (dir, options) => runPlaytest(dir, api2, options),
     index: async (dir) => (await loadIndex({ dir, api: api2 })).index,
@@ -8538,7 +9215,7 @@ function mcpHost(api2) {
     searchAssets: (dir, query, options) => searchAssets(dir, api2, query, options),
     serve: async (dir, options) => {
       const { root, name } = await servedRoot(dir);
-      if (!existsSync8(join12(root, "index.html"))) throw new CliError(`No index.html in ${root}: serve plays the page a game starts from.`);
+      if (!existsSync9(join13(root, "index.html"))) throw new CliError(`No index.html in ${root}: serve plays the page a game starts from.`);
       let served = serving.get(root);
       if (!served) {
         served = await serveFolder({ dir: root, api: api2, version: ENGINE_VERSION, port: 0 });