@homie-rocks/studio 0.46.0 → 0.46.2

package/lib/crowd-worker.mjs

@@ -0,0 +1,496 @@
+/** Load clients live on worker threads; every snapshot is decoded, no per-frame diagnostic re-encoding. */
+import { parentPort, workerData } from 'node:worker_threads';
+import { randomBytes } from 'node:crypto';
+import { performance, monitorEventLoopDelay } from 'node:perf_hooks';
+import WebSocket from 'ws';
+import { snapshotDecoder } from '../rules/interest.mjs';
+
+export class Histogram {
+  bins = new Uint32Array(60001);
+  count = 0;
+  max = 0;
+  add(ms) {
+    if (!Number.isFinite(ms) || ms < 0) return;
+    this.bins[Math.min(60000, Math.round(ms))]++;
+    this.count++;
+    this.max = Math.max(this.max, ms);
+  }
+  merge(h) {
+    for (let i = 0; i < this.bins.length; i++) this.bins[i] += h.bins[i];
+    this.count += h.count;
+    this.max = Math.max(this.max, h.max);
+  }
+  json() {
+    const p = (q) => {
+      let n = 0;
+      for (let i = 0; i < this.bins.length; i++) {
+        n += this.bins[i];
+        if (n >= Math.ceil(this.count * q)) return this.count ? i : null;
+      }
+      return null;
+    };
+    return {
+      count: this.count,
+      p50: p(0.5),
+      p95: p(0.95),
+      p99: p(0.99),
+      max: this.max
+    };
+  }
+}
+export function createLoad({
+  origin,
+  game,
+  room,
+  index = 0,
+  workers = 1,
+  lead = 3,
+  compress = true,
+  onProblem = () => {}
+}) {
+  const clients = [],
+    errors = new Map(),
+    first = new Histogram(),
+    welcome = new Histogram(),
+    ack = new Histogram(),
+    gaps = new Histogram(),
+    // From the tick a player held when it stamped an input to the tick it
+    // reached the rules, ms: what the system took, whatever the lead.
+    loops = new Histogram();
+  // Snapshots that said how early this player's input was, and how many said late.
+  let lateAcks = 0,
+    onTime = 0;
+  const loop = monitorEventLoopDelay({ resolution: 10 });
+  loop.enable();
+  let measuring = false,
+    rampCancelled = false,
+    stopping = false,
+    epoch = null,
+    totalUp = 0,
+    totalDown = 0,
+    up = 0,
+    down = 0,
+    sent = 0,
+    inputFrames = 0,
+    received = 0,
+    skipped = 0,
+    expired = 0,
+    disconnects = 0,
+    peakLag = 0,
+    badLag = 0,
+    stopReason = null;
+  let timer,
+    expected = performance.now();
+  const problem = (type, value) => {
+    const key = `${type}: ${String(value).slice(0, 300)}`;
+    if (errors.has(key)) errors.set(key, errors.get(key) + 1);
+    else if (errors.size < 100) {
+      errors.set(key, 1);
+      onProblem(key);
+    }
+  };
+  function send(c, m) {
+    if (c.ws?.readyState !== 1) return;
+    if (c.ws.bufferedAmount > 262144) {
+      stopReason ??= 'driver send backlog';
+      return;
+    }
+    const text = JSON.stringify(m),
+      bytes = Buffer.byteLength(text);
+    c.ws.send(text);
+    totalUp += bytes;
+    if (measuring) {
+      up += bytes;
+      sent++;
+      if (m.t === 'in') inputFrames++;
+      c.up += bytes;
+    }
+  }
+  function snapshot(c, raw) {
+    c.rawSnapshots++;
+    c.rawTick = raw.k;
+    const snap = c.decoder.decode(raw);
+    if (!snap) {
+      c.decodeMiss++;
+      return;
+    }
+    const own = snap.d[1].find((e) => e[9] === c.seat && e[10] !== 1);
+    if (!own) {
+      c.ownMissing++;
+      return;
+    }
+    const now = performance.now();
+    epoch ??= snap.e;
+    if (epoch !== snap.e) stopReason ??= 'room restarted';
+    if (c.first === null) {
+      c.first = now;
+      first.add(now - c.began);
+    }
+    if (c.epoch !== snap.e) {
+      c.pending.clear();
+      c.lastSent = 0;
+      c.epoch = snap.e;
+    }
+    const gap = c.at ? now - c.at : 0;
+    c.maxStateGapMs = Math.max(c.maxStateGapMs, gap);
+    c.k = snap.k;
+    c.at = now;
+    c.own = own;
+    c.r = own[2];
+    c.snapshots++;
+    if (measuring) {
+      c.firstTick ??= snap.k;
+      c.firstAt ??= now;
+      c.lastTick = snap.k;
+      c.lastAt = now;
+      c.frames++;
+      gaps.add(gap);
+    }
+    const control = snap.c?.find((row) => row[0] === c.seat);
+    // The room says how early this player's inputs arrive, in sixteenths of a
+    // tick (the smallest since its last snapshot). The toolkit's client steers
+    // its clock by that, to be half a tick early but for its jitter; this probe
+    // moves its whole-tick lead the same way: every two seconds, one more when
+    // the earliest twentieth of its last forty reports was under half a tick
+    // early, one fewer when it was over a tick and a half.
+    if (control && control[3] !== -128 && control[3] !== undefined) {
+      const early = control[3] / 16;
+      if (measuring) { if (early <= 0) lateAcks++; onTime++; loops.add((c.lead - early) * 50); }
+      (c.early ??= []).push(early); if (c.early.length > 40) c.early.shift();
+      if (c.early.length >= 20 && now - (c.leadAt ?? 0) > 2000) {
+        const low = c.early.slice().sort((a, b) => a - b)[Math.floor(c.early.length / 20)];
+        if (low < 0.5 && c.lead < 12) c.lead++;
+        else if (low > 1.5 && c.lead > 1) c.lead--;
+        c.leadAt = now; c.early.length = 0;
+      }
+    }
+    if (control)
+      for (const [tick, at] of c.pending) {
+        if (tick > control[2]) break;
+        c.pending.delete(tick);
+        if (measuring) {
+          if (tick === control[2]) ack.add(now - at);
+          else skipped++;
+        }
+      }
+  }
+  async function connect(i, reused) {
+    const c = {
+      i,
+      key: reused?.key ?? randomBytes(18).toString('base64url'),
+      seat: null,
+      token: reused?.token ?? null,
+      priorSeat: reused?.seat ?? null,
+      first: null,
+      lead,
+      began: performance.now(),
+      decoder: snapshotDecoder(),
+      pending: new Map(),
+      epoch: null,
+      k: 0,
+      r: 0,
+      at: 0,
+      lastSent: 0,
+      firstTick: null,
+      firstAt: null,
+      lastTick: null,
+      lastAt: null,
+      frames: 0,
+      up: 0,
+      down: 0,
+      snapshots: 0,
+      rawSnapshots: 0,
+      decodeMiss: 0,
+      ownMissing: 0,
+      maxStateGapMs: 0,
+      own: null,
+      nextPing: performance.now() + (i % 20) * 100,
+      nextInput: performance.now() + (i % 10) * 10
+    };
+    clients.push(c);
+    try {
+      const response = await fetch(
+        `${origin}/${game}/__game/?room=${encodeURIComponent(room)}&device=desk&want=play&b=${c.key}`,
+        { signal: AbortSignal.timeout(15000) }
+      );
+      if (!response.ok) throw Error(`bootstrap HTTP ${response.status}`);
+      const match = (await response.text()).match(
+        /window\.HOMIE_NET=(\{[^<]+\})<\/script>/
+      );
+      if (!match) throw Error('No HOMIE_NET bootstrap');
+      const cfg = JSON.parse(match[1]);
+      if (cfg.room !== undefined && cfg.room !== room)
+        throw Error('bootstrap changed the requested room');
+      c.ws = new WebSocket(cfg.url, {
+        origin: 'null',
+        handshakeTimeout: 15000,
+        // A browser always offers compression; a driver that refuses it asks
+        // one uplink for several times the bytes real players would cost it.
+        perMessageDeflate: compress
+      });
+      c.ws.on('open', () => {
+        c.helloAt = performance.now();
+        c.compressed = /permessage-deflate/.test(c.ws.extensions ?? '');
+        send(c, {
+          t: 'hello',
+          rules: true,
+          v: 1,
+          rev: 12,
+          token: c.token,
+          name: `Load ${i}`,
+          device: 'desk',
+          want: 'play',
+          canHost: false,
+          // As the toolkit's client (0.46.2): this decoder coasts a body it was not sent.
+          coast: 1,
+          game,
+          max: 1000,
+          ...(cfg.ver ? { ver: cfg.ver } : {})
+        });
+      });
+      c.ws.on('message', (data) => {
+        totalDown += data.length;
+        if (measuring) {
+          down += data.length;
+          received++;
+          c.down += data.length;
+        }
+        let m;
+        try {
+          m = JSON.parse(data.toString());
+        } catch {
+          problem('decode', i);
+          return;
+        }
+        if (m.t === 'welcome') {
+          c.token = m.token;
+          c.seat = m.seat;
+          welcome.add(performance.now() - c.began);
+          if (m.full || c.seat === null) problem('unseated', i);
+          if (m.snap) snapshot(c, m.snap);
+        } else if (m.t === 'snap') snapshot(c, m);
+        else if (m.t === 'seat') c.seat = m.seat;
+        else if (m.t === 'err' || m.t === 'error') {
+          problem(m.code ?? m.t, m.message);
+          if (
+            ['room-over', 'host-fault', 'host-failed', 'closed'].includes(
+              m.code
+            )
+          )
+            stopReason ??= `server ${m.code}`;
+        }
+      });
+      c.ws.on('error', (e) => problem('socket', e.message));
+      c.ws.on('unexpected-response', (_req, res) => {
+        problem('upgrade', res.statusCode);
+        res.resume();
+        c.ws.terminate();
+      });
+      c.ws.on('close', (code, reason) => {
+        c.closeCode = code;
+        c.closeReason = String(reason);
+        c.closedAt = performance.now();
+        if (!stopping && !c.retired) {
+          disconnects++;
+          problem('close', `${code} ${reason}`);
+        }
+      });
+    } catch (e) {
+      problem('connect', e.message);
+    }
+  }
+  // Stagger sends into 10 ms slices. No catch-up burst after a held timer.
+  timer = setInterval(() => {
+    const now = performance.now(),
+      lag = Math.max(0, now - expected - 10);
+    expected = now;
+    peakLag = Math.max(peakLag, lag);
+    badLag = lag > 2000 ? badLag + 1 : 0;
+    if (badLag >= 3) stopReason ??= 'driver event loop stalled';
+    for (const c of clients) {
+      if (c.retired || c.ws?.readyState !== 1) continue;
+      if (now >= c.nextPing) {
+        send(c, { t: 'ping', c: Date.now(), hid: false });
+        c.nextPing = now + 2000;
+      }
+      if (c.own && now - c.at > 5000 && !c.staleReported) {
+        c.staleReported = true;
+        problem('stale snapshot', 'own state absent for more than 5 seconds');
+      }
+      if (!c.own || now - c.at > 2000 || now < c.nextInput) continue;
+      c.nextInput += 100;
+      if (c.nextInput <= now) c.nextInput = now + 100;
+      const k = Math.max(
+          c.lastSent + 1,
+          c.k + Math.min(10, Math.floor((now - c.at) / 50)) + c.lead
+        ),
+        y = c.own[3][1],
+        east = Boolean(c.own[7][1]);
+      send(c, {
+        t: 'in',
+        e: c.epoch,
+        k,
+        s: [
+          [
+            0,
+            east ? 127 : -127,
+            y > 55
+              ? -35
+              : y < -55
+                ? 35
+                : Math.round(Math.sin(now / 3100 + c.i) * 35)
+          ]
+        ],
+        r: c.r,
+        // The newest tick this socket holds, as the toolkit's own client says it.
+        ...(c.rawTick !== undefined ? { g: c.rawTick } : {})
+      });
+      c.pending.set(k, now);
+      c.lastSent = k;
+      for (const [tick, at] of c.pending) {
+        if (now - at <= 5000) break;
+        c.pending.delete(tick);
+        if (measuring) expired++;
+      }
+    }
+  }, 10);
+  const summary = () => ({
+    worker: index,
+    attempted: clients.length,
+    connected: clients.filter((c) => c.ws?.readyState === 1).length,
+    joined: clients.filter((c) => !c.retired && c.first !== null).length,
+    fresh: clients.filter(
+      (c) =>
+        !c.retired &&
+        c.ws?.readyState === 1 &&
+        c.own &&
+        performance.now() - c.at < 2000
+    ).length,
+    stopReason,
+    epoch,
+    inputFrames,
+    disconnects,
+    loopP99Ms: loop.percentile(99) / 1e6,
+    peakTimerLagMs: peakLag,
+    upBytes: up,
+    downBytes: down,
+    upFrames: sent,
+    downFrames: received,
+    // Bytes off the wire (after TLS, before inflation) for sockets still open.
+    wireDownBytes: clients.reduce(
+      (a, c) =>
+        a + Math.max(0, (c.ws?._socket?.bytesRead ?? 0) - (c.wire0 ?? 0)),
+      0
+    ),
+    compressed: clients.filter((c) => c.compressed).length
+  });
+  return {
+    connect,
+    summary,
+    cancelRamp() {
+      rampCancelled = true;
+    },
+    async ramp(n, rampMs) {
+      await new Promise((r) => setTimeout(r, index * rampMs));
+      const pending = new Set();
+      for (let i = index; i < n && !stopping && !rampCancelled; i += workers) {
+        while (pending.size >= Math.max(1, Math.floor(8 / workers)))
+          await Promise.race(pending);
+        if (rampCancelled || stopping) break;
+        const task = connect(i).finally(() => pending.delete(task));
+        pending.add(task);
+        await new Promise((r) => setTimeout(r, rampMs * workers));
+      }
+      await Promise.all(pending);
+    },
+    start() {
+      measuring = true;
+      for (const c of clients) {
+        c.wire0 = c.ws?._socket?.bytesRead ?? 0;
+        c.pending.clear();
+        c.firstTick = null;
+        c.firstAt = null;
+        c.frames = 0;
+      }
+    },
+    async churn(count) {
+      const leaving = clients.filter(
+        (c) =>
+          c.i < count &&
+          !c.retired &&
+          c.first !== null &&
+          c.ws?.readyState === 1
+      );
+      for (const c of leaving) {
+        c.retired = true;
+        c.ws.close(1000, 'churn');
+      }
+      await new Promise((r) => setTimeout(r, 1000));
+      await Promise.all(leaving.map((c) => connect(c.i, c)));
+      return leaving.length;
+    },
+    async finish() {
+      const end = summary();
+      measuring = false;
+      stopping = true;
+      clearInterval(timer);
+      loop.disable();
+      for (const c of clients) c.ws?.close(1000, 'load step complete');
+      await new Promise((r) => setTimeout(r, 250));
+      for (const c of clients) if (c.ws?.readyState !== 3) c.ws?.terminate();
+      return {
+        ...end,
+        errors: [...errors].map(([text, count]) => ({ text, count })),
+        histograms: { first, welcome, ack, gaps, loops },
+        inputReports: onTime,
+        inputReportsLate: lateAcks,
+        leadTicks: clients.filter((c) => !c.retired).map((c) => c.lead),
+        ackSkipped: skipped,
+        ackExpired: expired,
+        totalUp,
+        totalDown,
+        players: clients.map((c) => ({
+          i: c.i,
+          seat: c.seat,
+          epoch: c.epoch,
+          priorSeat: c.priorSeat,
+          sameSeat: c.priorSeat === null ? null : c.seat === c.priorSeat,
+          retired: Boolean(c.retired),
+          firstStateMs: c.first === null ? null : c.first - c.began,
+          helloAfterMs: c.helloAt ? c.helloAt - c.began : null,
+          closeCode: c.closeCode,
+          closeReason: c.closeReason,
+          maxStateGapMs: c.maxStateGapMs,
+          rawSnapshots: c.rawSnapshots,
+          decodeMiss: c.decodeMiss,
+          ownMissing: c.ownMissing,
+          frames: c.frames,
+          tickHz:
+            c.lastAt > c.firstAt
+              ? ((c.lastTick - c.firstTick) * 1000) / (c.lastAt - c.firstAt)
+              : null,
+          deliveredHz:
+            c.lastAt > c.firstAt
+              ? ((c.frames - 1) * 1000) / (c.lastAt - c.firstAt)
+              : null,
+          upBytes: c.up,
+          downBytes: c.down
+        }))
+      };
+    }
+  };
+}
+if (parentPort) {
+  const load = createLoad({
+    ...workerData,
+    onProblem: (text) => parentPort.postMessage({ event: 'error', text })
+  });
+  parentPort.on('message', async ({ id, op, args = [] }) => {
+    try {
+      const value = await load[op](...args);
+      parentPort.postMessage({ id, value });
+    } catch (e) {
+      parentPort.postMessage({ id, error: e.stack });
+    }
+  });
+}

package/lib/scaffold.mjs

@@ -105,7 +105,7 @@ export function wranglerConfig({ worker, name, d1, d1Id = null, r2 = null, layou
     previews: { vars: { STUDIO_NAME: name, HOMIE_PREVIEW: '1' }, durable_objects: { bindings: rooms } },
   };
   return `// This studio's site on its own Cloudflare account (written by homie-studio). Everything here runs on
-// Cloudflare's Workers Free plan. \`npm run deploy\` (on this computer, or in Workers Builds) puts it live;
+// the studio's Cloudflare Workers account. \`npm run deploy\` (on this computer, or in Workers Builds) puts it live;
 // \`npx wrangler preview\` puts a branch on its own Preview URL with its own rooms. There is no R2 binding
 // until \`homie-studio storage add\` gives the studio storage for large media.
 ${JSON.stringify(config, null, 2)}
@@ -118,7 +118,7 @@ export function agentsMd({ name, slug }) {
 This folder is a studio: **${name}** (\`${slug}\`). It is one repository.
 Its games, music, videos and posts live here; its website and public game rooms
 run on the studio's **own Cloudflare account** (one Worker, one D1 database and
-the Table/Lobby Durable Objects, all on Cloudflare's free Workers plan), built
+the Table/Lobby Durable Objects, on the studio's Cloudflare account), built
 from \`@homie-rocks/studio\`, pinned in \`package.json\`. The homie.rocks
 directory lists its games; homie.rocks does not host them.
 
@@ -217,7 +217,7 @@ studio's pinned copy, never a registry lookup of the bare name.
 - \`npx --no-install homie-studio deploy --plan\` — says what deploy will create on Cloudflare and what it
   costs, and changes nothing. Tell the person before the first deploy.
 - \`npm run deploy\` — the site on this studio's Cloudflare: one Worker, one D1 database, two
-  SQLite-backed Durable Objects, all on the free Workers plan (no payment method needed).
+  SQLite-backed Durable Objects on the studio’s Cloudflare account; its subscription is not inferred.
   If Wrangler is not signed in, run \`npx wrangler login\`: the person approves once in
   their browser. It never overwrites a Worker or database this studio did not create.
 - **Workers Builds** (Cloudflare's own CI, set up by the "Deploy to Cloudflare" button or in the dashboard): on
@@ -553,9 +553,9 @@ chat's card follows the work from then on) and, for a studio still being set up,
   \`"games/*/game.json"\`) and \`"budget"\` (\`{ "usd": <n>, "credits": <n> }\`: the most the studio's media jobs spend
   in all). In Claude Code, the Homie plugin's mod holds an edit to a protected file, a deploy, and a paid call past
   the budget until the person says Proceed, and takes keys out of command output. In Codex the plugin's hooks hold
-  the same calls until the person's own \`proceed <code>\`, once the person has trusted them, and in Grok Build once
+  unrequested deploys and the other held calls until the person's own \`proceed <code>\`, once the person has trusted them, and in Grok Build once
   the plugin is trusted. \`npx --no-install homie-studio setup status --client codex\` (or \`grok\`) says whether Homie's
-  holds are on, and while they are off, ask before each of those yourself. When a call is refused, say what you
+  holds are on. A deploy the person requested in their own words is already approved for that task; do not ask again or demand a typed code. Stop an unrequested deploy and ask once. When a call is refused, say what you
   meant to do and why; do not retry it unless the person asks.
 
 ## Telling Homie

package/lib/template-history.json

@@ -2733,6 +2733,48 @@
      }
     }
    }
+  },
+  "0.46.2": {
+   "files": {
+    "CLAUDE.md": "ddf2b2a0376202f6",
+    "README.md": "684b3cca8001673c",
+    "HANDOFF.md": "29337e2ace95b2e7",
+    "games/README.md": "5ad32fe80c61f117",
+    "music/README.md": "a3dc042dadd39df8",
+    "videos/README.md": "16babc3437d5545b",
+    "posts/README.md": "37841aae476bd540",
+    "site/README.md": "732894273a32dc3f",
+    "site/src/worker.mjs": "6cc5c6131eaf6fd0"
+   },
+   "sections": {
+    "AGENTS.md": {
+     "(intro)": "394cbbe934e80722",
+     "## Version-matched authoring guides": "f6261a0e5801b96b",
+     "## Layout": "f3a280b8c96cd068",
+     "## Apps: one screen, roles and parts": "8596f2b25edda3e2",
+     "## Commands (all through the pinned CLI in node_modules)": "5222e08ca55e326e",
+     "## The site": "0cb8dd9a6f8a0096",
+     "## Making games": "bb715272fd1a615b",
+     "## The Game Codex and progress": "0738ef719cef3a4c",
+     "## Art direction and models": "a48fff7bf0a5f2fc",
+     "## Running live games (the back office)": "51ebf2ab756f6e4d",
+     "## Servers and AI seats": "1ccfd549d2369a60",
+     "## Selling things (the shop)": "9e020d69dd6a954e",
+     "## Continuing a build from the Claude app": "0d68081e924ca419",
+     "## Rules": "27881d11d3ff3803",
+     "## Telling Homie": "80b46fdd9e578db8",
+     "## Beta": "9d02638207a26e73"
+    }
+   },
+   "named": {
+    "Homie Arcade": {
+     "sections": {
+      "AGENTS.md": {
+       "## Commands (all through the pinned CLI in node_modules)": "611b437f5b3303f0"
+      }
+     }
+    }
+   }
   }
  }
 }

package/netplay/netplay.ts

@@ -529,6 +529,7 @@ export interface NetStats {
   offline: boolean;
   rtt: number | null;
   offset: number;
+  telemetrySource: 'server' | 'browser' | 'offline' | 'disconnected';
   snapHzIn: number;
   snapHzOut: number;
   inputHzIn: number;
@@ -550,6 +551,8 @@ export interface NetStats {
   stateKeys: number;
   peers: number;
   reconnects: number;
+  /** Most recent loss, retained after recovery so a brief reconnect is diagnosable. */
+  lastDisconnect?: { at: number; why: string; code: number | null; reason: string | null; silentMs: number };
   /** Revision 9: times a link that was up went down (a reconnect that worked on the first knock counts once). */
   drops?: number;
   /** Revision 9: where this browser stands with its room. */
@@ -1695,6 +1698,7 @@ export function createNetplay<S = unknown, A = unknown, C = unknown>(opts: Netpl
   let ws: WebSocketLike | null = null;
   let attempt = 0;
   let reconnects = 0;
+  let lastDisconnect: NetStats['lastDisconnect'];
   let drops = 0;
   let heartbeats = 0;
   /** My welcome gave me back the seat my token named (the same player), and a newer build is live (section 23). */
@@ -1777,6 +1781,9 @@ export function createNetplay<S = unknown, A = unknown, C = unknown>(opts: Netpl
   let playableSent = false;
   let autoArmed = false;
   let snapSeen = false;
+  /** The newest tick this socket has been sent (rules games): said on inputs and pings as `g`, so a Gate that
+   * finds this player far behind the room sends it fewer, fresher frames instead of every one late. */
+  let gotTick: number | null = null;
   let loadingAt = 0;
   const createdAt = (typeof performance !== 'undefined' ? performance.now() : Date.now());
   const arrived: ArrivalInfo = { mode: arrival, by: null, playableMs: null, explicitMs: null, lateMs: null };
@@ -2619,6 +2626,7 @@ export function createNetplay<S = unknown, A = unknown, C = unknown>(opts: Netpl
     if (wasOffline && rulesGame) rulesNotice('Connection restored. Joining the online round.');
     offline = false;
     connected = true;
+    gotTick = null;
     downSince = 0;
     attempt = 0;
     if (reconnectTimer) { clearTimeout(reconnectTimer); reconnectTimer = null; }
@@ -2764,6 +2772,7 @@ export function createNetplay<S = unknown, A = unknown, C = unknown>(opts: Netpl
     if (Array.isArray(m['c'])) s.c = m['c'] as ControlWire[];
     if (m['hb'] === 1) s.hb = 1;
     if (typeof m['e'] === 'number') s.e = m['e'];
+    if (!local && rulesGame) gotTick = s.k;
     if (acceptSnap(s, bytes, true, local)) { emit('snapshot', s); if (!snapSeen) { snapSeen = true; autoPlayable(); } }
   }
 
@@ -2881,7 +2890,7 @@ export function createNetplay<S = unknown, A = unknown, C = unknown>(opts: Netpl
     pingsOut.set(c, c);
     if (pingsOut.size > 16) { const first = pingsOut.keys().next().value; if (first !== undefined) pingsOut.delete(first); }
     // A hidden host's yield is behind its checkpoint in the sender: the relay hears of the hidden tab after both.
-    raw({ t: 'ping', c, hid: hidden() && !rulesSender?.handing, ...(rulesGame ? { readySpeed } : {}) });
+    raw({ t: 'ping', c, hid: hidden() && !rulesSender?.handing, ...(rulesGame ? { readySpeed } : {}), ...(gotTick !== null ? { g: gotTick } : {}) });
   }
 
   function sendCheckpoint(): void {
@@ -2939,12 +2948,13 @@ export function createNetplay<S = unknown, A = unknown, C = unknown>(opts: Netpl
   function statsNow(): NetStats {
     const t = wall();
     return {
+      telemetrySource: offline ? 'offline' : !connected ? 'disconnected' : opts.rulesHost?.mode === 'server' ? 'server' : 'browser',
       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), 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,
-      peers: peers.size, reconnects, drops, link, heartbeats, promotions, round: roundInfo ? roundInfo.n : null,
+      peers: peers.size, reconnects, lastDisconnect, drops, link, heartbeats, promotions, round: roundInfo ? roundInfo.n : null,
       decides: { asked: decideStats.asked, ai: decideStats.ai, local: decideStats.local, floor: decideStats.floor, msP50: [...decideStats.ms].sort((x, y) => x - y)[Math.floor(decideStats.ms.length / 2)] ?? null },
     };
   }
@@ -2980,8 +2990,10 @@ export function createNetplay<S = unknown, A = unknown, C = unknown>(opts: Netpl
     else paintLink();
   }
 
-  function lost(sock: WebSocketLike, why: string): void {
+  function lost(sock: WebSocketLike, why: string, event?: unknown): void {
     if (ws !== sock) return;
+    const detail = event && typeof event === 'object' ? event as { code?: unknown; reason?: unknown } : null;
+    lastDisconnect = { at: Date.now(), why, code: typeof detail?.code === 'number' ? detail.code : null, reason: typeof detail?.reason === 'string' ? detail.reason.slice(0, 160) : null, silentMs: Math.max(0, wall() - lastMsgAt) };
     ws = null;
     sock.onclose = null; sock.onmessage = null; sock.onerror = null; sock.onopen = null;
     if (why !== 'closed') { try { sock.close(4000, why); } catch { /* gone */ } }
@@ -3011,13 +3023,14 @@ export function createNetplay<S = unknown, A = unknown, C = unknown>(opts: Netpl
       lastMsgAt = wall();
       raw({
         t: 'hello', rules: rulesGame, v: NETPLAY_VERSION, rev: NETPLAY_REVISION, token, name: name || undefined, device, want, canHost: asAgent && asAgent.hands === 'host' ? false : canHost, game: opts.game, max: opts.maxPlayers,
+        ...(rulesGame ? { coast: 1 } : {}),
         ...(watching ? { watch: true } : {}), ...(caps.size ? { caps: [...caps] } : {}), ...(asAgent ? { agent: asAgent } : {}),
         // Revision 9 (an older relay ignores both): the game's revision and what this build can do.
         ...(version ? { ver: version } : {}), ...(features.length ? { feat: features } : {}),
       });
     };
     sock.onmessage = (ev) => onMessage(ev.data);
-    sock.onclose = () => lost(sock, 'closed');
+    sock.onclose = (event) => lost(sock, 'closed', event);
     // Browsers follow an error with close; Node's WebSocket, on a refused connection, never does.
     sock.onerror = () => lost(sock, 'error');
   }
@@ -3415,7 +3428,7 @@ export function createNetplay<S = unknown, A = unknown, C = unknown>(opts: Netpl
       if (seat === null || !entries.length) return false;
       if (rulesHost && offline) { rulesHost.frame({ t: 'in', from: seat, e, k, s: entries, r }); return true; }
       if ((!rulesGame && role === 'host') || offline || !connected) return false;
-      if (!raw({ t: 'in', e, k, s: entries, r })) return false;
+      if (!raw({ t: 'in', e, k, s: entries, r, ...(gotTick !== null ? { g: gotTick } : {}) })) return false;
       inputOut.hit(wall());
       return true;
     },