thrunium 0.0.0-stage → 1.2.0-rc.2

package/dist/cli.mjs

@@ -0,0 +1,1150 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// cli/errors.ts
+var UserError;
+var init_errors = __esm({
+  "cli/errors.ts"() {
+    "use strict";
+    UserError = class extends Error {
+    };
+  }
+});
+
+// cli/engine.ts
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+function cdnBase() {
+  return process.env.THRUNIUM_CDN_URL || DEFAULT_CDN;
+}
+function packageRoot() {
+  if (cachedRoot) return cachedRoot;
+  let dir = dirname(fileURLToPath(import.meta.url));
+  for (; ; ) {
+    const manifest = join(dir, "package.json");
+    if (existsSync(manifest)) {
+      try {
+        if (JSON.parse(readFileSync(manifest, "utf8")).name === "thrunium") {
+          return cachedRoot = dir;
+        }
+      } catch {
+      }
+    }
+    const parent = dirname(dir);
+    if (parent === dir) throw new Error("Could not locate the thrunium package root.");
+    dir = parent;
+  }
+}
+function engineVersion() {
+  const manifest = JSON.parse(readFileSync(join(packageRoot(), "package.json"), "utf8"));
+  return manifest.version;
+}
+function engineFile(name) {
+  return join(packageRoot(), "dist", name);
+}
+function globalShimFile() {
+  return join(packageRoot(), "dist", "thrunium-global.mjs");
+}
+function sriHash(file) {
+  return "sha384-" + createHash("sha384").update(readFileSync(file)).digest("base64");
+}
+function cdnEngineUrl(version) {
+  return `${cdnBase()}/v${version}/thrunium.min.js`;
+}
+function cdnScriptTag(version, integrity) {
+  return `<script src="${cdnEngineUrl(version)}" integrity="${integrity}" crossorigin="anonymous"></script>`;
+}
+async function assertOnCdn(version, integrity, fetchImpl = fetch) {
+  const fail = (reason) => new UserError(
+    `Thrunium ${version} could not be confirmed on the CDN (${reason}). Check your connection or use --engine bundle to include the engine in your build.`
+  );
+  const get = async (url) => {
+    let res;
+    try {
+      res = await fetchImpl(url, { signal: AbortSignal.timeout(CDN_TIMEOUT_MS) });
+    } catch (err) {
+      throw fail(`${url} is unreachable: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (!res.ok) throw fail(`${url} returned ${res.status}`);
+    return res;
+  };
+  const read = async (url, res, parse) => {
+    try {
+      return await parse(res);
+    } catch (err) {
+      if (err instanceof SyntaxError) throw fail(`${url} returned an invalid response`);
+      throw fail(`${url} is unreachable: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  };
+  const listUrl = `${cdnBase()}/versions.json`;
+  const body = await read(listUrl, await get(listUrl), (r) => r.json());
+  const versions = body !== null && typeof body === "object" ? body.versions : void 0;
+  if (!Array.isArray(versions)) throw fail(`${listUrl} returned an invalid response`);
+  if (!versions.some((v) => v !== null && typeof v === "object" && v.version === version)) {
+    throw fail("version not published");
+  }
+  const engineUrl = cdnEngineUrl(version);
+  const bytes = await read(engineUrl, await get(engineUrl), (r) => r.arrayBuffer());
+  const cdnIntegrity = "sha384-" + createHash("sha384").update(new Uint8Array(bytes)).digest("base64");
+  if (cdnIntegrity !== integrity) {
+    throw new UserError(
+      `The CDN copy of Thrunium ${version} differs from the installed one (e.g. npm link or local changes). Use --engine bundle to include the installed engine in your build.`
+    );
+  }
+}
+var DEFAULT_CDN, cachedRoot, CDN_TIMEOUT_MS;
+var init_engine = __esm({
+  "cli/engine.ts"() {
+    "use strict";
+    init_errors();
+    DEFAULT_CDN = "https://cdn.thrungames.com/thrunium";
+    CDN_TIMEOUT_MS = 1e4;
+  }
+});
+
+// cli/html.ts
+function parseAttributes(tag) {
+  const attrs = /* @__PURE__ */ new Map();
+  const body = tag.slice("<script".length);
+  for (const m of body.matchAll(ATTRIBUTE)) {
+    const name = m[1].toLowerCase();
+    if (!attrs.has(name)) attrs.set(name, m[2] ?? m[3] ?? m[4] ?? "");
+  }
+  return attrs;
+}
+function scriptTags(html) {
+  return [...html.matchAll(SCRIPT_TAG)].map((m) => ({
+    index: m.index,
+    text: m[0],
+    attrs: parseAttributes(m[0])
+  }));
+}
+function isModuleWithSrc(tag) {
+  return tag.attrs.get("type")?.toLowerCase() === "module" && tag.attrs.has("src");
+}
+function isRemote(src) {
+  return /^(https?:|\/\/|data:)/i.test(src.trim());
+}
+function normaliseEntry(src) {
+  return src.trim().replace(/[?#].*$/, "").replace(/^(\.\/|\/)+/, "");
+}
+function localModuleTags(html) {
+  return scriptTags(html).filter((t) => isModuleWithSrc(t) && !isRemote(t.attrs.get("src")));
+}
+function findModuleEntries(html) {
+  return localModuleTags(html).map((t) => normaliseEntry(t.attrs.get("src")));
+}
+function hasEngineTag(html) {
+  return scriptTags(html).some((t) => ENGINE_SRC.test(t.attrs.get("src") ?? ""));
+}
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function generatePage(title, entry) {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+	<meta charset="utf-8">
+	<meta name="viewport" content="width=device-width, initial-scale=1">
+	<title>${escapeHtml(title)}</title>
+</head>
+<body style="margin: 0; padding: 0;">
+	<script type="module" src="${escapeHtml(entry)}"></script>
+</body>
+</html>
+`;
+}
+function transformHtml(html, opts) {
+  let out = html;
+  const hasHead = /<\/head\s*>/i.test(html);
+  const styleLinks = opts.styles.map((href) => `<link rel="stylesheet" href="${escapeHtml(href)}">`).join("");
+  const tags = localModuleTags(html);
+  for (let i = tags.length - 1; i >= 0; i--) {
+    const tag = tags[i];
+    const srcValue = tag.attrs.get("src");
+    const mapped = opts.entryMap.get(normaliseEntry(srcValue));
+    let text = tag.text;
+    if (mapped !== void 0) {
+      text = text.replace(/(\ssrc\s*=\s*)(?:"[^"]*"|'[^']*'|[^\s"'=<>`]+)/i, (_m, pre) => `${pre}"${mapped}"`);
+    }
+    if (i === 0) {
+      if (opts.engineTag !== null) text = opts.engineTag + text;
+      if (!hasHead) text = styleLinks + text;
+    }
+    out = out.slice(0, tag.index) + text + out.slice(tag.index + tag.text.length);
+  }
+  if (hasHead && styleLinks !== "") {
+    const at = /<\/head\s*>/i.exec(out).index;
+    out = out.slice(0, at) + styleLinks + out.slice(at);
+  }
+  if (opts.inject !== null) {
+    const at = [/<\/body\s*>/i, /<\/html\s*>/i].map((re) => re.exec(out)?.index).find((i) => i !== void 0);
+    out = at === void 0 ? out + opts.inject : out.slice(0, at) + opts.inject + out.slice(at);
+  }
+  return out;
+}
+var SCRIPT_TAG, ATTRIBUTE, ENGINE_SRC;
+var init_html = __esm({
+  "cli/html.ts"() {
+    "use strict";
+    SCRIPT_TAG = /<script\b[^>]*>/gi;
+    ATTRIBUTE = /([^\s"'<>\/=]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/g;
+    ENGINE_SRC = /(^|\/)thrunium(\.min)?\.js([?#]|$)/;
+  }
+});
+
+// cli/project.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, statSync } from "node:fs";
+import { basename, isAbsolute, join as join2, normalize, resolve } from "node:path";
+function resolveEngineMode(root, flag) {
+  if (flag) return flag;
+  const manifest = join2(root, "package.json");
+  if (!existsSync2(manifest)) return "cdn";
+  let pkg;
+  try {
+    pkg = JSON.parse(readFileSync2(manifest, "utf8"));
+  } catch {
+    throw new UserError("package.json is not valid JSON.");
+  }
+  const value = pkg.thrunium?.engine;
+  if (value === void 0) return "cdn";
+  if (value === "cdn" || value === "bundle") return value;
+  throw new UserError(`Invalid "thrunium.engine" in package.json: ${JSON.stringify(value)}. Use "cdn" or "bundle".`);
+}
+function isFile(path) {
+  return existsSync2(path) && statSync(path).isFile();
+}
+function readGameJson(root) {
+  const file = join2(root, "game.json");
+  if (!existsSync2(file)) return null;
+  let json;
+  try {
+    json = JSON.parse(readFileSync2(file, "utf8"));
+  } catch {
+    throw new UserError("game.json is not valid JSON.");
+  }
+  if (typeof json !== "object" || json === null || Array.isArray(json)) {
+    throw new UserError("game.json must contain a JSON object.");
+  }
+  const { name, entry } = json;
+  if (name !== void 0 && typeof name !== "string") throw new UserError('"name" in game.json must be a string.');
+  if (entry !== void 0 && typeof entry !== "string") throw new UserError('"entry" in game.json must be a string.');
+  return { name, entry };
+}
+function validateEntry(root, entry) {
+  const inside = !isAbsolute(entry) && !normalize(entry).split(/[\\/]/).includes("..");
+  if (!inside) throw new UserError(`"entry" in game.json must be a relative path inside the project: ${entry}`);
+  if (!ENTRY_EXTENSIONS.test(entry)) {
+    throw new UserError(`"entry" in game.json must end in .ts, .js, .mts or .mjs: ${entry}`);
+  }
+  if (!isFile(join2(root, entry))) throw new UserError(`"entry" in game.json points to ${entry}, which does not exist.`);
+}
+function hasEntryKey(file) {
+  try {
+    const json = JSON.parse(readFileSync2(file, "utf8"));
+    return typeof json === "object" && json !== null && !Array.isArray(json) && "entry" in json;
+  } catch {
+    return false;
+  }
+}
+function resolvePage(root) {
+  const indexPath = join2(root, "index.html");
+  if (existsSync2(indexPath)) {
+    if (hasEntryKey(join2(root, "game.json"))) {
+      throw new UserError('game.json has "entry", but index.html also exists and is used instead. Remove one of them.');
+    }
+    return { html: readFileSync2(indexPath, "utf8"), htmlSource: "file" };
+  }
+  const game = readGameJson(root);
+  let entry = game?.entry;
+  if (entry !== void 0) validateEntry(root, entry);
+  else entry = DEFAULT_ENTRIES.find((candidate) => isFile(join2(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(", ")}.`
+    );
+  }
+  return { html: generatePage(game?.name ?? basename(resolve(root)), entry), htmlSource: "generated" };
+}
+function loadProject(root, engineFlag) {
+  const { html, htmlSource } = resolvePage(root);
+  const entries = findModuleEntries(html);
+  for (const entry of entries) {
+    if (!existsSync2(join2(root, entry))) {
+      throw new UserError(`Entry file ${entry} (from ${htmlSource === "file" ? "index.html" : "game.json"}) does not exist.`);
+    }
+  }
+  const usesModules = entries.length > 0;
+  if (usesModules && hasEngineTag(html)) {
+    throw new UserError("Remove the Thrunium <script> tag from index.html; thrunium adds it for you.");
+  }
+  return { root, html, htmlSource, entries, usesModules, engineMode: resolveEngineMode(root, engineFlag) };
+}
+function thruniumPlugin() {
+  return {
+    name: "thrunium",
+    setup(build2) {
+      build2.onResolve({ filter: /^thrunium$/ }, () => ({ path: globalShimFile() }));
+      const assetFilter = new RegExp(`(${ASSET_EXTENSIONS.map((e) => e.replace(".", "\\.")).join("|")})$`, "i");
+      build2.onResolve({ filter: assetFilter }, (args) => {
+        if (args.kind === "url-token" || args.kind === "import-rule") return void 0;
+        return {
+          errors: [
+            {
+              text: `Cannot import ${args.path} from game code. Load the file by path instead, for example with game.assets.`
+            }
+          ]
+        };
+      });
+    }
+  };
+}
+function baseBuildOptions(root) {
+  return {
+    absWorkingDir: root,
+    bundle: true,
+    format: "esm",
+    target: "es2017",
+    plugins: [thruniumPlugin()],
+    // CSS imported from game code is bundled; fonts and images it references
+    // are emitted as files (hashed names in build) rather than inlined.
+    loader: Object.fromEntries(ASSET_EXTENSIONS.map((ext) => [ext, "file"])),
+    logLevel: "silent"
+  };
+}
+var DEFAULT_ENTRIES, ENTRY_EXTENSIONS, ASSET_EXTENSIONS;
+var init_project = __esm({
+  "cli/project.ts"() {
+    "use strict";
+    init_engine();
+    init_errors();
+    init_html();
+    DEFAULT_ENTRIES = ["game.ts", "game.js", "src/game.ts", "src/game.js"];
+    ENTRY_EXTENSIONS = /\.(ts|js|mts|mjs)$/;
+    ASSET_EXTENSIONS = [".woff", ".woff2", ".ttf", ".otf", ".png", ".jpg", ".jpeg", ".gif", ".svg", ".webp"];
+  }
+});
+
+// cli/reload-client.ts
+var RELOAD_CLIENT;
+var init_reload_client = __esm({
+  "cli/reload-client.ts"() {
+    "use strict";
+    RELOAD_CLIENT = `<script>
+(function () {
+  var overlay = null;
+  function clearOverlay() {
+    if (overlay) { overlay.remove(); overlay = null; }
+  }
+  function showError(message) {
+    clearOverlay();
+    overlay = document.createElement('div');
+    overlay.setAttribute('data-thrunium-overlay', '');
+    overlay.style.cssText = 'position:fixed;left:0;top:0;right:0;z-index:2147483647;max-height:100vh;overflow:auto;' +
+      'box-sizing:border-box;padding:16px;background:#2a0f12;color:#ffb4b4;border-bottom:3px solid #ff5555;';
+    var pre = document.createElement('pre');
+    pre.style.cssText = 'margin:0;font:13px/1.4 ui-monospace,Menlo,Consolas,monospace;white-space:pre-wrap;';
+    pre.textContent = message; // textContent: never interpreted as HTML
+    overlay.appendChild(pre);
+    document.body.appendChild(overlay);
+  }
+  var source = new EventSource('/__thrunium/events');
+  source.addEventListener('reload', function () { clearOverlay(); location.reload(); });
+  source.addEventListener('error', function (e) {
+    // The browser also fires a bare 'error' when the connection drops; only SSE messages carry data.
+    if (typeof e.data === 'string') showError(JSON.parse(e.data));
+  });
+})();
+</script>`;
+  }
+});
+
+// cli/dev.ts
+var dev_exports = {};
+__export(dev_exports, {
+  dev: () => dev,
+  startDev: () => startDev
+});
+import { spawn } from "node:child_process";
+import { existsSync as existsSync3, readdirSync, realpathSync, statSync as statSync2, 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 isAbsolute2, join as join3, normalize as normalize2, relative, resolve as resolve2, sep } from "node:path";
+import { parseArgs } from "node:util";
+import { context as esbuildContext, formatMessages } from "esbuild";
+function openBrowser(url) {
+  const [cmd, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
+  try {
+    const child = spawn(cmd, args, { stdio: "ignore", detached: true });
+    child.on("error", () => {
+    });
+    child.unref();
+  } catch {
+  }
+}
+async function listen(server, port, host) {
+  const last = Math.min(port + PORT_ATTEMPTS - 1, 65535);
+  for (let candidate = port; candidate <= last; candidate++) {
+    try {
+      await new Promise((resolveListen, reject) => {
+        const onError = (err) => reject(err);
+        server.once("error", onError);
+        server.listen(candidate, host, () => {
+          server.off("error", onError);
+          resolveListen();
+        });
+      });
+      const address = server.address();
+      return typeof address === "object" && address ? address.port : candidate;
+    } catch (err) {
+      const code = err.code;
+      if (code === "EADDRINUSE" && port !== 0) continue;
+      throw new UserError(`Cannot listen on ${host}:${candidate}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  throw new UserError(`Ports ${port}-${last} are all in use. Pass a different --port.`);
+}
+async function startDev(opts) {
+  const root = resolve2(opts.root);
+  const host = opts.host ?? "localhost";
+  const outDir = join3(root, "dist");
+  const realRoot = realpathSync(root);
+  const outTmp = outDir + ".tmp";
+  const virtualOut = join3(root, ".thrunium-dev");
+  loadProject(root);
+  const clients = /* @__PURE__ */ new Set();
+  let lastError = null;
+  let buildError = null;
+  const send = (res, event, data) => res.write(`event: ${event}
+data: ${JSON.stringify(data)}
+
+`);
+  const broadcastReload = () => {
+    lastError = null;
+    for (const res of clients) send(res, "reload", "");
+  };
+  const broadcastError = (message) => {
+    lastError = message;
+    for (const res of clients) send(res, "error", message);
+  };
+  const bundles = /* @__PURE__ */ new Map();
+  let owned = /* @__PURE__ */ new Set();
+  let entries = [];
+  let ctx = null;
+  const formatErrors = async (errors) => (await formatMessages(errors, { kind: "error", color: false })).join("\n").trim();
+  async function startBundler(newEntries) {
+    await ctx?.dispose();
+    ctx = null;
+    entries = newEntries;
+    buildError = null;
+    bundles.clear();
+    owned = new Set(entries.map((e) => resolve2(root, e)));
+    if (entries.length === 0) return;
+    let first = true;
+    let firstDone;
+    const firstBuild = new Promise((r) => firstDone = r);
+    const base = baseBuildOptions(root);
+    const created = await esbuildContext({
+      ...base,
+      entryPoints: entries.map((entry, i) => ({ in: entry, out: String(i) })),
+      sourcemap: "inline",
+      // inline maps: a bundle is a single file, there is no .js.map to serve
+      outdir: virtualOut,
+      metafile: true,
+      write: false,
+      plugins: [
+        ...base.plugins,
+        {
+          name: "thrunium-dev-events",
+          setup(build2) {
+            build2.onEnd(async (result) => {
+              const wasFirst = first;
+              first = false;
+              if (result.errors.length > 0) {
+                buildError = await formatErrors(result.errors);
+                broadcastError(buildError);
+              } else {
+                buildError = null;
+                const next = /* @__PURE__ */ new Map();
+                for (const f of result.outputFiles ?? []) next.set(f.path.slice(virtualOut.length + 1).split(sep).join("/"), f.contents);
+                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);
+                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();
+              }
+              if (wasFirst) firstDone();
+            });
+          }
+        }
+      ]
+    });
+    ctx = created;
+    await created.watch();
+    await firstBuild;
+  }
+  await startBundler(findModuleEntries(loadProject(root).html));
+  const server = createServer((req, res) => {
+    handle(req.url ?? "/", req.headers.host, res).catch((err) => {
+      if (res.headersSent) return res.end();
+      const message = err instanceof UserError ? err.message : "Internal server error";
+      res.writeHead(500, { "content-type": "text/plain" }).end(message);
+    });
+  });
+  const allowedHosts = /* @__PURE__ */ new Set(["localhost", host.toLowerCase(), `[${host.toLowerCase()}]`]);
+  const hostAllowed = (header) => {
+    if (header === void 0) return true;
+    const name = header.toLowerCase().replace(/:\d*$/, "");
+    if (allowedHosts.has(name)) return true;
+    if (isIP(name) === 4) return true;
+    return name.startsWith("[") && name.endsWith("]") && isIP(name.slice(1, -1)) === 6;
+  };
+  async function handle(rawUrl, hostHeader, res) {
+    if (!hostAllowed(hostHeader)) {
+      res.writeHead(403, { "content-type": "text/plain" }).end("Forbidden: unexpected Host header");
+      return;
+    }
+    let pathname;
+    try {
+      pathname = decodeURIComponent(rawUrl.split(/[?#]/)[0]);
+    } catch {
+      res.writeHead(400).end();
+      return;
+    }
+    const noCache = { "cache-control": "no-store" };
+    if (pathname === "/__thrunium/events") {
+      res.writeHead(200, { ...noCache, "content-type": "text/event-stream", connection: "keep-alive" });
+      res.write(": connected\n\n");
+      clients.add(res);
+      res.on("close", () => clients.delete(res));
+      if (lastError !== null) send(res, "error", lastError);
+      return;
+    }
+    if (pathname === "/" || pathname === "/index.html") {
+      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 html = transformHtml(project.html, {
+        engineTag: project.usesModules ? ENGINE_TAG : null,
+        entryMap,
+        inject: RELOAD_CLIENT,
+        styles
+      });
+      res.writeHead(200, { ...noCache, "content-type": MIME[".html"] }).end(html);
+      return;
+    }
+    if (pathname === "/__thrunium/engine/thrunium.js") {
+      res.writeHead(200, { ...noCache, "content-type": MIME[".js"] }).end(await readFile(engineFile("thrunium.js")));
+      return;
+    }
+    if (pathname.startsWith(BUNDLE_PREFIX)) {
+      const name = pathname.slice(BUNDLE_PREFIX.length);
+      const contents = bundles.get(name);
+      if (!contents) {
+        res.writeHead(404).end();
+        return;
+      }
+      const type = MIME[extname(name).toLowerCase()] ?? "application/octet-stream";
+      res.writeHead(200, { ...noCache, "content-type": type }).end(contents);
+      return;
+    }
+    const file = normalize2(join3(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) || isAbsolute2(rel) || !existsSync3(file) || !statSync2(file).isFile()) {
+      res.writeHead(404).end();
+      return;
+    }
+    const realRel = relative(realRoot, realpathSync(file));
+    if (realRel === ".." || realRel.startsWith(".." + sep) || isAbsolute2(realRel)) {
+      res.writeHead(404).end();
+      return;
+    }
+    res.writeHead(200, { ...noCache, "content-type": MIME[extname(file).toLowerCase()] ?? "application/octet-stream" }).end(await readFile(file));
+  }
+  const ignored = (abs) => {
+    const rel = relative(root, abs);
+    if (rel.split(sep).some((part) => part === "node_modules" || part.startsWith("."))) return true;
+    for (const dir of [outDir, outTmp]) if (abs === dir || abs.startsWith(dir + sep)) return true;
+    if (owned.has(abs)) return true;
+    try {
+      return statSync2(abs).isDirectory();
+    } catch {
+      return false;
+    }
+  };
+  let timer;
+  let closed = false;
+  let pending = Promise.resolve();
+  let indexChanged = false;
+  const flush = async () => {
+    const checkEntries = indexChanged;
+    indexChanged = false;
+    try {
+      if (checkEntries) {
+        const next = findModuleEntries(loadProject(root).html);
+        if (next.join("\n") !== entries.join("\n")) await startBundler(next);
+      }
+    } catch (err) {
+      broadcastError(err instanceof Error ? err.message : String(err));
+      return;
+    }
+    if (buildError !== null) {
+      if (lastError !== buildError) broadcastError(buildError);
+      return;
+    }
+    broadcastReload();
+  };
+  const schedule = () => {
+    clearTimeout(timer);
+    timer = setTimeout(() => {
+      if (!closed) pending = pending.then(flush);
+    }, WATCH_DEBOUNCE_MS);
+  };
+  const watchers = /* @__PURE__ */ new Map();
+  const skippedTop = (name) => {
+    const abs = join3(root, name);
+    return name === "node_modules" || name.startsWith(".") || abs === outDir || abs === outTmp;
+  };
+  const onWatchError = (path) => (err) => {
+    watchers.get(path)?.close();
+    watchers.delete(path);
+    if (existsSync3(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(join3(root, entry.name));
+      }
+    } catch {
+      return;
+    }
+    for (const [path, w] of watchers) {
+      if (path !== root && !dirs.has(path)) {
+        w.close();
+        watchers.delete(path);
+      }
+    }
+    for (const dir of dirs) {
+      if (watchers.has(dir)) continue;
+      try {
+        const w = watch(dir, { recursive: true }, (_event, filename) => {
+          if (!filename) return schedule();
+          const name = filename.toString();
+          if (name === basename2(dir) && !existsSync3(join3(dir, name))) return;
+          if (!ignored(resolve2(dir, name))) schedule();
+        });
+        w.on("error", onWatchError(dir));
+        watchers.set(dir, w);
+      } catch {
+      }
+    }
+  };
+  const rootWatcher = watch(root, (event, filename) => {
+    if (event === "rename") rescan();
+    const abs = filename ? resolve2(root, filename.toString()) : root;
+    const pageInput = !filename || abs === join3(root, "index.html") || abs === join3(root, "game.json");
+    if (!pageInput && ignored(abs)) return;
+    if (pageInput) indexChanged = true;
+    schedule();
+  });
+  rootWatcher.on("error", onWatchError(root));
+  watchers.set(root, rootWatcher);
+  rescan();
+  const closeWatchers = () => {
+    for (const w of watchers.values()) w.close();
+    watchers.clear();
+  };
+  let port;
+  try {
+    port = await listen(server, opts.port ?? 3e3, host);
+  } catch (err) {
+    closeWatchers();
+    await ctx?.dispose();
+    throw err;
+  }
+  const url = `http://${host}:${port}`;
+  console.log(`  \u25B2 Thrunium dev  ${url}  (engine ${engineVersion()})`);
+  if (opts.open ?? true) openBrowser(url);
+  return {
+    url,
+    async close() {
+      closed = true;
+      clearTimeout(timer);
+      closeWatchers();
+      for (const res of clients) res.end();
+      clients.clear();
+      await pending;
+      await ctx?.dispose();
+      await new Promise((r) => {
+        server.close(() => r());
+        server.closeAllConnections();
+      });
+    }
+  };
+}
+async function dev(args) {
+  let values;
+  try {
+    ({ values } = parseArgs({
+      args,
+      options: {
+        port: { type: "string" },
+        host: { type: "string" },
+        "no-open": { type: "boolean" },
+        help: { type: "boolean", short: "h" }
+      },
+      allowPositionals: false
+    }));
+  } catch (err) {
+    throw new UserError(`${err instanceof Error ? err.message : String(err)}
+
+${USAGE}`);
+  }
+  if (values.help) {
+    console.log(USAGE);
+    return;
+  }
+  let port;
+  if (values.port !== void 0) {
+    port = Number(values.port);
+    if (!Number.isInteger(port) || port < 0 || port > 65535) throw new UserError(`Invalid --port "${values.port}".`);
+  }
+  const server = await startDev({ root: process.cwd(), port, host: values.host, open: !values["no-open"] });
+  await new Promise((done) => {
+    const stop = () => {
+      process.off("SIGINT", stop);
+      process.off("SIGTERM", stop);
+      done();
+    };
+    process.on("SIGINT", stop);
+    process.on("SIGTERM", stop);
+  });
+  await server.close();
+}
+var USAGE, MIME, ENGINE_TAG, BUNDLE_PREFIX, WATCH_DEBOUNCE_MS, PORT_ATTEMPTS;
+var init_dev = __esm({
+  "cli/dev.ts"() {
+    "use strict";
+    init_engine();
+    init_errors();
+    init_html();
+    init_project();
+    init_reload_client();
+    USAGE = `Usage: thrunium dev [options]
+
+Options:
+  --port <n>     Port to listen on (default: 3000; the next free one is used if busy)
+  --host <name>  Host to listen on (default: localhost)
+  --no-open      Do not open the browser
+  --help, -h     Show this help
+`;
+    MIME = {
+      ".html": "text/html",
+      ".js": "text/javascript",
+      ".xml": "text/xml",
+      ".json": "application/json",
+      ".png": "image/png",
+      ".jpg": "image/jpeg",
+      ".gif": "image/gif",
+      ".svg": "image/svg+xml",
+      ".mp3": "audio/mpeg",
+      ".wav": "audio/wav",
+      ".ogg": "audio/ogg",
+      ".css": "text/css",
+      ".ts": "text/javascript",
+      ".wasm": "application/wasm",
+      ".woff": "font/woff",
+      ".woff2": "font/woff2",
+      ".ttf": "font/ttf",
+      ".otf": "font/otf",
+      ".webp": "image/webp"
+    };
+    ENGINE_TAG = '<script src="/__thrunium/engine/thrunium.js"></script>';
+    BUNDLE_PREFIX = "/__thrunium/bundle/";
+    WATCH_DEBOUNCE_MS = 50;
+    PORT_ATTEMPTS = 11;
+  }
+});
+
+// cli/build.ts
+var build_exports = {};
+__export(build_exports, {
+  build: () => build,
+  runBuild: () => runBuild
+});
+import { existsSync as existsSync4, mkdirSync, readdirSync as readdirSync2, readFileSync as readFileSync3, renameSync, rmSync, statSync as statSync3, writeFileSync, copyFileSync } from "node:fs";
+import { dirname as dirname2, isAbsolute as isAbsolute3, join as join4, 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 = join4(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));
+  }
+  return files;
+}
+async function runBuild(opts) {
+  const root = resolve3(opts.root);
+  const outDir = resolve3(root, opts.outDir ?? "dist");
+  const rel = relative2(root, outDir);
+  if (rel === "" || rel === ".." || rel.startsWith(".." + sep2) || isAbsolute3(rel)) {
+    throw new UserError(`The output folder must be inside the project and not the project itself: ${outDir}`);
+  }
+  const project = loadProject(root, opts.engine);
+  const bundled = project.engineMode === "bundle";
+  if (bundled && !project.usesModules) {
+    throw new UserError(
+      `Engine mode "bundle" needs a module entry: a <script type="module" src="..."> in index.html that imports 'thrunium'. A game that loads Thrunium with its own <script> tag keeps that tag; build copies it unchanged.`
+    );
+  }
+  const integrity = sriHash(engineFile("thrunium.min.js"));
+  if (project.usesModules && !bundled) await assertOnCdn(engineVersion(), integrity, opts.fetchImpl);
+  const written = /* @__PURE__ */ new Map();
+  const consumed = /* @__PURE__ */ new Set();
+  const entryMap = /* @__PURE__ */ new Map();
+  const styles = [];
+  if (project.usesModules) {
+    const outAbs = join4(root, ".thrunium-out");
+    const result = await esbuild({
+      ...baseBuildOptions(root),
+      entryPoints: project.entries,
+      minify: true,
+      sourcemap: "linked",
+      outdir: outAbs,
+      entryNames: "assets/[name]-[hash]",
+      assetNames: "assets/[name]-[hash]",
+      // fonts/images referenced by CSS or code
+      metafile: true,
+      write: false
+    }).catch(async (err) => {
+      const failure = err;
+      if (!Array.isArray(failure.errors)) throw err;
+      const text = await formatMessages2(failure.errors, { kind: "error", color: false });
+      throw new UserError(text.join("\n").trim());
+    });
+    for (const f of result.outputFiles) written.set(relative2(outAbs, f.path).split(sep2).join("/"), f.contents);
+    for (const [file, meta] of Object.entries(result.metafile.outputs)) {
+      if (meta.entryPoint) entryMap.set(meta.entryPoint, relative2(outAbs, resolve3(root, file)).split(sep2).join("/"));
+    }
+    for (const entry of project.entries) {
+      const output = Object.entries(result.metafile.outputs).find(([, meta]) => meta.entryPoint === entry);
+      const cssBundle = output?.[1].cssBundle;
+      if (cssBundle) styles.push(relative2(outAbs, resolve3(root, cssBundle)).split(sep2).join("/"));
+    }
+    for (const input of Object.keys(result.metafile.inputs)) {
+      if (!ASSET_EXTENSIONS.some((ext) => input.toLowerCase().endsWith(ext))) consumed.add(resolve3(root, input));
+    }
+  }
+  let engineTag = null;
+  if (project.usesModules) {
+    if (bundled) {
+      engineTag = '<script src="thrunium.min.js"></script>';
+      written.set("thrunium.min.js", readFileSync3(engineFile("thrunium.min.js")));
+      const map = engineFile("thrunium.min.js") + ".map";
+      if (existsSync4(map)) written.set("thrunium.min.js.map", readFileSync3(map));
+    } else {
+      engineTag = cdnScriptTag(engineVersion(), integrity);
+    }
+  }
+  const tmp = outDir + ".tmp";
+  written.set("index.html", transformHtml(project.html, { engineTag, entryMap, inject: null, styles }));
+  rmSync(tmp, { recursive: true, force: true });
+  try {
+    const skipDirs = /* @__PURE__ */ new Set([outDir, tmp]);
+    for (const file of listFiles(root, root, skipDirs)) {
+      const key = file.split(sep2).join("/");
+      if (written.has(key) || consumed.has(resolve3(root, file))) continue;
+      const dest = join4(tmp, file);
+      mkdirSync(dirname2(dest), { recursive: true });
+      copyFileSync(join4(root, file), dest);
+    }
+    for (const [file, contents] of written) {
+      const dest = join4(tmp, file);
+      mkdirSync(dirname2(dest), { recursive: true });
+      writeFileSync(dest, contents);
+    }
+    rmSync(outDir, { recursive: true, force: true });
+    renameSync(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(statSync3(join4(outDir, f)).size)}`);
+  return { outDir, files };
+}
+function listAll(base, dir) {
+  return readdirSync2(dir, { withFileTypes: true }).flatMap(
+    (e) => e.isDirectory() ? listAll(base, join4(dir, e.name)) : [relative2(base, join4(dir, e.name)).split(sep2).join("/")]
+  );
+}
+function formatSize(bytes) {
+  return bytes < 1024 ? `${bytes} B` : `${(bytes / 1024).toFixed(1)} kB`;
+}
+async function build(args) {
+  let values;
+  try {
+    ({ values } = parseArgs2({
+      args,
+      options: {
+        out: { type: "string" },
+        engine: { type: "string" },
+        help: { type: "boolean", short: "h" }
+      },
+      allowPositionals: false
+    }));
+  } catch (err) {
+    throw new UserError(`${err instanceof Error ? err.message : String(err)}
+
+${USAGE2}`);
+  }
+  if (values.help) {
+    console.log(USAGE2);
+    return;
+  }
+  if (values.engine !== void 0 && values.engine !== "cdn" && values.engine !== "bundle") {
+    throw new UserError(`Invalid --engine "${values.engine}". Use "cdn" or "bundle".`);
+  }
+  await runBuild({ root: process.cwd(), outDir: values.out, engine: values.engine });
+}
+var USAGE2, SKIPPED_NAMES;
+var init_build = __esm({
+  "cli/build.ts"() {
+    "use strict";
+    init_engine();
+    init_errors();
+    init_html();
+    init_project();
+    USAGE2 = `Usage: thrunium build [options]
+
+Options:
+  --out <dir>             Output folder inside the project (default: dist)
+  --engine cdn|bundle     Load the engine from the CDN (default) or ship it in the build
+  --help, -h              Show this help
+`;
+    SKIPPED_NAMES = /^(package\.json|package-lock\.json|npm-shrinkwrap\.json|pnpm-lock\.yaml|pnpm-workspace\.yaml|yarn\.lock|bun\.lockb?|bunfig\.toml|tsconfig.*\.json|.*\.ts)$/;
+  }
+});
+
+// cli/init.ts
+var init_exports = {};
+__export(init_exports, {
+  detectPackageManager: () => detectPackageManager,
+  devCommand: () => devCommand,
+  init: () => init,
+  installCommand: () => installCommand,
+  runInit: () => runInit,
+  spawnInstall: () => spawnInstall
+});
+import { spawn as spawn2 } from "node:child_process";
+import { cpSync, existsSync as existsSync5, mkdirSync as mkdirSync2, readdirSync as readdirSync3, readFileSync as readFileSync4, renameSync as renameSync2, statSync as statSync4, writeFileSync as writeFileSync2 } from "node:fs";
+import { basename as basename3, join as join5, resolve as resolve4 } from "node:path";
+import { parseArgs as parseArgs3 } from "node:util";
+function detectPackageManager(userAgent) {
+  const [name, version] = (userAgent?.split(" ")[0] ?? "").split("/");
+  if (!PACKAGE_MANAGERS.includes(name)) return { name: "npm", version: null };
+  return { name, version: version && version !== "?" ? version : null };
+}
+function installCommand(pm) {
+  return { cmd: pm, args: pm === "yarn" ? [] : ["install"] };
+}
+function devCommand(pm) {
+  return pm === "npm" || pm === "bun" ? `${pm} run dev` : `${pm} dev`;
+}
+function spawnInstall(cmd, args, cwd) {
+  return new Promise((done) => {
+    const child = process.platform === "win32" ? spawn2([cmd, ...args].join(" "), { cwd, stdio: "inherit", shell: true }) : spawn2(cmd, args, { cwd, stdio: "inherit" });
+    child.on("error", () => done(false));
+    child.on("close", (code) => done(code === 0));
+  });
+}
+async function runInit(opts) {
+  const dir = resolve4(opts.dir);
+  if (existsSync5(dir)) {
+    if (!statSync4(dir).isDirectory() || readdirSync3(dir).length > 0) {
+      throw new UserError(`${dir} already exists and is not an empty folder.`);
+    }
+  } else {
+    mkdirSync2(dir, { recursive: true });
+  }
+  cpSync(join5(packageRoot(), "templates", opts.template), dir, { recursive: true });
+  if (opts.pm.name === "pnpm") cpSync(join5(packageRoot(), "templates", "pnpm"), dir, { recursive: true });
+  renameSync2(join5(dir, "gitignore"), join5(dir, ".gitignore"));
+  const name = basename3(dir).toLowerCase().replace(/[^a-z0-9-]/g, "-");
+  for (const file of TEXT_FILES) {
+    const path = join5(dir, file);
+    const text = readFileSync4(path, "utf8").replace(/\{\{name\}\}/g, name).replace(/\{\{version\}\}/g, engineVersion());
+    writeFileSync2(path, text);
+  }
+  const pinPnpm = opts.pm.name === "pnpm" && opts.pm.version;
+  if (pinPnpm || opts.pm.name === "npm") {
+    const path = join5(dir, "package.json");
+    const pkg = JSON.parse(readFileSync4(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)}
+`);
+  }
+  if (!opts.install) return;
+  const { cmd, args } = installCommand(opts.pm.name);
+  const ok = await (opts.runInstall ?? spawnInstall)(cmd, args, dir);
+  if (!ok) {
+    throw new UserError(`The project was created, but "${[cmd, ...args].join(" ")}" failed. Run it in the project folder to finish.`);
+  }
+}
+async function init(args) {
+  let parsed;
+  try {
+    parsed = parseArgs3({
+      args,
+      options: {
+        js: { type: "boolean" },
+        pm: { type: "string" },
+        install: { type: "boolean", default: true },
+        help: { type: "boolean", short: "h" }
+      },
+      allowPositionals: true,
+      allowNegative: true
+    });
+  } catch (err) {
+    throw new UserError(`${err instanceof Error ? err.message : String(err)}
+
+${USAGE3}`);
+  }
+  const { values, positionals } = parsed;
+  if (values.help) {
+    console.log(USAGE3);
+    return;
+  }
+  if (positionals.length > 1) throw new UserError(`Expected at most one folder name.
+
+${USAGE3}`);
+  const dir = positionals[0] ?? ".";
+  let pm = detectPackageManager(process.env.npm_config_user_agent);
+  if (values.pm !== void 0) {
+    if (!PACKAGE_MANAGERS.includes(values.pm)) {
+      throw new UserError(`Unknown package manager "${values.pm}". Use one of: ${PACKAGE_MANAGERS.join(", ")}.
+
+${USAGE3}`);
+    }
+    pm = values.pm === pm.name ? pm : { name: values.pm, version: null };
+  }
+  await runInit({ dir, template: values.js ? "js" : "ts", pm, install: values.install });
+  console.log(`Created ${dir === "." ? "the project" : dir}. Next:
+
+${dir === "." ? "" : `  cd ${dir}
+`}  ${devCommand(pm.name)}`);
+}
+var USAGE3, PACKAGE_MANAGERS, TEXT_FILES;
+var init_init = __esm({
+  "cli/init.ts"() {
+    "use strict";
+    init_engine();
+    init_errors();
+    USAGE3 = `Usage: thrunium init [dir] [options]
+
+Creates a new game project in <dir> (default: the current folder, which must be empty)
+and installs its dependencies.
+
+Options:
+  --js            Use JavaScript instead of TypeScript
+  --pm <name>     Package manager: npm, pnpm, yarn or bun
+                  (default: the one that ran this command, else npm)
+  --no-install    Do not install dependencies
+  --help, -h      Show this help
+`;
+    PACKAGE_MANAGERS = ["npm", "pnpm", "yarn", "bun"];
+    TEXT_FILES = ["package.json", "game.json"];
+  }
+});
+
+// cli/main.ts
+init_errors();
+import { readFileSync as readFileSync5 } from "node:fs";
+import { parseArgs as parseArgs4 } from "node:util";
+var USAGE4 = `Usage: thrunium <command>
+
+Commands:
+  dev       Start the development server
+  build     Build the game for upload
+  init      Create a new game project
+
+Options:
+  --help, -h     Show this help
+  --version, -v  Show the thrunium version
+`;
+function packageVersion() {
+  const url = new URL("../package.json", import.meta.url);
+  return JSON.parse(readFileSync5(url, "utf8")).version;
+}
+async function main(argv) {
+  try {
+    const commandIndex = argv.findIndex((a) => !a.startsWith("-"));
+    const globalArgs = commandIndex === -1 ? argv : argv.slice(0, commandIndex);
+    const command = commandIndex === -1 ? void 0 : argv[commandIndex];
+    const { values } = parseArgs4({
+      args: globalArgs,
+      options: { help: { type: "boolean", short: "h" }, version: { type: "boolean", short: "v" } },
+      strict: false
+    });
+    if (values.version) {
+      console.log(packageVersion());
+      return 0;
+    }
+    if (values.help || command === void 0) {
+      (command === void 0 && !values.help ? console.error : console.log)(USAGE4);
+      return values.help ? 0 : 1;
+    }
+    const commandArgs = argv.slice(commandIndex + 1);
+    switch (command) {
+      case "dev":
+        await (await Promise.resolve().then(() => (init_dev(), dev_exports))).dev(commandArgs);
+        return 0;
+      case "build":
+        await (await Promise.resolve().then(() => (init_build(), build_exports))).build(commandArgs);
+        return 0;
+      case "init":
+        await (await Promise.resolve().then(() => (init_init(), init_exports))).init(commandArgs);
+        return 0;
+      default:
+        console.error(`thrunium: unknown command "${command}"
+
+${USAGE4}`);
+        return 1;
+    }
+  } catch (err) {
+    if (err instanceof UserError) {
+      console.error(`thrunium: ${err.message}`);
+      return 1;
+    }
+    throw err;
+  }
+}
+
+// cli-entry.ts
+main(process.argv.slice(2)).then((code) => {
+  process.exitCode = code;
+});