@homie-rocks/studio 0.44.3 → 0.45.0

package/netplay/NETPLAY.md

@@ -1,3 +1,10 @@
+> 0.45.0: this document describes the internal transport used by rules rooms.
+> Games have one authoring path: rules plus view with `openRoom`. Browser/offline
+> hosting uses that same contract. Existing netplay builds and port host helpers
+> remain supported with their original 32-seat limit. Historical protocol revisions below explain wire fields, not an
+> alternative way to author new games. `players.max` chooses the room size without
+> a 32-seat ceiling for rules games. Revision 12 adds roster patches and ordered chained deltas.
+
 # Homie netplay contract, v1 (revision 11)
 
 **Authoring now:** New games use rules plus view and the server as host. Read the
@@ -55,11 +62,9 @@ revision-8 relay ignore every new field and frame):
   because the frame has no storage), `net.params` (the address's switches), `net.shell` (where the
   page's own controls sit over the game), `guardGestures()` for a touch game.
 - **Whose body** (section 25): `peer.occ` (which stay in a seat), `Roster.claim(…, occ)`,
-  the `admit` callback, and createRoom's takeover and adopt callbacks for a room revived from its
-  checkpoint and for a host that reconnects as host.
+  and restoring a room's holders from its checkpoint.
 - **Places** (section 26): a tie policy for results. **The relay's log** (section 27).
-- **Seat or solo** (section 28, added after 0.31.0 with no change to the wire): `createRoom({ fallback })`,
-  `room.standing`, `net.full`, `net.line()`, a bound on `reconnecting` (`reconnectMaxMs`), and typed
+- **Seat or solo** (section 28, added after 0.31.0 with no change to the wire):  `net.full`, `net.line()`, a bound on `reconnecting` (`reconnectMaxMs`), and typed
   readers for `net.prefs` (section 24).
 - New optional fields `hello.ver`, `hello.feat`, `welcome.ver`, `welcome.stale`, `welcome.stall`,
   `peer.occ`, `peer.ver`, `peer.feat`, `snap.hb`; a relay → client `stale` frame; the final refusal
@@ -255,7 +260,7 @@ code.
 - **Room size.** `maxPlayers` comes from the game's netplay manifest: game.json's
   `netplay.maxPlayers`, or a `netplay.json` beside game.json or in the game's build
   (`maxPlayers` or `players.max`), else game.json's `players.max`, else 8. **A room holds
-  at most 32** (`SEAT_MAX`). `homie-studio build` writes the number into the catalogue and
+  chosen by the studio** (`players.max`). `homie-studio build` writes the number into the catalogue and
   the site's Table takes it from there; the first visitor of an empty room may lower it
   (`hello.max`), never raise it.
 - **A dropped seat is held 60 s** for its token, which covers a reload or a network blip.
@@ -1099,12 +1104,8 @@ function stepBots(dt: number): void {
 | `aiName(label)`, `stripAi(name)`, `AI_MARK`, `SKILLS`, `skillPreset(n, kids?)` | Names and the dial. |
 | `Roster({ …, policy })` | Keeps `aiSeats + guides` slots marked `agent` (a person never takes one); `claim(seat, name, agent?)` (hands `host`: the slot stays a bot, `agent.seat` set; hands `self`: claimed like a person's); `release(seat)` gives an agent's slot back as a seat kept for AI; `bots: 'off'` adds no filler. |
 
-`createRoom` (the port kit) does all of it: its roster keeps the AI seats, its join passes
-`p.agent`, it declares `caps: ['agents']`, and `room.skillOf(body)` is the dial. `BotBrain`
-takes `skill: () => room.skillOf(body)` and maps it: `reactionMs`, an aim error of
-`aimNoise × 0.8` rad, and a commitment of `2500 × (1.3 − 0.6 × aggression)` ms; `port/skill.ts`
-adds `jitter(s, maxPx)`, `engages(s, dt)` and `standoff(s, near, far)`. A ported game built on
-`BotBrain` gets the dial with a rebuild.
+Rules rooms provide the agent roster and skill dial. Declare deterministic bot inputs
+in `think`; presentation and controls remain in the view.
 
 **Old games and old relays.**
 - A game built with a helper before revision 6 plays on every server: doors, the human seat
@@ -1572,7 +1573,7 @@ and its page, so the wire did not change for it.
   that was, null when it was not late); on the play page `window.__shell.arrival` has `mode`,
   `by`, `explicitMs` (the page's clock) and `lateMs`, and `window.__shell.ready` the message
   itself. The fix is one option: `createNetplay({ arrival: 'game' })`, or in a port
-  `createRoom({ netplay: { arrival: 'game' } })`.
+  the rules view's transport options.
 
 ## 22. The link, said out loud (revision 9)
 
@@ -1608,7 +1609,7 @@ A page stands in one of six places with its room, and the helper says which:
   | `alone`, a room still on the old build (`room-stale`) | `alone` | Playing on your own · this room opens when its players have the new version |
   | `alone`, the room did not come back | `alone` | Playing on your own · the room dropped, still trying… |
   | `online`, every seat taken (`net.full`) | `full` | This room is full · watching until a seat is free |
-  | `online`, the game's own sentence (`net.line(text)`; `createRoom`'s `fallback` uses it) | `seat` | for example: Playing on your own until the next round |
+  | `online`, the game's own sentence (`net.line(text)`) | `seat` | for example: Playing on your own until the next round |
   | `closed`: `room-full`, `too-many` | `closed` | This room is full. (with "· playing on your own" once it does) |
   | `closed`: `replaced`, `kicked`, `room-closed`, `version` | `closed` | This game is open in another tab. / This room is closed. / This game needs a reload to play online. |
   | `closed`: `stale`, or a newer build is live | `stale` | This game was updated. Tap to reload. |
@@ -1625,9 +1626,7 @@ A page stands in one of six places with its room, and the helper says which:
   `reconnectMaxMs`, in `alone` (before this bound a replica whose room never came back showed a
   frozen round and "Reconnecting…" for good). Going `alone` from a room is a `role` event (`role:
   'host'`, `why: 'reconnect-timeout'`), also for a page that was the room's host: its seat went
-  with the room. `createRoom` keeps the round such a host was running (its own body and score,
-  everybody else's body a bot's); a game on raw `createNetplay` starts a round of its own, as it
-  does for `relay-timeout`. `closed` is said in words and the play page offers the way out.
+  with the room. Rules views start their offline rules runtime when going alone. `closed` is said in words and the play page offers the way out.
 - **`net.full`** is true when this browser asked to play and every seat is taken: it is in the
   room with no seat (`seat === null`, role `screen`) and the relay seats it when one frees up (a
   `role` event with `why: 'seated'`). Section 28 says what a game does meanwhile.
@@ -1875,114 +1874,11 @@ const off = guardGestures({ touch: 'canvas, [data-action]' });   // once, early;
   listeners and the stylesheet are tested, and emulated touch does not raise the callout, so try
   a real long press on a real iPhone and Android phone before calling it done.
 
-## 25. Whose body: seats that change hands (revision 9)
-
-A seat number is not a person. The relay reuses a number when its player has been gone a minute
-(or sooner, in a full room), a host can be cut off while people come and go, and a round can
-outlive everyone in it. Three cases went wrong in real games; all three now run the same code as
-an ordinary join.
-
-**`peer.occ`: which stay in the seat.** The relay numbers every stay: a new number whenever a seat
-is given to a new token, the same number across that browser's reloads and reconnects, kept
-through a deploy. `Roster.claim(seat, name, agent, occ)` and `Roster.reconcile(peers)` (pass
-`occ`) use it: the same stay keeps its body; a seat that changed hands gives the old body back to
-a bot and admits the newcomer like any arrival. `roster.occupants()` belongs in the checkpoint
-beside `roster.toJSON()`, and `Roster.from(slots, opts, occupants)` reads it back. With a relay
-that says no `occ`, a seat is taken to be the same player's, as before, and the helper still knows
-its own: `net.resumed` is true when its welcome gave back the seat its token named.
-
-**The takeover callbacks cover every way a body changes hands** (`createRoom`):
-
-| How | `onTakeover(body, info)` | `adopt(body)` |
-|---|---|---|
-| A person joins a running round | `{ why: 'join', own: false }` | on the joiner, when the host resets its body |
-| A visitor revives a room from its checkpoint | `{ why: 'restore', own: true }` for its own body, and for anyone claimed with it | on the new host, with the body it took |
-| A replica is promoted and someone arrived since the last checkpoint | `{ why: 'migrate' }` | on that player, by reset |
-| A host reconnects as host and someone arrived while it was away | `{ why: 'join' }` (the missed `join` is replayed) | on that player, by reset |
-| The same player comes back to the body they held | not called when the slot never left them; called with `back: true` when they left and returned (a reload) | as before |
-
-`info.back` is true when the player held that body before. The default (no `onTakeover`) is still
-"score 0, where it stands".
-
-**The restored room.** Everyone leaves; the relay keeps the round for 60 s; a new visitor arrives
-before that. It is welcomed as host with the checkpoint (`why: 'resumed'`), and the round goes on
-with the clock where it was. Before revision 9 the newcomer inherited a departed player's body
-without `onTakeover` (their score, with eleven seconds left) and without `adopt` (its local pose
-stayed at a default, so it could not move until the next round). Now `createRoom` hands the
-departed players' bodies back to bots, claims one for the newcomer through `admit`, calls
-`onTakeover` and then `adopt`. A player who comes back to their own room (their token) keeps
-their body and score, and is adopted onto it. A game on raw `createNetplay` does the same with
-`roster.reconcile(peers)` in its `role` handler: treat every slot in `claimed` as a takeover.
-
-**The host that reconnects as host.** A host whose socket drops and comes back while nobody else
-could host gets a welcome, not a `role` (its role did not change), so its `role` handler never
-ran, and the relay never told it who came or went meanwhile. A player who arrived in that window
-had no body for the rest of the visit, and one who left kept a frozen one. The helper now says
-the difference as the events it would have been: `leave` (with `why: 'gone'`) and `join`, by seat,
-with a seat whose `occ` changed as both. Nothing to write: the handlers a game already has do it.
-The same change stopped `createRoom` calling `onTakeover` (and zeroing the score) for a player
-whose body never left them.
-
-**`admit`: which body an arrival takes.** By default a newcomer takes the lowest bot's body. In an
-elimination round that can be a dead one while living bots stand by.
-
-```ts
-createRoom({
-  admit: (candidates, who) => candidates.find((b) => b.alive) ?? null,   // null: none will do
-});
-new Roster({ min, max, admit: (slots, who) => pickSlotId(slots) });      // raw: slots in, a slot id out
-```
-
-- Asked for every NEW arrival: a fresh join, a restored room's claims, a promoted host's
-  reconcile, a missed join replayed. Return the body (the slot id, on `Roster`), `undefined` for the
-  default, or `null` for "none of these": a new body is spawned while the room has space, and when
-  it has none the default applies (a seated person always gets a body).
-- Never asked for a player returning to the body they held: an eliminated player who reloads gets
-  their own dead body back, not a way into the round. `occ` is how the roster knows.
-- Never offered a seat kept for AI when a person arrives; an agent is offered the kept seats first
-  (the reservation of section 17 holds).
-- Decide from the bodies' own state so the next host makes the same choice. The host still resets
-  the body (`net.reset`), announces the roster and checkpoints, as for any claim.
-
-**The late-join checklist.** A game is not done with joining until each of these is true in two
-real browsers:
-
-1. A joiner mid-round takes a bot's body, the right one (`admit`), is reset onto it and can move.
-2. The host leaves; the other browser continues the same round; a joiner after that still works.
-3. A joiner who reloads comes back to the same body (and the same score, if the game keeps it:
-   `info.back`).
-4. **Everyone leaves, and a new visitor enters before the room is forgotten (60 s).** The round is
-   the same one; the visitor has a body it did not inherit silently (`onTakeover` ran, `adopt` ran),
-   can move at once, and is ranked as a newcomer.
-5. The same, but the visitor is one of the players who left (same tab, reloaded): their own body
-   and score.
-6. The host's network drops for a second while a third browser joins: after it reconnects, three
-   people, three bodies, and nobody's score was reset.
-7. A deploy with tabs open: section 23.
-8. **A slow browser joins mid-round** (throttle one to "4x slowdown" and open the room's link
-   while a round runs, then again during the results). Within a few seconds it is in one of the
-   places section 28 names, and the screen says which: playing in the room on its own body,
-   playing on its own with bots, or watching with a line that says until when. Never a body-less
-   camera with nothing said, never "Reconnecting…" on a page that was never connected, and never
-   a line left up after the link came back. `room.standing` (or `net.link`, `net.full` and your
-   own roster on raw `createNetplay`) is what a test asserts.
-
-## 26. Places and ties (revision 9)
-
-`createRoom` ranks a round's results by score. The order of the rows was always: higher score
-first, then **people before bots**, then **the lower slot**. Two bodies on 61 points were shown
-first and second with nothing saying why. The order is the tiebreaker and is unchanged; what
-place a tie gets is now the game's to say:
-
-| `createRoom({ ties })` | 61, 61, 40, 12 | |
-|---|---|---|
-| `'order'` (default) | 1, 2, 3, 4 | What results always were: the order above is the place. Say so to players if you keep it ("ties go to the player, then the earlier seat"). |
-| `'shared'` | 1, 1, 3, 4 | Standard competition places: equal scores share one and the next is skipped. |
-| `'dense'` | 1, 1, 2, 3 | Equal scores share one and none is skipped. |
+## 25–26. Player bodies and places
 
-`placesOf(scores, ties)` is the same rule for a game that ranks its own rows (pass the scores in
-the order you show them). A game with a real tiebreaker (time, kills, who got there first) sorts
-by it before ranking and keeps `'order'`.
+Rules own player bodies, arrival, departure and round results. Use the rules
+contract and `openRoom` view. The port-owned `createRoom` host scaffold and its
+callbacks remain available for existing games in 0.45.0. New games use rules plus view.
 
 ## 27. The relay's log (revision 9)
 
@@ -2009,61 +1905,10 @@ and `failed`.
   host is closed, it comes from somewhere these boundaries do not cover; the `leave` and
   `socket-gone` lines beside it say what the room was doing at that second.
 
-## 28. Seat or solo: a page with no body (after 0.31.0)
+## 28. A page waiting for its body
 
-A page can be in its room and have nothing to play: `net.link === 'online'`, and no body. It
-happened three ways, and none of them said anything:
-
-| How | What the page had | What happens now |
-|---|---|---|
-| The relay seated the player and the host had no body free (every body was somebody's: a server stopped keeping seats for AI mid-round, or the game has fewer bodies than the room has seats). The claim was tried once, at the join. | a seat, role `replica`, no body, for the rest of the visit | The host seats everybody who is waiting **whenever a body frees up and at every round start** (`createRoom`; the starters on raw `createNetplay` do the same in `seatWaiting()`). |
-| Every seat is taken. The relay lets the page in with no seat. | `seat === null`, role `screen`, nothing said | `net.full` is true and the line says so; the relay seats it when a seat frees up, as before. |
-| The page was reset by its host before a snapshot showed its body. | a body it never adopted (it could not move until the next round) | `createRoom` owes the adoption until a snapshot shows the body. |
-
-**The recipe is an option, not prose.** `createRoom` decides what a body-less page does, after
-`seatWaitMs` (default 4000, 1000 to 30000) of time it could actually listen:
-
-```ts
-const room = createRoom({
-  // …
-  fallback: 'solo',        // 'wait' (default) | 'solo' | 'spectate'
-  seatWaitMs: 4000,
-  onStanding: (s) => hud.say(s.line),   // optional: the line over the game says it already
-});
-room.standing;   // { state: 'joining' | 'playing' | 'solo' | 'watching' | 'waiting' | 'closed', why, line }
-```
-
-| `fallback` | What the page does while the room has no body for it | The line |
-|---|---|---|
-| `'wait'` (default) | What a game did before: it waits. Now it says so, and the host seats it as above. | Waiting for a place in this round… |
-| `'solo'` | A private round with bots, here: `room.hosting` is true, `room.mine()` is its body, `room.solo` is true. Nothing of it is sent (no round, roster, snapshot or `room.send`). The moment the room has a body for it, the private round ends and `adopt` is called with the room's body. | Playing on your own until the next round (in a full room: This room is full · playing on your own until a seat is free) |
-| `'spectate'` | No body; `room.viewBody()` follows a person in the room until it has one. | Watching until the next round |
-
-`room.standing` ties it to the link states of section 22, so a game (and a test) asks one thing:
-
-| `standing.state` | `why` | `net.link` | Can the player play? |
-|---|---|---|---|
-| `joining` | `connecting`, `no-body`, `full`, `reconnecting` | `connecting`, or `online` inside `seatWaitMs` | not yet; a line after 0.7 s ("Joining the round…") |
-| `playing` | `seated`, `reconnecting` | `online` (or `reconnecting`, bounded) | yes, in the room |
-| `solo` | `alone`, `offline` (the link); `no-body`, `full` (the fallback) | `alone`, `offline`, or `online` | yes, on their own, with bots |
-| `watching` | `screen` (a watcher or a big screen, by choice); `no-body`, `full` (`spectate`) | `online` | no; the line says until when |
-| `waiting` | `no-body`, `full` (`wait`) | `online` | no; the line says so |
-| `closed` | `net.closedWhy` | `closed` | no; the line says why and the play page offers another room |
-
-- **Solo is the game's own host code, run privately.** `onRoundStart` runs for the private round
-  (with the room's round number, a clock of its own) and the game's rules move its bots, exactly
-  as offline. A score made there stays there: the room's body starts as the host made it. Events
-  from the real room still arrive on `room.on('event')` while solo; a game that plays sounds for
-  them checks `room.solo`.
-- **The wait counts only time the page could listen**, like the wait for the welcome: a page
-  blocked for six seconds by its own boot runs its timers before the snapshots queued behind
-  them, and a body that is already on its way is not "missing".
-- **The default changes nothing a working game did.** A page that gets its body with its first
-  snapshots never sees any of this; `'wait'` only adds the line and the host's second try.
-- **On raw `createNetplay`** there is no option: do what the starters do. Host: try the claim
-  again on `leave` and at a round's rollover (`seatWaiting()`). Everyone: test
-  `net.link === 'reconnecting'` for your own "Reconnecting…", read `net.full`, and say where the
-  player stands with `net.line('…')`.
+The rules view owns connecting, playing, offline and closed states. The same
+rules run for offline/browser play; a separate port host is not supported.
 
 ## 29. The server as host (revision 10)
 

package/netplay/netplay.ts

@@ -88,9 +88,9 @@
 
 export const NETPLAY_VERSION = 1;
 /** The contract revision this helper speaks (NETPLAY.md): its hello says so (`rev`), and so does every build of it. */
-export const NETPLAY_REVISION = 11;
+export const NETPLAY_REVISION = 12;
 /** In every bundle that includes the helper: `homie-studio build` reads it to tell the office which revision a build speaks. */
-export const NETPLAY_MARK = 'homie-netplay-rev:11';
+export const NETPLAY_MARK = 'homie-netplay-rev:12';
 
 export type Role = 'host' | 'replica' | 'screen';
 export type Device = 'phone' | 'desk' | 'tv';
@@ -802,13 +802,13 @@ export interface Netplay<S = unknown, A = unknown, C = unknown> {
   /**
    * This browser asked to play and every seat is taken: it is in the room with no seat (`seat === null`, role
    * `screen`) and the relay seats it when one frees up (a `role` event with `why: 'seated'`). The line over the game
-   * says so; `createRoom({ fallback })` decides what the page does meanwhile.
+   * says so; the rules view decides what the page shows meanwhile.
    */
   readonly full: boolean;
   /**
    * The line over the game is the game's to use too: one short sentence about where this player stands ("Playing
    * on your own until the next round"), or null to take it away. Shown while the link is `online`; a link that is
-   * down says its own line first. `createRoom` uses it for its `fallback`.
+   * down says its own line first.
    */
   line(text: string | null): void;
   /** `connectClock: 'game'`: the game has finished booting; the wait for the room's welcome starts now. Once. */
@@ -1046,7 +1046,7 @@ export interface RosterOptions {
   max: number;
   botName?: (slot: number) => string;
   /**
-   * Revision 6: the room's policy (createRoom passes `() => net.policy`). A hybrid or beginner server keeps
+   * Revision 6: the room's policy (read from `net.policy`). A hybrid or beginner server keeps
    * `aiSeats + guides` slots for AI (marked `agent`, never given to a person); `bots: 'off'` adds no other filler.
    */
   policy?: () => Policy | null;
@@ -1371,7 +1371,7 @@ export function cleanFeatures(list: unknown): string[] {
 
 /**
  * PLACES (NETPLAY.md section 26): rows ranked by score, with a tie policy said out loud. `rows` must already be in the
- * order to show them (the tiebreak is the caller's: createRoom puts people before bots, then the lower slot).
+ * order to show them (the tiebreak is the caller's).
  * `'order'` (the default, what results always were): places 1, 2, 3… in that order, so two equal scores get different
  * places. `'shared'`: standard competition places, equal scores share one and the next is skipped (1, 1, 3).
  * `'dense'`: equal scores share one and none is skipped (1, 1, 2).
@@ -1799,7 +1799,7 @@ export function createNetplay<S = unknown, A = unknown, C = unknown>(opts: Netpl
     const late = playableSent && arrived.by === 'auto' && arrived.playableMs !== null ? arrived.explicitMs - arrived.playableMs : null;
     if (late !== null && late >= 250) {
       arrived.lateMs = late;
-      console.warn(`[netplay] net.playable() came ${late} ms after the arrival card had already lifted: this game uses the automatic arrival (seated, with the room's state), so its own word changed nothing and the card left before the game was ready. Pass createNetplay({ arrival: 'game' }) (createRoom: netplay: { arrival: 'game' }) so the card waits for net.playable().`);
+      console.warn(`[netplay] net.playable() came ${late} ms after the arrival card had already lifted: this game uses the automatic arrival (seated, with the room's state), so its own word changed nothing and the card left before the game was ready. Pass createNetplay({ arrival: 'game' }) so the card waits for net.playable().`);
     }
     post?.({ what: 'ready', by: 'game', mode: arrival, ms: arrived.explicitMs, ...(arrived.lateMs !== null ? { lateMs: arrived.lateMs } : {}) });
     sayPlayable('game');
@@ -2437,7 +2437,12 @@ export function createNetplay<S = unknown, A = unknown, C = unknown>(opts: Netpl
         return;
       }
       case 'roster': {
-        slots = (m['slots'] as Slot[]) ?? null;
+        if (m['patch'] === true) {
+          const next = new Map((slots ?? []).map(row => [row.slot, row]));
+          for (const slot of (m['removed'] as number[] ?? [])) next.delete(slot);
+          for (const row of (m['slots'] as Slot[] ?? [])) next.set(row.slot, row);
+          slots = [...next.values()].sort((a, b) => a.slot - b.slot);
+        } else slots = (m['slots'] as Slot[]) ?? null;
         post?.({ what: 'roster', slots });
         if (slots) emit('roster', slots);
         return;
@@ -2965,7 +2970,7 @@ export function createNetplay<S = unknown, A = unknown, C = unknown>(opts: Netpl
     if (full) { full = false; post?.({ what: 'full', full: false }); }
     aloneWhy = why;
     // A page that gives up on a room it WAS in says so as a role event even when it was that room's host: its seat is
-    // gone with the room, and the game seats itself again for a round of its own (createRoom keeps the round it had).
+    // gone with the room, and the game seats itself again for a round of its own.
     if (!roleKnown || role !== 'host' || (rulesGame && !rulesHost) || why === 'reconnect-timeout') setRole(canOffline ? 'host' : 'replica', why, rulesGame && kept ? { ckpt: { k: tick, st: now(), d: kept as C } } : {});
     // No shell at all is `offline` from the start; a room that never answered is `alone` (and still knocked at). A
     // page the relay refused for good stays `closed` (nothing is knocking): it plays by itself and its line says why.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@homie-rocks/studio",
-  "version": "0.44.3",
+  "version": "0.45.0",
   "description": "A studio for games, music and video on its own Cloudflare: scaffold, multiplayer starters on the netplay contract, a port toolkit that makes existing single-player web games multiplayer, the site Worker with public rooms (Table/Lobby Durable Objects and D1, all on the free Workers plan, no payment method), 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/host.ts

@@ -100,6 +100,7 @@ export interface Host {
   readonly paused: boolean;
   readonly people: number;
   readonly viewRadiusM: number | null;
+  readonly viewSettings: Compiled['settings']['view'];
   frame(m: Record<string, unknown>): void;
   /** Start the tick loop (the first person has joined). */
   start(): void;
@@ -768,6 +769,7 @@ export function createHost(o: HostOptions): Host {
   }
 
   return {
+    get viewSettings() { return c.settings.view; },
     get viewRadiusM() { return c.settings.view?.radiusM ?? null; },
     get tick() { return core.tick; },
     get epoch() { return epoch; },

package/rules/interest.mjs

@@ -1,41 +1,77 @@
 /** Per-connection state delivery. Pure data, shared by the relay and the view.
- * Deltas name a keyframe, never an unacknowledged previous delta. Losing a delta
- * therefore loses no baseline. A new keyframe bounds recovery to one second.
+ * Deltas may name a periodic keyframe or the previous ordered frame. A missing
+ * chained predecessor is ignored until the next keyframe (at most one second).
  * No history grows with time: one keyframe per connection, no per-frame queue.
  */
+const spatial = new WeakMap(), controls = new WeakMap();
+function indexFor(snap, radius) {
+  let byRadius = spatial.get(snap.d[1]);
+  if (!byRadius) { byRadius = new Map(); spatial.set(snap.d[1], byRadius); }
+  if (byRadius.has(radius)) return byRadius.get(radius);
+  const own = new Map(), cells = new Map(), order = new Map();
+  const size = radius > 0 ? radius : 1;
+  for (const [i, e] of snap.d[1].entries()) {
+    order.set(e, i);
+    if (e[9] !== undefined && e[10] !== 1) own.set(e[9], e);
+    const p = e[3], key = `${Math.floor(p[0]/size)},${Math.floor(p[1]/size)},${Math.floor((p[2]??0)/size)}`;
+    const list = cells.get(key) ?? []; list.push(e); cells.set(key, list);
+  }
+  const index = { own, cells, size, order }; byRadius.set(radius,index); return index;
+}
 export function interestSnapshot(snap, seat, radiusM) {
   const [round, entities] = snap.d;
-  const own = seat === null ? null : entities.find(e => e[9] === seat && e[10] === 0);
-  const visible = own && radiusM !== null ? entities.filter(e => {
-    const p = e[3], q = own[3];
-    return e === own || (p[0] - q[0]) ** 2 + (p[1] - q[1]) ** 2 + ((p[2] ?? 0) - (q[2] ?? 0)) ** 2 <= radiusM ** 2;
-  }) : seat === null ? entities : own ? entities : [];
-  // Collision revisions are prediction inputs, independent of visual interest.
-  // Deliver all geometry: authored sweeps/dashes need not fit inside the view radius.
-  return { ...snap, d: [round, visible, ...snap.d.slice(2)], c: (snap.c ?? []).filter(row => row[0] === seat) };
+  let visible = entities;
+  if (seat !== null) {
+    const index = indexFor(snap, radiusM), own = index.own.get(seat);
+    visible = [];
+    if (own && radiusM === null) visible = entities;
+    else if (own) {
+      const q=own[3], x=Math.floor(q[0]/index.size), y=Math.floor(q[1]/index.size), z=Math.floor((q[2]??0)/index.size);
+      for(let dx=-1;dx<=1;dx++)for(let dy=-1;dy<=1;dy++)for(let dz=-1;dz<=1;dz++)
+        for(const e of index.cells.get(`${x+dx},${y+dy},${z+dz}`)??[]) {
+          const p=e[3];
+          if(e===own||(p[0]-q[0])**2+(p[1]-q[1])**2+((p[2]??0)-(q[2]??0))**2<=radiusM**2)visible.push(e);
+        }
+      // Snapshot order is part of the view contract, even though cells are not.
+      visible.sort((a,b)=>index.order.get(a)-index.order.get(b));
+    }
+  }
+  let control = snap.c && controls.get(snap.c);
+  if (!control) { control = new Map((snap.c ?? []).map(row => [row[0], row])); if (snap.c) controls.set(snap.c, control); }
+  return { ...snap, d: [round, visible, ...snap.d.slice(2)], c: control.has(seat) ? [control.get(seat)] : [] };
 }
+const encodedRows = new WeakMap();
+const rowText = row => {
+  let text=encodedRows.get(row);
+  if(!text){text=row.map(v=>JSON.stringify(v));encodedRows.set(row,text);}
+  return text;
+};
 
-export function snapshotEncoder(keyframeTicks) {
+export function snapshotEncoder(keyframeTicks, chained = false) {
   let base = null;
-  let rows = new Map();
+  let rows = new Map(), keyTick = -Infinity;
   return {
-    reset() { base = null; rows.clear(); },
-    encode(snap) {
-      if (!base || snap.e !== base.e || snap.k <= base.k || snap.k - base.k >= keyframeTicks) {
-        base = snap;
-        rows = new Map(snap.d[1].map(e => [e[0], e.map(v => JSON.stringify(v))]));
+    reset() { base = null; rows.clear(); keyTick = -Infinity; },
+    encode(snap, seat = null) {
+      if (!base || snap.e !== base.e || snap.k <= base.k || snap.k - keyTick >= keyframeTicks) {
+        base = snap; keyTick = snap.k;
+        rows = new Map(snap.d[1].map(e => [e[0], rowText(e)]));
         return snap;
       }
       const present = new Set(), changed = [];
+      const own = chained && seat !== null ? snap.d[1].filter(e => e[9] === seat && e[10] !== 1) : null;
       for (const entity of snap.d[1]) {
         const id = entity[0]; present.add(id);
+        if (own?.includes(entity)) continue;
         const before = rows.get(id);
         if (!before) { changed.push(entity); continue; }
         let mask = 0; const values = [];
-        for (let i = 1; i < entity.length; i++) if (JSON.stringify(entity[i]) !== before[i]) { mask |= 1 << i; values.push(entity[i]); }
+        for (let i = 1; i < entity.length; i++) if (rowText(entity)[i] !== before[i]) { mask |= 1 << i; values.push(entity[i]); }
         if (mask) changed.push([id, mask, values]);
       }
-      return { ...snap, d: { base: base.k, round: snap.d[0], ...(snap.d.length > 2 ? { collision: snap.d[2] } : {}), changed, removed: [...rows.keys()].filter(id => !present.has(id)) } };
+      const out = { ...snap, d: { base: base.k, round: snap.d[0], ...(snap.d.length > 2 ? { collision: snap.d[2] } : {}), changed, removed: [...rows.keys()].filter(id => !present.has(id)), ...(chained ? { chain: true } : {}), ...(own ? { own } : {}) } };
+      if (chained) { base = snap; rows = new Map(snap.d[1].map(e => [e[0], rowText(e)])); }
+      return out;
     },
   };
 }
@@ -57,8 +93,18 @@ export function snapshotDecoder() {
         return snap;
       }
       const d = snap.d;
-      if (!base || !d || d.base !== base.k || snap.e !== base.e || snap.k <= base.k) return null;
+      if (!base || !d || snap.e !== base.e || snap.k <= base.k) return null;
+      if (d.own !== undefined && (!Array.isArray(d.own) || !d.own.every(e => Array.isArray(e) && e.length >= 9 && typeof e[0] === 'string'))) return null;
       if (!Array.isArray(d.round) || !Array.isArray(d.removed) || !Array.isArray(d.changed)) return null;
+      if (d.base !== base.k) {
+        // A skipped remote delta must not stall local prediction or collider edits.
+        // Keep the remote baseline unchanged until a keyframe repairs the chain.
+        if (!d.chain || !d.own?.length || !Array.isArray(d.round)) return null;
+        const visible = new Map(rows);
+        for (const id of d.removed) visible.delete(id);
+        for (const e of d.own) visible.set(e[0], e);
+        return { ...snap, d: [d.round, [...visible.values()], ...(d.collision === undefined ? [] : [d.collision])] };
+      }
       const next = new Map(rows);
       for (const id of d.removed) next.delete(id);
       for (const change of d.changed) {
@@ -75,7 +121,46 @@ export function snapshotDecoder() {
         if (j !== change[2].length) return null;
         next.set(entity[0], entity);
       }
-      return { ...snap, d: [d.round, [...next.values()], ...(d.collision === undefined ? [] : [d.collision])] };
+      for (const e of d.own ?? []) next.set(e[0], e);
+      const decoded = { ...snap, d: [d.round, [...next.values()], ...(d.collision === undefined ? [] : [d.collision])] };
+      if (d.chain) { base = decoded; rows = next; }
+      return decoded;
     },
   };
 }
+
+/** Studio-chosen visual precision and rates. The controlled body stays exact.
+ * Exits are immediate even between far updates; new arrivals never wait.
+ */
+const quantizedRows = new WeakMap();
+export function scheduledView({ radiusM = null, precisionM = 0, nearM = null, farHz = null } = {}, tickHz = 20) {
+  let previous = new Map(), epoch = null;
+  return (snap, seat) => {
+    if (snap.e !== epoch) { previous.clear(); epoch = snap.e; }
+    const selected = interestSnapshot(snap, seat, radiusM);
+    const own = selected.d[1].find(e => e[9] === seat && e[10] !== 1);
+    const next = new Map();
+    const entities = selected.d[1].map(entity => {
+      let row = entity;
+      if (entity !== own) {
+        const distance = own ? Math.hypot(...entity[3].map((n, i) => n - (own[3][i] ?? 0))) : 0;
+        const old = previous.get(entity[0]);
+        const interval = farHz && nearM !== null && distance > nearM ? Math.max(1, Math.round(tickHz / farHz)) : 1;
+        if (old && snap.k % interval !== 0) row = old;
+        else if (precisionM > 0) {
+          let versions = quantizedRows.get(entity);
+          if (!versions) { versions = new Map(); quantizedRows.set(entity, versions); }
+          row = versions.get(precisionM);
+          if (!row) {
+            row = entity.slice();
+            for (const i of [3, 4]) row[i] = entity[i].map(n => Number((Math.round(n / precisionM) * precisionM).toPrecision(12)));
+            versions.set(precisionM, row);
+          }
+        }
+      }
+      next.set(entity[0], row); return row;
+    });
+    previous = next;
+    return { ...selected, d: [selected.d[0], entities, ...selected.d.slice(2)] };
+  };
+}

package/rules/rules.ts

@@ -181,7 +181,7 @@ export interface RoomSettings {
   tickHz: number;
   inputHz: number;
   /** Omit the radius to send the whole room. No implicit visibility or bandwidth cap. */
-  view: { radiusM: number | null };
+  view: { radiusM: number | null; precisionM?: number; nearM?: number | null; farHz?: number | null };
   durability: { movementSeconds: number };
   budget: { tick: number };
   predict: { catchM: number | null; catchUp: number; snapM: number | null; blendMs: number; interpMs: number | null };
@@ -229,13 +229,13 @@ export function roomSettings(raw: unknown): { settings: RoomSettings; problems:
   if (host === 'browser' && r.view?.radiusM != null) problems.push('"room.view.radiusM" needs room.host "server"; browser hosting sends the whole room');
   if (r.view !== undefined) {
     if (!r.view || typeof r.view !== 'object' || Array.isArray(r.view)) problems.push('"room.view" is an object with an optional radiusM');
-    else for (const key of Object.keys(r.view)) if (key !== 'radiusM') problems.push(`"room.view.${key}" is not a setting; use radiusM`);
+    else for (const key of Object.keys(r.view)) if (!['radiusM', 'precisionM', 'nearM', 'farHz'].includes(key)) problems.push(`"room.view.${key}" is not a setting; use radiusM, precisionM, nearM or farHz`);
   }
   const p = r.predict && typeof r.predict === 'object' ? r.predict : {};
   return {
     settings: {
       host, offline, tickHz, inputHz,
-      view: { radiusM: r.view?.radiusM === null ? null : num('view.radiusM', r.view?.radiusM, null) },
+      view: { radiusM: r.view?.radiusM === null ? null : num('view.radiusM', r.view?.radiusM, null), ...(r.view?.precisionM !== undefined ? { precisionM: num('view.precisionM', r.view.precisionM, 0) as number } : {}), ...(r.view?.nearM !== undefined ? { nearM: num('view.nearM', r.view.nearM, null) } : {}), ...(r.view?.farHz !== undefined ? { farHz: whole('view.farHz', r.view.farHz, 1, tickHz, tickHz) } : {}) },
       durability: { movementSeconds: whole('durability.movementSeconds', r.durability?.movementSeconds, 1, 60, 1) },
       budget: { tick: Math.max(1, Math.floor(num('budget.tick', r.budget?.tick, budgetFor(tickHz)) as number)) },
       predict: { catchM: num('predict.catchM', p.catchM, null), catchUp: num('predict.catchUp', p.catchUp, 1.25) as number, snapM: num('predict.snapM', p.snapM, null), blendMs: num('predict.blendMs', p.blendMs, 100) as number, interpMs: num('predict.interpMs', p.interpMs, null) },

package/starters/coin-dash/game.json

@@ -2,10 +2,20 @@
   "id": "coin-dash",
   "name": "Coin Dash",
   "blurb": "Run for the coins before the others do. Sixty-second rounds, and the score is kept on the server, where nobody can change it.",
-  "players": { "min": 1, "max": 8 },
+  "players": {
+    "min": 1,
+    "max": 8
+  },
   "entry": "src/view.ts",
   "example": true,
-  "netplay": { "v": 1, "public": true },
-  "room": { "host": "server" },
-  "landing": { "pitch": "Run for the coins. First one there takes it.", "controls": { "phone": "Drag to run.", "computer": "WASD or arrows to run." } }
+  "room": {
+    "host": "server"
+  },
+  "landing": {
+    "pitch": "Run for the coins. First one there takes it.",
+    "controls": {
+      "phone": "Drag to run.",
+      "computer": "WASD or arrows to run."
+    }
+  }
 }

package/starters/ember-vale/game.json

@@ -8,10 +8,6 @@
   },
   "roundSeconds": 90,
   "entry": "src/view.ts",
-  "netplay": {
-    "v": 1,
-    "public": true
-  },
   "saves": true,
   "decide": false,
   "landing": {

package/starters/ember-vale/src/view.ts

@@ -1,7 +1,7 @@
 // Presentation only: openRoom gives predicted own movement and interpolated other bodies.
 // Send intent; rules decide outcomes. Keep rendered obstacles aligned with room.map.
 /** Ember Vale: server-run hunts, with the hero save and memorials owned by its player. */
-import { AI_MARK, BUBBLE_FONT, createBubbles, createControls, createLabels, paintBubbles, type BubbleIn, type BubbleOut, createSaves, easeView, exposePort, fitView, stripAi, type BodyBase, type Fit, type LabelIn, type LabelOut, type NetEvent } from '@homie-rocks/studio/port';
+import { AI_MARK, BUBBLE_FONT, createBubbles, createControls, createLabels, paintBubbles, type BubbleIn, type BubbleOut, createSaves, easeView, exposePort, fitView, stripAi, type Slot, type Fit, type LabelIn, type LabelOut, type NetEvent } from '@homie-rocks/studio/port';
 // The Game Lab: tunables, phases, tracks and overlays (no-ops outside the lab).
 import { lab } from '@homie-rocks/studio/lab';
 import { openRoom, type Entity } from '@homie-rocks/studio/rules/view';
@@ -28,7 +28,7 @@ const clamp = (v: number, a: number, b: number): number => Math.max(a, Math.min(
 
 /** The hero: the one thing that lasts. Kept in the save key 'hero'. */
 interface Hero { v: 1; name: string; level: number; xp: number; gold: number; hardcore: boolean; kills: number; deaths: number; born: number }
-interface Body extends BodyBase { x: number; y: number; hp: number; maxHp: number; level: number; face: number; flags: number; downUntil: number; atkAt: number; strikeAt: number; tx: number; ty: number; seenAt?: number; ax?: number; ay?: number }
+interface Body { slot: number; seat: number | null; name: string; bot: boolean; score: number; agent?: Slot['agent']; x: number; y: number; hp: number; maxHp: number; level: number; face: number; flags: number; downUntil: number; atkAt: number; strikeAt: number; tx: number; ty: number; seenAt?: number; ax?: number; ay?: number }
 /** A slime; while it is struck: where its push starts (kx, ky), along (kdx, kdy), from when (kat, after the hit-stop). */
 interface Slime { id: number; x: number; y: number; hp: number; maxHp: number; size: number; hitAt: number; lastHit: number; kx?: number; ky?: number; kdx?: number; kdy?: number; kat?: number }
 type SlimeRow = [id: number, x: number, y: number, hp: number, size: number];

package/starters/gem-rush/game.json

@@ -8,10 +8,6 @@
   },
   "roundSeconds": 60,
   "entry": "src/view.ts",
-  "netplay": {
-    "v": 1,
-    "public": true
-  },
   "landing": {
     "pitch": "Grab the gems. Bump your rivals away.",
     "controls": {