@homie-rocks/studio 0.11.0 → 0.12.1

package/lib/progress.mjs

@@ -57,6 +57,7 @@ import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, sta
 import { extname, join } from 'node:path';
 import { refreshCodexFile } from './codex.mjs';
 import { readStudio, siteUrl } from './studio.mjs';
+import { request, whyRefused } from './net.mjs';
 
 export const PROGRESS_KIND = 'homie-studio-progress';
 export const PROGRESS_DIR = join('.studio', 'progress');
@@ -89,18 +90,10 @@ const keyPath = (root, id) => join(dir(root), `${id}.key`);
 const currentPath = (root) => join(dir(root), 'current');
 const loopback = (url) => { try { return ['127.0.0.1', 'localhost', '[::1]'].includes(new URL(url).hostname); } catch { return false; } };
 
-/*
- * A CLAUDE CODE CLOUD SESSION ON THE DEFAULT NETWORK. Its "Trusted" network reaches package registries and GitHub,
- * not homie.rocks: the session's proxy answers 403 with `x-deny-reason: host_not_allowed`. Say which setting lets
- * the card follow the build, instead of "did not answer"; the build itself goes on with its local feed.
- */
+/** Kept for callers of 0.11.0: whether an answer is the proxy refusing the host (lib/net.mjs says the rest). */
 export function networkWhy(res, at) {
-  if (res?.status === 403 && /host_not_allowed/i.test(res.headers?.get?.('x-deny-reason') ?? '')) {
-    let host = at;
-    try { host = new URL(at).host; } catch { /* as given */ }
-    return `this Claude Code cloud environment's network does not reach ${host}. In claude.ai/code, open the environment's settings, set Network access to Custom, add ${host} (keep "Also include default list of common package managers"), and start a new session; until then the build goes on with its local feed only`;
-  }
-  return null;
+  const r = whyRefused(res, null, '', at);
+  return r.needs === 'network' ? r.why : null;
 }
 
 /** The studio's live address for the card: an https origin (or this computer's own dev site), else null. */
@@ -153,23 +146,24 @@ async function pushDoc(root, id) {
   let key = null;
   try { key = readFileSync(keyPath(root, id), 'utf8').trim(); } catch { return null; }
   const { shared, ...body } = doc;
-  const res = await fetch(`${shared.directory}/api/studio/progress/${shared.build}`, {
+  const sent = await request(`${shared.directory}/api/studio/progress/${shared.build}`, {
     method: 'PUT',
     headers: { authorization: `Bearer ${key}`, 'content-type': 'application/json', 'user-agent': 'homie-studio' },
     body: JSON.stringify({ ...body, build: shared.build }),
-    signal: AbortSignal.timeout(8000),
-  });
-  const blocked = networkWhy(res, shared.directory);
-  if (blocked) {
-    mutateDoc(root, id, (d) => { d.shared = { ...d.shared, ended: true }; pushLog(d, `The Claude app cannot follow this build: ${blocked}`); });
-    return null;
-  }
-  if (res.status === 404 || res.status === 410) {
-    // The shared copy ended (24 hours, or the directory dropped it): keep the local feed, stop sending.
-    mutateDoc(root, id, (d) => { d.shared = { ...d.shared, ended: true }; });
+  }, { timeout: 8000 });
+  if (!sent.ok) {
+    if (sent.status === 404 || sent.status === 410 || sent.needs === 'network') {
+      // The shared copy ended (24 hours, or the directory dropped it), or the proxy refuses the directory: keep the
+      // local feed, stop sending, and say why in its log.
+      mutateDoc(root, id, (d) => { d.shared = { ...d.shared, ended: true }; pushLog(d, `The Claude app's card stopped following this build: ${sent.why}`); });
+      return null;
+    }
+    // Anything else (a slow answer, a refused write): the next write tries again; the log keeps what happened once.
+    mutateDoc(root, id, (d) => { if (d.shared && d.shared.lastError !== sent.why) { d.shared = { ...d.shared, lastError: sent.why }; pushLog(d, `Sending to the card failed: ${sent.why}`); } });
     return null;
   }
-  const reply = await res.json().catch(() => null);
+  const reply = sent.body;
+  if (readFeed(root, id)?.shared?.lastError) mutateDoc(root, id, (d) => { delete d.shared.lastError; });
   if (reply?.stop) {
     mutateDoc(root, id, (d) => {
       if (!d.stop?.requested) { d.stop = { requested: true, at: now(), by: 'person' }; pushLog(d, 'Stop pressed in the Claude app; stopping at the next safe point.'); }
@@ -467,36 +461,38 @@ export async function startProgress(root, { what = 'game', id, title, budget, un
   writeAtomic(currentPath(root), `${build}\n`);
   let shared = null;
   let why = null;
+  let failure = {};
   if (share) {
     const at = String(directory || studio.homie?.directory || 'https://homie.rocks').replace(/\/+$/, '');
     if (!/^https:\/\//.test(at) && !(/^http:\/\//.test(at) && loopback(at))) why = `the directory ${at} is not https`;
     else {
-      try {
-        // A build the chat opened is attached (once); otherwise a new one is opened here.
-        const res = await fetch(attach ? `${at}/api/studio/progress/${attach}/attach` : `${at}/api/studio/progress`, {
-          method: 'POST', headers: { 'content-type': 'application/json', 'user-agent': 'homie-studio' },
-          body: JSON.stringify({ what, id: id ?? null, title: doc.title, studio: doc.studio }), signal: AbortSignal.timeout(10_000),
-        });
-        const body = await res.json().catch(() => null);
-        if (!res.ok && networkWhy(res, at)) why = networkWhy(res, at);
-        else if (res.ok && body?.ok && REMOTE_ID.test(String(body.build)) && /^hbk_[a-f0-9]{48}$/.test(String(body.key))) {
-          // The chat named the build: its title is the one the person saw.
-          if (attach && body.title && !title) mutateDoc(root, build, (d) => { d.title = plain(body.title, LIMITS.title); });
-          writeFileSync(keyPath(root, build), `${body.key}\n`, { mode: 0o600 });
-          try { chmodSync(keyPath(root, build), 0o600); } catch { /* not on this filesystem */ }
-          shared = { build: body.build, directory: at, expiresAt: body.expiresAt ?? null };
-          mutateDoc(root, build, (d) => { d.shared = { build: body.build, directory: at }; });
-          schedule(root, build, { soon: true });
-          heartbeat(root, build, true);
-        } else why = body?.message ?? `${at} answered ${res.status}`;
-      } catch (error) { why = `${at} did not answer (${error?.message ?? error})`; }
+      // A build the chat opened is attached (once); otherwise a new one is opened here.
+      const sent = await request(attach ? `${at}/api/studio/progress/${attach}/attach` : `${at}/api/studio/progress`, {
+        method: 'POST', headers: { 'content-type': 'application/json', 'user-agent': 'homie-studio' },
+        body: JSON.stringify({ what, id: id ?? null, title: doc.title, studio: doc.studio }),
+      });
+      const body = sent.body;
+      if (sent.ok && REMOTE_ID.test(String(body?.build)) && /^hbk_[a-f0-9]{48}$/.test(String(body?.key))) {
+        // The chat named the build: its title is the one the person saw.
+        if (attach && body.title && !title) mutateDoc(root, build, (d) => { d.title = plain(body.title, LIMITS.title); });
+        writeFileSync(keyPath(root, build), `${body.key}\n`, { mode: 0o600 });
+        try { chmodSync(keyPath(root, build), 0o600); } catch { /* not on this filesystem */ }
+        shared = { build: body.build, directory: at, expiresAt: body.expiresAt ?? null };
+        mutateDoc(root, build, (d) => { d.shared = { build: body.build, directory: at }; });
+        schedule(root, build, { soon: true });
+        heartbeat(root, build, true);
+      } else {
+        // As it is: the directory's own answer (its status and message) or the connection's error, never a guess.
+        why = sent.ok ? `${at} answered without a build and key` : sent.why;
+        failure = { ...(sent.status ? { status: sent.status } : {}), ...(sent.code ? { code: sent.code } : {}), ...(sent.needs ? { needs: sent.needs } : {}) };
+      }
     }
   }
   if (attach && !shared) {
     // Attaching is the point of `progress attach`: without it, say why and leave no open feed behind.
     rmSync(docPath(root, build), { force: true });
     rmSync(currentPath(root), { force: true });
-    return { ok: false, command: 'progress attach', build: attach, why: `could not attach to ${attach}: ${why}` };
+    return { ok: false, command: 'progress attach', build: attach, ...failure, why: `could not attach to ${attach}: ${why}` };
   }
   return {
     ok: true, command: attach ? 'progress attach' : 'progress start', build, file: join(PROGRESS_DIR, `${build}.json`), what, id: id ?? null, title: readFeed(root, build)?.title ?? doc.title,

package/lib/repo.mjs

@@ -0,0 +1,51 @@
+/**
+ * WHICH GITHUB REPOSITORY THIS STUDIO IS. The Claude app's hand-off opens Claude Code on it, so it must be the
+ * studio's own: never the engine and template repository (homie-rocks/homie) that Cloudflare's "Deploy to
+ * Cloudflare" copied the studio from, and never a guess.
+ *
+ * In order:
+ *   1. HOMIE_REPO, a build variable naming it;
+ *   2. studio.json `github` (`setup attach` writes it, and the person may);
+ *   3. the checkout's git remotes, origin first. A Workers Builds checkout, a Claude Code cloud session (its remote
+ *      goes through the session's own git proxy) and a person's clone all carry one. Only owner/name is kept,
+ *      never a token in the URL.
+ *
+ * A deploy hands it to the live Worker as a variable (HOMIE_REPO), never into a public file. The Worker tells its
+ * directory alongside its claim, so the setup card can open the right repository.
+ */
+import { spawnSync } from 'node:child_process';
+import { readStudio } from './studio.mjs';
+
+export const REPO = /^[A-Za-z0-9](?:[A-Za-z0-9-]{0,38})\/[A-Za-z0-9._-]{1,100}$/;
+/** The engine and template repository: a studio is never this. */
+export const ENGINE_REPO = 'homie-rocks/homie';
+
+/** owner/name in a git remote URL (https, ssh, a proxy's /git/owner/name path), without any credentials; or null. */
+export function repoFromUrl(url) {
+  const s = String(url ?? '').trim().replace(/\.git$/, '').replace(/\/+$/, '');
+  if (!s) return null;
+  const m = /[/:]([A-Za-z0-9](?:[A-Za-z0-9-]{0,38}))\/([A-Za-z0-9._-]{1,100})$/.exec(s);
+  return m ? studioRepo(`${m[1]}/${m[2]}`) : null;
+}
+
+/** A studio repository slug, or null (not a slug, or the engine repository). */
+export function studioRepo(value) {
+  const r = String(value ?? '').trim();
+  return REPO.test(r) && r.toLowerCase() !== ENGINE_REPO ? r : null;
+}
+
+/** This studio's repository: HOMIE_REPO, studio.json `github`, else its git remotes (origin first). */
+export function repoOf(root, { env = process.env } = {}) {
+  const named = studioRepo(env.HOMIE_REPO);
+  if (named) return named;
+  try { const s = studioRepo(readStudio(root).github); if (s) return s; } catch { /* no studio.json */ }
+  const git = (args) => spawnSync('git', args, { cwd: root, encoding: 'utf8', timeout: 5000 });
+  const origin = git(['remote', 'get-url', 'origin']);
+  if (origin.status === 0) { const r = repoFromUrl(origin.stdout); if (r) return r; }
+  const all = git(['config', '--get-regexp', '^remote\\..*\\.url$']);
+  for (const line of (all.status === 0 ? all.stdout : '').split('\n')) {
+    const r = repoFromUrl(line.split(/\s+/)[1]);
+    if (r) return r;
+  }
+  return null;
+}

package/lib/scaffold.mjs

@@ -24,6 +24,7 @@ import { homedir } from 'node:os';
 import { dirname, join, relative, resolve } from 'node:path';
 import { STUDIO_VERSION, packageSpec } from './version.mjs';
 import { STATS_MIGRATION, STATS_MIGRATION_FILE } from '../worker/stats.mjs';
+import { PLAYERS_MIGRATION, PLAYERS_MIGRATION_FILE } from '../worker/players.mjs';
 import { themeFile } from './site.mjs';
 import { PACKAGE_ROOT } from './studio.mjs';
 
@@ -149,6 +150,10 @@ studio's pinned copy, never a registry lookup of the bare name.
   \`studio_stats\` (never paste a key anywhere else). \`stats share on\` tells the directory two numbers
   (played this week). The site counts and never tracks: no cookie on a visitor, no person identified,
   nothing sent anywhere; house QA and \`check\` runs are not counted.
+- \`npx --no-install homie-studio players\` — how many players have accounts here (and guests, and who played
+  this week): counts and names for the owner, never a passkey or an email. \`players owner\` gives the owner a
+  one-time link that marks their own player account (a passkey on this site) as the owner's, so their games and
+  the studio's back office recognise them.
 - \`npx --no-install homie-studio upgrade\` — after pinning a newer \`@homie-rocks/studio\` (or through
   \`npx -y --package=<its tarball> homie-studio upgrade\`): what the newer template adds to this studio (AGENTS.md
   sections, READMEs, .gitignore lines) and what it keeps. It changes nothing until \`--apply\`, and never
@@ -191,6 +196,13 @@ studio's pinned copy, never a registry lookup of the bare name.
   a small icon (\`node_modules/@homie-rocks/studio/site/SITE.md\`). Look at it on a phone and a computer.
 - Change a game in small steps, build, and look at it (\`dev\`, then \`check\`).
 - A game's id is its URL (\`/<id>/\`); keep it once published.
+- **Progress that lasts** (a character, unlocks, a collection, days of play) goes in **saves**, never in the room:
+  a room forgets everything 60 s after its last player leaves. game.json \`"saves": true\` and
+  \`createSaves\` from \`@homie-rocks/studio/saves\` (\`node_modules/@homie-rocks/studio/saves/SAVES.md\`): per
+  player and game, versioned, offline-tolerant, in this studio's own D1. Pressing Play needs no account; a guest's
+  progress stays on that device until they make a passkey account (at \`/account/\`, or the game's own button), and
+  then it follows them to every device. Lifetime stats and a hardcore "hall of the fallen" are in it too. The
+  \`ember-vale\` starter shows the whole pattern.
 
 ## The Game Codex and progress
 
@@ -359,7 +371,7 @@ export function studioFiles({ name, slug, homie, template = false }) {
       products: ['Workers', 'D1', 'Durable Objects'],
       bindings: {
         STUDIO_NAME: { description: 'Your studio\'s name, as its site shows it (for example **Night Owls**). Claude can change it later.' },
-        DB: { description: 'The studio\'s own database: finished rounds, the studio\'s own stats (counts, never a visitor) and its claim in the [homie.rocks](https://homie.rocks/studios/) directory. Free plan.' },
+        DB: { description: 'The studio\'s own database: finished rounds, the studio\'s own stats (counts, never a visitor), player accounts and cloud saves for games that keep them, and its claim in the [homie.rocks](https://homie.rocks/studios/) directory. Free plan.' },
       },
     },
   };
@@ -384,6 +396,7 @@ export { default, Table, Lobby } from '@homie-rocks/studio/worker';
 `,
     'site/migrations/0001_studio.sql': MIGRATION,
     [`site/migrations/${STATS_MIGRATION_FILE}`]: STATS_MIGRATION,
+    [`site/migrations/${PLAYERS_MIGRATION_FILE}`]: PLAYERS_MIGRATION,
     'wrangler.jsonc': wranglerConfig({ worker, name, d1: studio.cloudflare.d1, r2: studio.cloudflare.r2, layout: 'root' }),
     '.claude/skills/.gitkeep': '',
   };
@@ -453,6 +466,23 @@ export function ensureStatsMigration(root) {
   return `site/migrations/${STATS_MIGRATION_FILE}`;
 }
 
+/**
+ * A studio made before 0.12.0 has no players migration (player accounts and cloud saves, saves/SAVES.md): add it,
+ * so the next `d1 migrations apply` makes the tables. Returns the file it wrote, or null when it was there.
+ */
+export function ensurePlayersMigration(root) {
+  const file = join(root, 'site', 'migrations', PLAYERS_MIGRATION_FILE);
+  if (existsSync(file)) return null;
+  mkdirSync(dirname(file), { recursive: true });
+  writeFileSync(file, PLAYERS_MIGRATION);
+  return `site/migrations/${PLAYERS_MIGRATION_FILE}`;
+}
+
+/** Every migration the template owns that this studio lacks, added: the files written (deploy and dev say so). */
+export function ensureMigrations(root) {
+  return [ensureStatsMigration(root), ensurePlayersMigration(root)].filter(Boolean);
+}
+
 /**
  * A studio made before 0.6.0 committed nothing under .studio/ yet: make sure git leaves it out before the first
  * deploy writes the workers.dev address there. Returns true when it added the line.

package/lib/setup.mjs

@@ -13,43 +13,32 @@
  * A setup id is single use per repository: a second attach from the same repository answers the same; another
  * repository is refused.
  */
-import { spawnSync } from 'node:child_process';
 import { existsSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { configNames } from './cloudflare.mjs';
-import { networkWhy } from './progress.mjs';
+import { request } from './net.mjs';
+import { ENGINE_REPO, repoOf } from './repo.mjs';
 import { CONNECT_BAND, agentsMd, readme, slugify, templateReadme } from './scaffold.mjs';
 import { configPath, readStudio, writeLocal, writeStudio } from './studio.mjs';
 import { STUDIO_VERSION } from './version.mjs';
 
 const SETUP_ID = /^hs_[a-f0-9]{32}$/;
 
-/** owner/repo of this checkout's GitHub remote (a Claude Code cloud session's remote goes through its own proxy). */
-export function repoOf(root) {
-  const r = spawnSync('git', ['remote', 'get-url', 'origin'], { cwd: root, encoding: 'utf8', timeout: 5000 });
-  if (r.status !== 0) return null;
-  const url = r.stdout.trim().replace(/\.git$/, '').replace(/\/+$/, '');
-  const m = /[/:]([A-Za-z0-9](?:[A-Za-z0-9-]{0,38}))\/([A-Za-z0-9._-]{1,100})$/.exec(url);
-  return m ? `${m[1]}/${m[2]}` : null;
-}
-
 export async function setupAttach(root, id, { homie } = {}) {
   if (!SETUP_ID.test(String(id ?? ''))) return { ok: false, command: 'setup attach', why: 'attach to the setup id the Claude app\'s setup card showed: hs_ and 32 hex digits' };
   const studio = readStudio(root);
   const directory = String(homie || studio.homie?.directory || 'https://homie.rocks').replace(/\/+$/, '');
   const repo = repoOf(root);
-  let res; let body = null;
-  try {
-    res = await fetch(`${directory}/api/studio/setup/${id}/attach`, {
-      method: 'POST', headers: { 'content-type': 'application/json', 'user-agent': `homie-studio/${STUDIO_VERSION}` },
-      body: JSON.stringify({ repo, studio: { name: studio.name, slug: studio.slug, template: studio.template === true }, version: STUDIO_VERSION }),
-      signal: AbortSignal.timeout(10_000),
-    });
-    body = await res.json().catch(() => null);
-  } catch (error) { return { ok: false, command: 'setup attach', why: `${directory} did not answer (${error?.message ?? error})` }; }
-  const blocked = networkWhy(res, directory);
-  if (blocked) return { ok: false, command: 'setup attach', needs: 'network', why: blocked };
-  if (!res.ok || !body?.ok) return { ok: false, command: 'setup attach', why: body?.message ?? `${directory} answered ${res.status}` };
+  if (!repo) {
+    return { ok: false, command: 'setup attach', needs: 'repository', why: `this checkout names no GitHub repository of its own (its git remote is missing, or is ${ENGINE_REPO}, Homie's engine and template, which a studio never is). Run this in the studio's own repository, the one Cloudflare's Deploy to Cloudflare made, or name it in studio.json as "github": "<owner>/<name>"` };
+  }
+  const sent = await request(`${directory}/api/studio/setup/${id}/attach`, {
+    method: 'POST', headers: { 'content-type': 'application/json', 'user-agent': `homie-studio/${STUDIO_VERSION}` },
+    body: JSON.stringify({ repo, studio: { name: studio.name, slug: studio.slug, template: studio.template === true }, version: STUDIO_VERSION }),
+  });
+  // What went wrong, as it is: the directory's own answer, or the connection's error. Never a guess at the network.
+  if (!sent.ok) return { ok: false, command: 'setup attach', repo, ...(sent.status ? { status: sent.status } : {}), ...(sent.code ? { code: sent.code } : {}), ...(sent.needs ? { needs: sent.needs } : {}), why: sent.why };
+  const body = sent.body;
 
   const renamed = [];
   const name = typeof body.name === 'string' && body.name.trim() ? body.name.trim().slice(0, 60) : null;
@@ -78,6 +67,9 @@ export async function setupAttach(root, id, { homie } = {}) {
     const band = join(root, 'site', 'partials', 'home.html');
     if (existsSync(band) && readFileSync(band, 'utf8') === CONNECT_BAND) { rmSync(band); renamed.push('site/partials/home.html (removed)'); }
   }
+  // The repository goes into studio.json, so the next deploy (and Workers Builds) tells the live Worker which it is.
+  const now = readStudio(root);
+  if (now.github !== repo) { writeStudio(root, { ...now, github: repo }); if (!renamed.includes('studio.json')) renamed.push('studio.json'); }
   if (body.site) writeLocal(root, { url: body.site, connectedAt: new Date().toISOString() });
   return {
     ok: true, command: 'setup attach', setup: id, repo, site: body.site ?? null, name: name ?? studio.name, renamed,

package/lib/site.mjs

@@ -214,9 +214,9 @@ export function readPosts(root, { games = [], songs = [], videos = [], log = ()
 
 export const PARTIALS = ['head', 'header', 'footer', 'home', 'game', 'post'];
 /** Paths a page of the studio's own can never take: the rooms, the game files, the API and the owner's pages. */
-const RESERVED_PAGE = /^\/(?:api|_studio|_homie|_site|media|\.well-known|games\/[^/]+)\/|^\/[a-z0-9][a-z0-9-]{0,39}\/(?:play|tv|live|api|__[a-z]+)(?:\/|$)/;
+const RESERVED_PAGE = /^\/(?:api|account|_studio|_homie|_site|media|\.well-known|games\/[^/]+)\/|^\/[a-z0-9][a-z0-9-]{0,39}\/(?:play|tv|live|api|__[a-z]+)(?:\/|$)/;
 /** Top-level names site/public must not take (the build's own output). */
-const RESERVED_PUBLIC = new Set(['games', 'music', 'videos', 'games.json', '_site', '_homie', '_studio', 'api', 'media']);
+const RESERVED_PUBLIC = new Set(['games', 'music', 'videos', 'games.json', '_site', '_homie', '_studio', 'api', 'media', 'account']);
 
 function walk(dir, fn, rel = '') {
   for (const e of readdirSync(join(dir, rel), { withFileTypes: true })) {

package/lib/stats.mjs

@@ -21,9 +21,9 @@ const HOUR = 3600_000;
 const RANGES = new Set(['1d', '7d', '30d', '90d']);
 const SLUG = /^[a-z0-9][a-z0-9-]{0,39}$/;
 
-const loopback = (url) => { try { return ['127.0.0.1', 'localhost', '[::1]'].includes(new URL(url).hostname); } catch { return false; } };
+export const loopback = (url) => { try { return ['127.0.0.1', 'localhost', '[::1]'].includes(new URL(url).hostname); } catch { return false; } };
 
-function siteOf(root, url) {
+export function siteOf(root, url) {
   const studio = readStudio(root);
   const site = String(url || siteUrl(root, studio) || '').replace(/\/+$/, '');
   if (!/^https?:\/\//.test(site)) return { studio, site: null };
@@ -31,7 +31,7 @@ function siteOf(root, url) {
 }
 
 /** Put a key's hash into the studio's D1 (remote, or local for a loopback site). The key never leaves this machine. */
-function mint(root, studio, kind, ttlMs, { local }) {
+export function mint(root, studio, kind, ttlMs, { local }) {
   const key = `hsk_${randomBytes(24).toString('hex')}`;
   const hash = createHash('sha256').update(key).digest('hex');
   const now = Date.now();

package/lib/studio.mjs

@@ -8,7 +8,7 @@ import { fileURLToPath } from 'node:url';
 
 export const PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
 export const GAME_ID = /^[a-z0-9][a-z0-9-]{0,39}$/;
-const RESERVED_IDS = new Set(['api', 'media', 'games', 'assets', '_homie', '_site', '_studio', 'well-known', 'index', 'play', 'studio', 'studios', 'music', 'videos', 'posts', 'rooms', 'feed']);
+const RESERVED_IDS = new Set(['api', 'media', 'games', 'assets', '_homie', '_site', '_studio', 'well-known', 'index', 'play', 'studio', 'studios', 'music', 'videos', 'posts', 'rooms', 'feed', 'account']);
 
 export function findStudio(from = process.cwd()) {
   let at = resolve(from);

package/lib/template-history.json

@@ -199,6 +199,54 @@
      "## Beta": "9d02638207a26e73"
     }
    }
+  },
+  "0.12.0": {
+   "files": {
+    "CLAUDE.md": "ddf2b2a0376202f6",
+    "README.md": "684b3cca8001673c",
+    "games/README.md": "5e5e942baa7e0372",
+    "music/README.md": "b8a828de9311bd28",
+    "videos/README.md": "70614388cbb203c7",
+    "posts/README.md": "37841aae476bd540",
+    "site/README.md": "ca131cd0472464fb",
+    "site/src/worker.mjs": "ca3f1630f2420ad3"
+   },
+   "sections": {
+    "AGENTS.md": {
+     "(intro)": "214aa46eb3a895d5",
+     "## Layout": "f14d641159480e6c",
+     "## Commands (all through the pinned CLI in node_modules)": "3a3d3bef7e8d1a50",
+     "## The site": "7d3525ba39b7f262",
+     "## Making games": "63069b31c87a2aa2",
+     "## The Game Codex and progress": "0738ef719cef3a4c",
+     "## Rules": "969318425c99f5a5",
+     "## Beta": "9d02638207a26e73"
+    }
+   }
+  },
+  "0.12.1": {
+   "files": {
+    "CLAUDE.md": "ddf2b2a0376202f6",
+    "README.md": "684b3cca8001673c",
+    "games/README.md": "5e5e942baa7e0372",
+    "music/README.md": "b8a828de9311bd28",
+    "videos/README.md": "70614388cbb203c7",
+    "posts/README.md": "37841aae476bd540",
+    "site/README.md": "ca131cd0472464fb",
+    "site/src/worker.mjs": "ca3f1630f2420ad3"
+   },
+   "sections": {
+    "AGENTS.md": {
+     "(intro)": "214aa46eb3a895d5",
+     "## Layout": "f14d641159480e6c",
+     "## Commands (all through the pinned CLI in node_modules)": "3a3d3bef7e8d1a50",
+     "## The site": "7d3525ba39b7f262",
+     "## Making games": "63069b31c87a2aa2",
+     "## The Game Codex and progress": "0738ef719cef3a4c",
+     "## Rules": "969318425c99f5a5",
+     "## Beta": "9d02638207a26e73"
+    }
+   }
   }
  }
 }

package/netplay/NETPLAY.md

@@ -194,6 +194,11 @@ it.
 - If the old host does not return, the relay elects someone else. That browser restores
   from the stored checkpoint (at most 30 s old) and from its own newest snapshot.
 
+**What a room is not.** A room forgets everything 60 s after its last player leaves (`forgetMs`). Progress that
+must last (a character, unlocks, days of play) is the player's, not the room's: it goes in cloud saves
+(`@homie-rocks/studio/saves`, `../saves/SAVES.md`). The host decides what happened and tells that player's own
+browser (an `ev` to its seat); only that browser changes and saves the player's progress.
+
 ## 5. Wire protocol v1
 
 - **Transport:** one WebSocket per game document, carrying JSON text frames

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@homie-rocks/studio",
-  "version": "0.11.0",
+  "version": "0.12.1",
   "description": "A studio for games, music and video on its own Cloudflare: scaffold, multiplayer starters on the netplay contract, a port toolkit that makes existing single-player web games multiplayer, the site Worker with public rooms (Table/Lobby Durable Objects and D1, all on the free Workers plan, no payment method), a site with the hub's sections (Home, Games, Music, Videos, Rooms, Posts with feeds) in the studio's own look, an epic landing page for every game, optional R2 storage for large media, deploy, and the homie.rocks directory.",
   "type": "module",
   "license": "Apache-2.0",
@@ -26,6 +26,10 @@
       "types": "./port/early.ts",
       "default": "./port/early.ts"
     },
+    "./saves": {
+      "types": "./saves/saves.ts",
+      "default": "./saves/saves.ts"
+    },
     "./worker": "./worker/index.mjs",
     "./package.json": "./package.json"
   },
@@ -35,6 +39,7 @@
     "netplay/",
     "port/",
     "worker/",
+    "saves/",
     "starters/",
     "media/",
     "site/",

package/port/index.ts

@@ -12,6 +12,7 @@
  *   createHud    a minimal clock / scores / results overlay
  *   BotBrain, seek, nearest, rubberBand
  *                bot scaffolds
+ *   createSaves  player accounts and cloud saves (a character that lasts days, on every device; saves/SAVES.md)
  * and everything from @homie-rocks/studio/netplay.
  */
 import './early';
@@ -27,3 +28,4 @@ export { exposePort, type PortProbeOptions, type View } from './probe';
 export { createRoom, type Room, type RoomOptions, type BodyBase, type RoomSnap, type RoomCkpt } from './room';
 export { createHud, type HudOptions } from './hud';
 export { BotBrain, seek, flee, wanderer, nearest, rubberBand, protectedNewcomer, type V2 } from './bots';
+export { createSaves, SAVES_VERSION, type Saves, type SavesOptions, type Player, type SaveEntry, type SetResult, type Memorial, type SavesStatus, type Conflict } from '../saves/saves';

package/port/keys.ts

@@ -75,6 +75,9 @@ export function createKeys(target: Window | HTMLElement = window): Keys {
   const edges = new Set<string>();
   const kd = (e: Event): void => {
     const k = e as KeyboardEvent;
+    // A key typed into the game's own text box (a hero's name, a chat line) is a word, never a move.
+    const el = k.target as HTMLElement | null;
+    if (el && (el.isContentEditable || /^(INPUT|TEXTAREA|SELECT)$/.test(el.tagName ?? ''))) return;
     if (['ArrowUp', 'ArrowDown', 'ArrowLeft', 'ArrowRight', 'Space'].includes(k.code)) k.preventDefault();
     if (!held.has(k.code)) edges.add(k.code);
     held.add(k.code);