@homie-rocks/studio 0.44.3 → 0.45.0

package/CHANGELOG.md

@@ -17,6 +17,27 @@ 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.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,51 @@
      }
     }
    }
+  },
+  "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"
+      }
+     }
+    }
+   }
   }
  }
 }

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] ?? '';

package/lib/worker-build.mjs

@@ -4,7 +4,7 @@ import {pathToFileURL} from 'node:url';
 import {existsSync,mkdirSync,writeFileSync,renameSync,readFileSync,mkdtempSync,rmSync} from 'node:fs';
 import {join,relative,basename,sep,resolve} from 'node:path';
 import {readConfig} from './routes.mjs';
-import {workerDir} from './studio.mjs';
+import {PACKAGE_ROOT,workerDir} from './studio.mjs';
 import {paidReleases} from './parts-upload.mjs';
 /** Preserve dynamic imports as real Worker modules: page startup never evaluates MCP libraries. */
 export async function buildWorker(root,esbuild) {
@@ -15,7 +15,10 @@ export async function buildWorker(root,esbuild) {
   const toolModule=join(root,'site/src/tools/index.mjs');
   const pricedTools=existsSync(toolModule) && (await import(pathToFileURL(toolModule).href+'?worker='+Date.now())).default.some(tool=>tool.price);
   if(paidReleases(root).length || existsSync(join(root,'shop.json')) || pricedTools)alias['@homie-rocks/studio/worker']='@homie-rocks/studio/worker/selling';
-  const result=await esbuild.build({entryPoints:[source],absWorkingDir:root,alias,outdir:out,bundle:true,splitting:true,format:'esm',platform:'browser',mainFields:['module','main'],conditions:['workerd','worker','browser'],external:['node:*','cloudflare:*'],target:'es2022',write:false,minify:true,metafile:true,logLevel:'silent'});
+  // Older studio entries export only Table and Lobby. Supply the new toolkit-owned
+  // classes in the generated bundle without rewriting the studio's source/customizations.
+  const contents=`export * from ${JSON.stringify(source)};\nexport { default } from ${JSON.stringify(source)};\nexport { Gate, Concentrator } from ${JSON.stringify(join(PACKAGE_ROOT,'worker/gate.mjs'))};\n`;
+  const result=await esbuild.build({stdin:{contents,resolveDir:root,sourcefile:'worker.mjs'},entryNames:'worker',absWorkingDir:root,alias,outdir:out,bundle:true,splitting:true,format:'esm',platform:'browser',mainFields:['module','main'],conditions:['workerd','worker','browser'],external:['node:*','cloudflare:*'],target:'es2022',write:false,minify:true,metafile:true,logLevel:'silent'});
   // A watcher may already have read the previous entry while this build is
   // publishing. Keep its entire graph available. Publish immutable modules first,
   // then switch the single entry atomically; never remove a running graph.