@xgamesfun/xcore 0.1.0 → 0.2.1

package/bin/xcore.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// The `xcore` command (@xgamesfun/xcore): games.fun's own (sign in, bring a game, check it as the host serves it, its
+// The `xcore` command (@xgamesfun/xcore): xgames.fun's own (sign in, bring a game, check it as the host serves it, its
 // backend and economy, publish). Each command is a module in ../commands/<name>.mjs exporting `default { name,
 // summary, usage, run(args) }`, and optionally `helpFor(args)`, the --help text of a subcommand. Everything else is the
 // kit's (@xgamesfun/kit: create, verify, the build loop and the rest): when the kit is here, those go to it as
@@ -9,6 +9,7 @@ import { spawn } from 'node:child_process';
 import { existsSync, readFileSync, realpathSync } from 'node:fs';
 import { readdir } from 'node:fs/promises';
 import path from 'node:path';
+import { parseArgs } from 'node:util';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { CMD } from '../lib/command.mjs';
 
@@ -39,9 +40,14 @@ export function findKit({ cwd = process.cwd(), env = process.env, here = HERE }
   return null;
 }
 
+// the flags of check, publish, dev and backend that take a value: their value is never the game's folder
+const VALUE_FLAGS = Object.fromEntries(
+  ['out', 'port', 'title', 'url', 'origin'].map(f => [f, { type: 'string', multiple: true }]),
+);
+
 /** Does this command, with these arguments, belong to the kit even though this package has a command by its name? */
-function kitsTurn(name, args) {
-  const positionals = args.filter(a => !a.startsWith('-'));
+export function kitsTurn(name, args) {
+  const { positionals } = parseArgs({ args, options: VALUE_FLAGS, strict: false, allowPositionals: true });
   if (name === 'backend') return !(positionals[0] === 'use' && positionals[1] === 'custom');
   if (name === 'publish' || name === 'check' || name === 'dev') {
     const dir = path.resolve(positionals[0] ?? '.');
@@ -72,12 +78,11 @@ function runKit(kit, args) {
   });
 }
 
-const NO_KIT = `That is the kit's (@xgamesfun/kit): it makes games, the studio page, verify and the build loop. Get it with
-  git clone https://github.com/XGamesFun/games-kit && cd games-kit && npm ci
-then run xcore inside that folder, or set GAMESFUN_KIT=<folder> to use a kit from anywhere.`;
+const NO_KIT = `That is the kit's (@xgamesfun/kit): it makes games, the studio page, verify and the build loop. The kit is
+not released yet; with a checkout of it, run xcore inside that folder, or set GAMESFUN_KIT=<folder> to use it from anywhere.`;
 
 function help(commands, kit) {
-  const lines = ['Usage: xcore <command> [options]', '', 'games.fun:'];
+  const lines = ['Usage: xcore <command> [options]', '', 'xgames.fun:'];
   for (const c of commands.values()) lines.push(`  ${c.name.padEnd(10)} ${c.summary}`);
   lines.push(
     '',
@@ -119,7 +124,7 @@ export async function main([name, ...args]) {
     console.error(
       own
         ? `${NO_KIT}\n\n${own.usage ?? ''}`
-        : `"${name}" is not a games.fun command. ${NO_KIT}\n\n${help(commands, null)}`,
+        : `"${name}" is not an xgames.fun command. ${NO_KIT}\n\n${help(commands, null)}`,
     );
     return 1;
   }

package/commands/add.mjs

@@ -1,4 +1,4 @@
-// `xcore add signin|database|multiplayer|rpc|vouchers [folder]`: games.fun's player sign-in, saves and leaderboards, a database of
+// `xcore add signin|database|multiplayer|rpc|vouchers [folder]`: xgames.fun's player sign-in, saves and leaderboards, a database of
 // the game's own, multiplayer rooms, the economy's own Solana RPC or its own voucher key, put into a web game, a Godot 4 project or a Unity project (../lib/add.mjs).
 import path from 'node:path';
 import { guard, parse, printJson, UsageError } from '../lib/cli.mjs';
@@ -7,29 +7,32 @@ import { addDatabase, addMultiplayer, addRpc, addSignin, addVouchers } from '../
 
 const usage = `Usage: xcore add signin|database|multiplayer|rpc|vouchers [folder] [--json]
 
-  signin     games.fun's player sign-in (X first, or a wallet), each player's saves and leaderboards, from the game's
+  signin     xgames.fun's player sign-in (X first, or a wallet), each player's saves and leaderboards, from the game's
              own code. A web game gets gamesfun.js beside its page; a Godot 4 project an autoload (GamesFun); a Unity
              project a WebGL plugin (Assets/Plugins/GamesFun). On this machine a local player stands in.
-  database   all of signin, and a database of the game's own: server code (server/database.js, SQLite on games.fun)
-             that publish puts up with the game. Documents in collections; who may read and write each is in its RULES.
+  database   all of signin, and a database of the game's own (one D1 database a game, made on xgames.fun by the
+             first publish: gamesfun.json → database). With a server of its own, its code reads and writes it
+             (server/gf-db.js; tables from server/migrations/); with none, xcore's stock server keeps the page's
+             documents in it (gf.db), each player's own, under gamesfun.json → database.collections. xcore db
+             queries, exports and restores it.
   multiplayer
              all of signin, and rooms of the game's own: server code (server/rooms.js) that relays between the players
              of a room, the first in its host. Godot's high-level multiplayer (RPCs, spawners, synchronizers) runs over
              it unchanged (GamesFun.join_room); Unity and web games get a room with send and events.
   rpc        the economy's Solana calls through the game's own devnet RPC (server/rpc.js at api/rpc, its URL a
-             secret of the server: xcore secret set XSOLANA_RPC_URL), not games.fun's shared relay, which counts
+             secret of the server: xcore secret set XSOLANA_RPC_URL), not xgames.fun's shared relay, which counts
              every call toward the game's plan.
   vouchers   the game's own voucher key, so its server pays the results it checked from a grant in the economy
              (server/vouchers.js at api/vouchers/: PAY.check decides; a Durable Object pays each result once). Makes
              a test key (its seed in .dev.vars; the live key: xcore secret set VOUCHER_SEED --new-key) and says its
-             address for the grant. For prizes by place that games.fun's keeper can sign instead, docs/SERVER.md.
+             address for the grant. For prizes by place that xgames.fun's keeper can sign instead, docs/SERVER.md.
 
 Run it again to bring the files it wrote up to date. The folder defaults to the one you are in.`;
 
 export default {
   name: 'add',
   summary:
-    "give a web, Godot or Unity game games.fun's sign-in, saves and leaderboards, a database, multiplayer, its own RPC or voucher key",
+    "give a web, Godot or Unity game xgames.fun's sign-in, saves and leaderboards, a database, multiplayer, its own RPC or voucher key",
   usage,
   run: args =>
     guard(async () => {
@@ -51,5 +54,5 @@ export default {
       for (const w of r.written.length ? r.written : ['already up to date']) console.log(`  ${w}`);
       console.log('\nNext:');
       for (const s of r.steps) console.log(`  - ${s}`);
-    }),
+    }, args),
 };

package/commands/adopt.mjs

@@ -1,9 +1,9 @@
-// `xcore adopt [folder]`: bring a web game made anywhere, to check it, add an economy and publish it on games.fun
+// `xcore adopt [folder]`: bring a web game made anywhere, to check it, add an economy and publish it on xgames.fun
 // (../lib/publish/adopt.mjs; README.md).
 import { guard, parse, printJson } from '../lib/cli.mjs';
 import path from 'node:path';
 import { shown } from '../lib/games.mjs';
-import { adopt, reportLines } from '../lib/publish/adopt.mjs';
+import { adopt, adoptNext, reportLines } from '../lib/publish/adopt.mjs';
 import { CMD } from '../lib/command.mjs';
 
 const usage = `Usage: xcore adopt [folder] [--build "<command>"] [--out <dir>] [--static <dir>] [--no-build] [--json]
@@ -11,7 +11,7 @@ const usage = `Usage: xcore adopt [folder] [--build "<command>"] [--out <dir>] [
 Bring a web game you already made (plain static files, or a project whose build makes them: Vite, Next.js static
 export, Astro, SvelteKit's static adapter, Nuxt generate, Create React App, Parcel, Gatsby, any build script). It reads
 the folder's shape, builds it, writes its record (gamesfun.json → page: how it builds and what is published; never
-published itself) and lists everything that does not fit games.fun's hosting, each with its fix: no static index.html
+published itself) and lists everything that does not fit xgames.fun's hosting, each with its fix: no static index.html
 (server-side rendering, a Node server as the frontend), secrets, .env files, links, files over the limits, paths from
 the root, scripts, styles, fonts or frames from other sites, sites the code names that backend.json does not list.
 Then: ${CMD} check (the page in Chrome as the host serves it), ${CMD} backend use custom (a backend you
@@ -27,7 +27,7 @@ The folder (default: the one you are in) may be anywhere: in games/ or outside i
 
 export default {
   name: 'adopt',
-  summary: 'bring a web game you already made: its record, and what to fix for games.fun hosting',
+  summary: 'bring a web game you already made: its record, and what to fix for xgames.fun hosting',
   usage,
   run: args =>
     guard(async () => {
@@ -49,9 +49,11 @@ export default {
         noBuild: values['no-build'] === true,
         onLine: values.json ? () => {} : l => console.error(`  build: ${l}`),
       });
-      if (values.json) printJson({ ...r, dir: shown(r.dir) });
-      else console.log(reportLines(r, { shown }).join('\n'));
+      if (values.json) {
+        const { state, next } = adoptNext(r, { shown });
+        printJson({ ...r, dir: shown(r.dir), state, next });
+      } else console.log(reportLines(r, { shown }).join('\n'));
       // 1 while anything is refused or left to fix (for scripts and agents); 0 when only "worth a look" remains
       return r.refused.length || r.fix.length ? 1 : 0;
-    }),
+    }, args),
 };

package/commands/backend.mjs

@@ -1,5 +1,5 @@
 // `xcore backend use custom`: a backend you already run on the public internet (an API, a WebSocket server). It
-// writes backend.json with its URL and the origins the page talks to, so games.fun's play host lets the published page
+// writes backend.json with its URL and the origins the page talks to, so xgames.fun's play host lets the published page
 // reach them (its page policy opens to exactly those). Nothing is signed in to or deployed; its keys stay on its
 // server. A backend the kit connects for you (Supabase, Railway) is the kit's: `backend connect` with @xgamesfun/kit.
 import { mkdir, writeFile } from 'node:fs/promises';
@@ -66,5 +66,5 @@ export default {
           `Wrote ${shown(file)}: the published page may reach ${config.origins.join(', ')}. Next: ${CMD} check, which fails on a request to any other origin.`,
         );
       return 0;
-    }),
+    }, args),
 };

package/commands/check.mjs

@@ -1,4 +1,4 @@
-// `xcore check [dir]`: the page check (../lib/check.mjs) on a game you brought: it builds, fits games.fun's hosting,
+// `xcore check [dir]`: the page check (../lib/check.mjs) on a game you brought: it builds, fits xgames.fun's hosting,
 // starts clean in Chrome as the play host serves it, and stays inside its origins. publish runs the same check first.
 import { guard, parse, printJson, UsageError } from '../lib/cli.mjs';
 import { resolveGame, shown } from '../lib/games.mjs';
@@ -7,7 +7,7 @@ import { CMD } from '../lib/command.mjs';
 
 const usage = `Usage: xcore check [dir] [--no-build] [--out <dir>] [--port <n>] [--json]
 
-The page check, as games.fun hosts the game: 1 it builds (gamesfun.json page.build), 2 it fits the hosting (what
+The page check, as xgames.fun hosts the game: 1 it builds (gamesfun.json page.build), 2 it fits the hosting (what
 publish would refuse, and what breaks once hosted: paths from the root, scripts, styles, fonts or frames from other
 sites), 3 it starts clean in Chrome at a phone's size and a desktop's under the play host's page policy, 4 it stays
 inside its origins (its own files, the host's own paths, backend.json's origins). It does not check that the game plays
@@ -19,7 +19,7 @@ as it should: that is your own game's tests. Run ${CMD} adopt <dir> first.
 
 export default {
   name: 'check',
-  summary: 'the page check: it builds, fits games.fun hosting, starts clean, stays inside its origins',
+  summary: 'the page check: it builds, fits xgames.fun hosting, starts clean, stays inside its origins',
   usage,
   run: args =>
     guard(async () => {
@@ -56,5 +56,5 @@ export default {
         );
       }
       return r.pass ? 0 : 1;
-    }),
+    }, args),
 };

package/commands/db.mjs

@@ -0,0 +1,218 @@
+// `xcore db info|query|export|import|restore`: the game's own database (gamesfun.json → database), on this machine
+// (the one `xcore dev` runs) or, with --live, on xgames.fun (../lib/db.mjs).
+import { createInterface } from 'node:readline/promises';
+import { guard, parse, printJson, UsageError } from '../lib/cli.mjs';
+import { resolveGame, shown } from '../lib/games.mjs';
+import { dbExport, dbImport, dbInfo, dbQuery, dbRestore, importOf, queryProblem } from '../lib/db.mjs';
+import { economyFile } from '../lib/economy.mjs';
+import { pageRoots } from '../lib/publish/page.mjs';
+import { CMD } from '../lib/command.mjs';
+
+const usage = `Usage: xcore db info [dir] [--live] [--json]
+       xcore db query "<sql>" [dir] [--params '<json list>'] [--write] [--live [--yes]] [--json]
+       xcore db export [dir] [--out <file>] [--live] [--json]
+       xcore db import <file.sql> [dir] [--live [--yes]] [--json]
+       xcore db restore <time> [dir] --live [--yes] [--json]
+
+The game's own database (${CMD} add database: gamesfun.json → database, one D1 database a game). Without --live,
+the one on this machine that ${CMD} dev runs (kept in .gamesfun/dev/d1/, its migrations applied first); with --live,
+the game's database on xgames.fun, which keeps every call in the game's audit log.
+  info               where it is, its size, the migrations applied (and, here, its tables and their rows)
+  query "<sql>"      one statement; it only reads (SELECT, EXPLAIN, PRAGMA table_info or table_list) unless
+                     --write. --params '["moon", 3]' fills its ? marks
+  export             the whole database as SQL, into --out <file> or .gamesfun/exports/ (hidden: never published;
+                     it holds your players' data, so keep it out of git and off shared drives)
+  import <file.sql>  run a file of SQL statements, all of it or none; at most 5 MB (live, 4.5 MB as sent). A dump
+                     from export (here, live or D1's) goes in over what is there, or into an empty database:
+                     tables kept, each row updated by its key where it is (none deleted)
+A change to the live database (query --write --live, import --live, restore) goes on only with --yes or when you
+type its word (write, import, restore); where there is no terminal to ask in, it needs --yes.
+  restore <time>     live only: the database as it was at <time> (a date such as 2026-11-08T12:00:00Z, or unix
+                     seconds; up to 30 days back). It says what it would go back to first, and goes on only with
+                     --yes or when you type "restore". A game with an economy: what happened on chain (loot
+                     balances, payouts) stays as it is, so the database and the chain can disagree after it.`;
+
+const plural = (n, w) => `${n} ${w}${n === 1 ? '' : 's'}`;
+const kb = n => (n >= 1048576 ? `${(n / 1048576).toFixed(1)} MB` : `${(n / 1024).toFixed(1)} KB`);
+
+/** Rows as columns a person reads; long values cut short. */
+function table(rows) {
+  if (!rows.length) return '(no rows)';
+  const cols = [...new Set(rows.flatMap(r => Object.keys(r)))];
+  const cell = v => {
+    const s = v === null || v === undefined ? 'NULL' : typeof v === 'object' ? JSON.stringify(v) : String(v);
+    return s.length > 60 ? `${s.slice(0, 59)}…` : s;
+  };
+  const width = cols.map(c => Math.max(c.length, ...rows.map(r => cell(r[c]).length)));
+  const line = vals =>
+    vals
+      .map((v, i) => v.padEnd(width[i]))
+      .join('  ')
+      .trimEnd();
+  return [line(cols), line(width.map(w => '-'.repeat(w))), ...rows.map(r => line(cols.map(c => cell(r[c]))))].join(
+    '\n',
+  );
+}
+
+/**
+ * A change to the live database goes on only with --yes, or when the person types `word` at the terminal; with no
+ * terminal to ask in (a script, CI), it is refused. → true to go on
+ */
+async function confirmed(question, word, nothing) {
+  if (!process.stdin.isTTY)
+    throw new UsageError(`${nothing}: add --yes to go on (this is not a terminal to ask in)\n\n${usage}`);
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  try {
+    return (await rl.question(question)).trim().toLowerCase() === word;
+  } finally {
+    rl.close();
+  }
+}
+
+export default {
+  name: 'db',
+  summary: "the game's own database (D1): info, query, export, import, restore; here, or --live on xgames.fun",
+  usage,
+  run: args =>
+    guard(async () => {
+      const { values, positionals } = parse(
+        args,
+        {
+          live: { type: 'boolean' },
+          write: { type: 'boolean' },
+          params: { type: 'string' },
+          out: { type: 'string' },
+          yes: { type: 'boolean' },
+        },
+        usage,
+      );
+      const [verb, ...rest] = positionals;
+      const takes = { query: 'a statement', import: 'a file', restore: 'a time' };
+      if (!['info', 'query', 'export', 'import', 'restore'].includes(verb)) throw new UsageError(usage);
+      if (takes[verb] && !rest[0]) throw new UsageError(`${verb} needs ${takes[verb]}\n\n${usage}`);
+      const arg = takes[verb] ? rest[0] : null;
+      const dir = await resolveGame(takes[verb] ? rest[1] : rest[0]);
+      const live = !!values.live;
+      const where = live ? `${shown(dir)}'s database on xgames.fun` : `${shown(dir)}'s database on this machine`;
+      const log = m => console.error(m);
+
+      if (verb === 'info') {
+        const r = await dbInfo(dir, { live, log });
+        if (values.json) return printJson(r);
+        if (live && !r.exists) {
+          console.log(`${shown(dir)} has no database on xgames.fun yet: it is made on the first publish with one.`);
+          return 0;
+        }
+        console.log(
+          `${where}${r.name ? ` (${r.name})` : ''}: ${kb(r.sizeBytes ?? 0)}${r.cap ? ` of ${kb(r.cap)}` : ''}${r.folder ? `, in ${r.folder}/` : ''}`,
+        );
+        const applied = r.applied ?? [];
+        console.log(`  migrations applied: ${applied.length ? applied.map(m => m.name ?? m).join(', ') : 'none'}`);
+        if (r.tables)
+          console.log(
+            `  tables: ${r.tables.length ? r.tables.map(t => `${t.name} (${plural(t.rows, 'row')})`).join(', ') : 'none yet'}`,
+          );
+        return 0;
+      }
+      if (verb === 'query') {
+        let params = [];
+        if (values.params !== undefined) {
+          try {
+            params = JSON.parse(values.params);
+          } catch {
+            throw new UsageError(`--params is a JSON list, such as '["moon", 3]'\n\n${usage}`);
+          }
+        }
+        if (live && values.write && !values.yes) {
+          // what would be refused anyway is refused before anyone is asked
+          const why = queryProblem(arg, { write: true });
+          if (why) throw Object.assign(new Error(why), { code: 'bad-sql' });
+          console.error(
+            `This changes ${where}, which your players use: ${arg.length > 200 ? `${arg.slice(0, 199)}…` : arg}. Only ${CMD} db restore --live puts it back.`,
+          );
+          if (!(await confirmed('Type write to go on, anything else to stop: ', 'write', 'nothing was written'))) {
+            console.log('Nothing was written.');
+            return 1;
+          }
+        }
+        const r = await dbQuery(dir, arg, { live, params, write: !!values.write, log });
+        if (values.json) return printJson(r);
+        console.log(table(r.results ?? []));
+        const m = r.meta ?? {};
+        const changed = m.changes ?? m.rows_written;
+        console.log(
+          `${plural((r.results ?? []).length, 'row')}${changed ? `; ${plural(changed, 'row')} changed` : ''} (${where})`,
+        );
+        return 0;
+      }
+      if (verb === 'export') {
+        const r = await dbExport(dir, { live, out: values.out ?? null, log });
+        if (values.json) return printJson(r);
+        console.log(`Exported ${where} (${kb(r.bytes)}) to ${r.file}. It holds your players' data: keep it private.`);
+        if (r.note) console.log(`  ${r.note}`);
+        return 0;
+      }
+      if (verb === 'import') {
+        if (live && !values.yes) {
+          // what would be refused anyway (not there, too big to send) is refused before anyone is asked
+          await importOf(arg, { live });
+          console.error(
+            `This runs ${arg} on ${where}, which your players use: rows can change or go, and while it runs the database answers nothing else. ${CMD} db export --live keeps a copy first; ${CMD} db restore --live puts it back.`,
+          );
+          if (!(await confirmed('Type import to go on, anything else to stop: ', 'import', 'nothing was imported'))) {
+            console.log('Nothing was imported.');
+            return 1;
+          }
+        }
+        const r = await dbImport(dir, arg, { live, log });
+        if (values.json) return printJson(r);
+        console.log(
+          `Imported ${arg} into ${where}${r.meta?.queries !== undefined ? ` (${plural(r.meta.queries, 'statement')})` : ''}${r.statements !== undefined ? ` (${plural(r.statements, 'statement')})` : ''}.${r.dump ? ' A dump goes in over what is there: its tables kept, each row updated by its key where it is, none deleted.' : ''}${r.left ? ` Its record of migrations (_gf_migrations, ${plural(r.left, 'statement')}) was left out: this database keeps its own.` : ''}`,
+        );
+        if (r.note) console.log(`  ${r.note}`);
+        return 0;
+      }
+      // restore: what it would do, the chain's warning, then only on a yes
+      if (!live)
+        throw new UsageError(
+          `restore is --live only: the database on this machine has no history (${CMD} db import a dump from ${CMD} db export)\n\n${usage}`,
+        );
+      const p = await dbRestore(dir, arg, { live, log });
+      const roots = pageRoots(dir);
+      const economy = !!(p.economy || economyFile(roots.static ?? dir) || economyFile(dir));
+      const at = p.preview?.at ?? arg;
+      const warning = economy
+        ? 'This game has an economy: what happened on chain since then stays as it is. Loot balances, items and payouts are not rolled back, so a player can keep what they won while the database forgets it (or the other way round).'
+        : null;
+      if (!values.yes) {
+        if (values.json)
+          return printJson({ ...p, economy, restored: null, next: `${CMD} db restore ${arg} --live --yes` });
+        console.log(
+          `${where} would go back to how it was at ${at}${p.preview?.bookmark ? ` (bookmark ${p.preview.bookmark})` : ''}. Everything written after that is lost; ${CMD} db export --live keeps a copy first.`,
+        );
+        const undone = p.preview?.migrations ?? [];
+        if (undone.length)
+          console.log(
+            `It rolls back ${plural(undone.length, 'migration')} applied after that time: ${undone.map(m => `${m.name}${m.at ? ` (${m.at})` : ''}`).join(', ')}.`,
+          );
+        if (p.preview?.warning) console.log(`Warning: ${p.preview.warning}`);
+        if (warning) console.log(`Warning: ${warning}`);
+        if (!(await confirmed('Type restore to go on, anything else to stop: ', 'restore', 'nothing was restored'))) {
+          console.log('Nothing was restored.');
+          return 1;
+        }
+      } else if (warning && !values.json) console.error(`Warning: ${warning}`);
+      // the moment before the restore: going back to it undoes the restore (D1 Time Travel keeps that point too)
+      const before = new Date().toISOString();
+      const r = await dbRestore(dir, arg, { live, confirm: true, log });
+      const undo = `${CMD} db restore ${before} --live`;
+      if (values.json) return printJson({ ...r, economy, undo: { at: before, command: undo } });
+      console.log(
+        `Restored ${where} to ${r.restored?.at ?? at}${r.restored?.bookmark ? ` (bookmark ${r.restored.bookmark})` : ''}.`,
+      );
+      console.log(
+        `  Before it, the database was at ${r.restored?.previous ? `bookmark ${r.restored.previous}` : before}. To undo this restore: ${undo} (the moment before it, by this machine's clock).`,
+      );
+      return 0;
+    }, args),
+};

package/commands/dev.mjs

@@ -1,4 +1,4 @@
-// `xcore dev [dir]`: the game as games.fun hosts it, on this machine, with its server, sign-in, saves, rooms and
+// `xcore dev [dir]`: the game as xgames.fun hosts it, on this machine, with its server, sign-in, saves, rooms and
 // economy RPC (../lib/dev/index.mjs). Runs until Ctrl+C.
 import { guard, parse, printJson, UsageError } from '../lib/cli.mjs';
 import { resolveGame, shown } from '../lib/games.mjs';
@@ -7,11 +7,11 @@ import { CMD } from '../lib/command.mjs';
 
 const usage = `Usage: xcore dev [dir] [--port <n>] [--no-build] [--open] [--json]
 
-Play the game on this machine as games.fun will host it, with everything a published game has behind it:
+Play the game on this machine as xgames.fun will host it, with everything a published game has behind it:
   http://127.0.0.1:<port>/game/   the published files, with the play host's headers
   /game/api/*                     the game's own server/ (Durable Objects, WebSockets, env.GF), reloaded on change
   /platform/v1/*                  sign-in (a local player), saves and leaderboards, the same store env.GF uses
-  /loot/v1/rpc                    the economy's Solana devnet RPC (XSOLANA_RPC_URL in .env, else games.fun's relay)
+  /loot/v1/rpc                    the economy's Solana devnet RPC (XSOLANA_RPC_URL in .env, else xgames.fun's relay)
 gamesfun.js (${CMD} add signin|database|multiplayer) uses all of it here, from any engine: open the page in two
 windows to play a room together. Running server/ needs Miniflare (workerd), installed once on first use (~140 MB).
 Saves, scores and Durable Object storage are kept in <dir>/.gamesfun/ (never published).
@@ -22,7 +22,7 @@ Saves, scores and Durable Object storage are kept in <dir>/.gamesfun/ (never pub
 
 export default {
   name: 'dev',
-  summary: 'play the game here as games.fun hosts it: its server, sign-in, saves, rooms and economy RPC',
+  summary: 'play the game here as xgames.fun hosts it: its server, sign-in, saves, rooms and economy RPC',
   usage,
   run: args =>
     guard(async () => {
@@ -51,11 +51,13 @@ export default {
           throw new Error(`port ${port} is in use: pick another with --port <n>`, { cause: e });
         throw e;
       }
-      if (values.json) printJson({ url: dev.url, origin: dev.origin, server: dev.server, rpc: dev.rpc });
+      if (values.json)
+        printJson({ url: dev.url, origin: dev.origin, files: dev.files, server: dev.server, rpc: dev.rpc });
       else {
         say(`\n${shown(dir)} on this machine: ${dev.url}`);
         say(`  server: ${dev.server ? (dev.server.running ? 'running' : 'not running (above)') : 'none (no server/)'}`);
         say(`  sign-in, saves, scores: a local player; kept in ${shown(dev.store.file)}`);
+        say(`  project files (env.GF.files, xcore files): public ones at ${dev.files}/, an origin of their own`);
         say(`  economy RPC: ${dev.rpc}`);
         say('Ctrl+C stops it.');
       }
@@ -70,5 +72,5 @@ export default {
       });
       await dev.close();
       return 0;
-    }),
+    }, args),
 };

package/commands/domain.mjs

@@ -12,16 +12,16 @@ const usage = `Usage: xcore domain [list] [dir] [--json]
        xcore domain remove <domain> [dir] [--json]
 
 The published game on a domain of your own (play.mygame.com), besides its xgames.fun link: players see your
-address, and sign-in, saves, scores, rooms and the economy work there as on games.fun. Creator has 1 domain, Scale 5;
-Free has none. Sign-in still opens a small games.fun window, and a post on X still uses the xgames.fun link.
+address, and sign-in, saves, scores, rooms and the economy work there as on xgames.fun. Creator has 1 domain, Scale 5;
+Free has none. Sign-in still opens a small xgames.fun window, and a post on X still uses the xgames.fun link.
   list              the domains and their state
   add <domain>      ask for one: prints the DNS records to add where your domain's DNS is
-  check <domain>    look at its records now (games.fun also checks by itself); live once they are right
+  check <domain>    look at its records now (xgames.fun also checks by itself); live once they are right
   remove <domain>   stop serving the game there
 A game whose plan no longer has room for a domain keeps it, paused: it sends players to the xgames.fun link.`;
 
 const plainly = e => {
-  // games.fun's own words already say what to do; add the command only when they don't
+  // xgames.fun's own words already say what to do; add the command only when they don't
   if (e?.code === 'plan')
     throw new Error(
       /plan activate/.test(e.message)
@@ -29,7 +29,7 @@ const plainly = e => {
         : `${e.message} Custom domains come with Creator (1) and Scale (5): put the game in a slot with ${CMD} plan activate.`,
     );
   if (e?.code === 'domains-off')
-    throw new Error(`${e.message} (custom domains need games.fun's operator to set them up first.)`);
+    throw new Error(`${e.message} (custom domains need xgames.fun's operator to set them up first.)`);
   throw e;
 };
 
@@ -72,11 +72,11 @@ export default {
         );
         return 0;
       }
-      if (!d) throw new Error(`games.fun did not answer with ${host}.`);
+      if (!d) throw new Error(`xgames.fun did not answer with ${host}.`);
       console.log(describeDomain(d));
       if (d.status !== 'active')
         console.log(
-          `\nThen: ${CMD} domain check ${host} (DNS can take a few minutes; games.fun also checks by itself).`,
+          `\nThen: ${CMD} domain check ${host} (DNS can take a few minutes; xgames.fun also checks by itself).`,
         );
       // the page must know its domain: gamesfun.js 1.2.0 asks the play edge which game it is on a host of its own
       const stale = await staleClient(dir).catch(() => []);
@@ -85,5 +85,5 @@ export default {
           `\nThis folder's ${stale.join(', ')} is older than this xcore's: on its own domain an older copy can't tell which game it is, so sign-in fails there. Run ${CMD} add signin ${dir}, then ${CMD} publish ${dir}, so the page knows its domain.`,
         );
       return 0;
-    }),
+    }, args),
 };

package/commands/embed.mjs

@@ -9,13 +9,13 @@ const usage = `Usage: xcore embed [list] [dir] [--json]
        xcore embed add <site> [dir] [--json]
        xcore embed remove <site> [dir] [--json]
 
-The sites of your own that may show the published game in a frame (an <iframe> in your page), besides games.fun
+The sites of your own that may show the published game in a frame (an <iframe> in your page), besides xgames.fun
 and posts on X. A site is its origin: https://mygame.com (http://localhost:<port> while you build it). It applies
 within about a minute, with no publish. Free allows 3 sites, Creator 10, Scale 25.
   list            the sites, and where the game plays
   add <site>      allow one, and print the <iframe> to put in its page
   remove <site>   take one off
-Framed on your site, the game signs players in by itself (a small games.fun window, or a code), as it does in a post
+Framed on your site, the game signs players in by itself (a small xgames.fun window, or a code), as it does in a post
 on X: your page can't sign them in for it.`;
 
 export default {
@@ -53,5 +53,5 @@ export default {
         );
       } else console.log(r.changed ? `${r.origin} may no longer show the game.` : `${r.origin} was not on the list.`);
       return 0;
-    }),
+    }, args),
 };