@homie-rocks/studio 0.9.0 → 0.11.0

package/lib/statusline.mjs

@@ -0,0 +1,155 @@
+/**
+ * THE CLAUDE CODE STATUS LINE: one quiet line under the prompt with the studio's current build, from its progress
+ * feed (lib/progress.mjs), for example
+ *
+ *   ▶ Ember Run · Checks ▰▰▰▰▰▰▱▱▱▱ 62% · 3/5 checks · $0.40 of $2.00
+ *
+ * Optional, and only on the person's yes: `homie-studio statusline --install` writes the `statusLine` setting into
+ * this studio's `.claude/settings.local.json` (this person, this studio; Claude Code keeps that file out of git, and
+ * the studio's .gitignore does too). Claude Code runs the command after each message and, with `refreshInterval`,
+ * every few seconds while a long check runs; it sends the session as JSON on stdin (`workspace.current_dir`), and
+ * shows what the command prints. With no build running it shows only the studio's name, dimmed; a build that ended
+ * stays for a few minutes (passed, failed or stopped), then goes.
+ *
+ * Plugins cannot set a status line (a plugin's settings take only `agent` and `subagentStatusLine`), so this is a
+ * one-line project setting the person agrees to, never something the plugin switches on.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { currentFeedDoc, latestFeedFor, summarize } from './feed-summary.mjs';
+import { PACKAGE_ROOT, findStudio } from './studio.mjs';
+
+const ANSI = { reset: '\x1b[0m', dim: '\x1b[2m', bold: '\x1b[1m', green: '\x1b[32m', red: '\x1b[31m', yellow: '\x1b[33m', cyan: '\x1b[36m' };
+/** How long an ended build stays on the line. */
+export const RECENT_MS = 10 * 60_000;
+
+function bar(percent, width) {
+  const full = Math.round((percent / 100) * width);
+  return { done: '▰'.repeat(full), left: '▱'.repeat(Math.max(0, width - full)) };
+}
+
+/**
+ * The line for the studio at or above `dir`, or '' outside a studio. Parts are dropped from the end (spend, then
+ * checks) until the line fits in `columns`.
+ */
+export function statusLine({ dir = process.cwd(), now = Date.now(), columns = 100, color = true } = {}) {
+  const root = findStudio(dir);
+  if (!root) return '';
+  let name = 'Studio';
+  try { name = JSON.parse(readFileSync(join(root, 'studio.json'), 'utf8')).name || name; } catch { /* keep */ }
+  const s = summarize(currentFeedDoc(root) ?? latestFeedFor(root, null));
+  const paint = (code, text) => (color && text ? `${code}${text}${ANSI.reset}` : text);
+  const fit = (parts) => {
+    // parts: [[plain, painted], …]; keep the first two whole, then as many as fit.
+    const width = Math.max(20, columns - 2);
+    let keep = parts.length;
+    const len = (n) => parts.slice(0, n).reduce((a, [plain]) => a + plain.length, 0) + (n - 1) * 3;
+    while (keep > 1 && len(keep) > width) keep -= 1;
+    const out = parts.slice(0, keep).map(([, painted]) => painted).join(paint(ANSI.dim, ' · '));
+    const plain = parts.slice(0, keep).map(([p]) => p).join(' · ');
+    return plain.length > width ? `${plain.slice(0, width - 1)}…` : out;
+  };
+  const ended = s && s.state !== 'running' ? Date.parse(s.endedAt ?? s.updatedAt ?? 0) : null;
+  if (!s || (ended !== null && !(now - ended < RECENT_MS))) return fit([[`◇ ${name}`, paint(ANSI.dim, `◇ ${name}`)]]);
+
+  const title = s.title.length > 40 ? `${s.title.slice(0, 39)}…` : s.title;
+  if (s.state === 'passed') {
+    return fit([[`✓ ${title} done`, paint(ANSI.green, `✓ ${title} done`)], ...(s.preview ? [[s.preview, paint(ANSI.dim, s.preview)]] : [])]);
+  }
+  if (s.state === 'failed') {
+    const why = `failed${s.stage ? ` at ${s.stage.label}` : ''}${s.error ? `: ${s.error}` : ''}`;
+    return fit([[`✗ ${title}`, paint(ANSI.red, `✗ ${title}`)], [why, paint(ANSI.red, why)]]);
+  }
+  if (s.state === 'stopped') return fit([[`■ ${title} stopped`, paint(ANSI.yellow, `■ ${title} stopped`)]]);
+
+  const width = columns < 70 ? 6 : 10;
+  const b = bar(s.percent, width);
+  const stage = s.stopping ? 'stopping…' : (s.stage?.label ?? 'Starting');
+  const progress = `${stage} ${b.done}${b.left} ${s.percent}%`;
+  const parts = [
+    [`▶ ${title}`, paint(ANSI.bold, `▶ ${title}`)],
+    [progress, `${paint(ANSI.cyan, stage)} ${paint(ANSI.green, b.done)}${paint(ANSI.dim, b.left)} ${s.percent}%`],
+  ];
+  if (s.checks.total) {
+    const text = `${s.checks.pass}/${s.checks.total} checks${s.checks.fail ? `, ${s.checks.fail} failing` : ''}`;
+    parts.push([text, paint(s.checks.fail ? ANSI.red : ANSI.dim, text)]);
+  }
+  if (s.spend.text) parts.push([s.spend.text, paint(ANSI.dim, s.spend.text)]);
+  return fit(parts);
+}
+
+/* ------------------------------------------------------------------ the setting */
+
+const LOCAL = join('.claude', 'settings.local.json');
+const readJson = (path) => { if (!existsSync(path)) return {}; return JSON.parse(readFileSync(path, 'utf8')); };
+/** Our own status line: a command that runs this toolkit's statusline. */
+export const isOurs = (statusLine) => typeof statusLine?.command === 'string' && /homie-studio|@homie-rocks[\\/]studio/.test(statusLine.command) && /statusline/.test(statusLine.command);
+
+/**
+ * The command the setting runs: this studio's pinned toolkit, by an absolute path (forward slashes, for Windows
+ * too). Set in another folder (the one Claude Code was started in, above the studio), it names the studio too.
+ */
+export function statusLineCommand(root, { named = false } = {}) {
+  const pinned = join(root, 'node_modules', '@homie-rocks', 'studio', 'bin', 'statusline.mjs');
+  const script = existsSync(pinned) ? pinned : join(PACKAGE_ROOT, 'bin', 'statusline.mjs');
+  const slash = (p) => p.replace(/\\/g, '/');
+  return `node "${slash(script)}"${named ? ` --studio "${slash(root)}"` : ''}`;
+}
+
+/** Every settings file that may already hold a status line for this studio, most specific first. */
+function settingsFiles(project, env) {
+  const user = env.CLAUDE_CONFIG_DIR ? join(env.CLAUDE_CONFIG_DIR, 'settings.json') : join(env.HOME || homedir(), '.claude', 'settings.json');
+  return [
+    { where: 'this project, this person (.claude/settings.local.json)', path: join(project, LOCAL) },
+    { where: 'this project (.claude/settings.json)', path: join(project, '.claude', 'settings.json') },
+    { where: 'every project of this person (the user settings)', path: user },
+  ];
+}
+
+/**
+ * `homie-studio statusline --install`: the status line in this studio's .claude/settings.local.json. It never
+ * replaces a status line the person already has (anywhere Claude Code would read one) unless `replace`.
+ * `remove`: take ours out again.
+ */
+export function installStatusLine(root, { replace = false, remove = false, project = null, env = process.env } = {}) {
+  // Claude Code reads project settings from the folder it was started in. A studio made as a subfolder of that
+  // folder is named in the command, and the setting goes where Claude Code reads it (`--project <that folder>`).
+  const here = project ? resolve(project) : root;
+  if (!existsSync(here)) return { ok: false, command: 'statusline install', why: `no folder ${here}` };
+  const files = settingsFiles(here, env);
+  const local = files[0].path;
+  let mine;
+  try { mine = readJson(local); } catch { return { ok: false, command: 'statusline install', why: `${LOCAL} is not valid JSON; fix it by hand first (nothing was changed)` }; }
+  if (remove) {
+    if (!isOurs(mine.statusLine)) return { ok: true, command: 'statusline remove', removed: false, message: 'No Homie status line in this studio; nothing changed.' };
+    delete mine.statusLine;
+    writeFileSync(local, `${JSON.stringify(mine, null, 2)}\n`);
+    return { ok: true, command: 'statusline remove', removed: true, file: LOCAL, message: `Removed the Homie status line from ${LOCAL}.` };
+  }
+  const command = statusLineCommand(root, { named: here !== root });
+  if (isOurs(mine.statusLine) && mine.statusLine.command === command) return { ok: true, command: 'statusline install', already: true, file: LOCAL, statusLine: mine.statusLine, message: 'The status line is already on in this studio.' };
+  if (!replace) {
+    for (const f of files) {
+      let s = null;
+      try { s = readJson(f.path).statusLine ?? null; } catch { s = null; }
+      if (s && !isOurs(s)) {
+        return { ok: false, command: 'statusline install', exists: { where: f.where, command: String(s.command ?? s.type ?? '').slice(0, 120) }, why: `there is already a status line (${f.where}). Nothing was changed. With --replace, this studio shows the build's progress instead (only here; the other one stays everywhere else).` };
+      }
+    }
+  }
+  mine.statusLine = { type: 'command', command, padding: 0, refreshInterval: 5 };
+  mkdirSync(join(here, '.claude'), { recursive: true });
+  writeFileSync(local, `${JSON.stringify(mine, null, 2)}\n`);
+  // Claude Code keeps settings.local.json out of git when it makes the file; this one we made, so say it here too.
+  const ignore = join(here, '.gitignore');
+  let ignored = false;
+  if (existsSync(ignore) || here === root) try {
+    const text = existsSync(ignore) ? readFileSync(ignore, 'utf8') : '';
+    if (!/^\.claude\/settings\.local\.json\s*$/m.test(text)) { writeFileSync(ignore, `${text}${text && !text.endsWith('\n') ? '\n' : ''}# This person's own Claude Code settings for this studio (the status line).\n.claude/settings.local.json\n`); ignored = true; }
+  } catch { /* no .gitignore to keep */ }
+  return {
+    ok: true, command: 'statusline install', file: here === root ? LOCAL : join(here, LOCAL), statusLine: mine.statusLine, gitignore: ignored,
+    message: `The status line is on ${here === root ? `in this studio (${LOCAL})` : `for Claude Code started in ${here} (${LOCAL} there)`}: one line under the prompt with the current build's stage, a progress bar, its checks and what it spent. Claude Code reloads settings by itself; it shows from the next message. Turn it off with: npx --no-install homie-studio statusline --remove`,
+  };
+}

package/lib/studio.mjs

@@ -26,6 +26,17 @@ export function requireStudio(from) {
   return root;
 }
 
+/*
+ * WHERE THE WORKER'S CONFIG LIVES. From 0.10.0 a new studio keeps `wrangler.jsonc` at its root, which is what
+ * Cloudflare's Workers Builds and its "Deploy to Cloudflare" button read (they run the studio's own `npm run build`
+ * and `npm run deploy` at the repository's root). A studio made before 0.10.0 keeps `site/wrangler.jsonc`; every
+ * command runs Wrangler next to whichever the studio has, so both keep working.
+ */
+export function workerDir(root) { return existsSync(join(root, 'wrangler.jsonc')) || !existsSync(join(root, 'site', 'wrangler.jsonc')) ? root : join(root, 'site'); }
+export function configPath(root) { return join(workerDir(root), 'wrangler.jsonc'); }
+/** 'root' (0.10.0 and later: Workers Builds ready) or 'site' (older studios). */
+export function layoutOf(root) { return workerDir(root) === root ? 'root' : 'site'; }
+
 export function readStudio(root) { return JSON.parse(readFileSync(join(root, 'studio.json'), 'utf8')); }
 export function writeStudio(root, studio) { writeFileSync(join(root, 'studio.json'), `${JSON.stringify(studio, null, 2)}\n`); }
 

package/lib/template-history.json

@@ -152,6 +152,53 @@
      "## Beta": "9d02638207a26e73"
     }
    }
+  },
+  "0.10.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)": "2af7c804c1e81d86",
+     "## The site": "7d3525ba39b7f262",
+     "## Making games": "c204473d9b468f49",
+     "## Rules": "969318425c99f5a5",
+     "## Beta": "9d02638207a26e73"
+    }
+   }
+  },
+  "0.11.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)": "2af7c804c1e81d86",
+     "## The site": "7d3525ba39b7f262",
+     "## Making games": "c204473d9b468f49",
+     "## The Game Codex and progress": "0738ef719cef3a4c",
+     "## Rules": "969318425c99f5a5",
+     "## Beta": "9d02638207a26e73"
+    }
+   }
   }
  }
 }

package/lib/version.mjs

@@ -8,10 +8,14 @@ import { readFileSync } from 'node:fs';
 const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
 export const STUDIO_VERSION = pkg.version;
 
-/** The pinned tarball of this version, on a Homie directory (homie.rocks by default). */
+/** The pinned tarball of this version, on a Homie directory (homie.rocks by default). Kept for older studios. */
 export function tarballUrl(base = 'https://homie.rocks', version = STUDIO_VERSION) {
   return `${String(base).replace(/\/+$/, '')}/npm/homie-studio-${version}.tgz`;
 }
 
-/** What a studio's package.json names: until @homie-rocks/studio is on the npm registry, its versioned tarball URL. */
-export function packageSpec(base) { return tarballUrl(base); }
+/**
+ * What a studio's package.json names: this exact version, from registry.npmjs.org (package-lock.json keeps its
+ * integrity). The public registry is what Cloudflare's Workers Builds and a Claude Code cloud session reach with
+ * their default network settings; a directory's /npm/ tarball is not.
+ */
+export function packageSpec() { return STUDIO_VERSION; }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@homie-rocks/studio",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "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",

package/worker/codex-script.mjs

@@ -0,0 +1,6 @@
+/**
+ * The Game Codex page's one script (lib/codex.mjs draws the page): its tabs, "Updated 5 s ago", and a reload every
+ * few seconds while a build runs in the local copy. Constant text with no data in it, so the site's private codex
+ * page (worker/stats-page.mjs) allows exactly this script by its hash and nothing else.
+ */
+export const CODEX_SCRIPT = `(function(){var d=document,t=[].slice.call(d.querySelectorAll('.tab')),n=[].slice.call(d.querySelectorAll('nav.tabs a'));if(!t.length)return;d.documentElement.classList.add('js');function show(id){var f=t.filter(function(s){return s.id===id})[0]||t.filter(function(s){return s.id===d.body.getAttribute('data-start')})[0]||t[0];t.forEach(function(s){s.classList.toggle('on',s===f)});n.forEach(function(a){a.classList.toggle('on',a.getAttribute('href')==='#'+f.id)});return f}var cur=show(location.hash.slice(1));var nav=d.querySelector('nav.tabs');window.addEventListener('hashchange',function(){cur=show(location.hash.slice(1));if(nav&&window.scrollY>nav.offsetTop)window.scrollTo(0,nav.offsetTop)});function ago(){[].forEach.call(d.querySelectorAll('[data-ago]'),function(e){var w=Date.parse(e.getAttribute('data-ago'));if(!w)return;var s=Math.max(0,Math.round((Date.now()-w)/1000));e.textContent='Updated '+(s<60?s+' s':s<3600?Math.round(s/60)+' min':Math.round(s/3600)+' h')+' ago'})}ago();setInterval(ago,1000);var st=d.getElementById('build-status');if(d.body.getAttribute('data-mode')==='file'&&st&&st.getAttribute('data-running')==='1')setTimeout(function(){if(cur===st)location.reload()},5000)})();`;

package/worker/index.mjs

@@ -90,9 +90,71 @@ async function postsOf(env, origin) {
   } catch { return []; }
 }
 
-async function claimOf(env) {
+/*
+ * THE SITE CLAIMS ITSELF IN THE DIRECTORY (0.10.0). The homie.rocks directory lists a studio only when its site
+ * serves the claim the directory handed out for that exact address, which proves the studio controls the site.
+ * Before 0.10.0 `homie-studio deploy` fetched the claim and stored it in D1 from the person's computer; a site built
+ * by Cloudflare's Workers Builds has no such step. So the site asks for its own claim the first time its manifest
+ * is read (by the directory publishing it, or `deploy` reading it once), for the address it is being read at, and
+ * keeps it in its D1 (`meta`, `homie_claim:<origin>`).
+ *
+ * It never asks from a Preview (HOMIE_PREVIEW: a Preview is a branch under review, not the studio), from a studio
+ * whose studio.json says `homie.directory: false`, or without its D1. A directory that does not answer is asked
+ * again at most once a minute per address; the page answers without a claim meanwhile.
+ */
+const CLAIM = /^[a-f0-9]{16,128}$/;
+const claimed = new Map();
+const claimMissed = new Map();
+
+async function storedClaim(env, origin) {
   if (!env.DB) return null;
-  try { return (await env.DB.prepare('SELECT value FROM meta WHERE key = ?').bind('homie_claim').first())?.value ?? null; } catch { return null; }
+  try {
+    const rows = (await env.DB.prepare('SELECT key, value FROM meta WHERE key IN (?1, ?2)').bind(`homie_claim:${origin}`, 'homie_claim').all()).results ?? [];
+    return { own: rows.find((r) => r.key === `homie_claim:${origin}`)?.value ?? null, older: rows.find((r) => r.key === 'homie_claim')?.value ?? null };
+  } catch { return null; }
+}
+
+export function directoryOf(cat) {
+  const d = cat?.studio?.directory;
+  if (d === null || d === false) return null;
+  const at = String(d ?? 'https://homie.rocks').replace(/\/+$/, '');
+  try {
+    const u = new URL(at);
+    return u.protocol === 'https:' || (u.protocol === 'http:' && ['127.0.0.1', 'localhost'].includes(u.hostname)) ? u.origin : null;
+  } catch { return null; }
+}
+
+/** This address's claim: kept, else asked of the directory now (and kept), else an older studio's single claim. */
+async function claimOf(env, cat, url) {
+  const origin = url.origin;
+  if (claimed.has(origin)) return claimed.get(origin);
+  const kept = await storedClaim(env, origin);
+  if (kept?.own) { claimed.set(origin, kept.own); return kept.own; }
+  const directory = directoryOf(cat);
+  const local = url.protocol === 'http:' && ['127.0.0.1', 'localhost'].includes(url.hostname);
+  const may = directory && env.DB && env.HOMIE_PREVIEW !== '1' && (url.protocol === 'https:' || (local && directory.startsWith('http://')))
+    && Date.now() - (claimMissed.get(origin) ?? 0) > 60_000;
+  if (may) {
+    try {
+      const res = await fetch(`${directory}/api/studio/claim?site=${encodeURIComponent(origin)}`, {
+        headers: { accept: 'application/json', 'user-agent': `homie-studio/${STUDIO_VERSION_TAG} (site claim)` }, signal: AbortSignal.timeout(5000),
+      });
+      const body = await res.json().catch(() => null);
+      if (res.ok && CLAIM.test(String(body?.claim ?? ''))) {
+        await env.DB.prepare('INSERT OR REPLACE INTO meta (key, value) VALUES (?1, ?2)').bind(`homie_claim:${origin}`, body.claim).run();
+        claimed.set(origin, body.claim);
+        return body.claim;
+      }
+    } catch { /* the directory is optional for a live site */ }
+    claimMissed.set(origin, Date.now());
+  }
+  return kept?.older ?? null;
+}
+
+/** A copy of the public template nobody has named yet shows the name typed into Cloudflare's form (STUDIO_NAME). */
+function named(cat, env) {
+  if (!cat?.studio?.template || !env.STUDIO_NAME) return cat;
+  return { ...cat, studio: { ...cat.studio, name: String(env.STUDIO_NAME).slice(0, 60) } };
 }
 
 /** Every public room with people in it, per game (the Lobby's list), and the number playing per game. */
@@ -303,8 +365,14 @@ async function route(request, env, ctx) {
   const parts = path.split('/').filter(Boolean);
   const read = request.method === 'GET' || request.method === 'HEAD';
   let catP = null;
-  const getCat = () => (catP ??= catalogue(env, url.origin));
+  const getCat = () => (catP ??= catalogue(env, url.origin).then((cat) => named(cat, env)));
 
+  // "Connect to Claude" (the template's first-run band): the directory's setup page, for this site's address.
+  if (path === '/_studio/connect' && read) {
+    const directory = directoryOf(await getCat());
+    if (!directory || env.HOMIE_PREVIEW === '1') return json({ ok: false, error: 'no-directory', message: 'This studio is not connected to a directory.' }, 404);
+    return Response.redirect(`${directory}/studio/setup/connect?site=${encodeURIComponent(url.origin)}`, 302);
+  }
   if (path.startsWith('/_studio/')) return ownerRoutes(request, env, url, { catalogueOf: getCat });
   if (path === '/__homie' || path.startsWith('/__homie/')) return notAHomie(request);
   if (path === '/_homie/site.js') return new Response(SITE_JS, { headers: { 'content-type': 'text/javascript; charset=utf-8', 'cache-control': url.searchParams.get('v') === STUDIO_VERSION_TAG ? 'public, max-age=31536000, immutable' : 'public, max-age=300', 'x-content-type-options': 'nosniff' } });
@@ -336,7 +404,10 @@ async function route(request, env, ctx) {
       ...(cat.studio?.tagline ? { tagline: cat.studio.tagline } : {}),
       site: url.origin,
       studio: cat.studio?.version ?? null,
-      claim: await claimOf(env),
+      claim: await claimOf(env, cat, url),
+      // What is deployed: the commit, when, and the marks of the newest changes (a merged pull request is live when
+      // its mark is here). A Preview says it is one.
+      ...(cat.studio?.build ? { build: { commit: cat.studio.build.commit ?? null, branch: cat.studio.build.branch ?? null, at: cat.studio.build.at ?? null, changes: (cat.studio.build.changes ?? []).slice(0, 50), ...(env.HOMIE_PREVIEW === '1' ? { preview: true } : {}) } } : {}),
       games: (cat.games ?? []).map((g) => {
         // The card picture is the landing's hero still (what the landing leads with), else the game's cover.
         const cover = gameCover(g);

package/worker/stats-page.mjs

@@ -8,6 +8,19 @@
  * never cached, never indexed.
  */
 import { OWNER_COOKIE, endSession, ownerAllowed, rangeOf, readStats, spendSignin, onlyOf } from './stats.mjs';
+import { CODEX_SCRIPT } from './codex-script.mjs';
+
+/** Where a sign-in may send the owner next: the stats, or one game's codex. */
+const NEXT = /^\/_studio\/(?:stats|codex\/[a-z0-9][a-z0-9-]{0,39}\/)$/;
+const nextOf = (url) => { const to = url.searchParams.get('to') ?? ''; return NEXT.test(to) ? to : '/_studio/stats'; };
+let scriptHash = null;
+async function codexScriptHash() {
+  if (!scriptHash) {
+    const digest = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(CODEX_SCRIPT));
+    scriptHash = `sha256-${btoa(String.fromCharCode(...new Uint8Array(digest)))}`;
+  }
+  return scriptHash;
+}
 
 const esc = (value) => String(value ?? '').replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[c]);
 const fmt = (n) => Number(n || 0).toLocaleString('en-US');
@@ -119,12 +132,12 @@ export async function ownerRoutes(request, env, url, { catalogueOf }) {
       // A GET spends nothing: a chat app's link preview must not use up the owner's one-time link.
       return page('Sign in · stats', `<h1>${esc(cat.studio?.name ?? 'Studio')} stats</h1>
 <p class="dim">Open this studio's private stats in this browser. The link works once.</p>
-<form method="post" action="/_studio/signin?k=${esc(encodeURIComponent(key))}"><button type="submit">Open the stats</button></form>`);
+<form method="post" action="/_studio/signin?k=${esc(encodeURIComponent(key))}${nextOf(url) !== '/_studio/stats' ? `&amp;to=${esc(encodeURIComponent(nextOf(url)))}` : ''}"><button type="submit">${nextOf(url).startsWith('/_studio/codex/') ? 'Open the codex' : 'Open the stats'}</button></form>`);
     }
     if (request.method !== 'POST' || !sameOrigin(request, url)) return page('Not allowed', '<h1>Not allowed</h1>', 403);
     const session = await spendSignin(env, key);
     if (!session) return page('Link used or expired', `<h1>That link has been used or has expired</h1><p class="note">A sign-in link works once, for 30 minutes. Ask your AI for a new one: <code>npx --no-install homie-studio stats link</code>.</p>`, 403);
-    return new Response(null, { status: 303, headers: { location: '/_studio/stats', 'cache-control': 'no-store', 'set-cookie': `${OWNER_COOKIE}=${session}; Path=/_studio/; HttpOnly; SameSite=Lax; Max-Age=${30 * 24 * 3600}${secure}` } });
+    return new Response(null, { status: 303, headers: { location: nextOf(url), 'cache-control': 'no-store', 'set-cookie': `${OWNER_COOKIE}=${session}; Path=/_studio/; HttpOnly; SameSite=Lax; Max-Age=${30 * 24 * 3600}${secure}` } });
   }
   if (path === '/_studio/signout') {
     if (request.method !== 'POST' || !sameOrigin(request, url)) return page('Not allowed', '<h1>Not allowed</h1>', 403);
@@ -140,5 +153,24 @@ export async function ownerRoutes(request, env, url, { catalogueOf }) {
     }
     return page(`Stats · ${cat.studio?.name ?? 'Studio'}`, statsBody(cat, stats, url));
   }
+  // A game's Game Codex (lib/codex.mjs, built into site/dist/_studio/codex/<id>/): the owner's only, never listed.
+  const codex = /^\/_studio\/codex\/([a-z0-9][a-z0-9-]{0,39})(\/|\/index\.html)?$/.exec(path);
+  if (codex) {
+    if (request.method !== 'GET' && request.method !== 'HEAD') return page('Not allowed', '<h1>Not allowed</h1>', 405);
+    if (!codex[2]) return new Response(null, { status: 301, headers: { location: `/_studio/codex/${codex[1]}/`, 'cache-control': 'no-store' } });
+    if ((await ownerAllowed(request, env, { kinds: ['session'] })) !== 'session') {
+      return page('Codex · private', `<h1>${esc(cat.studio?.name ?? 'Studio')}: Game Codex</h1>
+<p class="dim">A game's codex is for the studio's owner only.</p>
+<p class="note">To open it, the owner asks their AI in the studio's folder to run <code>npx --no-install homie-studio codex link ${esc(codex[1])}</code>. That uses the studio's own Cloudflare login, and gives a one-time link for this browser.</p>`, 401);
+    }
+    const res = env.ASSETS ? await env.ASSETS.fetch(new Request(`${url.origin}/_studio/codex/${codex[1]}/index.html`)) : null;
+    if (!res || !res.ok) return page('No codex yet', `<h1>No codex for this game yet</h1><p class="note">Its plan is <code>games/${esc(codex[1])}/CODEX.md</code> in the studio; the next <code>npm run deploy</code> puts it here.</p>`, 404);
+    return new Response(request.method === 'HEAD' ? null : await res.text(), {
+      headers: {
+        ...PRIVATE_HEADERS,
+        'content-security-policy': `default-src 'none'; style-src 'unsafe-inline' https://fonts.googleapis.com; font-src https://fonts.gstatic.com data:; img-src data:; script-src '${await codexScriptHash()}'; form-action 'none'; frame-ancestors 'none'; base-uri 'none'`,
+      },
+    });
+  }
   return page('Not found', '<h1>Not found</h1>', 404);
 }

package/worker/version.mjs

@@ -1,2 +1,2 @@
 /** The @homie-rocks/studio version this Worker code is (package.json's; a test keeps them equal). Cache-busts /_homie/site.js. */
-export const STUDIO_VERSION_TAG = '0.9.0';
+export const STUDIO_VERSION_TAG = '0.11.0';