thrunium 1.2.0-rc.3 → 1.2.0-rc.4

package/README.md

@@ -34,7 +34,7 @@ with a `/*! THRUNIUM v<version> | (c) Infobits ApS | MIT License */` banner and
 The engine is also on npm as `thrunium` (Node 24 or newer):
 
 ```bash
-npx thrunium init my-game   # new TypeScript project; add --js for JavaScript
+npx thrunium init my-game   # new TypeScript project in src/game.ts; add --js for JavaScript
 cd my-game && npm run dev   # init installs for you; use pnpm dev, yarn dev or bun run dev
 ```
 
@@ -57,7 +57,7 @@ Commands (`thrunium --help`, `--version`):
 |---|---|
 | `thrunium dev` | `--port <n>` (default 3000, tries the next 10 ports if busy), `--host <name>` (default `localhost`), `--no-open` |
 | `thrunium build` | `--out <dir>` (default `dist`), `--engine cdn\|bundle` |
-| `thrunium init [dir]` | `--js` (TypeScript by default), `--pm npm\|pnpm\|yarn\|bun` (default: the one that ran it, else npm), `--no-install`; the folder must be empty. Installs by default; if that fails the project is kept and the command is printed |
+| `thrunium init [dir]` | `--js` (TypeScript by default), `--no-src` (game file in the root instead of `src/`), `--pm npm\|pnpm\|yarn\|bun` (default: the one that ran it, else npm), `--no-install`; the folder must be empty. Installs by default; if that fails the project is kept and the command is printed |
 
 A project needs no `index.html`: without one, `dev` and `build` generate the page
 from `game.json` (`entry`, else the first of `game.ts`, `game.js`, `src/game.ts`,
@@ -69,6 +69,14 @@ favicon, link-preview image, address and language from `page` in `game.json`, an
 the contents of an optional `head.html` and `body.html` (see the "Dev server and
 builds" guide). None of these mix with a hand-written `index.html`.
 
+Games get keys and mouse state (`game.keys`, `game.mouse`), asset getters
+(`game.image`, `game.sound`, `game.sprite`), declared fonts (`game.fonts`),
+scenes with `game.paused`, timers (`game.after`, `game.every`), buttons
+(`game.button`) and a debug menu (`game.debug`). `thrunium build` downloads
+Google Fonts into the build, so players make no request to Google. See the
+"Making games easier" guide. The debug menu is on under `thrunium dev` and off
+in builds.
+
 `dev` never uses the CDN. For a project with a module entry
 (a generated page, or `<script type="module" src=...>` importing `thrunium`), `build` has two engine
 modes. `cdn` (the default) adds a script tag for

package/dist/cli.mjs

@@ -117,6 +117,112 @@ var init_engine = __esm({
   }
 });
 
+// cli/fonts.ts
+import { createHash as createHash2 } from "node:crypto";
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, renameSync, writeFileSync } from "node:fs";
+import { join as join2 } from "node:path";
+function findGoogleFontUrls(js) {
+  const urls = /* @__PURE__ */ new Set();
+  for (const m of js.matchAll(/(["'`])(https:\/\/fonts\.googleapis\.com\/css2?\?[^"'`\\\s]*)\1(?=\s*(\+)?)/g)) {
+    const url = m[2];
+    const concatenated = m[3] === "+";
+    const unfinished = /[=@&?]$/.test(url) || url.includes("${");
+    if (!concatenated && !unfinished) urls.add(url);
+  }
+  return [...urls];
+}
+function parseFontFaces(css) {
+  const faces = [];
+  for (const [, body] of css.matchAll(/@font-face\s*\{([^}]*)\}/g)) {
+    const prop = (name) => new RegExp(`(?:^|;)\\s*${name}\\s*:\\s*([^;]+)`, "i").exec(body)?.[1].trim();
+    const family = prop("font-family");
+    const src = /url\(\s*([^)]+?)\s*\)/.exec(prop("src") ?? "")?.[1];
+    if (!family || !src) continue;
+    const face = { family: unquote(family), src: unquote(src) };
+    const weight = prop("font-weight");
+    const style = prop("font-style");
+    const unicodeRange = prop("unicode-range");
+    if (weight) face.weight = weight;
+    if (style) face.style = style;
+    if (unicodeRange) face.unicodeRange = unicodeRange;
+    faces.push(face);
+  }
+  return faces;
+}
+function fontsCacheDir(root) {
+  return join2(root, "node_modules/.cache/thrunium/fonts");
+}
+function manifestScript(manifest) {
+  return `<script>window.THRUNIUM_FONTS = ${JSON.stringify(manifest).replace(/</g, "\\u003c")};</script>`;
+}
+function writeAtomic(file, data) {
+  writeFileSync(file + ".tmp", data);
+  renameSync(file + ".tmp", file);
+}
+async function download(url, fetchImpl) {
+  const res = await fetchImpl(url, { headers: { "user-agent": USER_AGENT }, signal: AbortSignal.timeout(TIMEOUT_MS) });
+  if (!res.ok) throw new Error(`${url} answered ${res.status}`);
+  return res;
+}
+function readCache(dir) {
+  try {
+    const stored = JSON.parse(readFileSync2(join2(dir, INDEX_FILE), "utf8"));
+    const fonts = stored.map((f) => ({ ...f, file: join2(dir, f.file) }));
+    return fonts.every((f) => existsSync2(f.file)) ? fonts : null;
+  } catch {
+    return null;
+  }
+}
+async function fetchOne(url, dir, fetchImpl) {
+  const cached = readCache(dir);
+  if (cached) return cached;
+  try {
+    const faces = parseFontFaces(await (await download(url, fetchImpl)).text());
+    if (faces.length === 0) throw new Error("the stylesheet has no @font-face blocks");
+    const names = /* @__PURE__ */ new Map();
+    for (const face of faces) {
+      const abs = new URL(face.src, url).href;
+      if (names.has(abs)) continue;
+      let name = (new URL(abs).pathname.split("/").pop() || "font").replace(/[^\w.-]/g, "_").replace(/^\./, "_");
+      if ([...names.values()].includes(name)) name = `${names.size}-${name}`;
+      names.set(abs, name);
+    }
+    mkdirSync(dir, { recursive: true });
+    const hashes = /* @__PURE__ */ new Map();
+    await Promise.all(
+      [...names].map(async ([abs, name]) => {
+        const bytes = new Uint8Array(await (await download(abs, fetchImpl)).arrayBuffer());
+        writeAtomic(join2(dir, name), bytes);
+        hashes.set(name, sha256(bytes));
+      })
+    );
+    const stored = faces.map((face) => {
+      const name = names.get(new URL(face.src, url).href);
+      return { ...face, file: name, hash: hashes.get(name) };
+    });
+    writeAtomic(join2(dir, INDEX_FILE), JSON.stringify(stored));
+    return stored.map((f) => ({ ...f, file: join2(dir, f.file) }));
+  } catch (err) {
+    throw new UserError(`Could not download the Google Font ${url}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+async function fetchFonts(urls, cacheDir, fetchImpl) {
+  const results = await Promise.all(urls.map((url) => fetchOne(url, join2(cacheDir, sha256(url).slice(0, 16)), fetchImpl)));
+  return new Map(urls.map((url, i) => [url, results[i]]));
+}
+var USER_AGENT, TIMEOUT_MS, INDEX_FILE, unquote, sha256;
+var init_fonts = __esm({
+  "cli/fonts.ts"() {
+    "use strict";
+    init_errors();
+    USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36";
+    TIMEOUT_MS = 3e4;
+    INDEX_FILE = "faces.json";
+    unquote = (s) => s.trim().replace(/^(["'])(.*)\1$/, "$2");
+    sha256 = (data) => createHash2("sha256").update(data).digest("hex");
+  }
+});
+
 // cli/html.ts
 function parseAttributes(tag) {
   const attrs = /* @__PURE__ */ new Map();
@@ -219,16 +325,16 @@ var init_html = __esm({
 });
 
 // cli/page.ts
-import { existsSync as existsSync2, statSync } from "node:fs";
-import { isAbsolute, join as join2, normalize } from "node:path";
+import { existsSync as existsSync3, statSync } from "node:fs";
+import { isAbsolute, join as join3, normalize } from "node:path";
 function checkAsset(root, field, value) {
   if (HTTP_URL.test(value)) return value;
   const problem = (why) => new UserError(`"page.${field}" in game.json must be an http(s) URL or a relative path to a file in the project (${why}): ${value}`);
   if (/^[a-z][a-z0-9+.-]*:/i.test(value) || value.startsWith("//")) throw problem("unsupported address");
   if (/[?#]/.test(value)) throw problem("no ? or # suffix");
   if (isAbsolute(value) || normalize(value).split(/[\\/]/).includes("..")) throw problem("outside the project");
-  const path = join2(root, value);
-  if (!existsSync2(path) || !statSync(path).isFile()) throw problem("file not found");
+  const path = join3(root, value);
+  if (!existsSync3(path) || !statSync(path).isFile()) throw problem("file not found");
   return value.replace(/^(\.\/)+/, "");
 }
 function readPageSettings(root, value) {
@@ -292,15 +398,15 @@ var init_page = __esm({
 });
 
 // cli/project.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
-import { basename, isAbsolute as isAbsolute2, join as join3, normalize as normalize2, resolve } from "node:path";
+import { existsSync as existsSync4, readFileSync as readFileSync3, statSync as statSync2 } from "node:fs";
+import { basename, isAbsolute as isAbsolute2, join as join4, normalize as normalize2, resolve } from "node:path";
 function resolveEngineMode(root, flag) {
   if (flag) return flag;
-  const manifest = join3(root, "package.json");
-  if (!existsSync3(manifest)) return "cdn";
+  const manifest = join4(root, "package.json");
+  if (!existsSync4(manifest)) return "cdn";
   let pkg;
   try {
-    pkg = JSON.parse(readFileSync2(manifest, "utf8"));
+    pkg = JSON.parse(readFileSync3(manifest, "utf8"));
   } catch {
     throw new UserError("package.json is not valid JSON.");
   }
@@ -310,14 +416,14 @@ function resolveEngineMode(root, flag) {
   throw new UserError(`Invalid "thrunium.engine" in package.json: ${JSON.stringify(value)}. Use "cdn" or "bundle".`);
 }
 function isFile(path) {
-  return existsSync3(path) && statSync2(path).isFile();
+  return existsSync4(path) && statSync2(path).isFile();
 }
 function readGameJson(root) {
-  const file = join3(root, "game.json");
-  if (!existsSync3(file)) return null;
+  const file = join4(root, "game.json");
+  if (!existsSync4(file)) return null;
   let json;
   try {
-    json = JSON.parse(readFileSync2(file, "utf8"));
+    json = JSON.parse(readFileSync3(file, "utf8"));
   } catch {
     throw new UserError("game.json is not valid JSON.");
   }
@@ -335,24 +441,24 @@ function validateEntry(root, entry) {
   if (!ENTRY_EXTENSIONS.test(entry)) {
     throw new UserError(`"entry" in game.json must end in .ts, .js, .mts or .mjs: ${entry}`);
   }
-  if (!isFile(join3(root, entry))) throw new UserError(`"entry" in game.json points to ${entry}, which does not exist.`);
+  if (!isFile(join4(root, entry))) throw new UserError(`"entry" in game.json points to ${entry}, which does not exist.`);
 }
 function hasKey(file, key) {
   try {
-    const json = JSON.parse(readFileSync2(file, "utf8"));
+    const json = JSON.parse(readFileSync3(file, "utf8"));
     return typeof json === "object" && json !== null && !Array.isArray(json) && key in json;
   } catch {
     return false;
   }
 }
 function readExtra(root, file) {
-  const path = join3(root, file);
-  return isFile(path) ? readFileSync2(path, "utf8").replace(/^\uFEFF/, "").trimEnd() : "";
+  const path = join4(root, file);
+  return isFile(path) ? readFileSync3(path, "utf8").replace(/^\uFEFF/, "").trimEnd() : "";
 }
 function resolvePage(root) {
-  const indexPath = join3(root, "index.html");
-  if (existsSync3(indexPath)) {
-    const gameJson = join3(root, "game.json");
+  const indexPath = join4(root, "index.html");
+  if (existsSync4(indexPath)) {
+    const gameJson = join4(root, "game.json");
     if (hasKey(gameJson, "entry")) {
       throw new UserError('game.json has "entry", but index.html also exists and is used instead. Remove one of them.');
     }
@@ -362,18 +468,18 @@ function resolvePage(root) {
       );
     }
     for (const file of ["head.html", "body.html"]) {
-      if (isFile(join3(root, file))) {
+      if (isFile(join4(root, file))) {
         throw new UserError(
           `${file} exists, but index.html also exists and is used instead. Move its contents into index.html or delete it.`
         );
       }
     }
-    return { html: readFileSync2(indexPath, "utf8"), htmlSource: "file", extras: { head: "", body: "" } };
+    return { html: readFileSync3(indexPath, "utf8"), htmlSource: "file", extras: { head: "", body: "" } };
   }
   const game = readGameJson(root);
   let entry = game?.entry;
   if (entry !== void 0) validateEntry(root, entry);
-  else entry = DEFAULT_ENTRIES.find((candidate) => isFile(join3(root, candidate)));
+  else entry = DEFAULT_ENTRIES.find((candidate) => isFile(join4(root, candidate)));
   if (entry === void 0) {
     throw new UserError(
       `No game found: add game.ts or game.js (or set "entry" in game.json), or an index.html. Looked for: ${DEFAULT_ENTRIES.join(", ")}.`
@@ -394,7 +500,7 @@ function loadProject(root, engineFlag) {
   const { html, htmlSource, extras } = resolvePage(root);
   const entries = findModuleEntries(html);
   for (const entry of entries) {
-    if (!existsSync3(join3(root, entry))) {
+    if (!existsSync4(join4(root, entry))) {
       throw new UserError(`Entry file ${entry} (from ${htmlSource === "file" ? "index.html" : "game.json"}) does not exist.`);
     }
   }
@@ -456,6 +562,7 @@ var init_reload_client = __esm({
   "cli/reload-client.ts"() {
     "use strict";
     RELOAD_CLIENT = `<script>
+window.THRUNIUM_DEV = true;
 (function () {
   var overlay = null;
   function clearOverlay() {
@@ -491,11 +598,11 @@ __export(dev_exports, {
   startDev: () => startDev
 });
 import { spawn } from "node:child_process";
-import { existsSync as existsSync4, readdirSync, realpathSync, statSync as statSync3, watch } from "node:fs";
+import { existsSync as existsSync5, readdirSync, realpathSync, statSync as statSync3, watch } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { createServer } from "node:http";
 import { isIP } from "node:net";
-import { basename as basename2, extname, isAbsolute as isAbsolute3, join as join4, normalize as normalize3, relative, resolve as resolve2, sep } from "node:path";
+import { basename as basename2, dirname as dirname2, extname, isAbsolute as isAbsolute3, join as join5, normalize as normalize3, relative, resolve as resolve2, sep } from "node:path";
 import { parseArgs } from "node:util";
 import { context as esbuildContext, formatMessages } from "esbuild";
 function openBrowser(url) {
@@ -533,10 +640,10 @@ async function listen(server, port, host) {
 async function startDev(opts) {
   const root = resolve2(opts.root);
   const host = opts.host ?? "localhost";
-  const outDir = join4(root, "dist");
+  const outDir = join5(root, "dist");
   const realRoot = realpathSync(root);
   const outTmp = outDir + ".tmp";
-  const virtualOut = join4(root, ".thrunium-dev");
+  const virtualOut = join5(root, ".thrunium-dev");
   loadProject(root);
   const clients = /* @__PURE__ */ new Set();
   let lastError = null;
@@ -557,6 +664,25 @@ data: ${JSON.stringify(data)}
   let owned = /* @__PURE__ */ new Set();
   let entries = [];
   let ctx = null;
+  let fonts = /* @__PURE__ */ new Map();
+  const failedFonts = /* @__PURE__ */ new Set();
+  const fontUrl = (font) => `${FONTS_PREFIX}${basename2(dirname2(font.file))}/${basename2(font.file)}`;
+  async function refreshFonts(outputs) {
+    const urls = [...new Set([...outputs].flatMap(([name, contents]) => name.endsWith(".js") ? findGoogleFontUrls(Buffer.from(contents).toString("utf8")) : []))];
+    const next = /* @__PURE__ */ new Map();
+    await Promise.all(
+      urls.map(async (url2) => {
+        try {
+          next.set(url2, (await fetchFonts([url2], fontsCacheDir(root), opts.fetchImpl ?? fetch)).get(url2));
+          failedFonts.delete(url2);
+        } catch (err) {
+          if (!failedFonts.has(url2)) console.warn(`thrunium: ${err instanceof Error ? err.message : String(err)}. It loads from Google instead.`);
+          failedFonts.add(url2);
+        }
+      })
+    );
+    fonts = new Map(urls.flatMap((url2) => next.has(url2) ? [[url2, next.get(url2)]] : []));
+  }
   const formatErrors = async (errors) => (await formatMessages(errors, { kind: "error", color: false })).join("\n").trim();
   async function startBundler(newEntries) {
     await ctx?.dispose();
@@ -564,6 +690,7 @@ data: ${JSON.stringify(data)}
     entries = newEntries;
     buildError = null;
     bundles.clear();
+    fonts = /* @__PURE__ */ new Map();
     owned = new Set(entries.map((e) => resolve2(root, e)));
     if (entries.length === 0) return;
     let first = true;
@@ -596,6 +723,7 @@ data: ${JSON.stringify(data)}
                 const changed = next.size !== bundles.size || [...next].some(([k, v]) => !Buffer.from(v).equals(bundles.get(k) ?? new Uint8Array()));
                 bundles.clear();
                 for (const [k, v] of next) bundles.set(k, v);
+                await refreshFonts(next);
                 owned = new Set(Object.keys(result.metafile?.inputs ?? {}).map((p) => resolve2(root, p)));
                 for (const e of entries) owned.add(resolve2(root, e));
                 if (!wasFirst && (changed || lastError !== null)) broadcastReload();
@@ -651,9 +779,17 @@ data: ${JSON.stringify(data)}
       const project = loadProject(root);
       const entryMap = new Map(project.entries.map((e, i) => [e, `${BUNDLE_PREFIX}${i}.js`]));
       const styles = project.entries.flatMap((_, i) => bundles.has(`${i}.css`) ? [`${BUNDLE_PREFIX}${i}.css`] : []);
+      const manifest = {};
+      for (const [googleUrl, files] of fonts) {
+        manifest[googleUrl] = files.map((font) => {
+          const { file: _file, hash: _hash, ...face } = font;
+          return { ...face, src: fontUrl(font) };
+        });
+      }
+      const engineTag = (fonts.size > 0 ? manifestScript(manifest) : "") + ENGINE_TAG;
       const html = fillExtras(
         transformHtml(project.html, {
-          engineTag: project.usesModules ? ENGINE_TAG : null,
+          engineTag: project.usesModules ? engineTag : null,
           entryMap,
           inject: RELOAD_CLIENT,
           styles
@@ -678,10 +814,20 @@ data: ${JSON.stringify(data)}
       res.writeHead(200, { ...noCache, "content-type": type }).end(contents);
       return;
     }
-    const file = normalize3(join4(root, pathname));
+    if (pathname.startsWith(FONTS_PREFIX)) {
+      const font = [...fonts.values()].flat().find((f) => fontUrl(f) === pathname);
+      if (!font) {
+        res.writeHead(404).end();
+        return;
+      }
+      const type = MIME[extname(font.file).toLowerCase()] ?? "application/octet-stream";
+      res.writeHead(200, { ...noCache, "content-type": type }).end(await readFile(font.file));
+      return;
+    }
+    const file = normalize3(join5(root, pathname));
     const rel = relative(root, file);
     if (/[\\\0]/.test(pathname) || // backslashes act as separators on Windows; NUL is never valid
-    rel.split(/[\\/]/).some((part) => part.startsWith(".")) || rel === "" || rel === ".." || rel.startsWith(".." + sep) || isAbsolute3(rel) || !existsSync4(file) || !statSync3(file).isFile()) {
+    rel.split(/[\\/]/).some((part) => part.startsWith(".")) || rel === "" || rel === ".." || rel.startsWith(".." + sep) || isAbsolute3(rel) || !existsSync5(file) || !statSync3(file).isFile()) {
       res.writeHead(404).end();
       return;
     }
@@ -728,20 +874,20 @@ data: ${JSON.stringify(data)}
   };
   const watchers = /* @__PURE__ */ new Map();
   const skippedTop = (name) => {
-    const abs = join4(root, name);
+    const abs = join5(root, name);
     return name === "node_modules" || name.startsWith(".") || abs === outDir || abs === outTmp;
   };
   const onWatchError = (path) => (err) => {
     watchers.get(path)?.close();
     watchers.delete(path);
-    if (existsSync4(path)) console.error(`thrunium: file watching stopped for ${path}: ${err.message}`);
+    if (existsSync5(path)) console.error(`thrunium: file watching stopped for ${path}: ${err.message}`);
   };
   const rescan = () => {
     if (closed) return;
     const dirs = /* @__PURE__ */ new Set();
     try {
       for (const entry of readdirSync(root, { withFileTypes: true })) {
-        if (entry.isDirectory() && !skippedTop(entry.name)) dirs.add(join4(root, entry.name));
+        if (entry.isDirectory() && !skippedTop(entry.name)) dirs.add(join5(root, entry.name));
       }
     } catch {
       return;
@@ -758,7 +904,7 @@ data: ${JSON.stringify(data)}
         const w = watch(dir, { recursive: true }, (_event, filename) => {
           if (!filename) return schedule();
           const name = filename.toString();
-          if (name === basename2(dir) && !existsSync4(join4(dir, name))) return;
+          if (name === basename2(dir) && !existsSync5(join5(dir, name))) return;
           if (!ignored(resolve2(dir, name))) schedule();
         });
         w.on("error", onWatchError(dir));
@@ -770,7 +916,7 @@ data: ${JSON.stringify(data)}
   const rootWatcher = watch(root, (event, filename) => {
     if (event === "rename") rescan();
     const abs = filename ? resolve2(root, filename.toString()) : root;
-    const pageInput = !filename || PAGE_INPUTS.some((file) => abs === join4(root, file));
+    const pageInput = !filename || PAGE_INPUTS.some((file) => abs === join5(root, file));
     if (!pageInput && ignored(abs)) return;
     schedule();
   });
@@ -848,12 +994,13 @@ ${USAGE}`);
   });
   await server.close();
 }
-var USAGE, MIME, ENGINE_TAG, BUNDLE_PREFIX, PAGE_INPUTS, WATCH_DEBOUNCE_MS, PORT_ATTEMPTS;
+var USAGE, MIME, ENGINE_TAG, BUNDLE_PREFIX, FONTS_PREFIX, PAGE_INPUTS, WATCH_DEBOUNCE_MS, PORT_ATTEMPTS;
 var init_dev = __esm({
   "cli/dev.ts"() {
     "use strict";
     init_engine();
     init_errors();
+    init_fonts();
     init_html();
     init_project();
     init_reload_client();
@@ -888,6 +1035,7 @@ Options:
     };
     ENGINE_TAG = '<script src="/__thrunium/engine/thrunium.js"></script>';
     BUNDLE_PREFIX = "/__thrunium/bundle/";
+    FONTS_PREFIX = "/__thrunium/fonts/";
     PAGE_INPUTS = ["index.html", "game.json", "head.html", "body.html"];
     WATCH_DEBOUNCE_MS = 50;
     PORT_ATTEMPTS = 11;
@@ -900,14 +1048,14 @@ __export(build_exports, {
   build: () => build,
   runBuild: () => runBuild
 });
-import { existsSync as existsSync5, mkdirSync, readdirSync as readdirSync2, readFileSync as readFileSync3, renameSync, rmSync, statSync as statSync4, writeFileSync, copyFileSync } from "node:fs";
-import { dirname as dirname2, isAbsolute as isAbsolute4, join as join5, relative as relative2, resolve as resolve3, sep as sep2 } from "node:path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync2, readdirSync as readdirSync2, readFileSync as readFileSync4, renameSync as renameSync2, rmSync, statSync as statSync4, writeFileSync as writeFileSync2, copyFileSync } from "node:fs";
+import { basename as basename3, dirname as dirname3, extname as extname2, isAbsolute as isAbsolute4, join as join6, relative as relative2, resolve as resolve3, sep as sep2 } from "node:path";
 import { parseArgs as parseArgs2 } from "node:util";
 import { build as esbuild, formatMessages as formatMessages2 } from "esbuild";
 function listFiles(root, dir, skipDirs) {
   const files = [];
   for (const entry of readdirSync2(dir, { withFileTypes: true })) {
-    const abs = join5(dir, entry.name);
+    const abs = join6(dir, entry.name);
     if (entry.name.startsWith(".") || entry.name === "node_modules" || skipDirs.has(abs)) continue;
     if (entry.isDirectory()) files.push(...listFiles(root, abs, skipDirs));
     else if (entry.isFile() && !SKIPPED_NAMES.test(entry.name)) files.push(relative2(root, abs));
@@ -935,7 +1083,7 @@ async function runBuild(opts) {
   const entryMap = /* @__PURE__ */ new Map();
   const styles = [];
   if (project.usesModules) {
-    const outAbs = join5(root, ".thrunium-out");
+    const outAbs = join6(root, ".thrunium-out");
     const result = await esbuild({
       ...baseBuildOptions(root),
       entryPoints: project.entries,
@@ -970,12 +1118,25 @@ async function runBuild(opts) {
   if (project.usesModules) {
     if (bundled) {
       engineTag = '<script src="thrunium.min.js"></script>';
-      written.set("thrunium.min.js", readFileSync3(engineFile("thrunium.min.js")));
+      written.set("thrunium.min.js", readFileSync4(engineFile("thrunium.min.js")));
       const map = engineFile("thrunium.min.js") + ".map";
-      if (existsSync5(map)) written.set("thrunium.min.js.map", readFileSync3(map));
+      if (existsSync6(map)) written.set("thrunium.min.js.map", readFileSync4(map));
     } else {
       engineTag = cdnScriptTag(engineVersion(), integrity);
     }
+    const urls = [...new Set([...written].flatMap(([file, contents]) => file.endsWith(".js") ? findGoogleFontUrls(Buffer.from(contents).toString("utf8")) : []))];
+    if (urls.length > 0) {
+      const manifest = {};
+      for (const [url, fonts] of await fetchFonts(urls, fontsCacheDir(root), opts.fetchImpl ?? fetch)) {
+        manifest[url] = fonts.map(({ file, hash, ...face }) => {
+          const ext = extname2(file);
+          const src = `fonts/${basename3(file, ext)}-${hash.slice(0, 8)}${ext}`;
+          written.set(src, readFileSync4(file));
+          return { ...face, src };
+        });
+      }
+      engineTag = manifestScript(manifest) + engineTag;
+    }
   }
   const tmp = outDir + ".tmp";
   written.set("index.html", fillExtras(transformHtml(project.html, { engineTag, entryMap, inject: null, styles }), project.extras));
@@ -986,28 +1147,28 @@ async function runBuild(opts) {
       const key = file.split(sep2).join("/");
       if (written.has(key) || consumed.has(resolve3(root, file))) continue;
       if (project.htmlSource === "generated" && PAGE_PARTS.has(key)) continue;
-      const dest = join5(tmp, file);
-      mkdirSync(dirname2(dest), { recursive: true });
-      copyFileSync(join5(root, file), dest);
+      const dest = join6(tmp, file);
+      mkdirSync2(dirname3(dest), { recursive: true });
+      copyFileSync(join6(root, file), dest);
     }
     for (const [file, contents] of written) {
-      const dest = join5(tmp, file);
-      mkdirSync(dirname2(dest), { recursive: true });
-      writeFileSync(dest, contents);
+      const dest = join6(tmp, file);
+      mkdirSync2(dirname3(dest), { recursive: true });
+      writeFileSync2(dest, contents);
     }
     rmSync(outDir, { recursive: true, force: true });
-    renameSync(tmp, outDir);
+    renameSync2(tmp, outDir);
   } catch (err) {
     rmSync(tmp, { recursive: true, force: true });
     throw err;
   }
   const files = listAll(outDir, outDir).sort();
-  for (const f of files) console.log(`  ${f}  ${formatSize(statSync4(join5(outDir, f)).size)}`);
+  for (const f of files) console.log(`  ${f}  ${formatSize(statSync4(join6(outDir, f)).size)}`);
   return { outDir, files };
 }
 function listAll(base, dir) {
   return readdirSync2(dir, { withFileTypes: true }).flatMap(
-    (e) => e.isDirectory() ? listAll(base, join5(dir, e.name)) : [relative2(base, join5(dir, e.name)).split(sep2).join("/")]
+    (e) => e.isDirectory() ? listAll(base, join6(dir, e.name)) : [relative2(base, join6(dir, e.name)).split(sep2).join("/")]
   );
 }
 function formatSize(bytes) {
@@ -1045,6 +1206,7 @@ var init_build = __esm({
     "use strict";
     init_engine();
     init_errors();
+    init_fonts();
     init_html();
     init_project();
     USAGE2 = `Usage: thrunium build [options]
@@ -1070,8 +1232,8 @@ __export(init_exports, {
   spawnInstall: () => spawnInstall
 });
 import { spawn as spawn2 } from "node:child_process";
-import { cpSync, existsSync as existsSync6, mkdirSync as mkdirSync2, readdirSync as readdirSync3, readFileSync as readFileSync4, renameSync as renameSync2, statSync as statSync5, writeFileSync as writeFileSync2 } from "node:fs";
-import { basename as basename3, join as join6, resolve as resolve4 } from "node:path";
+import { cpSync, existsSync as existsSync7, mkdirSync as mkdirSync3, readdirSync as readdirSync3, readFileSync as readFileSync5, renameSync as renameSync3, rmdirSync, statSync as statSync5, writeFileSync as writeFileSync3 } from "node:fs";
+import { basename as basename4, join as join7, resolve as resolve4 } from "node:path";
 import { parseArgs as parseArgs3 } from "node:util";
 function detectPackageManager(userAgent) {
   const [name, version] = (userAgent?.split(" ")[0] ?? "").split("/");
@@ -1093,31 +1255,36 @@ function spawnInstall(cmd, args, cwd) {
 }
 async function runInit(opts) {
   const dir = resolve4(opts.dir);
-  if (existsSync6(dir)) {
+  if (existsSync7(dir)) {
     if (!statSync5(dir).isDirectory() || readdirSync3(dir).length > 0) {
       throw new UserError(`${dir} already exists and is not an empty folder.`);
     }
   } else {
-    mkdirSync2(dir, { recursive: true });
+    mkdirSync3(dir, { recursive: true });
   }
-  cpSync(join6(packageRoot(), "templates", opts.template), dir, { recursive: true });
-  if (opts.pm.name === "pnpm") cpSync(join6(packageRoot(), "templates", "pnpm"), dir, { recursive: true });
-  renameSync2(join6(dir, "gitignore"), join6(dir, ".gitignore"));
-  const name = basename3(dir).toLowerCase().replace(/[^a-z0-9-]/g, "-");
+  cpSync(join7(packageRoot(), "templates", opts.template), dir, { recursive: true });
+  if (opts.pm.name === "pnpm") cpSync(join7(packageRoot(), "templates", "pnpm"), dir, { recursive: true });
+  renameSync3(join7(dir, "gitignore"), join7(dir, ".gitignore"));
+  const name = basename4(dir).toLowerCase().replace(/[^a-z0-9-]/g, "-");
   for (const file of TEXT_FILES) {
-    const path = join6(dir, file);
-    const text = readFileSync4(path, "utf8").replace(/\{\{name\}\}/g, name).replace(/\{\{version\}\}/g, engineVersion());
-    writeFileSync2(path, text);
+    const path = join7(dir, file);
+    const text = readFileSync5(path, "utf8").replace(/\{\{name\}\}/g, name).replace(/\{\{version\}\}/g, engineVersion());
+    writeFileSync3(path, text);
   }
   const pinPnpm = opts.pm.name === "pnpm" && opts.pm.version;
   if (pinPnpm || opts.pm.name === "npm") {
-    const path = join6(dir, "package.json");
-    const pkg = JSON.parse(readFileSync4(path, "utf8"));
+    const path = join7(dir, "package.json");
+    const pkg = JSON.parse(readFileSync5(path, "utf8"));
     if (pinPnpm) pkg.packageManager = `pnpm@${opts.pm.version}`;
     if (opts.pm.name === "npm") pkg.allowScripts = { esbuild: true };
-    writeFileSync2(path, `${JSON.stringify(pkg, null, 2)}
+    writeFileSync3(path, `${JSON.stringify(pkg, null, 2)}
 `);
   }
+  if (opts.src === false) {
+    const file = opts.template === "ts" ? "game.ts" : "game.js";
+    renameSync3(join7(dir, "src", file), join7(dir, file));
+    rmdirSync(join7(dir, "src"));
+  }
   if (!opts.install) return;
   const { cmd, args } = installCommand(opts.pm.name);
   const ok = await (opts.runInstall ?? spawnInstall)(cmd, args, dir);
@@ -1134,6 +1301,7 @@ async function init(args) {
         js: { type: "boolean" },
         pm: { type: "string" },
         install: { type: "boolean", default: true },
+        src: { type: "boolean", default: true },
         help: { type: "boolean", short: "h" }
       },
       allowPositionals: true,
@@ -1162,7 +1330,7 @@ ${USAGE3}`);
     }
     pm = values.pm === pm.name ? pm : { name: values.pm, version: null };
   }
-  await runInit({ dir, template: values.js ? "js" : "ts", pm, install: values.install });
+  await runInit({ dir, template: values.js ? "js" : "ts", pm, install: values.install, src: values.src });
   console.log(`Created ${dir === "." ? "the project" : dir}. Next:
 
 ${dir === "." ? "" : `  cd ${dir}
@@ -1184,6 +1352,7 @@ Options:
   --pm <name>     Package manager: npm, pnpm, yarn or bun
                   (default: the one that ran this command, else npm)
   --no-install    Do not install dependencies
+  --no-src        Put game.ts (or game.js) in the project root instead of src/
   --help, -h      Show this help
 `;
     PACKAGE_MANAGERS = ["npm", "pnpm", "yarn", "bun"];
@@ -1193,7 +1362,7 @@ Options:
 
 // cli/main.ts
 init_errors();
-import { readFileSync as readFileSync5 } from "node:fs";
+import { readFileSync as readFileSync6 } from "node:fs";
 import { parseArgs as parseArgs4 } from "node:util";
 var USAGE4 = `Usage: thrunium <command>
 
@@ -1208,7 +1377,7 @@ Options:
 `;
 function packageVersion() {
   const url = new URL("../package.json", import.meta.url);
-  return JSON.parse(readFileSync5(url, "utf8")).version;
+  return JSON.parse(readFileSync6(url, "utf8")).version;
 }
 async function main(argv) {
   try {

package/dist/thrunium-global.mjs

@@ -14,6 +14,7 @@ export const Game = T.Game;
 export const Vector = T.Vector;
 export const Collider = T.Collider;
 export const Sprite = T.Sprite;
+export const Button = T.Button;
 export const Elem = T.Elem;
 export const ajax = T.ajax;
 export const Storage = T.Storage;