@homie-rocks/studio 0.57.0 → 0.58.1

package/CHANGELOG.md

@@ -17,15 +17,67 @@ To bring a studio up to date, tell Claude: "Upgrade my studio to the newest Homi
 `npx -y @homie-rocks/studio@latest upgrade`, which shows what's new since the version your studio pins (from this
 file) and what the upgrade would change, and changes nothing until you agree.
 
-## [Unreleased]
+## [0.58.1] - 2026-10-17
+
+**Plugin 0.58.1**
+
+A room nobody is playing rests, and the next touch wakes it with that input still applied.
+
+### Changed
+
+- Idle rooms sleep. A room whose people have all stopped playing now rests: nothing held, pressed or sent for a
+  minute (`room.restSeconds`), or every page in the background for ten seconds. Its clock stops with everybody still
+  connected and the room hibernates, so it is not charged for duration while it sleeps. It still wakes about once a
+  minute for a liveness alarm (one request, and the CPU of that short wake). A deliberate rest is restored as the
+  same world, under the same epoch, without rewriting the save. The first touch, command, AI command, returning page
+  or new arrival starts it again on the tick it stopped on, and a phone that reconnects keeps its seat. By default
+  (`room.rest: "quiet"`) a room rests only when its world has nothing of its own to do: no round clock, no event,
+  timer, spawn or ask waiting, nothing moving, and no AI command for that minute. `"idle"` rests anyway and pauses
+  round clocks, timers, bots and AI with it; Coin Dash, Ember Vale, Gem Rush, Gem Rush 3D and Hero Rush 3D use it.
+  `"never"` keeps a room going while anybody is there (a turn timer, a show). Browser-hosted rules games rest the
+  same way. A spectator or agent on an older build keeps pinging the room itself, so the object stays in memory
+  while that socket is open. Rebuild your games to get it: a room rests only when every seated browser is on this
+  version.
 
 ### Fixed
 
-- The MCP Events workerd conformance test now parses SSE frames across HTTP chunks, including combined event/heartbeat frames and split UTF-8. Its former one-chunk-per-event assumption caused the intermittent 0.57.0 publish-gate JSON parse failure; production delivery and webhook formats are unchanged. PR CI adds a path-filtered Events/webhook gate covering protocol, push, durable delivery and signed studio events.
+- A browser-hosted rest stays asleep when the hosting tab is hidden or sends no snapshots. The next browser takes
+  the same checkpoint and does not run until somebody plays. A backgrounded tab no longer ends the rest while people
+  are still in the room. Waking writes a new checkpoint, so a later handoff does not put the room back to sleep.
+
+### Upgrade notes
+
+- Rebuild your games. Set `room.rest` to `"never"` (or `restSeconds` to 0) for a turn timer or a show that must keep
+  going while people are present. A lasting world never rests.
+
+## [0.58.0] - 2026-10-16
+
+**Plugin 0.58.0**
+
+Two new shared parts — an owner action checklist and a 3D terrain route map — and booking calendars that can skip or change single dates in a weekly series.
+
+### Added
+
+- Two Apache-2.0 shared building blocks: an owner action checklist with visible consequences, one-tap confirmation, server-authorized undo and existing studio role/origin checks; and a three.js terrain route map with a local heightmap coastline, route tube, markers and phone/TV camera controls. Both include standard part manifests, catalogue entries, AI integration docs, self-contained previews and fast logic checks. No tile service is required.
+- Weekly booking calendars can omit individual dates or override an occurrence's time, capacity and duration. Occurrence IDs stay stable when a start time changes; undefined overrides, off-series or invalid dates and ambiguous DST times are refused, and a date that already has reservations cannot be silently removed.
+
+### Changed
+
+- Shared terrain map: smooth high-resolution coast, lit terrain with cavity shading, animated depth-coloured water and foam, sky/haze, flowing elevated route, collision-aware leader labels, intro camera and measured-frame lite fallback. Owner checklist distinguishes pending, confirming, done and undone, announces actual consequences, labels irreversible actions and restores fresh pending actions after undo.
+
+### Fixed
+
+- Public checklist proposals require per-action staff authorization, validate tokens, retain retry keys and use separate expiring undo grants. Terrain heightmaps restrict origins and PNG types and enforce byte/dimension budgets before decoding.
+- The MCP Events workerd conformance test parses SSE frames across HTTP chunks, including combined event/heartbeat frames and split UTF-8 (the intermittent 0.57.0 publish-gate failure); production delivery and webhook formats are unchanged. PR CI adds a path-filtered Events/webhook gate.
+- CI Chrome launches keep each caller's protocol timeout.
+
+### Upgrade notes
+
+- No migration and nothing to change. Studios use the new parts by asking their AI to add them from the catalogue; existing weekly calendars keep working, and dated exceptions are optional (see "Weekly calendar exceptions" in `packages/studio/docs/toolkit-place-patterns.md`).
 
 ## [0.57.0] - 2026-10-16
 
-**Plugin 0.57.0**
+**Plugin 0.57.0** · [release-2026-10-16-studio-0.57.0](https://github.com/homie-rocks/homie/releases/tag/release-2026-10-16-studio-0.57.0)
 
 Studios can book at each other on behalf of a person, with proven studio identity and signed events, and friends joining a browser-hosted game at the same moment always get their seat.
 
@@ -52,7 +104,7 @@ Studios can book at each other on behalf of a person, with proven studio identit
 
 ## [0.56.0] - 2026-10-15
 
-**Plugin 0.56.0**
+**Plugin 0.56.0** · [release-2026-10-15-studio-0.56.0](https://github.com/homie-rocks/homie/releases/tag/release-2026-10-15-studio-0.56.0)
 
 Studios scale with hibernating rooms, add custom routes with built-in access checks, and deploy reliably with background queue handlers.
 

package/docs/toolkit-place-patterns.md

@@ -66,3 +66,19 @@ Tokens are bound to this origin, limited to the exact named tools, expire after
 ## Deployment
 
 Cloudflare's official MCP request interface cannot authorize new static-asset uploads with an upload JWT; deploy with Wrangler, Cloudflare's own CLI using browser OAuth.
+
+## Weekly calendar exceptions
+
+`calendarSlots` (also exposed by `ctx.bookings.calendar`) accepts `exceptions`,
+keyed by local `YYYY-MM-DD`. Use `null` to omit a holiday or an object containing
+`time`, `capacity` and/or `durationMinutes` to override that occurrence. Dates
+must belong to the declared range and weekdays. The occurrence ID remains based
+on the original series time when an exception changes its start time. DST gaps
+and ambiguous times refuse rather than silently changing the booking. Publishing
+new calendar data does not itself move existing reservations or change payments.
+
+A `durationMinutes` exception replaces the series `days` duration for that date.
+Explicit `undefined` override values are invalid. Removing a published slot with
+active reservations is refused by the database (`slot has active bookings`).
+Release or cancel those reservations through the payment-aware booking flow before
+deleting the slot; omitting a generated date alone does not delete a published row.

package/guides/game/RULES.md

@@ -780,7 +780,21 @@ score and other shared outcomes still arrive with the network. The studio choose
 Room state is saved automatically (default movementSeconds: 1, plus round end,
 pause and finish; a lasting world instead journals its durable fields at once and
 checkpoints the rest every 30 seconds). After 60 seconds with no person the room ends even if screens or
-AI remain. Use browser createSaves for player-owned character progress; it is not
+AI remain. A room whose people have all stopped playing rests: its clock stops with everybody still
+connected and the room hibernates, so it is not charged for duration while it sleeps. It still wakes about once a
+minute for a liveness alarm (one request, and the CPU of that short wake). A deliberate rest is restored as the same
+world, under the same epoch, without rewriting the save. The first input, command, AI command, returning page
+or new arrival starts it again on the tick it rested on. "Stopped playing" is nothing held, pressed or sent for
+`room.restSeconds` (default 60), or ten seconds with every page in the background. An AI command counts as playing
+and wakes a room that is already resting. `room.rest` says what else must be true. `"quiet"` (the default): the
+world has nothing of its own to do, meaning no round clock running, no event, timer, spawn or ask waiting, nothing
+moving, and no AI command for `restSeconds`. `"idle"`: rest anyway, pausing round clocks, timers, bots and AI with
+it; Coin Dash, Ember Vale, Gem Rush, Gem Rush 3D and Hero Rush 3D use it, as an away-from-keyboard pause.
+`"never"` (or `restSeconds: 0`): never while somebody is here, for a world that must keep going untouched, such as a
+turn timer that skips an absent player or a show people watch. A lasting world never rests. A spectator or agent on
+an older build keeps pinging the room itself, so the object stays in memory while that socket is open. Browser-hosted
+rules games rest the same way. A resting host's silence is not a stall. If its tab is hidden, another browser takes
+the same rest and stays asleep until somebody plays. Use browser createSaves for player-owned character progress; it is not
 server-verified money. Entity fields default to public. Declare visibility explicitly for private information (below); shared state and motion remain public. Use declared server round records for verified match history.
 
 

package/lib/agent-seat.mjs

@@ -57,6 +57,8 @@ export class AgentSeat {
     this.errors = [];
     this.vocab = null;
     this.ping = null;
+    /** The room said it is resting (welcome or `{ t: 'rest' }`). Pings then stay at the edge and do not wake it. */
+    this.resting = false;
     /** brain 'local': Clef on this computer ({ base, model }) decides; its last decisions, and who said no thanks. */
     this.brain = brain === 'local' && local ? 'local' : null;
     this.local = local;
@@ -97,7 +99,7 @@ export class AgentSeat {
     this.ws = ws;
     const welcome = await new Promise((done) => {
       const timer = setTimeout(() => done({ t: 'timeout' }), 12_000);
-      ws.onopen = () => ws.send(JSON.stringify({ ...sat.hello, device: 'desk' }));
+      ws.onopen = () => ws.send(JSON.stringify({ ...sat.hello, device: 'desk', rest: 1 }));
       ws.onmessage = (e) => {
         let m; try { m = JSON.parse(String(e.data)); } catch { return; }
         if (m.t === 'welcome' || (m.t === 'error' && !this.seat)) { clearTimeout(timer); done(m); }
@@ -107,7 +109,9 @@ export class AgentSeat {
       ws.onerror = () => {};
     });
     if (welcome.t !== 'welcome') { this.close(); await this.revoke(); return { ok: false, why: welcome.message ?? `no seat (${welcome.code ?? welcome.t})`, error: welcome.code ?? welcome.t }; }
-    this.ping = setInterval(() => { try { ws.send(JSON.stringify({ t: 'ping', c: Date.now() })); } catch { /* closed */ } }, 2000);
+    this.ping = setInterval(() => {
+      try { ws.send(this.resting ? 'homie-ping' : JSON.stringify({ t: 'ping', c: Date.now() })); } catch { /* closed */ }
+    }, 2000);
     // The host shows a guide the game every 2 s: wait for the first look (up to 6 s).
     for (let i = 0; i < 30 && !this.view && !this.closed; i += 1) await wait(200);
     if (this.brain === 'local') this.autopilot();
@@ -122,6 +126,8 @@ export class AgentSeat {
   autopilot() {
     const tick = async () => {
       if (this.closed) { this.stopAuto(); return; }
+      // A resting room paused its AI with the people. The next decision waits until somebody plays.
+      if (this.resting) return;
       const now = Date.now();
       const a = this.auto;
       const asks = this.asks.filter((x) => now - x.at < 30_000);
@@ -162,7 +168,8 @@ export class AgentSeat {
 
   onFrame(m) {
     switch (m.t) {
-      case 'welcome': this.seat = m.seat; this.name = m.name; this.policy = m.policy ?? null; return;
+      case 'welcome': this.seat = m.seat; this.name = m.name; this.policy = m.policy ?? null; this.resting = m.rest === true; return;
+      case 'rest': this.resting = m.on === true; return;
       case 'policy': this.policy = m.policy ?? this.policy; return;
       case 'error': this.errors = [...this.errors, { code: m.code, message: m.message, at: Date.now() }].slice(-6); if (['agents-alone', 'agents-off', 'kicked', 'room-closed', 'agent-yield'].includes(m.code)) this.closed = m.code; return;
       case 'ev': {

package/lib/template-history.json

@@ -4134,6 +4134,90 @@
      }
     }
    }
+  },
+  "0.58.0": {
+   "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": "1dbdf22c03a1e505",
+    "site/src/worker.mjs": "6cc5c6131eaf6fd0"
+   },
+   "sections": {
+    "AGENTS.md": {
+     "(intro)": "af7f2f732505d379",
+     "## Version-matched authoring guides": "f6261a0e5801b96b",
+     "## Layout": "f3a280b8c96cd068",
+     "## Apps: one screen, roles and parts": "c10aa0441ea89702",
+     "## Commands (all through the pinned CLI in node_modules)": "c20d90de21cde0c7",
+     "## 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)": "0df5a5fe1833c624",
+     "## Continuing a build from the Claude app": "0d68081e924ca419",
+     "## Rules": "b2234d80f6cbe71d",
+     "## Telling Homie": "80b46fdd9e578db8",
+     "## Beta": "9d02638207a26e73"
+    }
+   },
+   "named": {
+    "Homie Arcade": {
+     "sections": {
+      "AGENTS.md": {
+       "## Commands (all through the pinned CLI in node_modules)": "8364e05cebefcba4"
+      }
+     }
+    }
+   }
+  },
+  "0.58.1": {
+   "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": "1dbdf22c03a1e505",
+    "site/src/worker.mjs": "6cc5c6131eaf6fd0"
+   },
+   "sections": {
+    "AGENTS.md": {
+     "(intro)": "af7f2f732505d379",
+     "## Version-matched authoring guides": "f6261a0e5801b96b",
+     "## Layout": "f3a280b8c96cd068",
+     "## Apps: one screen, roles and parts": "c10aa0441ea89702",
+     "## Commands (all through the pinned CLI in node_modules)": "c20d90de21cde0c7",
+     "## 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)": "0df5a5fe1833c624",
+     "## Continuing a build from the Claude app": "0d68081e924ca419",
+     "## Rules": "b2234d80f6cbe71d",
+     "## Telling Homie": "80b46fdd9e578db8",
+     "## Beta": "9d02638207a26e73"
+    }
+   },
+   "named": {
+    "Homie Arcade": {
+     "sections": {
+      "AGENTS.md": {
+       "## Commands (all through the pinned CLI in node_modules)": "8364e05cebefcba4"
+      }
+     }
+    }
+   }
   }
  }
 }

package/netplay/NETPLAY.md

@@ -27,6 +27,13 @@ welcome/promotion, explicit `rules: true` on runtime output, `hosted` relay even
 The hosting page's unmarked frames have ordinary player allowances. Old-style games
 keep revision 10's character counts and rates.
 
+**Resting rooms** need no new revision, since each side ignores what it does not know: a rules
+browser's hello says `rest: 1`, and a room of such browsers rests while nobody plays, sending
+`{ t: 'rest', on }` when it stops and starts again, and `rest: true` in the welcome of a page that
+arrives meanwhile (section 29.3). A room with an older seated browser never rests. An older watching
+page or agent socket in a resting room keeps pinging the room itself, so the object stays in memory
+while it is there.
+
 **What revision 10 added** (a game that knows none of it plays exactly as before, hosted by a player's
 browser; nothing here changes a frame such a game sends or receives):
 - **The server as host** (section 29): a game written as rules plus view (`src/rules.ts`, `src/move.ts`,
@@ -2063,6 +2070,9 @@ through a wall. New Coin Dash and Gem Rush use authoritative server movement ins
 | The seat's hold runs out | The body is removed, or stays as a bot (`player: { leave: 'bot' }`) |
 | The last person's socket closes | **The room pauses.** The tick timer is cleared and the clock stops. Watchers and AI seats never keep it ticking |
 | A person returns within 60 s | The room resumes at the tick it paused on. No tick is skipped and none runs for the gap |
+| People are here and nobody plays | **The room rests** (the game's `room.rest`). Nobody has held, pressed or sent anything (a command, a pulse, chat) and no AI has sent a command for `room.restSeconds` (60 by default; 0 never rests), or every page has been in the background for ten seconds. With `rest: 'quiet'` (the default) the world must also have nothing of its own to do: no round clock running, no event, timer, spawn or ask waiting, and nothing moving (bots, physics, tick handlers). With `rest: 'idle'` it rests regardless, and round clocks, timers, bots and AI pause with it (an away-from-keyboard pause). The host sends `{ t: 'rest', on: true }`, saves the room and clears its tick timer; the relay sleeps with everybody still connected, so the object hibernates and is not charged for duration while it sleeps. A page that arrives meanwhile is told in its welcome (`rest: true`), a spectator included. Browsers stop their input clock, ping the edge (`homie-ping`) and send nothing until a control is held or pressed. Only browsers whose hello said `rest: 1` let a room rest. A lasting world never rests. A resting room still wakes about once a minute for its liveness sweep (one alarm request, and the CPU of that short wake). That wake does not rewrite the save or change the epoch. Current agents ping the edge while the room rests. A spectator or agent on an older build keeps pinging the room itself, so the object stays in memory while that socket is open |
+| Somebody plays again | An input that holds or presses something, a command, an AI's command, a page brought to the front or a new arrival wakes the room: `{ t: 'rest', on: false }`, a retimed `round`, and ticks from the tick it rested on, on a clock started now. The first entry is stamped on that tick, so it applies. A room rebuilt from its rest's save comes back under the same epoch, so the waking frame is not dropped; any other restore takes a new one. A socket kept through hibernation is the same person, still resting; a phone that reconnects with its token gets its own seat and wakes the room |
+| A browser hosts the rules (`room.host: 'browser'`) | It rests and wakes its room the same way, in the page: it sends the relay `{ t: 'rest', on }`, stops its snapshots and checkpoints, and hears which pages went to the background (`{ t: 'hidden', seat, on }`). The relay fans the rest out and sleeps. That silence is not a stall. A hidden hosting tab hands the rest to another browser with the rest's checkpoint; the new host stays asleep until somebody plays. A handoff with no rest checkpoint ends the rest, so every clock matches a host that will run. Waking writes a new checkpoint, so a later handoff does not restore the rest |
 | Nobody returns within 60 s | **The room ends.** The relay forgets it and its stored seats are deleted (`office` and `recorded` are kept). The next visitor gets a fresh room, with a new epoch |
 | A restart or a deploy | The whole room restores at its saved tick, under a new epoch. Seats keep their tokens. A deploy that changed the state shape ends the match instead (section 29.6) |
 | The rules fail again and again | Every tick failing for two seconds of the clock (a handler that used its whole share, or a fault in the runtime itself), or ticks that ran slow for five: the room ends, its players get the error `room-over`, and the log names the game, its build, the kind and the handler (`why`: `budget`, `fault`, `overrun`). Both are seconds on the clock, not a count of ticks |

package/netplay/netplay.ts

@@ -590,7 +590,7 @@ export interface RulesHost {
   readonly tick: number;
   facts(): Record<string, unknown>;
 }
-export type RulesHostFactory = (o: { now(): number; send(m: Record<string, unknown>): void; restore: unknown; peers?: Peer[]; held?: Peer[]; policy?: Policy; onEnd(why: string): void }) => RulesHost;
+export type RulesHostFactory = (o: { now(): number; send(m: Record<string, unknown>): void; restore: unknown; peers?: Peer[]; held?: Peer[]; policy?: Policy; onEnd(why: string): void; onRest?(on: boolean): void }) => RulesHost;
 
 export interface RulesOutputSender {
   push(frame: Record<string, unknown>): void;
@@ -938,6 +938,11 @@ export interface Netplay<S = unknown, A = unknown, C = unknown> {
   readonly chatShown: boolean;
   /** Server time in ms (relay clock). Offline: Date.now(). */
   now(): number;
+  /**
+   * A server-hosted room is resting: nobody here has played for a while (or every page is in the background), so its
+   * clock is stopped and it sends nothing. Send input only when it changes: the first change wakes the room.
+   */
+  resting(): boolean;
   /** Host: true when the next `snapshot()` would be sent. Build the state only then. */
   snapshotDue(): boolean;
   /** Host: broadcast fast state (live bodies, projectiles); throttled to snapshotHz (1 Hz while alone). */
@@ -1626,7 +1631,9 @@ export function createNetplay<S = unknown, A = unknown, C = unknown>(opts: Netpl
         rulesPace = null;
         if (!opts.rulesLimits) throw new Error('Rules output limits are missing');
         rulesSender = opts.rulesLimits.output({ rates: opts.rulesLimits.rates, send: raw, now: () => performance.now() });
-        const options = { now: () => performance.now(), restore, peers: rulesPeers(), held: offline ? [] : heldPeers, policy: offline ? DEFAULT_POLICY : policy, send: rulesOut, onEnd: (why: string) => endRules(why) };
+        // A browser host rests its room as the server does (rules/host.ts): its own page then pings the edge and holds
+        // its clock like everybody else's, and its relay can sleep. Never offline: nobody pays for a page alone.
+        const options = { now: () => performance.now(), restore, peers: rulesPeers(), held: offline ? [] : heldPeers, policy: offline ? DEFAULT_POLICY : policy, send: rulesOut, onEnd: (why: string) => endRules(why), ...(offline ? {} : { onRest: (on: boolean) => { if (on) sendCheckpoint(); resting = on; if (!on) sendCheckpoint(); } }) };
         try { rulesHost = make(options); }
         catch (error) {
           if (!restore) throw error;
@@ -1714,6 +1721,8 @@ export function createNetplay<S = unknown, A = unknown, C = unknown>(opts: Netpl
   let heldPeers: Peer[] = [];
   let roundInfo: RoundInfo | null = null;
   let idlePing = false, lastClockPing = -Infinity;
+  /** The server's room is resting (`rest` frames): pings go to the edge and silence is expected, as between rounds. */
+  let resting = false;
   let slots: Slot[] | null = null;
   let lastCkpt: Checkpoint<C> | null = null;
 
@@ -2363,6 +2372,9 @@ export function createNetplay<S = unknown, A = unknown, C = unknown>(opts: Netpl
     switch (m['t']) {
       case 'welcome': return onWelcome(m);
       case 'snap': return onSnap(m, text.length);
+      case 'rest': resting = rulesGame && m.on === true; return;
+      // A browser host hears which pages went to the background, as the server's host does.
+      case 'hidden': rulesFrame(m); return;
       case 'free': if (![...peers.values()].some((p) => p.seat === m.seat)) rulesFrame(m); return;
       case 'in': if (rulesFrame(m)) return; return onInput(m);
       case 'ev': {
@@ -2585,7 +2597,8 @@ export function createNetplay<S = unknown, A = unknown, C = unknown>(opts: Netpl
   }
 
   function onWelcome(m: Record<string, unknown>): void {
-    idlePing = m.idlePing === true; lastClockPing = -Infinity;
+    // A room that rests when this page arrives (a watcher, a page back after a rest) says so in its welcome.
+    idlePing = m.idlePing === true; lastClockPing = -Infinity; resting = rulesGame && m.rest === true;
     post?.({ what: 'build', ver: version });
     clearTimeout(connectTimer);
     const next = m['role'] as Role;
@@ -2890,7 +2903,7 @@ export function createNetplay<S = unknown, A = unknown, C = unknown>(opts: Netpl
     // Dropping a healthy socket there turned every long hitch into a reconnect.
     const oldestPing = pingsOut.values().next().value;
     if (ws && oldestPing !== undefined && Date.now() - oldestPing >= 30_000 && !pingHeld) { lost(ws, 'stale'); return; }
-    const silence = idlePing && (roundInfo?.phase !== 'live' || wall() - lastClockPing > staleMs) ? Math.max(staleMs, 60_000) : staleMs;
+    const silence = idlePing && (resting || roundInfo?.phase !== 'live' || wall() - lastClockPing > staleMs) ? Math.max(staleMs, 60_000) : staleMs;
     if (ws && lastMsgAt && wall() - lastMsgAt > silence) {
       if (!pingHeld) { lost(ws, 'stale'); return; }
       // Two and a half seconds to be heard from (a pong answers the ping below): a socket that is really dead is
@@ -2899,7 +2912,7 @@ export function createNetplay<S = unknown, A = unknown, C = unknown>(opts: Netpl
     }
     // An idle hibernatable room can answer this at the edge. Keep a regular
     // clock/visibility sample on visibility changes, and every heartbeat during play.
-    if (idlePing && roundInfo?.phase !== 'live' && !(roundInfo?.phase === 'over' && now() >= roundInfo.endsAt) && !force) {
+    if (idlePing && (resting || roundInfo?.phase !== 'live' && !(roundInfo?.phase === 'over' && now() >= roundInfo.endsAt)) && !force) {
       try { ws?.send('homie-ping'); } catch { if(ws)lost(ws,'send'); }
       return;
     }
@@ -2912,7 +2925,8 @@ export function createNetplay<S = unknown, A = unknown, C = unknown>(opts: Netpl
   }
 
   function sendCheckpoint(): void {
-    if (role !== 'host' || (!opts.checkpoint && !rulesHost) || offline || !connected) return;
+    // A resting room's world does not change: its last checkpoint is still the room.
+    if (role !== 'host' || (!opts.checkpoint && !rulesHost) || offline || !connected || resting) return;
     let d: C;
     try { d = (rulesHost ? rulesHost.save() : opts.checkpoint!()) as C; } catch (err) { console.warn('[netplay] checkpoint()', err); return; }
     const c: Checkpoint<C> = { k: rulesHost?.tick ?? tick, st: now(), d, c: ctlWire() };
@@ -3042,7 +3056,8 @@ export function createNetplay<S = unknown, A = unknown, C = unknown>(opts: Netpl
       pingsOut.clear();
       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 } : {}),
+        // A browser that understands a resting room (the server's `rest` frames) says so; an older relay ignores it.
+        ...(rulesGame ? { coast: 1, rest: 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 } : {}),
@@ -3109,11 +3124,16 @@ export function createNetplay<S = unknown, A = unknown, C = unknown>(opts: Netpl
   try {
     g.document?.addEventListener('visibilitychange', () => {
       if (disposed) return;
-      if (hidden()) rulesHost?.pause(); else rulesHost?.resume();
+      // A rest already stopped this clock. Hiding records the page; showing it is somebody looking, which wakes
+      // the room. Pausing here would tell everyone the room is awake while the next host restores the rest and sleeps.
+      if (rulesHost && resting && seat !== null) rulesHost.frame({ t: 'hidden', seat, on: hidden() });
+      else if (hidden()) rulesHost?.pause();
+      else rulesHost?.resume();
       if (!hidden() && waitingVisible) { waitingVisible = false; attempt = 0; open(); return; }
       if (!connected) return;
       if (hidden()) {
-        // A hidden phone tab loses its timers and rAF: hand the round on before it stalls.
+        // A hidden phone tab loses its timers and rAF: hand the round on before it stalls. A rest goes with
+        // that handoff; the next host restores the checkpoint and stays asleep until somebody plays.
         if (role === 'host' && peers.size > 1) yieldHost();
         ping(true);
       } else ping(true);
@@ -3433,6 +3453,7 @@ export function createNetplay<S = unknown, A = unknown, C = unknown>(opts: Netpl
     },
     stateOf<T = unknown>(key: string) { return stateMap.get(key) as T | undefined; },
     stateKeys() { return [...stateMap.keys()]; },
+    resting: () => resting,
     input(a, held) {
       if (rulesGame) return;
       pendingA = a;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@homie-rocks/studio",
-  "version": "0.57.0",
+  "version": "0.58.1",
   "description": "A studio for games, music and video on its own Cloudflare: scaffold, multiplayer starters on the netplay contract, a port toolkit that makes existing single-player web games multiplayer, the site Worker with public rooms (Table/Lobby Durable Objects and D1, all on the free Workers plan, no payment method), a site with the hub's sections (Home, Games, Music, Videos, Rooms, Posts with feeds) in the studio's own look, an epic landing page for every game, big songs and videos in the studio's own R2 once it has storage (uploaded, checked by SHA-256, served at the same addresses), deploy, and the homie.rocks directory.",
   "type": "module",
   "license": "Apache-2.0",

package/parts/README.md

@@ -0,0 +1,28 @@
+# Toolkit parts catalogue
+
+These are reusable files, not new npm packages or complete apps. The catalogue entries
+are the standard `part.json` records, also collected in `catalogue.json` for local browsing.
+
+| Part | What it supplies | Source | Licence |
+| --- | --- | --- | --- |
+| [Owner action checklist](owner-action-checklist/README.md) | Consequence-first owner/staff action UI, server integration boundary, optional undo | Owner action checklist / Homie toolkit | Apache-2.0 |
+| [Terrain route map](terrain-route-map/README.md) | Local heightmap coast, draped route, markers and phone/TV camera controls | Terrain route map / Homie toolkit | Apache-2.0 (three.js MIT) |
+
+Each folder includes its licence, attribution, AI integration contract, tunables and small
+working preview. Ryan Campbell authored both. To preview locally, serve this directory with
+a static HTTP server, then open `<id>/preview/index.html`.
+
+These public source parts are explicitly shared in their manifests. This checkout is not
+a deployed studio and does not invent a catalogue host or claim a live directory listing.
+To distribute from a studio, retain the original provenance/credit, place these original
+source folders under that studio's `parts/`, run the existing `parts share` checks/packing,
+and deploy. The standard well-known catalogue then advertises exact immutable releases;
+consuming studios use `parts_find` / `part_add`, never copy another studio's release by hand.
+Follow [PARTS.md](PARTS.md) for hashes, licence checks, packing and delivery. Do not serve
+unpacked source as an immutable release. Later changes to a shared release need a new part
+version. These initial parts are 1.0.0; no toolkit version is changed.
+
+Maintainers: `node scripts/build-shared-parts.mjs` builds the local map preview and rewrites
+hashes with `writeHashes`. `node --test packages/studio/test/shared-parts.test.mjs` checks
+logic, licences and real pack/catalogue/integrity paths. Run
+`node scripts/check-shared-parts.mjs` for one short browser check and 4× CPU measurements.