@homie-rocks/studio 0.44.3 → 0.45.1

package/CHANGELOG.md

@@ -17,6 +17,46 @@ 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.
 
+## [0.45.1] - 2026-10-09
+
+**Plugin 0.45.1** · [#75](https://github.com/homie-rocks/homie/pull/75)
+
+Crowds keep finding their way while a world changes.
+
+### Added
+
+- **Navigation for walking agents in games and apps.** `@homie-rocks/nav` bakes tiled walking surfaces, finds routes across slopes and links, carves obstacles, streams tiles and moves crowds at a fixed tick. It supports either up axis, seeded queries and grid paths, with matching saved-state continuation in browsers and Workers.
+- **Edits and chase targets preserve useful progress.** An unrelated edit leaves active searches alone. Replaced tiles and polygons invalidate only requests that touch them. Repeating a goal is a no-op; a nearby moving goal keeps the route already being found. Neighbour storage depends on agents rather than the distance between loaded tiles.
+- **Portable room saves.** Save the mesh and crowd together and restore them with the original tile assets in any order. Malformed topology and span connections are refused with navigation errors. Crowds have an explicit `detach()` and meshes never retain discarded crowds.
+
+### Upgrade notes
+
+- Based directly on main after [#85](https://github.com/homie-rocks/homie/pull/85) released studio 0.45.0. If main advances again, rebase and run `node scripts/renumber-release.mjs`.
+- Navigation is optional for games and apps; existing studios gain no dependency. After its first npm publication, install `@homie-rocks/nav@0.1.0` in a studio that needs it. Its README has the imports, storage contract, larger test commands and CPU measurements for Node and workerd, including edits and full room wakes.
+
+- **First npm publication needs a maintainer.** Navigation remains private and studio does not depend on it, so releases skip it safely. After merge, run `node scripts/first-publish-private.mjs nav`, then remove the private flag and update the lockfile and package contract test in a follow-up after trusted publishing is registered.
+
+## [0.45.0] - 2026-10-10
+
+**Plugin 0.45.0** · [#85](https://github.com/homie-rocks/homie/pull/85)
+
+Choose room sizes in the hundreds and reduce the state each phone downloads.
+
+### Added
+
+- Gate connections and batched concentrator links, with seat resumption after a link restart.
+- Studio-selected `room.view.precisionM`, `nearM` and `farHz` for distant bodies. The controlled body keeps its exact movement state.
+
+### Changed
+
+- For rules games, public room admission, rules compilation and deploy planning use the studio's requested `players.max` without the 32-player clamp.
+- Ordered snapshot deltas and a shared spatial index reduce repeated state work. Rules rooms have no automatic guest ceiling for shared carrier addresses.
+
+### Upgrade notes
+
+- Rebuilding generates the Gate and Concentrator exports, bindings and SQLite migration, including for studios whose Worker entry predates Gates. Custom Worker source and routes are preserved.
+- Existing browser-hosted netplay games keep building, checking and running with the restored port host/HUD helpers and importer. Their 32-seat limit remains; a larger request prints the rewrite guide. New games and starters use rules plus view. A release gate packs this version and checks two browsers finishing a round in the unchanged released 0.32.1 starter. Retirement is a later step, after studio migrations and a shipped one-command assisted rewrite.
+
 ## [0.44.3] - 2026-10-10
 
 **Plugin 0.44.3**

package/README.md

@@ -202,30 +202,28 @@ game its studio chooses to share, each with its own licence ("Game parts", below
   RIGHTS.md has no "A remix" line. Whether a file may be handed on in a shared part is still its licence's.
 - `homie-studio game remix` answers with a sentence that points to parts; `office launch --remixable` is ignored.
 
-## Rooms of up to 32
+## Room size and delivery
 
-Every room of a game has the seats its netplay manifest names: game.json's `netplay`
-block (`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; at most 32.
-Bots and a late joiner taking a bot's body work the same at 32 as at 4.
-Server rules keep running when a browser leaves; older browser-hosted games elect a new host. One address may hold every seat plus four sockets, so a party
-on one Wi-Fi (or strangers behind one carrier's address) fills a room with a TV beside it.
+`players.max` in game.json is the room's chosen positive integer capacity; omitted means 8.
+There is no 32-player ceiling or default per-address admission limit. Public games use
+rules plus view with `room.host: "server"`. Gates carry the browser connections and
+concentrators combine Gate links for larger rooms. Server rules survive browser departures.
+New browser/offline games use the same rules contract. Existing netplay games and their
+port host helpers remain supported for upgrades, with their original 32-seat limit.
+For larger rooms, follow `guides/game/REWRITE.md`.
 
-## A game's netplay manifest
+For example, a 300-player room can choose spatial delivery explicitly:
 
-For rules games the build derives the revision from the rules and view; do not bump
-`netplay.version` or tune browser host election. `room` sets hosting and tick rate.
-The version and stall settings below describe existing browser-hosted games.
-
-game.json `"netplay"` says more than the room's size. All of it is optional, and `homie-studio build`
-writes it to the catalogue for the site's rooms (`netplay/NETPLAY.md` sections 22 to 24):
+```json
+{"players":{"min":1,"max":300},"entry":"src/view.ts","room":{"host":"server","view":{"radiusM":12,"precisionM":0.01,"nearM":4,"farHz":5}}}
+```
 
-| Field | What it does |
-|---|---|
-| `maxPlayers` | Seats in a room, up to 32. |
-| `version` | The game's revision (a word or a number). Bump it when a change makes an already-open tab unable to play with a new one: a room then runs one build at a time, strangers are matched within the live build, and an old tab is told to reload at its round's break. |
-| `stallMs` | How long a host may send no snapshot before the room is handed to another browser: 1500 (the default) to 10000. A heavy 3D game whose frames hitch on a slow phone raises it; the helper also sends a heartbeat for up to 4 s while a host's frames are stuck. |
-| `params` | Names of the play page's query parameters to hand the game (`/<id>/play?seed=42`), beside `debug` and `q`, which always are. The game reads them as `net.params`. |
+The studio chooses the radius, precision and distant update rate for its game. The
+controlled body stays precise. Whole-room state remains the default. The build runs a
+local capacity trial; its numbers are not Cloudflare capacity guarantees. Test the actual
+mechanic at the chosen size. Rules builds derive their revision from rules and view;
+do not manually bump `netplay.version`. Optional `netplay.params` still selects play-page
+query parameters passed to the view, beside `debug` and `q`.
 
 The game's frame is sandboxed without `allow-same-origin` (it must never read the site's storage or
 the owner's session), so `localStorage` throws inside it: a setting or a personal best goes in
@@ -1238,8 +1236,8 @@ npx homie-studio port check my-game --url http://127.0.0.1:8787   # the owner te
 | `template/` (repository root), `scripts/template.mjs` | The public "Deploy to Cloudflare" template, generated from `new --template`. |
 | `lib/port.mjs` | `port plan` (reads a game and grades the port) and `port import`. |
 | `lib/port-check.mjs` | `port check`: held and alternating directions on keys, Android Chrome and iPhone WebKit touch, UI cover, two browsers finishing a round, a killed host, a late joiner, the big screen. |
-| `port/` | The port toolkit (`@homie-rocks/studio/port`, or `window.HomiePort` from `homie-port.js` in a static game): `createRoom`, the touch kit, keys, camera rules, bots, a HUD, sandbox shims, first-touch audio, `exposePort`; `fitView` and `createLabels` (`port/view.ts`): a flat world on every screen (the whole of it where it reads, else filling a phone held upright and following the player) and names that never pile up when bodies crowd (yours placed first, the rest moved or faded). |
-| `worker/index.mjs` | The site Worker and the `Table` (netplay relay, `room.mjs`) and `Lobby` Durable Objects; `/<game>/tv` is the big screen with a join QR (`qr.mjs`); `/<game>/watch` watches a live room from any player's view (NETPLAY.md section 16); `/music/<slug>/` and `/videos/<slug>/` are song and video pages (their files served with byte ranges, from the site's files or, once moved, from the studio's R2 at the same address; a loose file from `media put` at `/media/<key>`). `seats.mjs`: room sizes (up to 32). |
+| `port/` | The port toolkit (`@homie-rocks/studio/port`, or `window.HomiePort` from `homie-port.js` in a static game): the touch kit, keys, camera rules, bots, sandbox shims, first-touch audio, `exposePort`; `fitView` and `createLabels` (`port/view.ts`): a flat world on every screen (the whole of it where it reads, else filling a phone held upright and following the player) and names that never pile up when bodies crowd (yours placed first, the rest moved or faded). |
+| `worker/index.mjs` | The site Worker and the `Table` (netplay relay, `room.mjs`) and `Lobby` Durable Objects; `/<game>/tv` is the big screen with a join QR (`qr.mjs`); `/<game>/watch` watches a live room from any player's view (NETPLAY.md section 16); `/music/<slug>/` and `/videos/<slug>/` are song and video pages (their files served with byte ranges, from the site's files or, once moved, from the studio's R2 at the same address; a loose file from `media put` at `/media/<key>`). `seats.mjs`: studio-chosen room sizes. |
 | `worker/site.mjs`, `lib/site.mjs`, `lib/markdown.mjs`, `site/SITE.md` | The site: its sections, each game's landing, posts and their feeds, the look (theme tokens) and what the studio's `site/` folder overrides; the safe markdown posts are written in. `worker/pages.mjs`: the play page; `worker/arrival.mjs`: its arrival card. |
 | `worker/stats.mjs`, `worker/stats-page.mjs`, `lib/stats.mjs` | The studio's own stats: what is counted and how, the owner-only `/api/stats` and `/_studio/stats`, and `homie-studio stats`. |
 | `lib/media.mjs`, `media/MEDIA.md` | The `music/` and `videos/` manifests: which entries get a page, and where each file's bytes come from (the site itself up to 25 MiB a file, the studio's R2, or a link). `media list` shows it; `media move` puts the big ones in R2 and records each one's SHA-256; `media put` uploads a loose file to `/media/<key>`. |

package/guides/game/REWRITE.md

@@ -1,8 +1,10 @@
 # Rewrite a browser-hosted game as rules plus view
 
 Use this path when the owner asks to move an old game's rules onto the server.
-There is no automatic converter. An ordinary edit is not permission to rewrite;
-old games continue to work as they are. Read RULES.md before starting.
+There is no automatic converter yet. Version 0.45.0 keeps existing netplay games
+and their port host helpers working, with their original 32-seat limit. Larger
+rooms require this rewrite. Keep a baseline copy and preserve the game throughout.
+Read RULES.md before starting.
 
 1. Read this game's codex, manifest, entry, host loop, input, packing/checkpoint
    code, bots, saves and tests. Record what players must keep: controls, timings,

package/guides/game/RULES.md

@@ -36,7 +36,7 @@ export default defineRules({
 
 The map must contain a nonempty `spots.start` list for that example:
 `{"bounds":{"min":[-12,-7],"max":[12,7]},"boxes":[],"spots":{"start":[[-5,0],[5,0]]}}`.
-Declare `players.max` in game.json (1–32); use `entry: "src/view.ts"` and
+Declare `players.max` in game.json (a positive integer, including hundreds); use `entry: "src/view.ts"` and
 `room: { host: "server" }`. Only public tunables are visible in move.ts.
 
 `index.html` is the browser entry document; include `<script type="module" src="./assets/main.js"></script>`. The manifest names the source, but HTML loads this relative built bundle. Never point HTML at /src/view.ts: that URL is not served. The build rewrites assets/main.js to its hashed bundle. A minimal manifest is:
@@ -134,7 +134,7 @@ with a real touchscreen tap in Chrome; calling `element.click()` does not test
 touch delivery.
 Use `rounds: { seconds: 0, breakSeconds: 0 }` for manual rounds, and no fill bots
 for an app. A wall/TV watches without taking a seat. Each interactive phone
-takes a seat (up to 32); shared state is replicated, public and transient. An app's
+takes one of the room's declared seats; shared state is replicated, public and transient. An app's
 lasting, authorized business data belongs in `createAppRecords`, not in room fields.
 
 ## State and field types
@@ -680,8 +680,7 @@ check green. Never rename rules.ts away or fall back to old-style hosting.
 `room.probe` adds truthful frame/mechanic/render counters to the built-in rules probe.
 Use the normal build, local dev and two-browser check, then play the requested mechanic
 for a minute with delay. Movement should respond before the authoritative response;
-score and other shared outcomes still arrive with the network. Milestone 1 supports
-up to 32 seats; neither frame rate nor feel is guaranteed by a passing build.
+score and other shared outcomes still arrive with the network. The studio chooses `players.max`; neither frame rate nor feel is guaranteed by a passing build.
 
 Room state is saved automatically (default movementSeconds: 1, plus round end,
 pause and finish). After 60 seconds with no person the room ends even if screens or
@@ -690,7 +689,7 @@ server-verified money. All replicated fields are public, including disguised rol
 Use a separate authorized records service for private or lasting app records.
 
 
-## Spatial delivery (0.44.0; milestone 2 slice 1)
+## Spatial delivery (0.45.0; milestone 2 slice 2)
 
 For a server game with a larger map, the studio's AI can set
 `"room": { "view": { "radiusM": 32 } }` in game.json to send each player only
@@ -708,12 +707,33 @@ may be absent from room.each while its geometry still blocks movement.
 Shared state, effects, rosters and watcher state are still public: this is not a
 hidden-information feature. Browser hosting sends the whole room.
 
-A request for hundreds of players also needs the next Gates release: 0.44.0's
-public build/join path still has the milestone 1 restriction of 32 seats. Do not
-silently clamp a requested bigger game or claim this setting raises admission.
-When Gates ship, `players.max` will choose the room's layout automatically; the
-studio will not create or find infrastructure by hand. The slice plan and local
-300-client measurements are in docs/rooms-milestone-2-notes.md in Homie's repo.
+Set the room size in `players.max`. The same setting feeds rules compilation,
+public admission and the automatic Gate layout; there is no 32-seat clamp.
+For example, in game.json:
+
+```json
+{
+  "players": { "min": 1, "max": 300 },
+  "room": {
+    "host": "server",
+    "view": { "radiusM": 12, "precisionM": 0.01, "nearM": 4, "farHz": 5 }
+  }
+}
+```
+
+These are example visual settings, not defaults. `precisionM` rounds remote
+positions and velocities in the delivered view; controlled bodies stay exact.
+Remote bodies outside `nearM` update at `farHz`; visibility exits are immediate.
+Rules, collision, saves and shared state stay authoritative and unchanged.
+Views must interpolate distant motion and dispose/recreate entities on view exit
+and entry. Omit the settings for full precision and the room's normal tick rate.
+
+A small room embeds delivery in its Table. Larger rooms open Gate connections;
+more than eight Gates use concentrators. The studio template supplies their exports, bindings and
+migration; upgrade the template before deploying an existing studio. No infrastructure naming or studio admission ceiling is required.
+Read the local measurements and their limitations in
+`docs/rooms-milestone-2-notes.md` before making a capacity claim.
+
 ## Live collision geometry (0.44.1)
 
 ```ts

package/guides/game/SKILL.md

@@ -30,9 +30,10 @@ other games and every existing test file, including its import paths. If an old
 do not redirect the tests to a new helper file. Run the original test command.
 
 For a request involving a larger room or map, read RULES.md's **Spatial delivery**
-section. 0.44.0 can reduce what a server player receives with `room.view.radiusM`;
-Gates and public admission above 32 seats are the next slice. Choose a radius
-only when it fits the game. No rules rewrite or new profile is needed.
+section. `players.max` chooses the room size and Gate layout. Choose `room.view.radiusM`
+for the playable neighbourhood, and visual precision and far update rates to fit
+the game. Local measurements are in docs/rooms-milestone-2-notes.md; they are not
+Cloudflare or physical-phone capacity guarantees.
 
 ## Start it
 
@@ -80,7 +81,7 @@ make every change it needs in ONE file_edit with an edits list. Build after each
 coherent change across rules, movement and view; use diagnostics to guide the next edit.
 
 New games use `game.json` `"entry": "src/view.ts"`, `"room": { "host": "server" }`,
-and `players.max` at most 32. HTML loads `<script type="module"
+and a studio-chosen `players.max`. HTML loads `<script type="module"
 src="./assets/main.js"></script>`, not the source-file URL. Choose seats, tick rate (20 by default), dimensions and
 starter yourself from the request; never ask the person an engineering question.
 `coin-dash` is the smallest reference; `gem-rush` adds bumps; `ember-vale` adds
@@ -142,9 +143,10 @@ a plain browser bundle is not a multiplayer game.
   responsible half, preserve unrelated play, and rebuild. The build/state hashes
   manage compatibility automatically; do not hand-pack snapshots or bump netplay.version.
   Recheck the changed mechanic, a late join and a reload in two browsers.
-- **Changing an old-style game:** ordinary requested edits keep it working untouched
-  in its existing architecture. When its owner asks to move rules to the server,
-  follow [REWRITE.md](REWRITE.md). There is no automatic converter.
+- **Changing an old-style game:** existing netplay games keep working on 0.45.0
+  with their original 32-seat limit. Preserve their behavior on ordinary edits.
+  For a server migration or larger room, follow [REWRITE.md](REWRITE.md).
+  New games use rules plus view; there is no automatic converter yet.
 - Phones get touch, computers get keys; typed names and chat are text only.
   Keep native DOM buttons outside `guardGestures`' touch-drag selector; otherwise bind
   touch pointers explicitly. Verify actual touchscreen taps, not only `.click()`.

package/lib/build.mjs

@@ -62,7 +62,7 @@ import { PACKAGE_ROOT, isRulesGame, listExperiences as listGames, readStudio } f
 // module is: Homie for Claude Desktop starts the toolkit with no node_modules beside it (scripts/desktop.mjs).
 let rulesBuildModule = null;
 const rulesBuild = () => (rulesBuildModule ??= import('./rules-build.mjs'));
-import { SEAT_MAX, netplayRow } from '../worker/seats.mjs';
+import { seatCount, SEAT_MAX, netplayRow } from '../worker/seats.mjs';
 import { STUDIO_VERSION } from './version.mjs';
 import { basedOnRow, licenseOf, retiredKeys } from '../worker/license.mjs';
 import { openStage, swapIn } from './stage.mjs';
@@ -266,10 +266,14 @@ export function netplayOf(g, out = null) {
 }
 
 /**
- * How many seats a room of this game has: the netplay manifest's `maxPlayers` (or `players.max`), else game.json's
- * `players.max`, else 8; at most SEAT_MAX (32). `asked` is what the game named, so a build can say it was capped.
+ * Room size comes from game.json's players.max, else 8 (32 for apps).
+ * Rules games have no admission ceiling; existing netplay games retain their manifest precedence and 32-seat limit.
  */
 export function seatsFor(g, net = netplayOf(g)) {
+  if (isRulesGame(g)) {
+    const max = seatCount(g.players?.max);
+    return { min: Math.min(max, seatCount(g.players?.min, 1)), max, asked: max };
+  }
   const named = [net.maxPlayers, net.players?.max, g.players?.max].map((n) => Math.floor(Number(n))).find((n) => Number.isFinite(n) && n >= 1);
   const asked = named ?? (g.kind === 'app' ? 32 : 8);
   const max = Math.min(SEAT_MAX, asked);
@@ -390,8 +394,7 @@ export async function buildGameFiles(esbuild, root, g, out, { maps = false, sour
   let chunks = [];
   const budgets = modelBudgetsOf(g, log);
   // RULES PLUS VIEW (rooms on the server). A game with "room" in game.json and a src/rules.ts has its rules checked, guarded and loaded first:
-  // a rule the wall refuses stops the build here, with the line named. A game without one is hosted by a player's
-  // browser exactly as before, and cannot ask for the server.
+  // a rule the wall refuses stops the build here, with the line named. Existing netplay games retain their browser host.
   const ruled = isRulesGame(g);
   if (!ruled && g.room?.host === 'server') {
     throw new Error(`${label}/${manifest} asks for "room": { "host": "server" }, but ${mode === 'bundle' ? 'this game has no src/rules.ts: its rules are inside its own code and run in a player\'s browser. Ask for it to be rewritten as rules plus view' : 'a ported game is someone else\'s browser code, which the server cannot run. It stays hosted by a player\'s browser'}.`);
@@ -517,8 +520,8 @@ export async function build(root, { only = null, log = () => {}, deploy = proces
   for (const g of games) if (g.kind === 'app') { const bad = appProblems(g); if (bad.length) throw new Error(`apps/${g.id}/app.json: ${bad.join('; ')}`); }
   // `--types`: the games' TypeScript is checked first (esbuild only strips types, it never reads them), and a type
   // error stops the build before anything is built.
-  // Rules always use their generated capability types, including the view. The legacy
-  // compiler sees broad source types and can falsely reject valid rules callbacks.
+  // Rules always use generated capability types, including the view. Existing netplay games and local apps
+  // use the source type checker.
   const legacy = games.filter((g) => !isRulesGame(g));
   const typed = types && legacy.length ? typecheck(root, legacy, { log }) : null;
   // What the build before this one made, to say which games changed.
@@ -561,7 +564,7 @@ async function buildInto(dist, { esbuild, studio, shop, live, games, before, typ
     const bytes = bundle ? statSync(join(out, bundle)).size : dirBytes(out);
     const later = chunks.reduce((n, c) => n + statSync(join(out, c)).size, 0);
     const seats = seatsFor(g, netplayOf(g, out));
-    if (seats.asked > SEAT_MAX) log(`warning: games/${g.id} asks for ${seats.asked} players; a room holds at most ${SEAT_MAX}, so its rooms have ${SEAT_MAX} seats`);
+    if (seats.asked > SEAT_MAX && !rules) log(`games/${g.id} asks for ${seats.asked} players; browser-hosted netplay rooms retain their ${SEAT_MAX}-player limit, so this build uses ${SEAT_MAX} seats. For larger rooms, rewrite as rules plus view: node_modules/@homie-rocks/studio/guides/game/REWRITE.md`);
     built.push({
       id: g.id, name: g.name, mode, bytes, ms: Date.now() - started, warnings, seats: seats.max,
       ...(rules ? { capacityTrial: rules.check.capacityTrial } : {}),

package/lib/cloudflare.mjs

@@ -1,4 +1,5 @@
 import {workerEntry} from './worker-build.mjs';
+import { seatCount } from '../worker/seats.mjs';
 import { refreshWorkerConfig } from './worker-config.mjs';
 import { paidReleases, uploadPaidParts } from './parts-upload.mjs';
 /**
@@ -184,7 +185,7 @@ export function deployPlan(root) {
   const studio = readStudio(root);
   // Games whose rules run on the server (a src/rules.ts, and not "room": { "host": "browser" }): one line each.
   const hosted = listGames(root).filter((g) => isRulesGame(g) && g.room?.host !== 'browser').map((g) => {
-    const seats = Math.max(1, Math.min(32, Math.floor(Number(g.players?.max)) || 8));
+    const seats = seatCount(g.players?.max);
     const tickHz = Math.max(1, Math.min(60, Math.floor(Number(g.room?.tickHz)) || 20));
     const use = hostedUse({ seats, inputHz: Math.max(1, Math.min(tickHz, Math.floor(Number(g.room?.inputHz)) || tickHz)) });
     return { id: g.id, name: g.name ?? g.id, ...use };

package/lib/mcp.mjs

@@ -35,7 +35,7 @@ export const INSTRUCTIONS = `Homie Studio, on this computer: make game studios a
 
 Carry the person's request through to a working result without a lesson or an interview. Use their name or business name, otherwise "My Studio". Setup, dependencies, a plan, building and checking are AI work, not approval gates. Choose engineering and design defaults from the request; record them in CODEX.md so the person can change them later by asking. Phone and computer controls, a small first version, local sound and CC0 art are the defaults. No paid media unless requested with a budget. A business or charity may need an app or a site, not a game: do not make them play a demo or choose a genre.
 Run setup_status (for a studio that is not made yet, pass its name as studio), studio_scaffold (NO game until one is requested), then build the requested thing and check it. A demo and a small-change lesson are optional only when requested. Look for existing engine mechanisms and parts_find before building systems. Use few, large edits: one file_edit carries every change to a file in its edits list. game_plan records your decisions; it does not require an interview. Install missing prerequisites yourself with setup_prepare; follow studio_job without asking the person to retry. Optional providers never block.
-New games and apps needing transient shared live state use rules plus view with room.host server. Read studio_guide topic game and its file RULES.md before writing rules: declared entity/shared state and events, guarded deterministic move for immediate local prediction, and a browser view for input and rendering. Read file REWRITE.md when an owner asks to move an old game's rules to the server; no automatic converter exists and ordinary old games keep working. Repair the full build diagnostics and prove the requested behavior in two browsers. Current rooms have at most 32 seats; larger rooms and private per-seat state are not delivered. Apps use authorized app records for lasting/private business data; room hosting is not staff permission.
+New games and apps needing transient shared live state use rules plus view with room.host server. Read studio_guide topic game and its file RULES.md before writing rules: declared entity/shared state and events, guarded deterministic move for immediate local prediction, and a browser view for input and rendering. Read file REWRITE.md when an owner asks to move an old game's rules to the server; no automatic converter exists; existing netplay games keep building and running with their original 32-seat limit; larger rooms require a rewrite. Repair the full build diagnostics and prove the requested behavior in two browsers. Set players.max to the chosen room size, including hundreds; public connections use Gates. Choose room.view radiusM, precisionM, nearM and farHz explicitly and measure at the requested size. Private per-seat state is not delivered. Apps use authorized app records for lasting/private business data; room hosting is not staff permission.
 Show progress briefly and give the preview link as soon as it works. Only when going live was requested, studio_deploy with plan: true says what it creates and costs; cloudflare_login asks for browser approval once; then studio_deploy. Publish to the directory only when requested (offer once after going live). Honour an existing request to deploy or list; do not ask again except for a host's mandatory approval.
 For a shop, stripe_login (shop connect) syncs Products, Prices, Payment Links and the webhook through one Stripe browser approval. No human-handled key. Follow studio_job and the result's single next step; rerun after shop.json changes. Test purchase, webhook, grant and refund with stand-ins before going live. Live payments only when requested.
 For a custom domain already on Cloudflare, studio_domain prepares the exact hostname route using the existing sign-in; studio_deploy applies it and Cloudflare creates DNS and TLS. Never ask for zone or account ids. Keep workers.dev until a domain is requested.

package/lib/rules-build.mjs

@@ -1,3 +1,4 @@
+import { seatsOf } from '../worker/seats.mjs';
 /**
  * What `homie-studio build` does for a game written as rules plus view (rooms-milestone-1-design.md, section 8).
  *
@@ -145,7 +146,7 @@ export async function prepareRules(esbuild, root, g, { log = () => {}, longCheck
   if (!guarded.ok) throw new Error(`${g.kind === 'app' ? 'apps' : 'games'}/${g.id}: its rules were refused.\n${guarded.problems.slice(0, 20).map((p) => `  ${problemLine(p)}`).join('\n')}${guarded.problems.length > 20 ? `\n  … and ${guarded.problems.length - 20} more` : ''}`);
   const tune = readJson(join(g.dir, 'tunables.json')) ?? {};
   const map = readMap(g);
-  const seats = Math.max(1, Math.min(32, Math.floor(Number(g.players?.max)) || 8));
+  const seats = seatsOf(g);
   const bundle = await loadRules(esbuild, root, g.id, guarded.code, { bundleOnly: true });
   const data = { id: g.id, tune, map, room: g.room, seats, vocab: readJson(join(g.dir, 'agents.json')), sites: guarded.sites };
   // The declarations first, for the type check: a wrong program is named by the compiler before anything is played.

package/lib/scaffold.mjs

@@ -71,7 +71,7 @@ export function slugify(name) {
 export function wranglerConfig({ worker, name, d1, d1Id = null, r2 = null, layout = 'root', main = null, ai = false, routes = null, paidParts = false, partsRateLimit = null, triggers = null }) {
   const at = layout === 'site' ? { schema: '../node_modules', main: 'src/runtime/worker.js', dist: './dist', migrations: 'migrations' }
     : { schema: 'node_modules', main: 'site/src/runtime/worker.js', dist: './site/dist', migrations: 'site/migrations' };
-  const rooms = [{ name: 'TABLE', class_name: 'Table' }, { name: 'LOBBY', class_name: 'Lobby' }];
+  const rooms = [{ name: 'TABLE', class_name: 'Table' }, { name: 'LOBBY', class_name: 'Lobby' }, { name: 'GATE', class_name: 'Gate' }, { name: 'CONCENTRATOR', class_name: 'Concentrator' }];
   const config = {
     $schema: `${at.schema}/wrangler/config-schema.json`,
     name: worker,
@@ -94,7 +94,7 @@ export function wranglerConfig({ worker, name, d1, d1Id = null, r2 = null, layou
     ...(triggers ? { triggers: paidParts ? { ...triggers, crons: [...new Set([...(triggers.crons ?? []), '*/5 * * * *'])] } : triggers } : {}),
     assets: { directory: at.dist, binding: 'ASSETS', run_worker_first: true },
     durable_objects: { bindings: rooms },
-    migrations: [{ tag: 'v1', new_sqlite_classes: ['Table', 'Lobby'] }],
+    migrations: [{ tag: 'v1', new_sqlite_classes: ['Table', 'Lobby'] }, { tag: 'v2-gates', new_sqlite_classes: ['Gate', 'Concentrator'] }],
     d1_databases: [{ binding: 'DB', database_name: d1, ...(d1Id ? { database_id: d1Id } : {}), migrations_dir: at.migrations }],
     ...(r2 ? { r2_buckets: [{ binding: 'MEDIA', bucket_name: r2 }, ...(paidParts ? [{ binding: 'PURCHASE_MEDIA', bucket_name: `${r2.slice(0, 52)}-purchases` }] : [])] } : {}),
     // Workers AI, only when a server's AI guides think with it (agents_brain workers-ai; deploy adds it, 0.17.0).
@@ -291,7 +291,7 @@ studio's pinned copy, never a registry lookup of the bare name.
   Start with coin-dash, gem-rush, ember-vale, gem-rush-3d or hero-rush-3d; all five follow this contract.
   In games/<id>/src/rules.ts, defineRules declares entities, fields, handlers, events, rounds and companions.
   The view calls openRoom and sends input/commands; it draws, plays sound and handles controls. It never
-  decides a hit, score, spawn, turn or result. Keep game.json room.host set to server, up to 32 seats.
+  decides a hit, score, spawn, turn or result. Keep game.json room.host set to server and players.max to the chosen room size.
 - **Movement feels immediate through prediction.** Put the shared defineMove callback in src/move.ts;
   it runs authoritatively on the server and immediately for your own view, then reconciles. Other bodies
   interpolate. Use the starter's sweep/slide and room.me/room.each poses; no second browser physics loop,
@@ -312,10 +312,10 @@ studio's pinned copy, never a registry lookup of the bare name.
   then check with two browsers and play the requested mechanic with network delay. Info is not a failure.
   Never remove rules, weaken checks, forge a probe or switch hosting to get past a message.
   Rules hashes and room saves are automatic; character saves are player-owned, untrusted input. Room state
-  is replicated, not secret. Bigger rooms and private state are not delivered by milestone 1.
+  is replicated, not secret. Rooms may have hundreds of seats; choose players.max and spatial delivery explicitly and measure. Private state is not delivered.
 - **Existing games:** change rules truth in rules and presentation in view. Browser hosting is for offline,
-  local development and private friends games. Untouched older createNetplay/createRoom games still work;
-  when asked to rewrite one, read the game skill's REWRITE.md and preserve its art, view and feel. There is
+  local development and private friends games. Existing netplay games and port host helpers remain supported at their original 32-seat limit;
+  to rewrite one, read the game skill's REWRITE.md and preserve its art, view and feel. There is
   no automatic converter. NETPLAY.md section 29 is the rules contract; earlier sections describe older APIs.
 - Phones and computers: touch controls on phones only, keys on computers; keep the
   centre of the screen clear during play.
@@ -473,7 +473,7 @@ studio's pinned copy, never a registry lookup of the bare name.
   aimNoise, aggression, positioning }\`. The party sets it by voting on a card in the play page (the middle vote
   wins, capped by the server's ceiling). Make a game's bots honour it: \`net.skillOf(slot)\` in their step (the
   snippet is in \`NETPLAY.md\` section 17; \`BotBrain\` from the port kit reads it with a rebuild), and declare
-  \`caps: ['skill', 'agents']\` in \`createNetplay\` (a game on \`createRoom\` has \`agents\` already). A build
+  \`caps: ['skill', 'agents']\` in \`createNetplay\` (rules rooms provide the agent runtime). A build
   from before 0.16.0 still plays on every server; the office says it predates servers until it is rebuilt.
 - **Agent passes:** \`npx --no-install homie-studio agents pass <id> --label Claude [--server <server>]\` gives an
   AI its way into a seat (shown once; \`agents revoke <pass>\` ends it). It sits with \`POST /<id>/api/agent\`
@@ -545,7 +545,7 @@ chat's card follows the work from then on) and, for a studio still being set up,
 - The site's workers.dev address names the Cloudflare account (often after its owner): \`deploy\` keeps it in
   \`.studio/local.json\`, which git ignores. Never copy it into a committed file. A custom domain goes in
   studio.json as \`cloudflare.domain\`.
-- A game's room size is its netplay manifest's \`maxPlayers\` (game.json \`netplay\`, or netplay.json), up to 32.
+- A game's room size is game.json \`players.max\`, a positive integer including hundreds; measure the chosen size.
 - Nothing in this studio needs \`~/.homie\` or a Homie box.
 - This studio is this folder. A studio in a folder beside it (another folder with its own \`studio.json\`) is
   somebody else's work: never read it or copy from it unless the person asks.
@@ -783,7 +783,7 @@ import rules from './rules/index.mjs';
 
 hostRules(rules);
 useTools(async () => (await import('./tools/index.mjs')).default);
-export { default, Table, Lobby } from '@homie-rocks/studio/worker';
+export { default, Table, Lobby, Gate, Concentrator } from '@homie-rocks/studio/worker';
 `,
     'site/src/rules/index.mjs': rulesIndex([]),
     'site/migrations/0001_studio.sql': MIGRATION,

package/lib/template-history.json

@@ -2447,14 +2447,24 @@
      "## Apps: one screen, roles and parts": "8596f2b25edda3e2",
      "## Commands (all through the pinned CLI in node_modules)": "159151b8861fc051",
      "## The site": "0cb8dd9a6f8a0096",
-     "## Making games": "9e44559de535d842",
+     "## Making games": [
+      "78950c6b4eb98ea6",
+      "796cc9389236c713",
+      "9e44559de535d842"
+     ],
      "## The Game Codex and progress": "0738ef719cef3a4c",
      "## Art direction and models": "a48fff7bf0a5f2fc",
      "## Running live games (the back office)": "51ebf2ab756f6e4d",
-     "## Servers and AI seats": "d0028361fe567add",
+     "## Servers and AI seats": [
+      "1ccfd549d2369a60",
+      "d0028361fe567add"
+     ],
      "## Selling things (the shop)": "9e020d69dd6a954e",
      "## Continuing a build from the Claude app": "0d68081e924ca419",
-     "## Rules": "2e6b29afb85dcf7e",
+     "## Rules": [
+      "2e6b29afb85dcf7e",
+      "c48971c1437414c2"
+     ],
      "## Telling Homie": "80b46fdd9e578db8",
      "## Beta": "9d02638207a26e73"
     }
@@ -2510,6 +2520,93 @@
      }
     }
    }
+  },
+  "0.45.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": "732894273a32dc3f",
+    "site/src/worker.mjs": "6cc5c6131eaf6fd0"
+   },
+   "sections": {
+    "AGENTS.md": {
+     "(intro)": "214aa46eb3a895d5",
+     "## Version-matched authoring guides": "f6261a0e5801b96b",
+     "## Layout": "f3a280b8c96cd068",
+     "## Apps: one screen, roles and parts": "8596f2b25edda3e2",
+     "## Commands (all through the pinned CLI in node_modules)": "159151b8861fc051",
+     "## The site": "0cb8dd9a6f8a0096",
+     "## Making games": [
+      "78950c6b4eb98ea6",
+      "bb715272fd1a615b"
+     ],
+     "## The Game Codex and progress": "0738ef719cef3a4c",
+     "## Art direction and models": "a48fff7bf0a5f2fc",
+     "## Running live games (the back office)": "51ebf2ab756f6e4d",
+     "## Servers and AI seats": "1ccfd549d2369a60",
+     "## Selling things (the shop)": "9e020d69dd6a954e",
+     "## Continuing a build from the Claude app": "0d68081e924ca419",
+     "## Rules": "c48971c1437414c2",
+     "## Telling Homie": "80b46fdd9e578db8",
+     "## Beta": "9d02638207a26e73"
+    }
+   },
+   "named": {
+    "Homie Arcade": {
+     "sections": {
+      "AGENTS.md": {
+       "## Commands (all through the pinned CLI in node_modules)": "2cdd530e48170bfd"
+      }
+     }
+    }
+   }
+  },
+  "0.45.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": "732894273a32dc3f",
+    "site/src/worker.mjs": "6cc5c6131eaf6fd0"
+   },
+   "sections": {
+    "AGENTS.md": {
+     "(intro)": "214aa46eb3a895d5",
+     "## Version-matched authoring guides": "f6261a0e5801b96b",
+     "## Layout": "f3a280b8c96cd068",
+     "## Apps: one screen, roles and parts": "8596f2b25edda3e2",
+     "## Commands (all through the pinned CLI in node_modules)": "159151b8861fc051",
+     "## The site": "0cb8dd9a6f8a0096",
+     "## Making games": "bb715272fd1a615b",
+     "## The Game Codex and progress": "0738ef719cef3a4c",
+     "## Art direction and models": "a48fff7bf0a5f2fc",
+     "## Running live games (the back office)": "51ebf2ab756f6e4d",
+     "## Servers and AI seats": "1ccfd549d2369a60",
+     "## Selling things (the shop)": "9e020d69dd6a954e",
+     "## Continuing a build from the Claude app": "0d68081e924ca419",
+     "## Rules": "c48971c1437414c2",
+     "## Telling Homie": "80b46fdd9e578db8",
+     "## Beta": "9d02638207a26e73"
+    }
+   },
+   "named": {
+    "Homie Arcade": {
+     "sections": {
+      "AGENTS.md": {
+       "## Commands (all through the pinned CLI in node_modules)": "2cdd530e48170bfd"
+      }
+     }
+    }
+   }
   }
  }
 }

package/lib/typecheck.mjs

@@ -1,3 +1,5 @@
+import {listOwnParts, readOrigins, vendorDir} from './parts.mjs';
+import {resolvePartImport} from './parts-build.mjs';
 import { runRulesCompiler } from './rules-compiler.mjs';
 /**
  * `homie-studio build --types` — the games' TypeScript, checked before anything is built.
@@ -7,7 +9,7 @@ import { runRulesCompiler } from './rules-compiler.mjs';
  * of its own to run `npx tsc` with.
  *
  *   - The compiler is the STUDIO'S OWN (`typescript` in its node_modules, which a new studio's package.json asks
- *     for). This optional check for legacy games keeps using that compiler. Rules games use the toolkit's own
+ *     for). This optional check for legacy games and local apps keeps using that compiler. Rules games use the toolkit's own
  *     pinned compiler through typecheckRules below, on every build.
  *   - A game with a tsconfig.json of its own is checked with it. Any other game is checked the way esbuild reads
  *     it: its entry and whatever that imports, as ES2022 for a browser, strictly, with the pictures, sounds and
@@ -15,7 +17,7 @@ import { runRulesCompiler } from './rules-compiler.mjs';
  *   - Only errors in the game's own files stop the build. A game imports the toolkit's helpers as TypeScript
  *     source, and a creator can do nothing about a line in node_modules; those are counted and said, never fatal.
  *
- * The legacy check runs only when asked with --types. The rules check is mandatory.
+ * The legacy/app check runs only when asked with --types. The rules check is mandatory.
  */
 import { spawnSync } from 'node:child_process';
 import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
@@ -116,8 +118,17 @@ export async function typecheckRules(root, g, checked, tune, { log = () => {} }
   writeFileSync(join(dir, 'rules.d.ts'), rulesTypes({ ...checked, answerScopes: await rulesAnswerScopes(join(g.dir, 'src/rules.ts')) }, tune));
   writeFileSync(join(dir, 'view.d.ts'), rulesViewTypes(checked));
   writeFileSync(join(dir, 'files.d.ts'), AMBIENT);
+  const partPaths = {};
+  const origins = readOrigins(root);
+  for (const ref of [...listOwnParts(root).map(p => p.id), ...Object.keys(origins.parts)]) {
+    const base = origins.parts[ref] ? vendorDir(root, ref) : join(root, 'parts', ref);
+    partPaths[`@parts/${ref}/*`] = [join(base, '*')];
+    const entry = resolvePartImport(root, `@parts/${ref}`, origins);
+    if (entry.path) partPaths[`@parts/${ref}`] = [entry.path];
+  }
   const project = join(dir, 'tsconfig.json');
   writeFileSync(project, `${JSON.stringify({ compilerOptions: { ...OPTIONS, checkJs: true, paths: {
+    ...partPaths,
     ...Object.fromEntries(Object.entries(JSON.parse(readFileSync(join(PACKAGE_ROOT, 'package.json'), 'utf8')).exports)
       .filter(([, entry]) => entry?.types).map(([name, entry]) => [`@homie-rocks/studio/${name.slice(2)}`, [join(PACKAGE_ROOT, entry.types)]])),
     '@homie-rocks/studio/rules': [join(dir, 'rules.d.ts')],
@@ -131,6 +142,9 @@ export async function typecheckRules(root, g, checked, tune, { log = () => {} }
     const at = /^(.+?)\((\d+),(\d+)\): error (TS\d+): (.*)$/.exec(line);
     if (at) {
       const file = resolve(at[1]);
+      const missingPart = /Cannot find module '(@parts\/[^']+)'/.exec(at[5]);
+      if (missingPart) { const result = resolvePartImport(root, missingPart[1]); if (result.error) at[5] = result.error; }
+
       // Imported game helpers count too. Only the toolkit's own implementation is outside the author's remit.
       if (!file.startsWith(`${PACKAGE_ROOT}${sep}`) && !file.includes(`${sep}node_modules${sep}`) || file.startsWith(`${g.dir}${sep}`)) {
         const sourceLine = readFileSync(file,'utf8').split(/\r?\n/)[Number(at[2])-1] ?? '';