@homie-rocks/studio 0.3.0 → 0.6.0

package/netplay/netplay.ts

@@ -161,6 +161,8 @@ export interface NetStats {
   snapHzOut: number;
   inputHzIn: number;
   inputHzOut: number;
+  /** Idle input frames not sent (identical to the last one, inside the keepalive interval). */
+  idleInputsSkipped?: number;
   lastSnapBytes: number;
   maxSnapBytes: number;
   bytesInPerS: number;
@@ -507,6 +509,13 @@ const IN_SLOW_CAP_PER_S = 15;
 const IN_SLOW_MS = 8000;
 /** A socket with this much still unsent does not queue another input frame (the newest one waits instead). */
 const IN_BACKLOG_BYTES = 2048;
+/**
+ * An input frame identical to the last one sent (same avatar or intent, same held keys, no press, same reset epoch)
+ * goes out at most this often: a player standing still says so four times a second, not twenty. The host already
+ * holds that frame, so nothing it reads changes; every incoming socket message is a Durable Object request
+ * (billed 20:1), and in a 32-seat room the replicas' inputs are nearly all of them (NETPLAY.md §11).
+ */
+const IDLE_INPUT_MS = 250;
 
 function heldList(held: Iterable<string> | Record<string, boolean> | undefined): string[] {
   if (!held) return [];
@@ -635,9 +644,12 @@ export function createNetplay<S = unknown, A = unknown, C = unknown>(opts: Netpl
   let prevHeld = new Set<string>();
   let pendingPresses: Record<string, number> = {};
   let inputTimer: ReturnType<typeof setTimeout> | null = null;
+  /** The last input frame sent, as text (idle frames repeat it at most every IDLE_INPUT_MS). */
+  let lastInputSig = '';
   /** Wall times of the input frames sent in the last second, and until when the slow cap holds. */
   const inSent: number[] = [];
   let inSlowUntil = 0;
+  let idleSkipped = 0;
   /** Why this client stopped for good (a FINAL_ERRORS refusal), or null while it plays or reconnects. */
   let closedWhy: string | null = null;
   /** Wall time the socket went down (0 while connected): how long a reconnect has taken. */
@@ -1071,12 +1083,17 @@ export function createNetplay<S = unknown, A = unknown, C = unknown>(opts: Netpl
     const budget = inputBudgetWait();
     const backlog = (ws?.bufferedAmount ?? 0) > IN_BACKLOG_BYTES;
     if (budget > 0 || backlog) { inputTimer = setTimeout(flushInput, backlog ? Math.max(budget, 30) : budget); return; }
+    // Standing still: the host has this exact frame already. Say it again only as a keepalive.
+    const pressed = Object.keys(pendingPresses).length > 0;
+    let sig = '';
+    try { sig = JSON.stringify([pendingA, pendingHeld, mine.rs]); } catch { sig = ''; }
+    if (!pressed && sig && sig === lastInputSig && wall() - lastInputSentAt < IDLE_INPUT_MS) { idleSkipped += 1; return; }
     inSent.push(wall());
     inSeq += 1;
     const msg: Record<string, unknown> = { t: 'in', q: inSeq, a: pendingA, h: pendingHeld, r: mine.rs };
     if (Object.keys(pendingPresses).length) msg['p'] = pendingPresses;
     if (raw(msg)) {
-      inputOut.hit(wall()); pendingPresses = {};
+      inputOut.hit(wall()); pendingPresses = {}; lastInputSig = sig;
       sentHist.push({ q: inSeq, a: pendingA, h: pendingHeld, at: wall(), r: mine.rs });
       if (sentHist.length > 64) sentHist.shift();
     }
@@ -1095,7 +1112,7 @@ export function createNetplay<S = unknown, A = unknown, C = unknown>(opts: Netpl
     const t = wall();
     return {
       role, seat, host, connected, offline, rtt, offset: Math.round(offset),
-      snapHzIn: snapIn.hz(t), snapHzOut: snapOut.hz(t), inputHzIn: inputIn.hz(t), inputHzOut: inputOut.hz(t),
+      snapHzIn: snapIn.hz(t), snapHzOut: snapOut.hz(t), inputHzIn: inputIn.hz(t), inputHzOut: inputOut.hz(t), idleInputsSkipped: idleSkipped,
       lastSnapBytes, maxSnapBytes, bytesInPerS: perSecond(bytesIn), bytesOutPerS: perSecond(bytesOut),
       interpDelay: Math.round(interpDelay()), snapAgeP90: Math.round(ageP90), starvedPct: +starvedPct.toFixed(3), rejectedSnaps,
       owned: api.owned, pending: sentHist.length, stateKeys: stateMap.size,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@homie-rocks/studio",
-  "version": "0.3.0",
-  "description": "A game studio 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, D1, R2), deploy, and the homie.rocks directory.",
+  "version": "0.6.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), song and video pages from the music/ and videos/ manifests, optional R2 storage for large media, deploy, and the homie.rocks directory.",
   "type": "module",
   "license": "Apache-2.0",
   "homepage": "https://homie.rocks/studio/",
@@ -36,6 +36,7 @@
     "port/",
     "worker/",
     "starters/",
+    "media/",
     "README.md",
     "LICENSE",
     "NOTICE"

package/worker/index.mjs

@@ -15,23 +15,40 @@
  *   /<game>/api/lobby          which public room to join (Lobby Durable Object)
  *   /api/games                 the catalogue plus live counts (D1 + Lobby)
  *   /.well-known/homie-studio.json   what the homie.rocks directory reads
- *   /media/<key>               the studio's large media, from R2 (when bound)
+ *   /music/, /music/<slug>/    the studio's songs, scores and loops (music/manifest.json)
+ *   /videos/, /videos/<slug>/  its trailers, music videos and cutscenes (videos/manifest.json)
+ *   /media/<key>               the studio's large media, from R2 (once `storage add` bound it), with byte ranges
+ *   /api/stats                 the studio's numbers, for its owner only (a read key, or the owner's page session)
+ *   /_studio/stats             the owner's private stats page (one-time sign-in link from `homie-studio stats link`)
+ *
+ * It counts, and never tracks (worker/stats.mjs): a page opened, a Play press, a room opened, a round finished,
+ * the peak of players, a song or video started, and which site sent the visitor (a host name), as daily counters
+ * in the studio's own D1. No cookie on a visitor, nothing sent anywhere.
  *
  * Bindings (site/wrangler.jsonc, written by `homie-studio new`): ASSETS (the
  * built site), TABLE and LOBBY (SQLite-backed Durable Objects, free plan
- * friendly), DB (D1: plays, finished rounds, the directory claim) and, when
- * the account has R2, MEDIA.
+ * friendly), DB (D1: plays, finished rounds, the directory claim) and, only
+ * after `homie-studio storage add` (R2 needs a payment method on the account),
+ * MEDIA. Everything else runs on Cloudflare's free Workers plan.
  *
- * The relay is the netplay contract's own room.mjs (NETPLAY.md v1 rev 2), run
+ * The relay is the netplay contract's own room.mjs (NETPLAY.md v1 rev 3), run
  * unchanged inside the Table, so a game that plays in `homie-studio dev`
  * plays the same way here.
  */
 import { NetRoom } from './room.mjs';
-import { gamePage, homePage, notFoundPage, playPage } from './pages.mjs';
+import { gamePage, homePage, mediaIndexPage, notFoundPage, playPage, songPage, videoPage } from './pages.mjs';
 import { qrSvg } from './qr.mjs';
+import { SEAT_MAX, perAddress, seatsOf } from './seats.mjs';
+import { count, countVisit, counter, isQa, onlyOf, ownerAllowed, playedThisWeek, rangeOf, readStats, today } from './stats.mjs';
+import { ownerRoutes } from './stats-page.mjs';
+
+export { SEAT_MAX } from './seats.mjs';
+/** For a studio's own wrapper Worker: count its own pages the way the template counts its pages. */
+export { countVisit } from './stats.mjs';
 
 const GAME_ID = /^[a-z0-9][a-z0-9-]{0,39}$/;
 const ROOM_ID = /^[A-Za-z0-9_-]{1,32}$/;
+
 const json = (body, status = 200, extra = {}) => new Response(`${JSON.stringify(body)}\n`, {
   status, headers: { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store', ...extra },
 });
@@ -62,6 +79,71 @@ async function liveCounts(env, games) {
   return out;
 }
 
+const MEDIA_SLUG = /^[a-z0-9][a-z0-9-]{0,39}$/;
+
+/** `bytes=a-b`, `bytes=a-`, `bytes=-n` against a length, or null (a malformed or multi-range header is served whole). */
+function parseRange(header, size) {
+  const m = /^bytes=(\d*)-(\d*)$/.exec(String(header ?? '').trim());
+  if (!m || (m[1] === '' && m[2] === '')) return null;
+  let start; let end;
+  if (m[1] === '') { const n = Number(m[2]); start = Math.max(0, size - n); end = size - 1; }
+  else { start = Number(m[1]); end = m[2] === '' ? size - 1 : Math.min(Number(m[2]), size - 1); }
+  if (!(start <= end) || start >= size) return { unsatisfiable: true };
+  return { start, end };
+}
+
+/** A media file from the site's own assets, answering a byte range (phones seek audio and video with them). */
+async function assetWithRange(request, env, url) {
+  const res = await env.ASSETS.fetch(new Request(url.toString(), { method: 'GET' }));
+  const range = request.headers.get('range');
+  if (!res.ok || !range || res.status === 206) return res;
+  const body = new Uint8Array(await res.arrayBuffer());
+  const r = parseRange(range, body.byteLength);
+  const headers = new Headers(res.headers);
+  headers.set('accept-ranges', 'bytes');
+  if (!r) return new Response(body, { status: 200, headers });
+  if (r.unsatisfiable) { headers.set('content-range', `bytes */${body.byteLength}`); return new Response(null, { status: 416, headers }); }
+  headers.set('content-range', `bytes ${r.start}-${r.end}/${body.byteLength}`);
+  headers.set('content-length', String(r.end - r.start + 1));
+  return new Response(body.subarray(r.start, r.end + 1), { status: 206, headers });
+}
+
+/** A file from the studio's R2 bucket, with byte ranges. */
+async function mediaObject(request, env, key) {
+  const range = request.headers.get('range');
+  let head = null;
+  if (range) head = await env.MEDIA.head(key);
+  if (range && !head) return new Response('not found', { status: 404 });
+  const r = head ? parseRange(range, head.size) : null;
+  if (r?.unsatisfiable) return new Response(null, { status: 416, headers: { 'content-range': `bytes */${head.size}` } });
+  const obj = await env.MEDIA.get(key, r ? { range: { offset: r.start, length: r.end - r.start + 1 } } : undefined);
+  if (!obj) return new Response('not found', { status: 404 });
+  const headers = new Headers();
+  obj.writeHttpMetadata(headers);
+  headers.set('etag', obj.httpEtag);
+  headers.set('cache-control', 'public, max-age=3600');
+  headers.set('accept-ranges', 'bytes');
+  if (r) {
+    headers.set('content-range', `bytes ${r.start}-${r.end}/${head.size}`);
+    headers.set('content-length', String(r.end - r.start + 1));
+    return new Response(obj.body, { status: 206, headers });
+  }
+  headers.set('content-length', String(obj.size));
+  return new Response(obj.body, { headers });
+}
+
+/** A catalogue media row as the directory reads it (absolute addresses). */
+function mediaRow(e, origin, kind) {
+  const abs = (u) => (u && u.startsWith('/') ? `${origin}${u}` : u ?? null);
+  const main = (e.files ?? []).find((f) => f.role === (kind === 'music' ? 'audio' : 'video'));
+  const art = (e.files ?? []).find((f) => f.role === (kind === 'music' ? 'cover' : 'poster'));
+  return {
+    slug: e.slug, kind: e.kind, title: e.title, blurb: e.blurb ?? '', duration: e.duration ?? null,
+    page: `${origin}/${kind}/${e.slug}/`, [kind === 'music' ? 'audio' : 'video']: abs(main?.url), [kind === 'music' ? 'cover' : 'poster']: abs(art?.url),
+    credits: e.credits ?? null, rights: e.rights ?? null, for: e.for ?? null,
+  };
+}
+
 /** The game's index.html with HOMIE_NET ahead of its modules, in the site's sandbox (an opaque origin). */
 async function gameDocument(request, env, url, game, meta) {
   const res = await env.ASSETS.fetch(new Request(`${url.origin}/games/${game}/index.html`));
@@ -104,14 +186,62 @@ async function gameAsset(env, url, game, rest) {
   return out;
 }
 
+/**
+ * A studio that shares its "played this week" (studio.json `stats.share`) asks the directory to re-read its
+ * manifest once a day per Worker instance: the directory reads the number from the studio's own site, so nothing
+ * it is told can be forged by anyone else. Nothing else is ever sent.
+ */
+let sharedDay = null;
+function shareDaily(cat, url, ctx) {
+  if (!cat.studio?.stats?.share || url.protocol !== 'https:' || sharedDay === today()) return;
+  sharedDay = today();
+  const directory = String(cat.studio.directory ?? 'https://homie.rocks').replace(/\/+$/, '');
+  const ping = fetch(`${directory}/api/studio/played`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ site: url.origin }) }).catch(() => {});
+  if (ctx?.waitUntil) ctx.waitUntil(ping);
+}
+
+/** A song's or video's player started (the page's one beacon, sent once per page): one counter. */
+async function mediaBeat(request, env, ctx, url) {
+  const site = request.headers.get('sec-fetch-site');
+  const origin = request.headers.get('origin');
+  if (origin && origin !== 'null' ? origin !== url.origin : site !== 'same-origin') return new Response(null, { status: 403 });
+  if (Number(request.headers.get('content-length') ?? 0) > 256) return new Response(null, { status: 413 });
+  let body = null;
+  try { body = JSON.parse(await request.text()); } catch { return new Response(null, { status: 400 }); }
+  const kind = body?.k === 'song' || body?.k === 'video' ? body.k : null;
+  const slug = typeof body?.s === 'string' && MEDIA_SLUG.test(body.s) ? body.s : null;
+  if (!kind || !slug) return new Response(null, { status: 400 });
+  const cat = await catalogue(env, url.origin);
+  const known = (kind === 'song' ? cat.songs : cat.videos) ?? [];
+  if (!known.some((e) => e.slug === slug)) return new Response(null, { status: 404 });
+  if (!isQa(request)) await count(env, ctx, { metric: kind, subject: slug }); // house QA is never counted
+  return new Response(null, { status: 204, headers: { 'cache-control': 'no-store' } });
+}
+
 export default {
-  async fetch(request, env) {
+  async fetch(request, env, ctx) {
     const url = new URL(request.url);
     const path = url.pathname;
     const parts = path.split('/').filter(Boolean);
 
+    if (path.startsWith('/_studio/')) return ownerRoutes(request, env, url, { catalogueOf: () => catalogue(env, url.origin) });
+    if (path === '/api/stats/beat' && request.method === 'POST') return mediaBeat(request, env, ctx, url);
+    if (path === '/api/stats') {
+      if (request.method !== 'GET') return json({ ok: false, error: 'method' }, 405);
+      if ((await ownerAllowed(request, env, { kinds: ['read'] })) !== 'read') {
+        return json({ ok: false, error: 'owner-only', message: 'The studio\'s numbers are for its owner. In the studio folder: `npx --no-install homie-studio stats` prints them; `npx --no-install homie-studio stats key` gives a read key for the Homie MCP tool studio_stats.' }, 401, { 'www-authenticate': 'Bearer' });
+      }
+      const cat = await catalogue(env, url.origin);
+      const studios = new Set(String(url.searchParams.get('studios') ?? '').split(',').filter((h) => /^[a-z0-9.-]{3,80}$/.test(h)).slice(0, 500));
+      try {
+        return json({ ok: true, site: url.origin, ...(await readStats(env, cat, { range: rangeOf(url.searchParams), only: onlyOf(url.searchParams), studios })) });
+      } catch (error) {
+        return json({ ok: false, error: 'no-stats', message: `The counters are not in this studio's D1 yet: \`npm run deploy\` applies migration 0002_studio_stats.sql. (${String(error?.message ?? error).slice(0, 120)})` }, 503);
+      }
+    }
     if (path === '/.well-known/homie-studio.json') {
       const cat = await catalogue(env, url.origin);
+      const played = cat.studio?.stats?.share ? await playedThisWeek(env) : null;
       return json({
         v: 1,
         kind: 'homie-studio',
@@ -124,6 +254,10 @@ export default {
           id: g.id, name: g.name, blurb: g.blurb ?? '', players: g.players ?? null, roundSeconds: g.roundSeconds ?? null,
           page: `${url.origin}/${g.id}/`, play: `${url.origin}/${g.id}/play`, cover: g.cover ? `${url.origin}/games/${g.id}/${g.cover}` : null,
         })),
+        songs: (cat.songs ?? []).map((e) => mediaRow(e, url.origin, 'music')),
+        videos: (cat.videos ?? []).map((e) => mediaRow(e, url.origin, 'videos')),
+        // Shared only when studio.json says `stats.share`: two numbers for the whole studio, for the hub.
+        ...(played ? { played } : {}),
       }, 200, { 'access-control-allow-origin': '*' });
     }
     if (path === '/api/games') {
@@ -133,16 +267,32 @@ export default {
     if (path.startsWith('/media/')) {
       if (!env.MEDIA) return new Response('this studio keeps no media in R2 yet', { status: 404 });
       const key = decodeURIComponent(path.slice('/media/'.length));
-      const obj = await env.MEDIA.get(key);
-      if (!obj) return new Response('not found', { status: 404 });
-      const headers = new Headers();
-      obj.writeHttpMetadata(headers);
-      headers.set('etag', obj.httpEtag);
-      headers.set('cache-control', 'public, max-age=3600');
-      return new Response(obj.body, { headers });
+      if (!key || key.includes('..')) return new Response('not found', { status: 404 });
+      return mediaObject(request, env, key);
+    }
+    if (parts[0] === 'music' || parts[0] === 'videos') {
+      const kind = parts[0];
+      if (parts.length === 1 && !path.endsWith('/')) return Response.redirect(`${url.origin}/${kind}/`, 301);
+      const cat = await catalogue(env, url.origin);
+      if (parts.length === 1) { await countVisit(request, env, ctx, kind); return mediaIndexPage(cat, kind); }
+      const slug = parts[1];
+      const list = (kind === 'music' ? cat.songs : cat.videos) ?? [];
+      const entry = MEDIA_SLUG.test(slug) ? list.find((e) => e.slug === slug) : null;
+      if (parts.length === 2) {
+        if (!entry) return notFoundPage(`No ${kind === 'music' ? 'song' : 'video'} called "${slug}" here.`);
+        if (!path.endsWith('/')) return Response.redirect(`${url.origin}/${kind}/${slug}/`, 301);
+        await countVisit(request, env, ctx, `${kind}/${slug}`);
+        return kind === 'music' ? songPage(cat, entry, url.origin) : videoPage(cat, entry, url.origin);
+      }
+      if (parts.some((p) => p === '..')) return notFoundPage('Nothing here.');
+      const file = await assetWithRange(request, env, url);
+      if (file.status === 404) return notFoundPage('Nothing here.');
+      return file;
     }
     if (path === '/' || path === '/index.html') {
       const cat = await catalogue(env, url.origin);
+      await countVisit(request, env, ctx, 'home');
+      shareDaily(cat, url, ctx);
       return homePage(cat, await liveCounts(env, cat.games ?? []));
     }
 
@@ -153,13 +303,14 @@ export default {
       if (!meta) return env.ASSETS.fetch(request);
       if (parts.length === 1 && !path.endsWith('/')) return Response.redirect(`${url.origin}/${game}/`, 301);
       const sub = parts.slice(1).join('/');
-      if (sub === '') return gamePage(cat, meta, (await liveCounts(env, [meta]))[game] ?? 0);
+      if (sub === '') { await countVisit(request, env, ctx, game); shareDaily(cat, url, ctx); return gamePage(cat, meta, (await liveCounts(env, [meta]))[game] ?? 0); }
       if (sub === 'tv' || (sub === 'play' && url.searchParams.get('screen') === '1')) {
+        await countVisit(request, env, ctx, game, 'screen');
         // The big screen picks its room now, so the QR it shows puts every phone in that same room.
         let room = ROOM_ID.test(url.searchParams.get('room') || '') ? url.searchParams.get('room') : null;
         if (!room) {
           try {
-            const max = Math.max(1, Math.min(16, Number(meta.players?.max) || 8));
+            const max = seatsOf(meta);
             room = (await (await env.LOBBY.get(env.LOBBY.idFromName(game)).fetch(`https://lobby/join?max=${max}`, { method: 'POST' })).json()).room ?? null;
           } catch { room = null; }
         }
@@ -168,9 +319,9 @@ export default {
         try { qr = qrSvg(joinUrl, { title: `Join ${meta.name ?? game}` }); } catch { /* too long for a QR: the address shows as text */ }
         return playPage(cat, meta, { screen: true, joinUrl, qr, room });
       }
-      if (sub === 'play') return playPage(cat, meta);
+      if (sub === 'play') { await countVisit(request, env, ctx, game, 'play'); shareDaily(cat, url, ctx); return playPage(cat, meta); }
       if (sub === 'api/lobby') {
-        const max = Math.max(1, Math.min(16, Number(meta.players?.max) || 8));
+        const max = seatsOf(meta);
         return env.LOBBY.get(env.LOBBY.idFromName(game)).fetch(`https://lobby/join?max=${max}`, { method: 'POST' });
       }
       if (sub === '__net' || sub === '__watch') {
@@ -178,7 +329,7 @@ export default {
         const room = url.searchParams.get('room') || 'main';
         if (!ROOM_ID.test(room)) return new Response('bad room', { status: 400 });
         const stub = env.TABLE.get(env.TABLE.idFromName(`${game}/${room}`));
-        const max = Math.max(1, Math.min(16, Number(meta.players?.max) || 8));
+        const max = seatsOf(meta);
         const target = `https://table/${sub}?game=${encodeURIComponent(game)}&room=${encodeURIComponent(room)}&max=${max}`;
         return stub.fetch(new Request(target, request));
       }
@@ -211,6 +362,8 @@ export class Table {
     this.code = null;
     this.recorded = 0;
     this.lastReport = -1;
+    /** This room was counted as opened (worker/stats.mjs `room`); cleared when its seats are all forgotten. */
+    this.openCounted = false;
     ctx.blockConcurrencyWhile(async () => {
       this.saved = (await ctx.storage.get('net')) ?? null;
       this.recorded = (await ctx.storage.get('recorded')) ?? 0;
@@ -225,6 +378,7 @@ export class Table {
     this.room = new NetRoom({
       code,
       maxPlayers: max,
+      perIp: perAddress(max),
       store: {
         save: (o) => { storage.put('net', o).catch(() => {}); },
         clear: () => { storage.delete('net').catch(() => {}); },
@@ -238,12 +392,14 @@ export class Table {
     const url = new URL(request.url);
     const game = url.searchParams.get('game');
     const code = url.searchParams.get('room');
-    const max = Math.max(1, Math.min(16, Number(url.searchParams.get('max')) || 8));
+    const max = Math.max(1, Math.min(SEAT_MAX, Math.floor(Number(url.searchParams.get('max'))) || 8));
     const room = this.roomFor(game, code, max);
     const [client, server] = Object.values(new WebSocketPair());
     server.accept();
     const conn = {
       ip: request.headers.get('cf-connecting-ip'),
+      // House QA and `homie-studio check` mark their browsers; their rooms, rounds and peaks are not the studio's numbers.
+      qa: isQa(request),
       send: (text) => { try { server.send(text); } catch { /* closed */ } },
       close: (c, r) => { try { server.close(c, r); } catch { /* closed */ } },
       buffered: () => 0,
@@ -254,7 +410,17 @@ export class Table {
       server.addEventListener('error', () => w.onClose());
     } else {
       const h = room.attach(conn);
-      server.addEventListener('message', (e) => { h.onMessage(typeof e.data === 'string' ? e.data : ''); });
+      // A room is OPENED when the first seat is taken in an empty one (a room restored after a deploy keeps its
+      // seats, so it is not counted twice). One counter write per room.
+      const fresh = room.seats.size === 0;
+      server.addEventListener('message', (e) => {
+        h.onMessage(typeof e.data === 'string' ? e.data : '');
+        if (fresh && !this.openCounted && room.seats.size > 0) {
+          this.openCounted = true;
+          if (conn.qa) return;
+          this.ctx.waitUntil(count(this.env, null, { metric: 'room', subject: this.game ?? '', source: /^pub-\d+$/.test(this.code ?? '') ? 'public' : 'named' }));
+        }
+      });
       server.addEventListener('close', () => { h.onClose(); this.report(); });
       server.addEventListener('error', () => { h.onClose(); this.report(); });
     }
@@ -271,6 +437,7 @@ export class Table {
       room.tick();
       n += 1;
       if (n % 4 === 0) { room.tellWatchers(); this.report(); this.recordRound(); }
+      if (room.seats.size === 0 && room.clients.size === 0) this.openCounted = false;
       if (room.clients.size === 0 && room.watchers.size === 0) { clearInterval(this.timer); this.timer = null; this.report(); }
     }, 250);
   }
@@ -280,10 +447,16 @@ export class Table {
     const room = this.room;
     if (!room || !this.game) return;
     const players = room.facts().counts.players;
-    if (players === this.lastReport) return;
+    // People for the stats: seated sockets that are not house QA (players is what the Lobby matches strangers by).
+    let people = 0;
+    for (const c of room.clients.values()) if (c.helloed && c.seat !== null && !c.conn?.qa) people += 1;
+    // On a change, and once a minute while anybody is here (so the Lobby's "playing now" forgets a room that died).
+    if (players === this.lastReport && people === this.lastPeople && (!players || Date.now() - (this.lastReportAt ?? 0) < 60_000)) return;
     this.lastReport = players;
+    this.lastPeople = people;
+    this.lastReportAt = Date.now();
     const lobby = this.env.LOBBY.get(this.env.LOBBY.idFromName(this.game));
-    this.ctx.waitUntil(lobby.fetch('https://lobby/report', { method: 'POST', body: JSON.stringify({ room: this.code, players }) }).catch(() => {}));
+    this.ctx.waitUntil(lobby.fetch(`https://lobby/report?game=${encodeURIComponent(this.game)}`, { method: 'POST', body: JSON.stringify({ room: this.code, players, people }) }).catch(() => {}));
   }
 
   /** A round the host called over becomes one D1 row (once per round number). */
@@ -292,11 +465,16 @@ export class Table {
     if (!r || r.phase !== 'over' || !Number.isFinite(r.n) || r.n <= this.recorded || !this.env.DB) return;
     this.recorded = r.n;
     this.ctx.storage.put('recorded', r.n).catch(() => {});
-    const results = Array.isArray(r.results) ? r.results.slice(0, 16) : [];
+    const results = Array.isArray(r.results) ? r.results.slice(0, SEAT_MAX * 2) : [];
     const humans = results.filter((row) => row && !row.bot).length;
-    this.ctx.waitUntil(this.env.DB.prepare(
-      'INSERT OR IGNORE INTO rounds (game, room, n, humans, bots, results, at) VALUES (?, ?, ?, ?, ?, ?, ?)',
-    ).bind(this.game, this.code, r.n, humans, results.length - humans, JSON.stringify(results), new Date().toISOString()).run().catch(() => {}));
+    // A round played only by house QA (every seated socket is marked) is kept in `rounds`, not in the stats.
+    const qaOnly = [...this.room.clients.values()].filter((c) => c.helloed && c.seat !== null).every((c) => c.conn?.qa);
+    const db = this.env.DB;
+    const insert = db.prepare('INSERT OR IGNORE INTO rounds (game, room, n, humans, bots, results, at) VALUES (?, ?, ?, ?, ?, ?, ?)')
+      .bind(this.game, this.code, r.n, humans, results.length - humans, JSON.stringify(results), new Date().toISOString());
+    // The round and the people in it, on the studio's daily counters (worker/stats.mjs). One batch, per round.
+    const counters = qaOnly ? [] : [counter(this.env, { metric: 'round', subject: this.game ?? '', source: humans ? 'people' : 'bots' }), humans ? counter(this.env, { metric: 'humans', subject: this.game ?? '', n: humans }) : null].filter(Boolean);
+    this.ctx.waitUntil(db.batch([insert, ...counters]).catch(() => insert.run().catch(() => {})));
   }
 }
 
@@ -307,16 +485,40 @@ export class Table {
  * in the same room.
  */
 export class Lobby {
-  constructor(ctx) {
+  constructor(ctx, env) {
     this.ctx = ctx;
+    this.env = env;
     this.rooms = new Map();
     this.next = 1;
+    /** Every room of this game that reported players (public and named), for "playing now" and the day's peak. */
+    this.live = new Map();
+    this.peak = { day: null, players: 0, room: 0 };
     ctx.blockConcurrencyWhile(async () => {
       const saved = await ctx.storage.get('lobby');
       if (saved) { this.next = saved.next ?? 1; for (const r of saved.rooms ?? []) this.rooms.set(r.name, { ...r, pending: [] }); }
     });
   }
 
+  /**
+   * The day's peak for this game, all rooms together and in one room: a counter write only when a new high is
+   * reached (in memory per day; after an eviction the stored max still wins), so at most a few a day.
+   */
+  notePeak(room, players, game) {
+    const now = Date.now();
+    if (players > 0) this.live.set(room, { players, at: now }); else this.live.delete(room);
+    for (const [name, r] of this.live) if (now - r.at > 180_000) this.live.delete(name); // a room that stopped reporting
+    const day = today();
+    if (this.peak.day !== day) this.peak = { day, players: 0, room: 0 };
+    let all = 0;
+    for (const r of this.live.values()) all += r.players;
+    const writes = [];
+    if (all > this.peak.players) { this.peak.players = all; writes.push(counter(this.env, { metric: 'peak', subject: game ?? this.game ?? '', n: all, day })); }
+    if (players > this.peak.room) { this.peak.room = players; writes.push(counter(this.env, { metric: 'peak-room', subject: game ?? this.game ?? '', n: players, day })); }
+    if (game) this.game = game;
+    const list = writes.filter(Boolean);
+    if (list.length) this.ctx.waitUntil(this.env.DB.batch(list).catch(() => {}));
+  }
+
   save() { this.ctx.storage.put('lobby', { next: this.next, rooms: [...this.rooms.values()].map(({ name, players, at }) => ({ name, players, at })) }).catch(() => {}); }
 
   prune(now) {
@@ -331,7 +533,7 @@ export class Lobby {
     const now = Date.now();
     this.prune(now);
     if (url.pathname === '/join') {
-      const max = Math.max(1, Math.min(16, Number(url.searchParams.get('max')) || 8));
+      const max = Math.max(1, Math.min(SEAT_MAX, Math.floor(Number(url.searchParams.get('max'))) || 8));
       let best = null;
       for (const r of this.rooms.values()) {
         const fill = r.players + r.pending.length;
@@ -351,18 +553,25 @@ export class Lobby {
     if (url.pathname === '/report' && request.method === 'POST') {
       const body = await request.json().catch(() => ({}));
       if (typeof body.room !== 'string' || !ROOM_ID.test(body.room)) return json({ ok: false }, 400);
+      this.notePeak(body.room, Math.max(0, Math.floor(Number(body.people ?? body.players) || 0)), url.searchParams.get('game'));
       // Only public rooms the Lobby made are matched with strangers; a named room (?room=) stays private.
       if (!this.rooms.has(body.room) && !/^pub-\d+$/.test(body.room)) return json({ ok: true, private: true });
       const r = this.rooms.get(body.room) ?? { name: body.room, players: 0, at: now, pending: [] };
       const grew = Math.max(0, (Number(body.players) || 0) - r.players);
+      const changed = !this.rooms.has(r.name) || r.players !== Math.max(0, Number(body.players) || 0);
       r.pending.splice(0, grew);
       r.players = Math.max(0, Number(body.players) || 0);
       r.at = now;
       this.rooms.set(r.name, r);
-      this.save();
+      if (changed) this.save(); // the minute's "still here" report writes nothing
       return json({ ok: true });
     }
     if (url.pathname === '/rooms') return json({ rooms: [...this.rooms.values()].map(({ name, players, at }) => ({ name, players, at })) });
+    if (url.pathname === '/now') {
+      let players = 0;
+      for (const [name, r] of this.live) { if (Date.now() - r.at > 180_000) this.live.delete(name); else players += r.players; }
+      return json({ players, rooms: this.live.size, peak: this.peak.day === today() ? { players: this.peak.players, room: this.peak.room } : { players: 0, room: 0 } });
+    }
     return json({ error: 'not found' }, 404);
   }
 }