@homie-rocks/studio 0.46.0 → 0.46.3

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/rules-check-worker.mjs

@@ -233,7 +233,7 @@ function play(c, companions, allow) {
   }
 
   /* ---- what the people press. Each plays one of three ways, changing every 20 s; seat 1 never sends anything. */
-  const ends = (fd) => (fd.t === 'bit' || fd.t === 'press' ? [false, true] : fd.t === 'fix' ? [-1, 1] : [L.P.coerce(fd, -Infinity, c.dims), L.P.coerce(fd, Infinity, c.dims)]);
+  const ends = (fd) => (fd.t === 'bit' || fd.t === 'press' ? [false, true] : fd.t === 'fix' || fd.t === 'held' ? [-1, 1] : [L.P.coerce(fd, -Infinity, c.dims), L.P.coerce(fd, Infinity, c.dims)]);
   const steering = new Map();
   let moveTick = 0;
   let moveSelf;

package/lib/rules-check.mjs

@@ -28,10 +28,10 @@ export const LONG_ALLOWANCE = Object.freeze({ ...ALLOWANCE, ticks: 8 * ALLOWANCE
 
 /** The ordered declarations a save depends on. Functions contribute their presence, never their implementation. */
 export function stateHash(c) {
-  const { kinds, events, commands, effects, shared, rounds, bots, roomOn, asks, map: geometry, dims, contract, seats, save, historySeconds } = c;
+  const { kinds, events, commands, effects, shared, rounds, bots, roomOn, asks, map: geometry, dims, contract, seats, save, historySeconds, rewindSeconds } = c;
   // Keep existing 2D save compatibility hashes when the 3D map vocabulary grows.
   const map = dims === 2 ? { name: geometry.name, bounds: geometry.bounds, boxes: geometry.boxes, circles: geometry.circles, spots: geometry.spots } : geometry;
-  return createHash('sha256').update(JSON.stringify({ kinds, events, commands, effects, shared, rounds, bots, roomOn, asks, map, dims, contract, seats, ...(historySeconds?{historySeconds}:{}), tickHz: c.settings.tickHz, save }, (k, v) => typeof v === 'function' ? true : v)).digest('hex').slice(0, 32);
+  return createHash('sha256').update(JSON.stringify({ kinds, events, commands, effects, shared, rounds, bots, roomOn, asks, map, dims, contract, seats, ...(historySeconds?{historySeconds}:{}), ...(rewindSeconds!==undefined?{rewindSeconds}:{}), tickHz: c.settings.tickHz, save }, (k, v) => typeof v === 'function' ? true : v)).digest('hex').slice(0, 32);
 }
 
 /**

package/lib/rules-types.mjs

@@ -78,7 +78,7 @@ type W = World<${parameters}>;
 type RW = World<${parameters}, true>;
 type Definition = Omit<RulesDef, 'entities' | 'room' | 'move' | 'asks'> & {
   entities: ${entities}; move?: Moves;
-  room?: { records?: {key:string;identity:string;eligible?:string;fields:Readonly<Record<string,string>>}; rounds?: { seconds: number; breakSeconds: number }; bots?: { keep: number }; historySeconds?: number;
+  room?: { records?: {key:string;identity:string;eligible?:string;fields:Readonly<Record<string,string>>}; rounds?: { seconds: number; breakSeconds: number }; bots?: { keep: number }; historySeconds?: number; rewindSeconds?: number;
     start?: (world: RW) => void;
     join?: (ctx: Pick<W, 'map' | 'shared' | 'tune' | 'math' | 'round'>, player: { seat: number; driver: 'person' | 'bot' | 'ai'; owner: string; character?: (${joins}) | null }) => ${joins};
     on?: { [K in keyof (Omit<Events, keyof GameRoomEvents> & GameRoomEvents)]?: (world: RW, event: EventData<(Omit<Events, keyof GameRoomEvents> & GameRoomEvents)[K]>) => void };

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,90 @@
      }
     }
    }
+  },
+  "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"
+      }
+     }
+    }
+   }
+  },
+  "0.46.3": {
+   "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"
+      }
+     }
+    }
+   }
   }
  }
 }