@xgamesfun/xcore 0.1.0 → 0.2.1

package/lib/dev/files.mjs

@@ -0,0 +1,247 @@
+// The game's project files on this machine (xgames.fun's STORAGE.md §2, §8.6–8.7): what env.GF.files keeps, here in
+// <game>/.gamesfun/dev/files/ (a hidden folder: never published), with the same paths, answers, limits and serving
+// rules as xgames.fun's bucket and files domain:
+//   - createFileStore: put, get, head, list, delete, usage, as env.GF.files answers them (./gf-local.js calls them
+//     through ./platform.mjs), and `xcore files` without --live;
+//   - serveFiles: the public files on an origin of their own (another port of this machine), as
+//     <slug>.xgamesusercontent.com serves them: cross-origin to the game's page, as live, though same-site here (both
+//     are 127.0.0.1), where live xgamesusercontent.com is another site as well.
+// Every answer is {ok: true, …} or {ok: false, code, why}; none throws.
+import { createHash } from 'node:crypto';
+import { createReadStream, existsSync } from 'node:fs';
+import { mkdir, readFile, rename, rm, stat, writeFile } from 'node:fs/promises';
+import { createServer } from 'node:http';
+import path from 'node:path';
+import { FILES, filePathProblem, fileType, servedType } from '../server/contract.mjs';
+import { stateFolder } from '../state-folder.mjs';
+
+const no = (code, why) => ({ ok: false, code, why });
+
+/** One game's files. `origin`: where the public ones are served (a function: the files server's port comes later). */
+export function createFileStore({ dir, origin = () => null, cap = FILES.capBytes, fileBytes = FILES.fileBytes }) {
+  const root = path.join(dir, '.gamesfun', 'dev', 'files');
+  const index = path.join(dir, '.gamesfun', 'dev', 'files.json');
+  let meta = null,
+    chain = Promise.resolve();
+  // the index by path, on an object with no prototype: a file may be called __proto__, constructor or toString
+  const load = async () => {
+    if (meta) return meta;
+    let read = null;
+    try {
+      read = JSON.parse(await readFile(index, 'utf8'));
+    } catch {
+      /* none yet, or unreadable: empty */
+    }
+    meta = Object.create(null);
+    if (read && typeof read === 'object' && !Array.isArray(read))
+      for (const [k, v] of Object.entries(read)) if (v && typeof v === 'object') meta[k] = v;
+    return meta;
+  };
+  const at = (m, p) => (Object.hasOwn(m, p) ? m[p] : undefined);
+  const save = async () => {
+    await stateFolder(dir);
+    await mkdir(path.dirname(index), { recursive: true });
+    await writeFile(`${index}.tmp`, JSON.stringify(meta, null, 2) + '\n');
+    await rename(`${index}.tmp`, index);
+  };
+  // one change at a time, so the byte count and the files agree
+  const queued = fn => (chain = chain.then(fn, fn));
+  const fileOf = p => path.join(root, ...p.split('/'));
+  const used = m => Object.values(m).reduce((n, f) => n + f.bytes, 0);
+  const urlOf = p => {
+    const o = origin();
+    return o ? `${o}/${p}` : null;
+  };
+  const item = (p, f) => ({ path: p, bytes: f.bytes, type: f.type, public: f.public, updatedAt: f.updatedAt });
+
+  return {
+    root,
+    /** body: a string, bytes (ArrayBuffer, a typed array, a Buffer). → {ok, path, bytes, url?} */
+    put(p, body, { type, public: isPublic = false } = {}) {
+      return queued(async () => {
+        const bad = filePathProblem(p);
+        if (bad) return no('path', bad);
+        const bytes =
+          typeof body === 'string'
+            ? Buffer.from(body, 'utf8')
+            : body instanceof ArrayBuffer
+              ? Buffer.from(body)
+              : ArrayBuffer.isView(body)
+                ? Buffer.from(body.buffer, body.byteOffset, body.byteLength)
+                : null;
+        if (!bytes) return no('body', 'A file is a string, an ArrayBuffer or a stream of bytes.');
+        if (bytes.length > fileBytes)
+          return no(
+            'too-big',
+            `A file may be ${Math.round(fileBytes / 1048576)} MB; this one is ${(bytes.length / 1048576).toFixed(1)} MB.`,
+          );
+        const m = await load();
+        const was = at(m, p)?.bytes ?? 0;
+        if (used(m) - was + bytes.length > cap)
+          return no('full', `The game's files would pass its ${Math.round(cap / 1048576)} MB: delete some first.`);
+        const file = fileOf(p);
+        // a file can't be where a folder is, nor the other way round
+        if (Object.keys(m).some(k => k.startsWith(`${p}/`) || p.startsWith(`${k}/`)))
+          return no('path', `${p} is a folder of other files, or inside a file: pick another path.`);
+        await mkdir(path.dirname(file), { recursive: true });
+        await writeFile(`${file}.gf-tmp`, bytes);
+        await rename(`${file}.gf-tmp`, file);
+        m[p] = {
+          bytes: bytes.length,
+          type: typeof type === 'string' && type ? type.slice(0, 200) : fileType(p),
+          public: !!isPublic,
+          updatedAt: Date.now(),
+          etag: createHash('sha256').update(bytes).digest('hex').slice(0, 32),
+        };
+        await save();
+        const url = m[p].public ? urlOf(p) : null;
+        return { ok: true, path: p, bytes: bytes.length, ...(url ? { url } : {}) };
+      });
+    },
+    /** → {ok, body (a Buffer), type, bytes, public} */
+    async get(p) {
+      const h = await this.head(p);
+      if (!h.ok) return h;
+      try {
+        return { ...h, body: await readFile(fileOf(p)) };
+      } catch {
+        return no('not-found', 'No such file.');
+      }
+    },
+    /** → {ok, path, type, bytes, public, updatedAt, etag} */
+    async head(p) {
+      const bad = filePathProblem(p);
+      if (bad) return no('path', bad);
+      await chain;
+      const f = at(await load(), p);
+      if (!f) return no('not-found', 'No such file.');
+      return { ok: true, ...item(p, f), etag: f.etag };
+    },
+    /** {prefix ('' or ending in /), after (the last path of the page before), limit ≤ 1000} → {ok, items, after} */
+    async list({ prefix = '', after = '', limit = 100 } = {}) {
+      if (typeof prefix !== 'string' || (prefix && (!prefix.endsWith('/') || filePathProblem(prefix.slice(0, -1)))))
+        return no('prefix', 'A prefix is empty, or a folder ending in /: "replays/".');
+      await chain;
+      const n = Math.max(1, Math.min(FILES.listMax, Number(limit) | 0 || 100));
+      const m = await load();
+      const names = Object.keys(m)
+        .filter(k => k.startsWith(prefix) && (!after || k > String(after)))
+        .sort();
+      const page = names.slice(0, n);
+      return {
+        ok: true,
+        items: page.map(k => item(k, m[k])),
+        after: names.length > n ? page.at(-1) : null,
+      };
+    },
+    /** → {ok, deleted} */
+    delete(p) {
+      return queued(async () => {
+        const bad = filePathProblem(p);
+        if (bad) return no('path', bad);
+        const m = await load();
+        if (!at(m, p)) return { ok: true, deleted: false };
+        delete m[p];
+        await rm(fileOf(p), { force: true });
+        await save();
+        return { ok: true, deleted: true };
+      });
+    },
+    /** → {ok, bytes, files, cap} */
+    async usage() {
+      await chain;
+      const m = await load();
+      return { ok: true, bytes: used(m), files: Object.keys(m).length, cap };
+    },
+    /** The file's bytes on disk, for the files server (a public file only). → {meta, file} | null */
+    async served(p) {
+      await chain;
+      const f = at(await load(), p);
+      if (!f?.public) return null;
+      const file = fileOf(p);
+      return existsSync(file) ? { meta: f, file, size: (await stat(file)).size } : null;
+    },
+  };
+}
+
+/** The headers every answer of the files domain carries (§8.7). */
+export const FILE_HEADERS = Object.freeze({
+  'x-content-type-options': 'nosniff',
+  'content-security-policy': "sandbox; default-src 'none'",
+  'cross-origin-resource-policy': 'cross-origin',
+  'access-control-allow-origin': '*',
+  'referrer-policy': 'no-referrer',
+});
+
+const isLocalHost = host =>
+  /^(localhost|127\.0\.0\.1|\[::1\]|[a-z0-9-]+\.localhost)(:\d{1,5})?$/i.test(String(host ?? ''));
+
+/**
+ * The public files on an origin of their own: GET, HEAD and OPTIONS; a path decoded once (an encoded / or a ..
+ * refused); only a public file; ETag and one byte range; media, fonts, JSON and plain text inline, anything else as
+ * application/octet-stream with Content-Disposition: attachment. → {origin, server, close()}
+ */
+export function serveFiles(store, { port = 0, host = '127.0.0.1' } = {}) {
+  const server = createServer(async (req, res) => {
+    const send = (status, extra = {}, body = '') => {
+      res.writeHead(status, { ...FILE_HEADERS, 'cache-control': 'no-store', ...extra });
+      res.end(body);
+    };
+    if (!isLocalHost(req.headers.host)) return send(403, { 'content-type': 'text/plain' }, 'This machine only.');
+    if (req.method === 'OPTIONS')
+      return send(204, {
+        'access-control-allow-methods': 'GET, HEAD, OPTIONS',
+        'access-control-allow-headers': 'range',
+      });
+    if (req.method !== 'GET' && req.method !== 'HEAD') return send(405, { allow: 'GET, HEAD, OPTIONS' });
+    const raw = new URL(req.url, 'http://x').pathname.slice(1);
+    // decoded once: an encoded slash (a path that is not the one it looks like) or a dot segment is refused
+    let p;
+    try {
+      if (/%2f|%5c/i.test(raw)) throw new Error('slash');
+      p = decodeURIComponent(raw);
+    } catch {
+      return send(400, { 'content-type': 'text/plain' }, 'Not a file path.');
+    }
+    if (filePathProblem(p)) return send(404, { 'content-type': 'text/plain' }, 'No such file.');
+    const f = await store.served(p);
+    if (!f) return send(404, { 'content-type': 'text/plain' }, 'No such file.');
+    const { type, inline } = servedType(f.meta.type);
+    const etag = `"${f.meta.etag}"`;
+    const head = {
+      'content-type': type,
+      etag,
+      'accept-ranges': 'bytes',
+      'last-modified': new Date(f.meta.updatedAt).toUTCString(),
+      ...(inline ? {} : { 'content-disposition': `attachment; filename="${path.basename(p)}"` }),
+    };
+    if (req.headers['if-none-match'] === etag) return send(304, head);
+    const range = /^bytes=(\d*)-(\d*)$/.exec(String(req.headers.range ?? ''));
+    let start = 0,
+      end = f.size - 1,
+      status = 200;
+    if (req.headers.range) {
+      if (!range || (range[1] === '' && range[2] === '')) return send(416, { 'content-range': `bytes */${f.size}` });
+      if (range[1] === '') start = Math.max(0, f.size - Number(range[2]));
+      else {
+        start = Number(range[1]);
+        if (range[2] !== '') end = Math.min(end, Number(range[2]));
+      }
+      if (start > end || start >= f.size) return send(416, { 'content-range': `bytes */${f.size}` });
+      status = 206;
+      head['content-range'] = `bytes ${start}-${end}/${f.size}`;
+    }
+    res.writeHead(status, { ...FILE_HEADERS, 'cache-control': 'no-store', ...head, 'content-length': end - start + 1 });
+    if (req.method === 'HEAD' || f.size === 0) return res.end();
+    createReadStream(f.file, { start, end })
+      .on('error', () => res.destroy())
+      .pipe(res);
+  });
+  return new Promise((resolve, reject) => {
+    server.once('error', reject);
+    server.listen(port, host, () => {
+      const origin = `http://${host}:${server.address().port}`;
+      resolve({ origin, server, close: () => new Promise(r => server.close(() => r())) });
+    });
+  });
+}

package/lib/dev/gf-local.js

@@ -1,9 +1,10 @@
 // env.GF on this machine: the platform binding a game's server gets in `xcore dev` (gf-server-v1,
 // ../server/contract.mjs GF_METHODS). It runs in workerd beside the game's server as a Workers RPC entrypoint, the way
-// games.fun binds its platform (entrypoint GameServices) to a hosted game's server, with the same methods, arguments
+// xgames.fun binds its platform (entrypoint GameServices) to a hosted game's server, with the same methods, arguments
 // and answers. Every call goes to the dev host (the HOST binding, a function in Node: ./platform.mjs), which keeps saves
-// and scores in the game's .gamesfun/dev-platform.json, checks its own local sign-in tokens, and prints loot reports.
-// Nothing here reaches games.fun. Every answer is {ok: true, …} or {ok: false, code, why}; nothing throws.
+// and scores in the game's .gamesfun/dev-platform.json and project files in .gamesfun/dev/files/ (env.GF.files), checks
+// its own local sign-in tokens, and prints loot reports.
+// Nothing here reaches xgames.fun. Every answer is {ok: true, …} or {ok: false, code, why}; nothing throws.
 import { WorkerEntrypoint, RpcTarget } from 'cloudflare:workers';
 
 async function call(env, op, args) {
@@ -81,7 +82,72 @@ class Loot extends RpcTarget {
   }
 }
 
+// the game's project files (STORAGE.md §8.6): the bytes go to the dev host as they are, not as JSON
+const unavailable = e => ({
+  ok: false,
+  code: 'unavailable',
+  why: `xcore dev's platform did not answer (${String(e?.message ?? e).slice(0, 120)}).`,
+});
+class Files extends RpcTarget {
+  #env;
+  constructor(env) {
+    super();
+    this.#env = env;
+  }
+  // a stream is held to exactly its declared `length`; one with none is read up to 1 MB (as xgames.fun's put)
+  async put(path, body, { type, public: isPublic = false, length = null } = {}) {
+    const stream = typeof ReadableStream !== 'undefined' && body instanceof ReadableStream;
+    const ok = typeof body === 'string' || body instanceof ArrayBuffer || ArrayBuffer.isView(body) || stream;
+    if (!ok) return { ok: false, code: 'body', why: 'A file is a string, an ArrayBuffer or a stream of bytes.' };
+    if (stream && length !== null && length !== undefined && !(Number.isSafeInteger(length) && length >= 0)) {
+      await body.cancel?.().catch(() => {});
+      return { ok: false, code: 'body', why: 'A put’s {length} is a whole number of bytes.' };
+    }
+    const q = new URLSearchParams({
+      path: String(path),
+      ...(typeof type === 'string' ? { type } : {}),
+      public: isPublic ? '1' : '',
+      ...(stream ? { stream: '1' } : {}),
+      ...(stream && length !== null && length !== undefined ? { length: String(length) } : {}),
+    });
+    try {
+      const r = await this.#env.HOST.fetch(`http://gf.local/files.put?${q}`, { method: 'POST', body });
+      return await r.json();
+    } catch (e) {
+      return unavailable(e);
+    }
+  }
+  /** → {ok, body (a ReadableStream), type, bytes, public} */
+  async get(path) {
+    try {
+      const r = await this.#env.HOST.fetch('http://gf.local/files.get', {
+        method: 'POST',
+        body: JSON.stringify([path]),
+      });
+      const meta = r.headers.get('x-gf-answer');
+      return meta ? { ...JSON.parse(meta), body: r.body } : await r.json();
+    } catch (e) {
+      return unavailable(e);
+    }
+  }
+  head(path) {
+    return call(this.#env, 'files.head', [path]);
+  }
+  list(opts = {}) {
+    return call(this.#env, 'files.list', [opts]);
+  }
+  delete(path) {
+    return call(this.#env, 'files.delete', [path]);
+  }
+  usage() {
+    return call(this.#env, 'files.usage', []);
+  }
+}
+
 export class GameServices extends WorkerEntrypoint {
+  get files() {
+    return new Files(this.env);
+  }
   get saves() {
     return new Saves(this.env);
   }

package/lib/dev/index.mjs

@@ -1,10 +1,14 @@
-// `xcore dev`: a game as games.fun hosts it, on this machine, with everything behind it that the play host gives a
+// `xcore dev`: a game as xgames.fun hosts it, on this machine, with everything behind it that the play host gives a
 // published game, so the whole game (page, server, sign-in, saves, rooms, economy) runs before it is published:
 //   /game/*            the published files (gamesfun.json page.out), with the play host's headers (../check.mjs servePage)
-//   /game/api/*        the game's own server/ under workerd (./server.mjs), WebSockets too, sent on as /api/*
+//   /game/api/*        the game's own server/ under workerd (./server.mjs), WebSockets too, sent on as /api/*; for a
+//                      game with a database and no server/, xcore's stock server, with a local D1 (./d1.mjs)
 //   /platform/v1/*     sign-in, saves and leaderboards (./platform.mjs), the store env.GF reads as well
+//   <files origin>/*   the game's public project files (env.GF.files, xcore files), on a port of its own: another
+//                      origin to the browser (cross-origin, though same-site: both are 127.0.0.1), as
+//                      <slug>.xgamesusercontent.com is live, where it is another site too (./files.mjs)
 //   /loot/v1/rpc       the economy's Solana RPC: forwarded to XSOLANA_RPC_URL when set (your own devnet RPC, its URL
-//                      never shown), else to games.fun's shared relay, the one a published page talks to
+//                      never shown), else to xgames.fun's shared relay, the one a published page talks to
 // Every HTML page served gets a one-line marker (globalThis.GAMESFUN_DEV) so gamesfun.js uses this host's sign-in,
 // saves, database and rooms instead of the browser-only stand-ins it uses on a plain local server.
 import { existsSync, readFileSync, watch } from 'node:fs';
@@ -17,6 +21,7 @@ import { readServerConfig, API_PREFIX } from '../server/contract.mjs';
 import { PAGE_RPC, rpcWords, solanaRpc } from '../solana-rpc.mjs';
 import { handlePlatform, createPlatformStore } from './platform.mjs';
 import { createLimitWatch } from './limits.mjs';
+import { serveFiles } from './files.mjs';
 
 const readJson = file => {
   try {
@@ -25,6 +30,10 @@ const readJson = file => {
     return null;
   }
 };
+/** What the dev log says about the game's local database. */
+const databaseLine = d =>
+  `database: env.${d.binding}, a local D1 kept in .gamesfun/dev/d1/${d.migrated.length ? ` (applied ${d.migrated.join(', ')})` : ''}`;
+
 export const DEV_MARK = '<script>globalThis.GAMESFUN_DEV=1</script>';
 /** The marker gamesfun.js reads, first thing in <head> (or the page) so it is set before any script runs. */
 export function markPage(html) {
@@ -37,7 +46,7 @@ export function markPage(html) {
     : DEV_MARK + html;
 }
 
-// ---- what games.fun's shared relay takes (its rules, said here so a game run against your own RPC hears what the
+// ---- what xgames.fun's shared relay takes (its rules, said here so a game run against your own RPC hears what the
 // published page would be refused) ------------------------------------------------------------------------------
 export const RELAY_METHODS = Object.freeze([
   'getAccountInfo',
@@ -71,7 +80,7 @@ function scanAllowed(program, filters) {
   const at = Object.hasOwn(RELAY_SCANS, program) ? RELAY_SCANS[program] : null;
   return at !== null && filters.some(f => f?.memcmp?.offset === at && ADDRESS.test(String(f.memcmp.bytes ?? '')));
 }
-/** Would games.fun's shared relay refuse this JSON-RPC body? → null, or why */
+/** Would xgames.fun's shared relay refuse this JSON-RPC body? → null, or why */
 export function relayRefuses(call) {
   if (Array.isArray(call)) return 'a batch (the relay takes one request a call)';
   if (!call || typeof call.method !== 'string') return 'not a JSON-RPC request';
@@ -94,8 +103,10 @@ async function body(req, cap = 256 * 1024) {
 }
 
 /**
- * Start the dev host for `dir`. Options: port (default 8787; 0 any), noBuild, log, env, fetchImpl (the RPC forward's).
- * → {url, origin, rpc, server (the game server's status, or null), store, reload(), close()}
+ * Start the dev host for `dir`. Options: port (default 8787; 0 any), filesPort (default the next one; 0 any), noBuild,
+ * log, env, fetchImpl (the RPC forward's).
+ * → {url, origin, files (the public files' origin), rpc, server (the game server's status, or null), store, reload(),
+ * close()}
  */
 /** A Host header naming this machine: localhost, 127.0.0.1, [::1] or a name under .localhost, with any port. */
 export const isLocalHost = host =>
@@ -103,7 +114,14 @@ export const isLocalHost = host =>
 
 export async function startDev(
   dir,
-  { port = 8787, noBuild = false, log = m => console.log(m), env = process.env, fetchImpl = fetch } = {},
+  {
+    port = 8787,
+    filesPort = port ? port + 1 : 0,
+    noBuild = false,
+    log = m => console.log(m),
+    env = process.env,
+    fetchImpl = fetch,
+  } = {},
 ) {
   const game = path.resolve(dir);
   const roots = pageRoots(game);
@@ -121,13 +139,24 @@ export async function startDev(
     );
 
   const store = createPlatformStore({ dir: game, log: m => log(`platform: ${m}`) });
+  // the game's public files on an origin of their own, as <slug>.xgamesusercontent.com is to the published game:
+  // another port is another origin (no sign-in, no calls to the game's api/), though the same site here (both are
+  // 127.0.0.1); live, xgamesusercontent.com is another site as well
+  const files = await serveFiles(store.files, { port: filesPort }).catch(e =>
+    e.code === 'EADDRINUSE' && filesPort ? serveFiles(store.files, { port: 0 }) : Promise.reject(e),
+  );
+  store.setFilesOrigin(files.origin);
   const cfg = await readServerConfig(game);
   let server = null;
   if (cfg.has) {
     const { startLocalServer } = await import('./server.mjs');
     server = await startLocalServer({ dir: game, store, log: m => log(`server: ${m}`), env });
     const s = server.status();
-    if (s.running) log(`server: running${s.objects.length ? ` (${s.objects.join(', ')})` : ''}`);
+    if (s.running)
+      log(
+        `server: running${s.stock ? " (xcore's stock server: the page's api/db/)" : s.objects.length ? ` (${s.objects.join(', ')})` : ''}`,
+      );
+    if (s.database) log(databaseLine(s.database));
     else for (const p of [s.error, ...s.problems].filter(Boolean)) log(`server: ${p}`);
     for (const w of s.warnings) log(`server: ${w}`);
   }
@@ -149,7 +178,7 @@ export async function startDev(
       const why = relayRefuses(call);
       if (why && !warned.has(why)) {
         warned.add(why);
-        log(`rpc: published, games.fun's shared relay would refuse ${why}; it reached your own RPC here`);
+        log(`rpc: published, xgames.fun's shared relay would refuse ${why}; it reached your own RPC here`);
       }
     }
     let a;
@@ -213,14 +242,23 @@ export async function startDev(
     return false;
   };
   const backend = backendOrigins(readJson(pageFile(roots, BACKEND_FILE)), { own: ownOrigins() }).origins;
-  const site = await servePage(roots.out, {
-    backend,
-    server: cfg.has,
-    route,
-    html: markPage,
-    port,
-    overlay: roots.overlay,
-  });
+  let site;
+  try {
+    site = await servePage(roots.out, {
+      backend,
+      files: [files.origin],
+      server: cfg.has,
+      route,
+      html: markPage,
+      port,
+      overlay: roots.overlay,
+    });
+  } catch (e) {
+    // the page could not be served (a port in use): the game's server started above stops with it
+    if (server) await server.close().catch(() => {});
+    await files.close();
+    throw e;
+  }
   site.server.on('upgrade', (req, socket, head) => {
     if (!isLocalHost(req.headers.host)) return socket.end('HTTP/1.1 403 Forbidden\r\nConnection: close\r\n\r\n');
     const u = new URL(req.url, 'http://x');
@@ -234,8 +272,11 @@ export async function startDev(
   // that the server imports from outside server/ (rules shared with the page) rebuilds and reloads it
   const watchers = [];
   const shared = new Map(); // a file the server's bundle reads from outside server/ → its watcher
+  // a change waits 200 ms for the next (an editor saves several files): `timer`, cleared by close(), after which no
+  // reload starts (closed)
+  let timer = null,
+    closed = false;
   if (server) {
-    let timer = null;
     const watchShared = () => {
       const want = new Set(
         (server.status().inputs ?? [])
@@ -259,13 +300,16 @@ export async function startDev(
           }
     };
     const again = what => {
+      if (closed) return;
       clearTimeout(timer);
       timer = setTimeout(async () => {
+        timer = null;
         const s = await server.reload();
+        if (closed) return;
         watchShared();
         log(
           s.running
-            ? `server: reloaded (${what} changed)`
+            ? `server: reloaded (${what} changed)${s.database?.migrated.length ? `; ${databaseLine(s.database).slice('database: '.length)}` : ''}`
             : `server: ${what} changed, and it does not start: ${[s.error, ...s.problems].filter(Boolean).join('; ')}`,
         );
       }, 200);
@@ -292,13 +336,17 @@ export async function startDev(
   return {
     url: site.url,
     origin: site.origin,
+    files: files.origin,
     rpc: rpcWords(rpc),
     server: server ? server.status() : null,
     store,
     reload: () => server?.reload(),
     async close() {
+      closed = true;
+      clearTimeout(timer);
       for (const w of [...watchers, ...shared.values()]) w.close();
       await site.close();
+      await files.close();
       if (server) await server.close();
       else await store.flush();
     },

package/lib/dev/limits.mjs

@@ -1,9 +1,9 @@
-// What `xcore dev` says about games.fun's plan limits (README §5, `xcore plan`). The local server runs with no CPU or
+// What `xcore dev` says about xgames.fun's plan limits (README §5, `xcore plan`). The local server runs with no CPU or
 // request limits, so a page that polls its server ten times a second works here and is refused once published. This
 // counts the page's requests to its server and times each one, and says so in the dev log, once a minute at most for
 // the rate and once per route for the time. It never refuses anything itself.
 //
-// The numbers are games.fun's plans; games.fun is the source and can change them.
+// The numbers are xgames.fun's plans; xgames.fun is the source and can change them.
 export const PLAN_LIMITS = Object.freeze({
   free: Object.freeze({ name: 'Free', perPlayer: 120, cpuMs: 50 }),
   creator: Object.freeze({ name: 'Creator', perPlayer: 600, cpuMs: 200 }),