@homie-rocks/studio 0.58.0 → 0.58.1

package/CHANGELOG.md

@@ -17,7 +17,38 @@ 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
+
+- 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
 

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

@@ -4176,6 +4176,48 @@
      }
     }
    }
+  },
+  "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.58.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/rules/browser.ts

@@ -71,6 +71,8 @@ export function browserHost(def: RulesDef, game: BrowserGame): RulesHostFactory
       stage: lab.stage ?? undefined, startPaused: false, restoreEpoch: (Math.floor(Math.random() * 4294967296) >>> 0) || 1,
       clock: { now: o.now, setTimer: (fn, ms) => setTimeout(fn, ms), clearTimer: (h) => clearTimeout(h as ReturnType<typeof setTimeout>) },
       onEnd: o.onEnd,
+      // Online, the page rests its room as the server does; offline nobody is charged for it, and it never rests.
+      ...(o.onRest ? { onRest: o.onRest } : {}),
     });
     if (game.vocab) host.frame({ t: 'vocabulary', vocab: game.vocab });
     const present = new Set<number>();

package/rules/core.ts

@@ -175,6 +175,8 @@ export interface Core {
   round(): Extract<CoreOut, { t: 'round' }>;
   /** End a settled wall-clock break without simulating its idle ticks. */
   resumeRound(): boolean;
+  /** What the world has waiting on its own clock: events and timers on the queue, bodies yet to spawn, asks unanswered, and a running round's deadline. */
+  waiting(): number;
   bodies(): Body[];
   /** Every person's body with where it stands: who an effect with an audience reaches (0.46.3). */
   listeners(): { seat: number; id: string; pos: Vec3 }[];
@@ -1539,6 +1541,7 @@ export function createCore(c: Compiled, opts: { characterForSeat?: (seat: number
   }
   return {
     round: () => ({ t: 'round', ...round, ...(round.phase === 'over' && !overAt ? { results: results() } : {}) }),
+    waiting: () => queue.length + spawns.length + pendingAsks.length + (round.phase === 'live' ? (round.endsAt > 0 ? 1 : 0) : (round.endsAt > tick ? 1 : 0)) + (restartAt > tick ? 1 : 0),
     resumeRound() {
       if (round.phase !== 'over' || overAt) return false;
       // Preserve queued events and their simulation-time deadlines. Nothing