@homie-rocks/studio 0.42.0 → 0.43.0

package/CHANGELOG.md

@@ -17,6 +17,32 @@ 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.43.0] - 2026-10-09
+
+**Plugin 0.43.0**
+
+Ask for a game and its rules run on your server.
+
+### Added
+
+- The game skill teaches the whole rules-and-view workflow: shared truth, immediate movement, levels, companions, saving and the checks that prove the requested game plays. Your AI chooses the engineering defaults.
+- A guided rewrite keeps an older game's look, controls and feel while moving its rules to the server. It preserves the studio's other games and existing tests; there is no automatic converter.
+
+### Changed
+
+- Apps that need a shared live screen now start with the same server rooms. A quiz, queue or turn-based app gets real actions and shared state without pretend movement or compulsory game rounds.
+- Playtests explain stationary controls and intentional freezes. Performance reports measure both players when the server hosts. Covers and trailers use a live rules room and explain when an empty spectator room is paused.
+
+### Fixed
+
+- Builds explain the exact script tag a game page needs, check rules types once, and keep guarded builds working through a temporary-directory alias.
+- Builds refuse a game with neither rules plus view nor a browser-hosted netplay contract, instead of silently calling an unconnected page multiplayer. Existing netplay games keep their compatibility path.
+
+### Upgrade notes
+
+- Existing games keep working as they are. A rewrite happens only when requested. Building a game does not ask for publication or deploy it.
+- Rooms still hold at most 32 seats. Larger rooms are a later milestone; Cloudflare capacity and billing remain unmeasured.
+
 ## [0.42.0] - 2026-10-09
 
 **Plugin 0.42.0**
@@ -46,7 +72,7 @@ Customers and other businesses can use a studio's tools, buy its goods and servi
 
 ## [0.40.0] - 2026-10-09
 
-**Plugin 0.40.0**
+**Plugin 0.40.0** · [#79](https://github.com/homie-rocks/homie/pull/79)
 
 New 3D games keep their matches on the server and answer your controls immediately.
 

package/README.md

@@ -38,6 +38,14 @@ A new studio has no game: its home page says "First game coming soon" until the
 `homie-studio demo` names a live game on Homie Arcade to try meanwhile. A starter is copied in only when the person
 asks (`game new <id> --from gem-rush`, or `--from ember-vale` for a hero who lasts, with cloud saves).
 
+New games are rules plus view: `src/rules.ts` declares state and server decisions,
+`src/move.ts` supplies shared movement and local prediction, and `src/view.ts` draws
+and sends input through `openRoom`. All five starters declare `room.host: server`.
+Follow the game skill and `RULES.md`; `build` checks rules, movement and view types
+and refuses a game with neither rules nor a browser-hosted netplay contract.
+The same rules support browser hosting for offline, local and private play.
+Existing browser-hosted games remain supported; rewriting one is an explicit task.
+
 ## In one chat: `homie-studio mcp`
 
 ```sh
@@ -143,7 +151,7 @@ Anyone can **watch** a live room from any player's view at `/<game>/watch?room=<
 Join on every room): the game itself, drawn by the watcher's own browser as a watcher that never takes a seat,
 with a strip of the players to switch between (a tap, keys 1-9, Auto, the whole room). A game draws the followed
 player's camera and HUD from `net.viewSeat` (Gem Rush and Ember Vale do; a game that does not is watched as its
-overview), and game.json `"watch": "overview"` or `false` keeps hidden hands hidden. Private and invite-only games
+overview), and game.json `"watch": "overview"` or `false` changes the watch UI. Rules state is public to replicas; these settings do not secure hidden hands. Private and invite-only games
 are watched only by those they let in (NETPLAY.md section 16, site/SITE.md).
 
 ## Upgrading a studio
@@ -198,12 +206,16 @@ game its studio chooses to share, each with its own licence ("Game parts", below
 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, a late joiner taking a bot's body and a new host after the old one leaves work
-the same at 32 as at 4. One address may hold every seat plus four sockets, so a party
+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.
 
 ## A game's netplay manifest
 
+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):
 
@@ -364,7 +376,8 @@ npx homie-studio agents pass night-rush --label Claude
   account) or invite (`office invite <id> --server <server>`).
 - **AI is always marked AI**, by the room's relay, not the game: every agent is named "<label> · AI", and the
   relay rewrites a host's roster and results so a game cannot hide one.
-- **The skill dial:** 1 Rookie to 5 Maxed (`{ reactionMs, aimNoise, aggression, positioning }`). The party votes it
+- **Rules authoring:** use `world.level`, `world.guideLevel`, `world.guideSeats` and `world.kids`; declare `guide.view`, `guide.floor`, `think` and `world.goalDone` for companions, and `asks` with `world.ask` / `on.answer` for decisions. The following `net.skillOf`, `BotBrain`, `useAgents` and `net.decide` recipes apply to existing browser-hosted games.
+- **The skill dial (browser-hosted games):** 1 Rookie to 5 Maxed (`{ reactionMs, aimNoise, aggression, positioning }`). The party votes it
   on a card in the play page (the middle vote wins); `net.skillOf(slot)` is what a bot reads (`NETPLAY.md` section
   17), and `BotBrain` reads it with a rebuild. In the starters, Gem Rush's Rookie bots collect far fewer gems than
   its Maxed ones.
@@ -372,7 +385,7 @@ npx homie-studio agents pass night-rush --label Claude
   (humans-only, a stricter door), closing it, removing a member, and the first time AI guides may talk are asked
   for, and the owner confirms with one tap.
 - **AI guides that talk** (0.17.0): a game's `agents.json` is its guides' vocabulary (goals, lines, the asks a
-  player taps), and `useAgents` from `@homie-rocks/studio/agents` its host side (Ember Vale is the reference). The
+  player taps), and `useAgents` from `@homie-rocks/studio/agents` its browser-host side (the pre-rules Ember Vale is the reference). The
   brain is the server's: `agents brain night-rush first-light workers-ai` (the studio's own Workers AI; deploy binds
   it; 8,000 neurons a day by default) or `owner-key` (the owner's own key, `agents brain key`, capped in dollars a
   day); with none, the game's scripted floor. The local MCP's `agent_sit` puts the owner's own Claude in a guide's
@@ -390,7 +403,7 @@ npx homie-studio agents pass night-rush --label Claude
 - **A game's own decisions** (0.24.4, NETPLAY.md section 20): `net.decide(state, questions, { floor })` on the host,
   for a game whose game.json says `"decide": true`: tactics for its opponents, an NPC's reaction, a director's call,
   a turn's move, answered by Clef in the room in about a quarter of a second, per beat (never per frame), within the
-  AI brains' day; the floor answers whenever it cannot. Ember Vale's slimes pick their tactics this way (opt-in).
+  AI brains' day; the floor answers whenever it cannot. Rules-based Ember Vale declares asks instead (opt-in).
 - Everything is in the studio's own Worker and D1 (migration `0006_studio_servers.sql`). The site's side is in
   [site/SITE.md](site/SITE.md); the room's in [netplay/NETPLAY.md](netplay/NETPLAY.md) sections 17, 18 and 20.
 
@@ -745,11 +758,10 @@ Web Workers, a live server) and what a game must do for its sound to be in the f
 ```sh
 npx homie-studio perf crown-thief --url http://127.0.0.1:8787 [--device computer,phone] [--runs 3] [--profile]
 npx homie-studio perf sizes crown-thief                     # every built file, raw and gzipped; with build --maps, the bundle's modules
-npx homie-studio perf compare .perf/crown-thief/<before> .perf/crown-thief/<after> --goal phone.host.frame.p95
+npx homie-studio perf compare .perf/crown-thief/<before> .perf/crown-thief/<after> --goal phone.replica.frame.p95
 ```
 
-One run is two headless Chromes on this computer's GPU in a fresh room of their own (`?room=perf-…`): the host (the
-rules, the bots, the snapshots) and a replica, both a computer (1280x800 at 2x) or both an emulated phone (390x844 at
+One run is two headless Chromes on this computer's GPU in a fresh room of their own (`?room=perf-…`): two replicas for server rules, or a host and replica for older browser-hosted games, both a computer (1280x800 at 2x) or both an emulated phone (390x844 at
 3x, touch, Chrome's CPU throttle at 4x with `--cpu`, 4G; each run records the slow-down the throttle really gave, which
 on a fast computer is less than its rate). They play the same seeded presses through a warm-up and a measured
 window, and each run's JSON says, per browser: the time between animation frames (median, p95, p99, the share over 33

package/app-starters/welcome/app.json

@@ -2,7 +2,7 @@
   "id": "welcome",
   "name": "Welcome together",
   "blurb": "A little place to gather. Join the queue, keep your ticket, and see when it is your turn.",
-  "entry": "src/main.ts",
+  "entry": "src/view.ts",
   "roles": {
     "customer": {
       "signIn": false,
@@ -102,5 +102,12 @@
       "phone": "Join once and keep your ticket.",
       "computer": "Staff call the next person from their signed-in tablet."
     }
+  },
+  "room": {
+    "host": "server"
+  },
+  "players": {
+    "min": 1,
+    "max": 32
   }
 }

package/app-starters/welcome/map/main.json

@@ -0,0 +1 @@
+{"bounds":{"min":[-1,-1],"max":[1,1]},"boxes":[],"spots":{"start":[[0,0]]}}

package/app-starters/welcome/src/move.ts

@@ -0,0 +1,3 @@
+// The current rules contract requires a move for a participant, even without an avatar.
+import { defineMove } from '@homie-rocks/studio/rules';
+export const move = defineMove({ participant() {} });

package/app-starters/welcome/src/rules.ts

@@ -0,0 +1,21 @@
+// Transient scene truth lives in the room; authorized queue records live in AppRecords.
+// A phone has a logical stationary seat anchor. The wall watches without a seat.
+import { defineRules, f } from '@homie-rocks/studio/rules';
+import { move } from './move';
+export default defineRules({
+  contract: 2, space: { dims: 2 }, move,
+  shared: { revision: f.u32() },
+  shapes: { events: { refresh: {} }, commands: { refresh: {} }, effects: { refresh: {} } },
+  entities: {
+    participant: {
+      player: true,
+      body: { shape: 'circle', radius: 0.1, maxSpeed: 0 },
+      commands: { refresh(world, self) { world.sendRoom('refresh', {}); } },
+    },
+  },
+  room: {
+    rounds: { seconds: 0, breakSeconds: 0 }, bots: { keep: 0 },
+    join() { return { kind: 'participant', at: { x: 0, y: 0 } }; },
+    on: { refresh(world) { world.shared.revision += 1; world.emit('refresh', { x: 0, y: 0 }, {}); } },
+  },
+});

package/app-starters/welcome/src/{main.ts → view.ts}

@@ -1,12 +1,14 @@
 import * as THREE from 'three';
 import { damp1 } from '@homie-rocks/camera/spring.js';
 import { chamferBox } from '@homie-rocks/geom/chamfer.js';
-import { createNetplay } from '@homie-rocks/studio/netplay';
+import { openRoom } from '@homie-rocks/studio/rules/view';
+import type rules from './rules';
 import { createAppRecords, type AppRecord } from '@homie-rocks/studio/apps';
 import { appLink, qrSvg, randomId } from '@homie-rocks/studio/links';
 
 type Ticket = { label: string; status: string };
-const net = createNetplay<{ light: number }>({ game: 'welcome', maxPlayers: 32, snapshotHz: 2 });
+const room = openRoom<typeof rules>();
+const net = room.net;
 const role = net.params.role ?? 'customer';
 document.body.className = role;
 const $ = <T extends HTMLElement = HTMLElement>(s: string) => document.querySelector<T>(s)!;
@@ -42,7 +44,7 @@ async function refresh() {
 }
 async function action(fn: () => Promise<unknown>) {
   pending = true; paint();
-  try { await fn(); net.send('records-changed'); await refresh(); }
+  try { await fn(); room.command('refresh', {}); await refresh(); }
   catch (e) { $('#status').textContent = (e as Error).message; }
   finally { pending = false; paint(); }
 }
@@ -61,10 +63,9 @@ next.onclick = () => action(async () => {
   if (first) await records.update(first, { ...first.data, status: 'called' });
 });
 // The room carries scene state and change notices; records always come from the authorized database.
-net.on('event', (e) => { if (e.k === 'records-changed') { if (net.role === 'host') net.send('records-changed'); void refresh(); } });
-net.on('snapshot', (s) => { light = s.d.light; });
+room.on('refresh', () => { void refresh(); });
 net.on('link', () => { void refresh(); });
-setInterval(() => { if (net.role === 'host') { light = net.now() / 1000; net.snapshot({ light }); } $('#connection').textContent = net.link === 'online' ? 'Here together · live' : 'Reconnecting…'; }, 500);
+setInterval(() => { $('#connection').textContent = net.link === 'online' ? 'Here together · live' : 'Reconnecting…'; }, 500);
 setInterval(() => void refresh(), 2000); // recover a missed notice; no dependency on a trusted browser host
 void refresh(); paint();
 
@@ -100,6 +101,7 @@ function draw(now: number) {
   const phone = innerWidth < 600;
   camera.position.set(phone ? 7 : 6, phone ? 6 : 5, distance); camera.lookAt(phone ? 1 : -.4, .6, 0);
   stage.position.x = phone ? 1.8 : 2.4;
+  light = net.now() / 1000;
   stage.rotation.y = reduced.matches ? 0 : Math.sin(light * .12) * .09;
   lanterns.forEach((g, i) => { const target = i < waiting ? 1 : .28; g.scale.y += (target - g.scale.y) * (1 - Math.exp(-dt * 5)); g.position.y = .18 + (reduced.matches ? 0 : Math.sin(now / 1000 + i) * .05); });
   renderer.render(scene, camera);

package/bin/homie-studio.mjs

@@ -57,8 +57,8 @@
  *                                          emulated (a --cpu times slower CPU, 4G) on this computer's GPU. The plugin's perf
  *                                          skill runs the whole measure, change, compare, keep-or-revert loop)
  *   homie-studio trailer <id> [--url <site>] [--seconds 40] [--length 20] [--title "…"] [--end "…"] [--skills <folder>]
- *                                         (a trailer in one command, by the plugin's video skill: the game rendered frame by
- *                                          frame on a virtual clock, its sound rebuilt from its own files and what it played,
+ *                                         (a trailer in one command, by the plugin's video skill: live footage for server rules,
+ *                                          or a virtual clock and rebuilt sound for older browser games,
  *                                          the highlights picked, an end card, 16:9, 1:1 and 9:16 in videos/<id>-trailer/)
  *   homie-studio perf sizes <id>          (what a player downloads: every built file, raw and gzipped, the biggest first; with
  *                                          build --maps, which modules make up the bundle; each big script read for whether it
@@ -412,7 +412,7 @@ function print(result) {
       lines.push(`${result.name} is a studio now: ${result.dir}`, '', 'Wrote:', ...result.wrote.map((f) => `  ${f}`), '', `Dependencies: ${result.installed}`, '', 'Next:', ...result.next.map((n) => `  ${n}`), '', result.online);
       break;
     case 'game new':
-      lines.push(`games/${result.id} is a new game from the ${result.from} starter. Change it in games/${result.id}/src/, then: npx homie-studio dev`);
+      lines.push(`games/${result.id} is a new game from the ${result.from} starter. Its server rules are src/rules.ts, shared movement src/move.ts, and browser view src/view.ts. Read the game skill and RULES.md, change the mechanic, then build and run: npx --no-install homie-studio dev`);
       if (result.installNeeded) lines.push(`It needs ${result.needsAdded.map((n) => `${n.name} ${n.version}`).join(', ')}, now in the studio's package.json: run npm install first.`);
       for (const h of result.needsHeld ?? []) lines.push(`It was written against ${h.name} ${h.want}; this studio pins ${h.have}, which stays.`);
       if (result.models) {

package/lib/build.mjs

@@ -210,11 +210,12 @@ export function genreOf(g, log = () => {}) {
  * bundle (netplay/netplay.ts NETPLAY_MARK). A build without it is revision 5 or older: it plays on every server, but
  * reserved AI seats stay empty and its bots do not read the dial, and the office says so. Null when nothing says.
  */
-export function netplayRevOf(out) {
+export function netplayRevOf(out, { skipPort = false } = {}) {
   const files = [];
   const walk = (dir, depth) => {
     if (depth > 3 || !existsSync(dir)) return;
     for (const name of readdirSync(dir)) {
+      if (skipPort && name === 'homie-port.js') continue;
       const f = join(dir, name);
       let st;
       try { st = statSync(f); } catch { continue; }
@@ -381,6 +382,8 @@ export async function buildGameFiles(esbuild, root, g, out, { maps = false, sour
   rmSync(out, { recursive: true, force: true });
   mkdirSync(join(out, 'assets'), { recursive: true });
   const mode = g.build?.mode ?? 'bundle';
+  const label = `${g.kind === 'app' ? 'apps' : 'games'}/${g.id}`;
+  const manifest = g.kind === 'app' ? 'app.json' : 'game.json';
   let warnings = 0;
   let metafile = null;
   let bundled = null;
@@ -391,14 +394,22 @@ export async function buildGameFiles(esbuild, root, g, out, { maps = false, sour
   // browser exactly as before, and cannot ask for the server.
   const ruled = isRulesGame(g);
   if (!ruled && g.room?.host === 'server') {
-    throw new Error(`games/${g.id}/game.json 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'}.`);
+    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'}.`);
+  }
+  if (ruled && mode !== 'bundle') throw new Error(`${label} has a src/rules.ts and ${manifest} "build": { "mode": "${mode}" }. A game written as rules plus view is built by Homie itself: take the "build" setting out.`);
+  if (ruled) {
+    const file = join(g.dir, 'index.html');
+    const html = existsSync(file) ? readFileSync(file, 'utf8') : '';
+    const scripts = html.match(/<script\b[^>]*>/gi) ?? [];
+    if (!scripts.some((tag) => /\btype\s*=\s*["']module["']/i.test(tag) && /\bsrc\s*=\s*(["'])(?:\.\/)?assets\/main\.js(?:[?#][^"']*)?\1/i.test(tag))) {
+      throw new Error(`${g.kind === 'app' ? 'apps' : 'games'}/${g.id}/index.html: load the built view with <script type="module" src="./assets/main.js"></script>. The manifest entry names src/view.ts; HTML loads the bundle, not /src/view.ts. Keep the path relative so it works inside the game frame.`);
+    }
   }
-  if (ruled && mode !== 'bundle') throw new Error(`games/${g.id} has a src/rules.ts and game.json "build": { "mode": "${mode}" }. A game written as rules plus view is built by Homie itself: take the "build" setting out.`);
   const { prepareRules, viewPlugin } = ruled ? await rulesBuild() : {};
   const rules = ruled ? await prepareRules(esbuild, root, g, { log, longCheck }) : null;
   const bundle = async (entryRel) => {
     const entry = join(g.dir, entryRel);
-    if (!existsSync(entry)) throw new Error(`games/${g.id}: entry ${entryRel} not found`);
+    if (!existsSync(entry)) throw new Error(`${label}: entry ${entryRel} not found`);
     const options = {
       entryPoints: [rules ? 'homie:view' : entry], bundle: true, format: 'esm', target: 'es2022', minify: true, sourcemap: sourcemap ?? false,
       outdir: join(out, 'assets'), splitting: true, entryNames: hashed ? 'main-[hash]' : 'main', chunkNames: 'chunk-[hash]',
@@ -411,14 +422,14 @@ export async function buildGameFiles(esbuild, root, g, out, { maps = false, sour
     };
     const failed = (error) => {
       const first = error.errors?.[0];
-      throw new Error(`games/${g.id} did not build: ${first ? `${first.text}${first.location ? ` (${first.location.file}:${first.location.line})` : ''}` : error.message}`);
+      throw new Error(`${label} did not build: ${first ? `${first.text}${first.location ? ` (${first.location.file}:${first.location.line})` : ''}` : error.message}`);
     };
     const result = await esbuild.build(options).catch(failed);
     warnings += result.warnings.length;
     metafile = result.metafile;
     const outputs = Object.entries(result.metafile.outputs).filter(([k]) => k.endsWith('.js'));
     const main = outputs.find(([, v]) => rules ? v.entryPoint === 'homie-view:homie:view' : Boolean(v.entryPoint))?.[0];
-    if (!main) throw new Error(`games/${g.id} did not build: esbuild wrote no bundle for ${entryRel}`);
+    if (!main) throw new Error(`${label} did not build: esbuild wrote no bundle for ${entryRel}`);
     bundled = `assets/${basename(main)}`;
     chunks = outputs.filter(([k]) => k !== main).map(([k]) => `assets/${basename(k)}`).sort();
     if (maps) {
@@ -442,25 +453,30 @@ export async function buildGameFiles(esbuild, root, g, out, { maps = false, sour
     writeFileSync(join(out, 'homie-port.js'), await portScript(esbuild, root, cache));
     if (g.entry) await bundle(g.entry);
     const html = readFileSync(join(out, 'index.html'), 'utf8');
-    if (!/homie-port\.js/.test(html)) log(`warning: games/${g.id}/index.html does not load ./homie-port.js (the port toolkit); add <script src="./homie-port.js"></script> first in <head>`);
+    if (!/homie-port\.js/.test(html)) log(`warning: ${label}/index.html does not load ./homie-port.js (the port toolkit); add <script src="./homie-port.js"></script> first in <head>`);
     if (hashed && bundled) writeFileSync(join(out, 'index.html'), pointAtBundle(html, bundled));
   } else if (mode === 'command') {
     const command = String(g.build.command ?? 'npm run build');
     const res = spawnSync(command, { cwd: g.dir, shell: true, encoding: 'utf8', timeout: 10 * 60_000, maxBuffer: 64 * 1024 * 1024 });
-    if (res.status !== 0) throw new Error(`games/${g.id}: \`${command}\` failed: ${`${res.stdout ?? ''}${res.stderr ?? ''}`.trim().split('\n').slice(-6).join(' ')}`);
+    if (res.status !== 0) throw new Error(`${label}: \`${command}\` failed: ${`${res.stdout ?? ''}${res.stderr ?? ''}`.trim().split('\n').slice(-6).join(' ')}`);
     const built = join(g.dir, String(g.build.out ?? 'dist'));
-    if (!existsSync(join(built, 'index.html'))) throw new Error(`games/${g.id}: \`${command}\` left no index.html in ${relative(g.dir, built) || '.'}`);
+    if (!existsSync(join(built, 'index.html'))) throw new Error(`${label}: \`${command}\` left no index.html in ${relative(g.dir, built) || '.'}`);
     cpSync(built, out, { recursive: true });
     writeFileSync(join(out, 'homie-port.js'), await portScript(esbuild, root, cache));
   } else {
     await bundle(g.entry ?? (rules ? 'src/view.ts' : 'src/main.ts'));
     const html = join(g.dir, 'index.html');
-    if (!existsSync(html)) throw new Error(`games/${g.id}/index.html is missing`);
+    if (!existsSync(html)) throw new Error(`${label}/index.html is missing`);
     const text = readFileSync(html, 'utf8');
     writeFileSync(join(out, 'index.html'), hashed ? pointAtBundle(text, bundled) : text);
   }
   if (mode !== 'static' && existsSync(join(g.dir, 'public'))) cpSync(join(g.dir, 'public'), out, { recursive: true });
-  if (!existsSync(join(out, 'index.html'))) throw new Error(`games/${g.id}/index.html is missing`);
+  if (!existsSync(join(out, 'index.html'))) throw new Error(`${label}/index.html is missing`);
+  // Older games declare netplay v1 or carry the helper's revision marker. A plain
+  // browser bundle is not automatically a multiplayer game. Apps may be local-only.
+  if (!rules && g.kind !== 'app' && netplayOf(g, out).v !== 1 && netplayRevOf(out, { skipPort: true }) === null) {
+    throw new Error(`${label}/${manifest}: this game is neither rules plus view nor a browser-hosted netplay game. Start with game new, src/rules.ts, src/view.ts and "room": { "host": "server" }. Existing browser-hosted games must retain their netplay v1 manifest or netplay helper.`);
+  }
   if (rules) {
     // Only this game's executable view and rules data: buildInfo, the site and other games cannot reload its players.
     const digest = createHash('sha256').update(rules.build);
@@ -501,7 +517,10 @@ 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.
-  const typed = types ? typecheck(root, games, { log }) : null;
+  // Rules always use their generated capability types, including the view. The legacy
+  // compiler sees broad source types and can falsely reject valid rules callbacks.
+  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.
   const before = readJson(join(live, '_site', 'build.json'))?.games ?? {};
   // Everything is built in a folder of its own and put in place only when all of it is there (lib/stage.mjs): a

package/lib/codex.mjs

@@ -723,7 +723,7 @@ ${game.planned ? `- [ ] The plan (this codex)
 -
 `;
   writeFileSync(file, text);
-  return { ok: true, command: 'codex new', id, file: relative(root, file), planned: Boolean(game.planned), next: [`fill it from the plan interview, then: npx --no-install homie-studio codex ${id}`, ...(game.planned ? [`once the plan is agreed: npx --no-install homie-studio game new ${id} --from gem-rush --name "<Name>" makes the game around it (the codex stays)`] : [])] };
+  return { ok: true, command: 'codex new', id, file: relative(root, file), planned: Boolean(game.planned), next: [`fill it from the request and sensible defaults (interview only when asked), then: npx --no-install homie-studio codex ${id}`, ...(game.planned ? [`after recording those defaults: npx --no-install homie-studio game new ${id} --from gem-rush --name "<Name>" makes the game around it (the codex stays)`] : [])] };
 }
 
 /** A sign-in link that opens one game's codex on the live site (the stats page's one-time sign-in, then the codex). */

package/lib/mcp-tools.mjs

@@ -925,7 +925,7 @@ export function toolDefs(ctx, avail = {}) {
     },
     {
       name: 'game_make', title: 'Make a multiplayer game',
-      description: 'Make a game in the studio from a multiplayer starter, under the id you choose, to change into the person\'s game: gem-rush (an arena: every browser renders, one hosts the rules, bots fill empty seats, rounds restart), gem-rush-3d (the same arena in three.js, dressed with free CC0 models through @homie-rocks/studio/assets: the start for a 3D game), hero-rush-3d (the arena with animated CC0 heroes that run, jump and swing through @homie-rocks/studio/animate, a shared clip library per skeleton, a jump and a swing tuned in the Game Lab: the start for a 3D game with characters) or ember-vale (a hero who lasts for days, with cloud saves: for persistent games). In a new studio only once their game is planned (game_plan), or when they ask for a copy of a working starter; never as a first step. A planned game\'s codex stays. Before writing one of its systems from scratch, look for a piece of an existing game that does it (parts_find; part_add brings it in), and for the general mechanism in the @homie-rocks/* packages.',
+      description: 'Make a game in the studio from a multiplayer starter, under the id you choose, to change into the person\'s game: coin-dash (the smallest rules-plus-view example), gem-rush (an arena: the server runs rules, browsers predict movement and render, bots fill empty seats, rounds restart), gem-rush-3d (the same arena in three.js, dressed with free CC0 models through @homie-rocks/studio/assets: the start for a 3D game), hero-rush-3d (the arena with animated CC0 heroes that run, jump and swing through @homie-rocks/studio/animate, a shared clip library per skeleton, a jump and a swing tuned in the Game Lab: the start for a 3D game with characters) or ember-vale (a hero who lasts for days, with cloud saves: for persistent games). In a new studio only once their game is planned (game_plan), or when they ask for a copy of a working starter; never as a first step. A planned game\'s codex stays. Before writing one of its systems from scratch, look for a piece of an existing game that does it (parts_find; part_add brings it in), and for the general mechanism in the @homie-rocks/* packages.',
       inputSchema: { type: 'object', properties: { id: str('The game\'s id (lowercase, digits, hyphens): its address'), name: str('The game\'s display name'), from: str('Starter id (default gem-rush)'), ...STUDIO_ARG }, required: ['id', 'name'] },
       annotations: { title: 'Make a game', ...RW },
       run: async (a) => {
@@ -948,7 +948,7 @@ export function toolDefs(ctx, avail = {}) {
         }
         const m = r.result?.models;
         const got = m ? ` Its models: ${m.fetched} from the starter library${m.missing.length ? `; ${m.missing.length} could not be fetched (${m.why ?? m.missing[0].why}), and it draws stand-ins for those` : ''}.` : '';
-        return ok(`games/${a.id} is ${a.name}, from the ${a.from ?? 'gem-rush'} starter (${(r.result?.files ?? []).length} files).${got}${install} Change it in games/${a.id}/src/main.ts: file_read it once (a long file in two or three reads), decide every change, and make them in ONE file_edit with an edits list (never a call per change: twenty single edits use up a turn before the game is checked); then build and preview_run; check proves two browsers finish a round.`, { kind: 'game', ...r.result });
+        return ok(`games/${a.id} is ${a.name}, from the ${a.from ?? 'gem-rush'} starter (${(r.result?.files ?? []).length} files).${got}${install} Read studio_guide topic game, then file RULES.md. Change games/${a.id}/src/rules.ts (declared state and decisions), src/move.ts (server movement and local prediction), src/view.ts (pictures and input), and map/main.json (shared geometry). Read each file once and make its changes in ONE file_edit with an edits list (never a call per change). Keep room.host server. Choose defaults yourself. Build, repair every named diagnostic, preview_run and check; then play the requested mechanic in two browsers. A green check is not a playtest.`, { kind: 'game', ...r.result });
       },
     },
     {
@@ -992,7 +992,7 @@ export function toolDefs(ctx, avail = {}) {
         const guide = a.interview === true && ctx.skillsDir && existsSync(join(ctx.skillsDir, 'plan', 'references', 'INTERVIEW.md')) ? readFileSync(join(ctx.skillsDir, 'plan', 'references', 'INTERVIEW.md'), 'utf8') : null;
         return ok([
           made ? `Wrote games/${a.id}/CODEX.md (every section${made.planned ? '; the game is planned here before it is made' : ''}).` : `games/${a.id}/CODEX.md is there already: change it, never replace it.`,
-          'From the request and sensible defaults, fill CODEX.md in one call, then show it with game_codex and continue building. Choose phone and computer controls, a small first version, local sound and CC0 art. Infer persistent progress from the premise. No interview unless the person explicitly asks to plan together; no engineering or design questions.',
+          'From the request and sensible defaults, fill CODEX.md in one call, then show it with game_codex and continue building. New games are rules plus view with room.host server; read the game guide and RULES.md. Choose phone and computer controls, a small first version, local sound and CC0 art. Infer persistent progress from the premise. No interview unless the person explicitly asks to plan together; no engineering or design questions.',
           '', PARTS_FIRST,
           ...(guide ? ['', 'Optional reference for a person who explicitly requests an interview:', guide] : []),
         ].join('\n'), { kind: 'plan', id: a.id, file: `games/${a.id}/CODEX.md`, created: Boolean(made) });
@@ -1018,7 +1018,7 @@ export function toolDefs(ctx, avail = {}) {
     },
     {
       name: 'build', title: 'Build the site',
-      description: 'Bundle every game (or one) and the studio\'s site into site/dist. A few seconds. A running preview shows the new build on reload.',
+      description: 'Bundle every game or app and the site into site/dist. Rules builds always run strict types, the guard and deterministic generated play, including save/restore and prediction checks. Read full diagnostics and repair the named handler; info lines do not fail. Never bypass checks or switch to browser hosting to escape a failure. A running preview shows the new build on reload.',
       inputSchema: { type: 'object', properties: { game: str('Optional: only this game'), ...STUDIO_ARG } },
       annotations: { title: 'Build', ...RW },
       run: async (a) => {
@@ -1097,8 +1097,9 @@ export function toolDefs(ctx, avail = {}) {
         const url = a.url ? String(a.url) : await devUrl(ctx, root);
         const shots = join('.checks', `${game}-look`);
         return startRun(ctx, root, { kind: 'playtest', game, title: `${games.find((g) => g.id === game)?.name ?? game}: playtest`, steps: [
+          ...(games.some((g) => g.id === game && isRulesGame(g)) ? [{ label: 'rules build check', args: ['build', game] }] : []),
           { label: 'two-browser check', args: ['check', game, '--url', url, '--shots', join('.checks', game)] },
-          { label: 'pictures on a computer and a phone', soft: true, args: ['look', `/${game}/`, `/${game}/play`, '--url', url, '--only', 'computer,phone', '--shots', shots],
+          { label: 'pictures on a computer and a phone', soft: true, args: ['look', `/${game}/`, `/${game}/${games.find((g) => g.id === game)?.kind === 'app' ? 'open' : 'play'}`, '--url', url, '--only', 'computer,phone', '--shots', shots],
             // The first screen of each page first (a whole page is a tall picture): what a person sees on arrival.
             after: (j, run) => { run.look = (j.result?.rows ?? []).flatMap((r) => [r.fold, r.shot]).filter(Boolean).map((f) => relative(root, resolve(root, f))).slice(0, 8); } },
         ] });
@@ -1456,11 +1457,13 @@ export function toolDefs(ctx, avail = {}) {
         if (!topics.includes(a.topic)) return fail(`guides: ${topics.join(', ')}`);
         const dir = join(ctx.skillsDir, a.topic);
         if (a.file) {
-          const f = join(dir, 'references', basename(String(a.file)));
+          const name = basename(String(a.file));
+          const direct = join(dir, name);
+          const f = name.endsWith('.md') && existsSync(direct) ? direct : join(dir, 'references', name);
           if (!existsSync(f)) return fail(`no reference ${a.file} in ${a.topic}`);
           return ok(readFileSync(f, 'utf8'));
         }
-        const refs = (() => { try { return readdirSync(join(dir, 'references')); } catch { return []; } })();
+        const refs = [...readdirSync(dir).filter(f => f.endsWith('.md') && f !== 'SKILL.md'), ...(() => { try { return readdirSync(join(dir, 'references')); } catch { return []; } })()];
         return ok(`${DESKTOP_NOTE}${ctx.desktop ? `\n\n${DESKTOP_APPROVALS}` : ''}\n\n${readFileSync(join(dir, 'SKILL.md'), 'utf8')}${refs.length ? `\n\nReferences (file): ${refs.join(', ')}` : ''}`);
       },
     });

package/lib/mcp.mjs

@@ -35,7 +35,8 @@ 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.
-Show progress briefly and give the preview link as soon as it works. For going live, 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.
+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.
+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/port-check.mjs

@@ -95,7 +95,7 @@ const steerable = (r) => finite(r) && !r[8];
 export function judgeHold(rows, dir, a, b, size, view) {
   const seg = rows.filter((r) => r[0] >= a && r[0] <= b + 40 && steerable(r));
   const busyFrames = rows.filter((r) => r[0] >= a && r[0] <= b + 40 && finite(r) && r[8]).length;
-  if (seg.length < 8) return { ok: false, dir, busyFrames, why: busyFrames ? `the body was busy (knocked back, stunned, respawning) for ${busyFrames} frames of the hold` : `too few samples (${seg.length}): no body on the probe?` };
+  if (seg.length < 8) return { ok: false, dir, busyFrames, why: busyFrames ? `the body was busy (knocked back, stunned, respawning, or an intentional phase freeze) for ${busyFrames} frames of the hold; retry the actual controls during an active, steerable phase. Keep the mechanic and report this sample as blocked, not a controls pass` : `too few samples (${seg.length}): no body on the probe?` };
   const u = DIRV[dir]; const r0 = seg[0];
   const side = view === 'side';
   const tiIdx = Math.max(0, seg.findIndex((r) => r[0] >= a + 400));
@@ -284,7 +284,7 @@ async function webkit(pw) {
 const frameOf = (h) => h.page.frames().find((f) => f.url().includes('/__game/')) ?? null;
 async function inFrame(h, src, v = null) { const f = frameOf(h); return f ? T(f.evaluate(src), 10_000, v) : v; }
 const shell = (h) => T(h.page.evaluate(() => { const s = window.__shell; return s ? { room: s.room, seat: s.seat, role: s.stats?.role ?? null, results: s.results ?? [], facts: s.facts ? { counts: s.facts.counts } : null } : null; }), 8000, null);
-const info = (h) => inFrame(h, '(() => { const p = window.__homiePort; if (!p) return null; const i = p.info(); i.observedAt = performance.now(); const n = window.__homieNet; i.net = n ? { snapHzIn: n.stats().snapHzIn, snapHzOut: n.stats().snapHzOut, rtt: n.stats().rtt, promotions: n.stats().promotions } : null; i.hosted = n?.probe?.hosted?.() ?? null; i.tick = n?.probe?.tick?.() ?? null; i.v = p.view; i.size = p.size; i.keys = p.keys; i.thumb = p.thumb; return i; })()');
+const info = (h) => inFrame(h, '(() => { const p = window.__homiePort; if (!p) return null; const i = p.info(); i.observedAt = performance.now(); const n = window.__homieNet; i.net = n ? { snapHzIn: n.stats().snapHzIn, snapHzOut: n.stats().snapHzOut, rtt: n.stats().rtt, promotions: n.stats().promotions } : null; i.movement = n?.probe?.movement?.() ?? null; i.hosted = n?.probe?.hosted?.() ?? null; i.tick = n?.probe?.tick?.() ?? null; i.v = p.view; i.size = p.size; i.keys = p.keys; i.thumb = p.thumb; return i; })()');
 const rowsSince = (h, t) => inFrame(h, `(window.__homiePort ? window.__homiePort.rows(${Number(t) || 0}) : [])`, []);
 const frameNow = (h) => inFrame(h, '(window.__homiePort ? window.__homiePort.now() : performance.now())', 0);
 
@@ -411,6 +411,7 @@ const UI_COVER = `(() => {
 
 async function ownerTests(h, how, log) {
   const i = await info(h);
+  if (i?.movement === 'stationary') return { ok: null, applicable: false, why: 'Rules declare all player anchors with maxSpeed 0: directional movement is not applicable. Exercise the actual buttons, taps or word/turn actions in two browsers; this is not a controls pass.' };
   const view = i?.v ?? 'top';
   const size = Number(i?.size) || 1;
   const keys = i?.keys ?? { up: 'ArrowUp', down: 'ArrowDown', left: 'ArrowLeft', right: 'ArrowRight' };
@@ -565,7 +566,8 @@ export async function portCheck({ url, game, root, only = null, shots = null, lo
           await shot(h, 'desk-playing');
           const audio = after?.audio ?? null;
           row('owner-desk', res.ok, { ...res, seatedMs: o.ms, fps: after?.fps ?? null });
-          if (audio) {
+          if (res.applicable === false) row('audio', null, { why: 'No directional input was sent to this stationary game. Test sound with its actual controls.' });
+          else if (audio) {
             const ctxs = audio.contexts ?? [];
             row('audio', ctxs.length ? ctxs.every((s) => s === 'running') : null, { contexts: ctxs, refusedMedia: audio.refusedMedia, why: ctxs.length ? (ctxs.every((s) => s === 'running') ? undefined : 'an AudioContext is still suspended after the first keys') : 'no Web Audio in this game (media elements only, or silent)' });
           }
@@ -591,7 +593,8 @@ export async function portCheck({ url, game, root, only = null, shots = null, lo
           const after = await info(h);
           await shot(h, 'phone-playing');
           row('owner-phone', res.ok, { ...res, seatedMs: o.ms, fps: after?.fps ?? null });
-          row('ui-cover', cover ? cover.cover <= 0.12 && !cover.opaqueCentre.length : null, { ...(cover ?? {}), why: cover && (cover.cover > 0.12 || cover.opaqueCentre.length) ? `UI covers ${Math.round(cover.cover * 100)}% of a phone${cover.opaqueCentre.length ? ' and something opaque sits in the middle' : ''}` : undefined });
+          const stationaryDom = res.applicable === false && await inFrame(h, "!document.querySelector('canvas')", false);
+          row('ui-cover', stationaryDom ? null : cover ? cover.cover <= 0.12 && !cover.opaqueCentre.length : null, { ...(cover ?? {}), why: stationaryDom ? 'The stationary DOM interface is its play surface. Inspect its actual buttons and layout; a movement-world overlay limit is not applicable.' : cover && (cover.cover > 0.12 || cover.opaqueCentre.length) ? `UI covers ${Math.round(cover.cover * 100)}% of a phone${cover.opaqueCentre.length ? ' and something opaque sits in the middle' : ''}` : undefined });
         }
         collect(h); await close(h);
       } catch (e) {

package/lib/port.mjs

@@ -269,8 +269,8 @@ export function importPort(root, folder, id, { name, mode } = {}) {
   return {
     ok: true, command: 'port import', id, dir: dest, from: src, mode: buildMode, files: copied.length, edits, plan: { grade: plan.grade, movement: plan.recommend.movement, view: plan.recommend.view },
     next: [
-      `Write games/${id}/PORT.md: the grade and why, the movement mode, what the host owns, what each browser owns, bots, touch, camera.`,
-      buildMode === 'static' ? 'Add the netplay layer as a script after the game\'s own (HomiePort.createRoom …), or an "entry" in game.json bundled to assets/main.js.' : 'Import \'@homie-rocks/studio/port/early\' first, then build the netplay layer with createRoom.',
+      `Write games/${id}/PORT.md: the grade and why, server truth, shared movement, the browser view, bots, touch and camera.`,
+      'Read the port skill and game RULES.md. Preserve the imported game as the baseline, then write server rules, shared movement and a view with openRoom. Use room.host server and the bundled view entry. The imported browser-hosted format remains available for local/offline/private use or maintaining an existing port.',
       `npm run dev (in the background), then: npx --no-install homie-studio port check ${id} --url http://127.0.0.1:8787`,
     ],
   };

package/lib/rules-build.mjs

@@ -53,9 +53,9 @@ function readMap(g) {
   const dir = join(g.dir, 'map');
   const names = existsSync(dir) ? readdirSync(dir).filter((n) => n.endsWith('.json')).sort() : [];
   const name = names.includes('main.json') ? 'main.json' : names[0];
-  if (!name) throw new Error(`games/${g.id}/map/ needs a map: map/main.json with "bounds", and the "boxes", "circles" and named "spots" the rules use`);
+  if (!name) throw new Error(`${g.kind === 'app' ? 'apps' : 'games'}/${g.id}/map/ needs a map: map/main.json with "bounds", and the "boxes", "circles" and named "spots" the rules use`);
   const raw = readJson(join(dir, name));
-  if (!raw || typeof raw !== 'object') throw new Error(`games/${g.id}/map/${name} is not JSON`);
+  if (!raw || typeof raw !== 'object') throw new Error(`${g.kind === 'app' ? 'apps' : 'games'}/${g.id}/map/${name} is not JSON`);
   return { ...raw, name: name.replace(/\.json$/, '') };
 }
 
@@ -142,7 +142,7 @@ export function smokeRun(H, compiled, id, { timer = () => { const t = process.cp
  */
 export async function prepareRules(esbuild, root, g, { log = () => {}, longCheck = false } = {}) {
   const guarded = await guardRules(esbuild, root, g.dir);
-  if (!guarded.ok) throw new Error(`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` : ''}`);
+  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));
@@ -151,12 +151,12 @@ export async function prepareRules(esbuild, root, g, { log = () => {}, longCheck
   // The declarations first, for the type check: a wrong program is named by the compiler before anything is played.
   await typecheckRules(root, g, await runRulesWorker(bundle, data, { declarationsOnly: true }), tune, { log });
   const checked = await runRulesWorker(bundle, data, { allowance: longCheck ? LONG_ALLOWANCE : ALLOWANCE });
-  for (const p of checked.problems) log(`warning: games/${g.id}/game.json: ${p}`);
+  for (const p of checked.problems) log(`warning: ${g.kind === 'app' ? 'apps' : 'games'}/${g.id}/${g.kind === 'app' ? 'app' : 'game'}.json: ${p}`);
   for (const line of checked.information) log(`info: ${line}`);
   const { settings, schema, publicTune, rounds, stateHash } = checked;
   const trial = RULES_CAPACITY_TRIAL;
   log(`info: rules runtime reference trial: ${trial.game}, ${trial.seats} players at ${trial.tickHz} Hz for ${trial.minutes} minutes on ${trial.host} (${trial.platform}). Cloudflare capacity and billing are unmeasured.`);
-  if (settings.tickHz > trial.tickHz) log(`info: games/${g.id} asks for ${settings.tickHz} Hz, above the completed local reference trial's ${trial.tickHz} Hz. This game's generated check does not establish live room capacity.`);
+  if (settings.tickHz > trial.tickHz) log(`info: ${g.kind === 'app' ? 'apps' : 'games'}/${g.id} asks for ${settings.tickHz} Hz, above the completed local reference trial's ${trial.tickHz} Hz. This game's generated check does not establish live room capacity.`);
   const { def, R, H } = await loadRules(esbuild, root, g.id, guarded.code);
   const compiled = R.compileRules(def, { tune, map: R.compileMap(map, map.name), settings, seats });
   const stats = smokeRun(H, compiled, g.id, { timer: () => 0, vocab: data.vocab });
@@ -168,7 +168,7 @@ export async function prepareRules(esbuild, root, g, { log = () => {}, longCheck
       ...(t !== 'snap' && rate > rateCap ? [`${t} ${rate}/s (cap ${rateCap}/s; over by ${rate - rateCap}/s)`] : [])];
   });
   if (exceeded.length) {
-    const message = `games/${g.id}: browser rules smoke run measured snapshot ${stats.snapshotBytes} B (cap ${snapshotCap} B), checkpoint ${stats.checkpointBytes} B (cap ${checkpointCap} B). Exceeded: ${exceeded.join(', ')}. Reduce these frames or use room.host: server; offline play has no relay caps.`;
+    const message = `${g.kind === 'app' ? 'apps' : 'games'}/${g.id}: browser rules smoke run measured snapshot ${stats.snapshotBytes} B (cap ${snapshotCap} B), checkpoint ${stats.checkpointBytes} B (cap ${checkpointCap} B). Exceeded: ${exceeded.join(', ')}. Reduce these frames or use room.host: server; offline play has no relay caps.`;
     if (settings.host === 'browser') throw new Error(message);
     log(`warning: ${message}`);
   }

package/lib/rules-guard.mjs

@@ -42,7 +42,7 @@ import babelTraverse from '@babel/traverse';
 import * as babelGenerator from '@babel/generator';
 import * as t from '@babel/types';
 import { TraceMap, originalPositionFor } from '@jridgewell/trace-mapping';
-import { existsSync, readFileSync, statSync } from 'node:fs';
+import { existsSync, readFileSync, realpathSync, statSync } from 'node:fs';
 import { dirname, join, relative, resolve } from 'node:path';
 
 const traverse = babelTraverse.default ?? babelTraverse;
@@ -757,12 +757,18 @@ export async function guardFiles(esbuild, root, gameDir, entry) {
 
 /** An esbuild plugin that serves a game's guarded files in place of its sources (`stub`: files a bundle must not hold at all). */
 export function guardedPlugin(files, { stub = [] } = {}) {
+  // esbuild resolves filesystem aliases (including macOS /tmp -> /private/tmp).
+  // Match those paths to the exact sources already checked and rewritten.
+  const canonical = (file) => existsSync(file) ? realpathSync(file) : file;
+  const guarded = new Map([...files].map(([file, code]) => [canonical(file), code]));
+  const omitted = new Set(stub.map(canonical));
   return {
     name: 'homie-rules-guard',
     setup(b) {
       b.onLoad({ filter: /\.(?:ts|js|mjs)$/ }, (a) => {
-        if (stub.includes(a.path)) return { contents: 'export default {};\n', loader: 'js' };
-        const code = files.get(a.path);
+        const file = canonical(a.path);
+        if (omitted.has(file)) return { contents: 'export default {};\n', loader: 'js' };
+        const code = guarded.get(file);
         return typeof code === 'string' ? { contents: code, loader: 'js' } : null;
       });
     },

package/lib/scaffold.mjs

@@ -126,7 +126,7 @@ directory lists its games; homie.rocks does not host them.
 
 | Path | What it is |
 | --- | --- |
-| \`games/<id>/\` | One game: \`game.json\` (id, name, blurb, players, round length), \`index.html\`, \`src/main.ts\`; and, when it has them, \`tunables.json\` (the numbers that shape how it feels: the Game Lab's sliders, kept values written back) and \`lab.json\` (the Game Lab's takes). |
+| \`games/<id>/\` | One game: \`game.json\` (id, name, blurb, players, round length), \`index.html\`, \`src/rules.ts\`, \`src/move.ts\`, \`src/view.ts\` and shared \`map/\` data; and, when it has them, \`tunables.json\` (the numbers that shape how it feels: the Game Lab's sliders, kept values written back) and \`lab.json\` (the Game Lab's takes). |
 | \`music/\`, \`videos/\` | Songs, scores, loops; trailers, music videos, cutscenes. \`manifest.json\` lists each one (\`node_modules/@homie-rocks/studio/media/MEDIA.md\`); a published entry gets a page at \`/music/<slug>/\` or \`/videos/<slug>/\`. Without storage the site serves each file itself (up to 25 MiB). Once the studio has storage (see below), its big media (over 1 MiB, or left out of git) lives in its own R2: every deploy uploads it, checks it by SHA-256 and serves it from R2 at the same address. Large files never go into git. The Homie plugin's \`music\` and \`video\` skills make them. |
 | \`games/<id>/assets/\` | Every model and texture a game ships, with where it came from and its licence (\`manifest.json\`), and \`RIGHTS.md\` in plain words; \`games/<id>/codex/decisions.json\` (private, like the codex) is its look as decisions, and \`style.json\` the palette, fonts, light and camera the game draws with. \`art/<slug>/\` holds art jobs (concepts, receipts; \`raw/\` is git-ignored). |
 | \`posts/\` | The studio's news and drops: one markdown file each (\`posts/2026-09-30-we-are-live.md\`: \`title:\`, \`date:\`, \`summary:\`, and \`game:\` / \`song:\` / \`video:\` to link one). They are the site's Posts, with Atom and JSON feeds. |
@@ -171,7 +171,7 @@ studio's pinned copy, never a registry lookup of the bare name.
   game: copy a starter only when the person asks for one, or once their game is planned.
 - \`npx --no-install homie-studio port plan <folder>\` — read an existing single-player web game and grade
   how hard making it multiplayer will be; \`port import\` brings it into \`games/\`, \`port check\` runs the
-  owner tests (real touch, a late joiner, a killed host, two browsers finishing a round). The Homie
+  owner tests (real touch, a late joiner, one browser leaving, two browsers finishing a round). The Homie
   plugin's \`port\` skill does the whole job.
 - \`npm run build\` — bundle every game into \`site/dist\`. It builds in a folder of its own and puts the result
   in place only when all of it is there: a game that does not build fails the command (a non-zero exit) and
@@ -197,7 +197,7 @@ studio's pinned copy, never a registry lookup of the bare name.
 - \`npx --no-install homie-studio check <id> --url <site>\` — two headless browsers press Play and must
   land in the same room and finish a round. Run it before you say a game works.
 - \`npx --no-install homie-studio perf <id> --url <site>\` — how fast a game runs, on a computer and an emulated
-  phone, with two browsers in a room (the host and a replica): frame times, the game's JavaScript and the main thread
+  phone, with two browsers in a room (two replicas when the server hosts): frame times, the game's JavaScript and the main thread
   per frame, time to playable, what it downloads, the heap, netplay messages a second (files under \`.perf/\`). The
   Homie plugin's \`perf\` skill runs the whole loop: one change at a time, kept only when it is better beyond the noise
   and \`check\` still passes, and a report in \`perf/<id>/\`.
@@ -279,11 +279,37 @@ studio's pinned copy, never a registry lookup of the bare name.
 
 ## Making games
 
-- Every game is multiplayer on the web through the netplay contract
-  (\`node_modules/@homie-rocks/studio/netplay/NETPLAY.md\`): every browser renders the game
-  itself, one browser hosts the rules, strangers meet in public rooms, bots fill empty
-  seats, anyone arriving takes a bot's place, rounds end and restart on their own.
-- Import it as \`import { createNetplay } from '@homie-rocks/studio/netplay'\`.
+- **New games are rules plus view, hosted by the server.** Read the Homie game skill and its
+  RULES.md before writing code (MCP: studio_guide game, then studio_guide game file RULES.md).
+  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.
+- **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,
+  and no owner-movement workaround. Discrete actions wait for the server's decision.
+- **Truth is declared and deterministic.** Entity handlers write their own fields and send next-tick events;
+  room handlers write shared fields. Use world.tick/dt/ticks/after/random and world.math (ctx.math in move),
+  never clocks, Math.random, hidden module state, async/network calls or browser APIs in rules.
+  Read RULES.md for the bounded query and execution budget, declared commands/effects/asks, and message fixes.
+- **Level data is shared.** map/main.json describes collision and bounds in metres. A 3D rules body's z is
+  height at its feet; Three.js draws x,z,y. Floors, walls and platforms must agree in rules and view.
+  Public tunables describe movement. Bots and companions use the same inputs and declared goals, with a
+  scripted floor that plays without AI. Asks declare bounded state, questions and a deterministic floor.
+- **Choose sensible defaults yourself.** Do not ask the person for a hosting mode, movement mode, tick rate
+  or serialization scheme. Preserve the requested mechanic. Turn-based games and live apps may use manual
+  rounds. Shared live app state uses these same rooms; durable records and authentication use the app APIs.
+  A build-only request ends with a working local result; publish only within the owner's requested scope.
+- **Check changes honestly.** Build first, repair each source-located guard/type/play-check error using RULES.md,
+  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.
+- **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
+  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.
 - The play page's small room button (Invite, Big screen, the room code) sits top right, with the Chat pill
@@ -433,7 +459,10 @@ studio's pinned copy, never a registry lookup of the bare name.
   \`--policy beginner --guides 2 [--kids]\`, \`--policy humans-only\`) makes one at once; \`servers set <id> <server>
   --level-max 3 …\` changes one; \`servers close <id> <server>\`. A change that narrows who may come in (humans-only,
   a stricter door) and closing one only ASK, with the owner's one-tap link, like \`office kick\`.
-- **The skill dial:** every room has a level, 1 Rookie, 2 Steady, 3 Fair, 4 Strong, 5 Maxed, each \`{ reactionMs,
+- **Rules companions:** use world.level, world.guideLevel, world.guideSeats and world.kids; guide.view,
+  guide.floor, think and goalDone follow the rules contract. The old BotBrain/useAgents/decide recipes below
+  apply only to unchanged browser-hosted games. Read RULES.md for a new game.
+- **The skill dial (older browser-hosted games):** every room has a level, 1 Rookie, 2 Steady, 3 Fair, 4 Strong, 5 Maxed, each \`{ reactionMs,
   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
@@ -1018,10 +1047,11 @@ export function newStudio(folder, { name, homie, slug: askedSlug, install = true
   const q = JSON.stringify(realpathSync(dir));
   return { ok: true, command: 'new', dir: realpathSync(dir), name, slug, wrote, git, installed, studio: STUDIO_VERSION, next: [
     `cd ${q}${install ? '' : ' && npm install'}`,
-    'see a working game first, with nothing copied here: npx --no-install homie-studio demo (a live game on Homie Arcade)',
-    'a copy of a starter only when the person asks for one: npx --no-install homie-studio game new <id> --from gem-rush --name "<Game Name>"',
+    'read the game skill and RULES.md; choose sensible defaults and make the requested game as server rules plus view',
+    'optional live example, without copying a game here: npx --no-install homie-studio demo',
+    'only when the person asks for a game: start from a rules starter and implement the requested mechanic: npx --no-install homie-studio game new <id> --from gem-rush --name "<Game Name>"',
     'npm run dev   (the home page, "first game coming soon", at http://127.0.0.1:8787/; with a game: npx --no-install homie-studio check <id> --url http://127.0.0.1:8787)',
-    'npm run deploy   (then the Homie MCP tool studio_publish, or: npx --no-install homie-studio publish)',
+    'when the owner asks to publish: npm run deploy   (then studio_publish, or: npx --no-install homie-studio publish)',
   ], online: 'Going online creates one Worker, one D1 database and two Durable Objects on your own Cloudflare account: free plan, no payment method, no R2. `npx --no-install homie-studio deploy --plan` says exactly what, and changes nothing.' };
 }
 

package/lib/studio.mjs

@@ -108,7 +108,7 @@ function listKind(root, kind) {
 /**
  * RULES ON THE SERVER (NETPLAY.md section 29). A game written as rules plus view says so in game.json with a `"room"`
  * object (where its rules run, its tick rate…; rules/rules.ts `roomSettings` checks them at build) and has a
- * src/rules.ts. Any other game is hosted by a player's browser, as before. The file alone decides nothing: games made
+ * src/rules.ts. Other games need the browser-hosted netplay contract checked by the build. The file alone decides nothing: games made
  * before this had their own src/rules.ts, with whatever they liked in it, and they build exactly as they did.
  */
 export const isRulesGame = (g) => g?.room != null && typeof g.room === 'object' && existsSync(join(g.dir, 'src', 'rules.ts'));
@@ -129,7 +129,7 @@ export function starters() {
   const dir = join(PACKAGE_ROOT, 'starters');
   return readdirSync(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => {
     const meta = JSON.parse(readFileSync(join(dir, d.name, 'game.json'), 'utf8'));
-    // `example`: a starter that shows how something is written (coin-dash: rules on the server) and is not yet offered as the start of a new game.
+    // `example`: marks the smallest reference (coin-dash); all starters use server rules and can start a new game.
     return { id: d.name, name: meta.name, blurb: meta.blurb, players: meta.players, roundSeconds: meta.roundSeconds, ...(meta.example === true ? { example: true } : {}) };
   });
 }
@@ -309,7 +309,7 @@ export async function newApp(root, id, { name } = {}) {
   const meta = JSON.parse(readFileSync(file, 'utf8'));
   meta.id = id; meta.name = String(name ?? 'Welcome together').slice(0, 60);
   writeFileSync(file, `${JSON.stringify(meta, null, 2)}\n`);
-  const main = join(dest, 'src/main.ts');
+  const main = join(dest, meta.entry ?? 'src/main.ts');
   writeFileSync(main, readFileSync(main, 'utf8').replaceAll("game: 'welcome'", `game: '${id}'`));
   return { ok: true, command: 'app new', id, dir: dest, files: readdirSync(dest, { recursive: true }).map(String), ...addNeeds(root, meta.needs) };
 }

package/lib/template-history.json

@@ -2199,6 +2199,68 @@
    }
   },
   "0.40.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": [
+     "34444a6ca4b14437",
+     "fc90f3609cad18ba"
+    ]
+   },
+   "sections": {
+    "AGENTS.md": {
+     "(intro)": "214aa46eb3a895d5",
+     "## Layout": [
+      "c18362ed28975d81",
+      "f3a280b8c96cd068"
+     ],
+     "## Apps: one screen, roles and parts": [
+      "4db0abe4cdfac09f",
+      "be6f8fa45f93211a"
+     ],
+     "## Commands (all through the pinned CLI in node_modules)": [
+      "a7f290579585368c",
+      "c920ac84d44c872a"
+     ],
+     "## The site": "0cb8dd9a6f8a0096",
+     "## Making games": [
+      "2da7fa74c8884834",
+      "9e44559de535d842"
+     ],
+     "## The Game Codex and progress": "0738ef719cef3a4c",
+     "## Art direction and models": "a48fff7bf0a5f2fc",
+     "## Running live games (the back office)": "51ebf2ab756f6e4d",
+     "## Servers and AI seats": [
+      "98d08705087a33ec",
+      "d0028361fe567add"
+     ],
+     "## Selling things (the shop)": "9e020d69dd6a954e",
+     "## Continuing a build from the Claude app": "0d68081e924ca419",
+     "## Rules": "2e6b29afb85dcf7e",
+     "## Telling Homie": "80b46fdd9e578db8",
+     "## Beta": "9d02638207a26e73"
+    }
+   },
+   "named": {
+    "Homie Arcade": {
+     "sections": {
+      "AGENTS.md": {
+       "## Commands (all through the pinned CLI in node_modules)": [
+        "7cad8fd10f62fef1",
+        "cae1df6235f51d17"
+       ]
+      }
+     }
+    }
+   }
+  },
+  "0.41.0": {
    "files": {
     "CLAUDE.md": "ddf2b2a0376202f6",
     "README.md": "684b3cca8001673c",
@@ -2213,15 +2275,15 @@
    "sections": {
     "AGENTS.md": {
      "(intro)": "214aa46eb3a895d5",
-     "## Layout": "c18362ed28975d81",
+     "## Layout": "f3a280b8c96cd068",
      "## Apps: one screen, roles and parts": "be6f8fa45f93211a",
-     "## Commands (all through the pinned CLI in node_modules)": "a7f290579585368c",
+     "## Commands (all through the pinned CLI in node_modules)": "159151b8861fc051",
      "## The site": "0cb8dd9a6f8a0096",
-     "## Making games": "2da7fa74c8884834",
+     "## Making games": "9e44559de535d842",
      "## The Game Codex and progress": "0738ef719cef3a4c",
      "## Art direction and models": "a48fff7bf0a5f2fc",
      "## Running live games (the back office)": "51ebf2ab756f6e4d",
-     "## Servers and AI seats": "98d08705087a33ec",
+     "## Servers and AI seats": "d0028361fe567add",
      "## Selling things (the shop)": "9e020d69dd6a954e",
      "## Continuing a build from the Claude app": "0d68081e924ca419",
      "## Rules": "2e6b29afb85dcf7e",
@@ -2233,7 +2295,7 @@
     "Homie Arcade": {
      "sections": {
       "AGENTS.md": {
-       "## Commands (all through the pinned CLI in node_modules)": "7cad8fd10f62fef1"
+       "## Commands (all through the pinned CLI in node_modules)": "2cdd530e48170bfd"
       }
      }
     }
@@ -2282,6 +2344,47 @@
      }
     }
    }
+  },
+  "0.43.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": "34444a6ca4b14437"
+   },
+   "sections": {
+    "AGENTS.md": {
+     "(intro)": "214aa46eb3a895d5",
+     "## Layout": "f3a280b8c96cd068",
+     "## Apps: one screen, roles and parts": "8596f2b25edda3e2",
+     "## Commands (all through the pinned CLI in node_modules)": "159151b8861fc051",
+     "## The site": "0cb8dd9a6f8a0096",
+     "## Making games": "9e44559de535d842",
+     "## The Game Codex and progress": "0738ef719cef3a4c",
+     "## Art direction and models": "a48fff7bf0a5f2fc",
+     "## Running live games (the back office)": "51ebf2ab756f6e4d",
+     "## Servers and AI seats": "d0028361fe567add",
+     "## Selling things (the shop)": "9e020d69dd6a954e",
+     "## Continuing a build from the Claude app": "0d68081e924ca419",
+     "## Rules": "2e6b29afb85dcf7e",
+     "## Telling Homie": "80b46fdd9e578db8",
+     "## Beta": "9d02638207a26e73"
+    }
+   },
+   "named": {
+    "Homie Arcade": {
+     "sections": {
+      "AGENTS.md": {
+       "## Commands (all through the pinned CLI in node_modules)": "2cdd530e48170bfd"
+      }
+     }
+    }
+   }
   }
  }
 }

package/lib/trailer.mjs

@@ -1,8 +1,8 @@
 /**
  * `homie-studio trailer <id>`: a trailer of a game, in one command.
  *
- * The work is not here. It is the Homie plugin's video skill (`video.mjs trailer`): the game rendered frame by frame
- * on a virtual clock, its sound rebuilt from its own files, the highlights picked from what it played, an end card,
+ * The work is not here. It is the Homie plugin's video skill (`video.mjs trailer`): live footage for server rules,
+ * or a virtual clock and rebuilt sound for older browser games, selected highlights, an end card,
  * and 16:9, 1:1 and 9:16 deliveries. This finds that script and hands the command over, so a person at a terminal
  * and an agent with the plugin run the same thing. The video goes to videos/<id>-trailer/ (or --slug <slug>).
  *
@@ -36,10 +36,14 @@ export function trailerCommand(root, id, rest, { skills = null, slug = null } =
 }
 
 export function trailerLines(r) {
+  const live = r.capture?.mode === 'live';
+  const audio = r.capture?.audio;
+  const sound = audio?.rebuilt ? `${audio.placed} sounds rebuilt from the game's own files`
+    : audio ? 'game audio captured live' : live ? 'no audio captured' : 'the game logged no sound';
   return [
     ...(r.problems ?? []).map((x) => `PROBLEM: ${x}`),
     `${r.seconds} s trailer of ${r.game}: ${Object.values(r.outputs ?? {}).map((o) => o.file).join(', ')}`,
-    `  filmed ${r.capture?.seconds} s frame by frame (${r.capture?.frames} frames, ${r.capture?.heldFrames} held); ${r.capture?.audio ? `${r.capture.audio.placed} sounds rebuilt from the game's own files` : 'the game logged no sound'}`,
+    `  filmed ${r.capture?.seconds} s ${live ? 'live' : 'frame by frame'} (${r.capture?.frames} frames, ${r.capture?.heldFrames} held); ${sound}`,
     `  ${r.edit?.shots} shots of ${r.edit?.shotSeconds} s, picked ${r.edit?.picked}`,
     ...(r.warnings ?? []).map((w) => `  warning: ${w}`),
     ...(r.next ? [`  next (the video skill's script): ${r.next}`] : []),

package/lib/typecheck.mjs

@@ -93,12 +93,12 @@ export function typecheck(root, games, { log = () => {} } = {}) {
       }
       // An error with no file is the project itself (a tsconfig.json that does not read): the game's to fix.
       const bare = /^error (TS\d+): (.*)$/.exec(line);
-      if (bare) mine.push(`games/${g.id}${own ? '/tsconfig.json' : ''} ${bare[1]} ${bare[2]}`);
+      if (bare) mine.push(`${g.kind === 'app' ? 'apps' : 'games'}/${g.id}${own ? '/tsconfig.json' : ''} ${bare[1]} ${bare[2]}`);
     }
     rows.push({ id: g.id, checked: true, with: own ? 'its tsconfig.json' : 'the build\'s own settings', errors: mine.length, elsewhere });
-    if (elsewhere) log(`types: games/${g.id}: ${elsewhere} ${elsewhere === 1 ? 'error' : 'errors'} outside the game's own files (a package it imports as source); not the game's, so not counted`);
+    if (elsewhere) log(`types: ${g.kind === 'app' ? 'apps' : 'games'}/${g.id}: ${elsewhere} ${elsewhere === 1 ? 'error' : 'errors'} outside the game's own files (a package it imports as source); not the game's, so not counted`);
     if (mine.length) found.push(...mine);
-    else log(`types: games/${g.id} has no type errors (TypeScript ${ts.version ?? '?'}, ${own ? 'its tsconfig.json' : 'the build\'s own settings'})`);
+    else log(`types: ${g.kind === 'app' ? 'apps' : 'games'}/${g.id} has no type errors (TypeScript ${ts.version ?? '?'}, ${own ? 'its tsconfig.json' : 'the build\'s own settings'})`);
   }
   if (found.length) {
     const shown = found.slice(0, 20);
@@ -125,7 +125,7 @@ export async function typecheckRules(root, g, checked, tune, { log = () => {} }
     '@homie-rocks/studio/*': [join(PACKAGE_ROOT, '*')],
   } }, files: [join(g.dir, 'src/rules.ts'), join(g.dir, g.entry ?? 'src/view.ts'), join(dir, 'files.d.ts')] }, null, 2)}\n`);
   const res = await runRulesCompiler(compiler, ['-p', project, '--pretty', 'false']);
-  if (res.error) throw new Error(`games/${g.id}: the rules type check could not finish: ${res.error.message}`);
+  if (res.error) throw new Error(`${g.kind === 'app' ? 'apps' : 'games'}/${g.id}: the rules type check could not finish: ${res.error.message}`);
   const messages = [];
   for (const line of `${res.stdout ?? ''}\n${res.stderr ?? ''}`.split(/\r?\n/)) {
     const at = /^(.+?)\((\d+),(\d+)\): error (TS\d+): (.*)$/.exec(line);
@@ -134,7 +134,9 @@ export async function typecheckRules(root, g, checked, tune, { log = () => {} }
       // 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] ?? '';
-        const advice = /Property 'ask'.*type 'never'/.test(at[5]) ? 'This handler scope never calls world.ask, so no answer can arrive here. Handle the answer in the scope that asks.'
+        const advice = /Property 'bot'.*RosterRow/.test(at[5]) ? "Rules roster rows use driver === 'bot' or 'ai' (not row.bot); preserve the visible AI label."
+          : /'[^']*\.at' is possibly 'undefined'/.test(at[5]) ? 'Effects carry either at (position) or id (entity). Check e.at before reading coordinates, or resolve e.id with room.get.'
+          : /Property 'ask'.*type 'never'/.test(at[5]) ? 'This handler scope never calls world.ask, so no answer can arrive here. Handle the answer in the scope that asks.'
           : /world\.round\.end/.test(sourceLine) && at[4] === 'TS2339' ? 'Only room handlers end a round. Send a declared event to a room handler that calls world.round.end().'
           : /'check'.*does not exist/.test(at[5]) ? 'Remove the obsolete check key. Generated observations require no exemption.'
           : /=> (?:GameDecision|GuideDecision)'/.test(at[5]) ? 'A floor returns goal and say names from agents.json with exactly the args and sayArgs each declares, or {} to decline. Forward a request as { goal: ask.k, args: ask.args }.'
@@ -150,7 +152,7 @@ export async function typecheckRules(root, g, checked, tune, { log = () => {} }
     } else if (/^error TS/.test(line)) messages.push(line);
     else if (/^\s+\S/.test(line) && messages.length) messages[messages.length - 1] += `\n${line.length > 360 ? line.slice(0, 220) + ' … ' + line.slice(-100) : line}`;
   }
-  if (messages.length) throw new Error(`games/${g.id}: its rules have type errors:\n${messages.slice(0, 30).map((m) => `  ${m}`).join('\n')}`);
-  if (res.status !== 0 && !res.stdout) throw new Error(`games/${g.id}: TypeScript stopped without diagnostics (${res.signal ?? res.status})`);
-  log(`types: games/${g.id}: rules, move and view checked with the toolkit's strict compiler`);
+  if (messages.length) throw new Error(`${g.kind === 'app' ? 'apps' : 'games'}/${g.id}: its rules have type errors:\n${messages.slice(0, 30).map((m) => `  ${m}`).join('\n')}`);
+  if (res.status !== 0 && !res.stdout) throw new Error(`${g.kind === 'app' ? 'apps' : 'games'}/${g.id}: TypeScript stopped without diagnostics (${res.signal ?? res.status})`);
+  log(`types: ${g.kind === 'app' ? 'apps' : 'games'}/${g.id}: rules, move and view checked with the toolkit's strict compiler`);
 }

package/netplay/NETPLAY.md

@@ -1,5 +1,13 @@
 # Homie netplay contract, v1 (revision 11)
 
+**Authoring now:** New games use rules plus view and the server as host. Read the
+Homie game skill's RULES.md and section 29 below. Sections 1–28 preserve the
+browser-hosted helper contract for existing games and describe shared shell
+features; their createNetplay/host-loop examples are not a recipe for new games.
+Use the skill's REWRITE.md for an owner-requested rewrite. All five starters use
+server rules. Room seats are capped at 32; larger rooms are future work.
+
+
 Status: **v1, revision 11** (2026-10-08, `@homie-rocks/studio` 0.33.1). The wire
 version is `v: 1`. Everything revisions 2 to 11 added is either an optional field, a new message type,
 a new refusal, or a change of pace inside the old caps, and both sides ignore types they do

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@homie-rocks/studio",
-  "version": "0.42.0",
+  "version": "0.43.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

@@ -2,8 +2,8 @@
  * host.ts — the host runtime: a rules module playing the host's part on the wire.
  * =============================================================================
  *
- * Today one player's browser is a room's host: it runs the rules and the clock and sends everybody the state. The host
- * runtime is that host with no browser in it. It takes a compiled rules module (rules.ts) and three things from its
+ * The server normally hosts the room: rules, clock and state. Browser hosting uses the same runtime
+ * for offline play, local development or private friends games. It takes a compiled rules module (rules.ts) and three things from its
  * caller: a way to send a frame, a clock and a store. It has no transport in it and no Cloudflare in it, in the style of
  * worker/room.mjs. Inside the `Table` (worker/index.mjs) the relay hands it parsed frames and fans out what it sends;
  * in Node the tests and the build check drive it with a clock of their own.

package/rules/view.ts

@@ -672,6 +672,7 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
   net.expose({
     self: () => { const m = meNow(); return m ? { x: m.pos.x, y: m.pos.y, z: m.pos.z } : null; },
     peer: (seat: number) => { if (!latest) return null; for (const u of latest.ents.values()) if (u.seat === seat) return { x: u.pos.x, y: u.pos.y, z: u.pos.z }; return null; },
+    movement: () => { const kinds = schema.kinds.filter(k => k.player); return kinds.length && kinds.every(k => k.maxSpeed === 0) ? 'stationary' : 'spatial'; },
     prediction: () => ({ ...correction, observedLeadAt, lastSendAt, now: clock(), serverTick: latest?.k, tick: stepped, catchTick, lead: targetLead(), medianLead: medianLead(), rate: speed, rtt: authorityRtt(), hostAge: quantile(hostAges, 0.5), pending: pending.length }),
     scores: () => roster().map((r) => ({ seat: r.seat, score: r.score })),
     score: myScore, tick: () => latest?.k ?? 0, epoch: () => epoch, hosted: () => net.rulesHosting ? 'browser' : schema.settings.host, status: () => solo ? 'offline' : status,

package/starters/coin-dash/src/move.ts

@@ -1,3 +1,5 @@
+// This same guarded step runs on the server and immediately for the local player.
+// Only pose/motion, input, ctx map/public tune/math/clocks: no scores, queries or random.
 /*
  * COIN DASH — how a runner moves. Its own file, because two places run it: the server, for every body it moves, and
  * each player's browser, for that player's own body. So it reads only what both have: the body's own position,

package/starters/coin-dash/src/rules.ts

@@ -1,3 +1,5 @@
+// Game truth lives here: declared fields, legal inputs, next-tick events and the server clock.
+// Read the game skill RULES.md before changing the mechanic; keep presentation in view.ts.
 /*
  * COIN DASH — the rules: the example of a game whose rules run on the server.
  *

package/starters/coin-dash/src/view.ts

@@ -1,3 +1,5 @@
+// Presentation only: openRoom gives predicted own movement and interpolated other bodies.
+// Send intent; rules decide outcomes. Keep rendered obstacles aligned with room.map.
 /*
  * COIN DASH — the view: what a player sees, and what they press.
  *

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

@@ -1,3 +1,5 @@
+// This same guarded step runs on the server and immediately for the local player.
+// Only pose/motion, input, ctx map/public tune/math/clocks: no scores, queries or random.
 import { defineMove } from '@homie-rocks/studio/rules';
 
 export const move = defineMove({

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

@@ -1,3 +1,5 @@
+// Game truth lives here: declared fields, legal inputs, next-tick events and the server clock.
+// Read the game skill RULES.md before changing the mechanic; keep presentation in view.ts.
 import { defineRules, f, type GameWorld, type GameSelf } from '@homie-rocks/studio/rules';
 import { move } from './move';
 

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

@@ -1,3 +1,5 @@
+// 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';
 // The Game Lab: tunables, phases, tracks and overlays (no-ops outside the lab).

package/starters/gem-rush/src/move.ts

@@ -1,3 +1,5 @@
+// This same guarded step runs on the server and immediately for the local player.
+// Only pose/motion, input, ctx map/public tune/math/clocks: no scores, queries or random.
 import { defineMove } from '@homie-rocks/studio/rules';
 
 export const move = defineMove({

package/starters/gem-rush/src/rules.ts

@@ -1,3 +1,5 @@
+// Game truth lives here: declared fields, legal inputs, next-tick events and the server clock.
+// Read the game skill RULES.md before changing the mechanic; keep presentation in view.ts.
 import { defineRules, f } from '@homie-rocks/studio/rules';
 import { move } from './move';
 

package/starters/gem-rush/src/view.ts

@@ -1,3 +1,5 @@
+// Presentation only: openRoom gives predicted own movement and interpolated other bodies.
+// Send intent; rules decide outcomes. Keep rendered obstacles aligned with room.map.
 /** Gem Rush: the canvas draws the room; rules.ts decides the game. Coordinates here are pixels (50 per metre). */
 import { openRoom, type Entity } from '@homie-rocks/studio/rules/view';
 import type rules from './rules';

package/starters/gem-rush-3d/src/move.ts

@@ -1,3 +1,5 @@
+// This same guarded step runs on the server and immediately for the local player.
+// Only pose/motion, input, ctx map/public tune/math/clocks: no scores, queries or random.
 import { defineMove, type Vec3 } from '@homie-rocks/studio/rules';
 
 import type { MoveBody, MoveContext } from '@homie-rocks/studio/rules/types';

package/starters/gem-rush-3d/src/rules.ts

@@ -1,3 +1,5 @@
+// Game truth lives here: declared fields, legal inputs, next-tick events and the server clock.
+// Read the game skill RULES.md before changing the mechanic; keep presentation in view.ts.
 import { defineRules, f, type GameWorld } from '@homie-rocks/studio/rules';
 import { move } from './move';
 

package/starters/gem-rush-3d/src/view.ts

@@ -1,3 +1,5 @@
+// Presentation only: openRoom gives predicted own movement and interpolated other bodies.
+// Send intent; rules decide outcomes. Keep rendered obstacles aligned with room.map.
 /** Gem Rush 3D: the room runs the rules; this view draws the meadow and its animals. */
 import {
   AmbientLight, AnimationClip, AnimationMixer, Box3, BoxGeometry, BufferAttribute, BufferGeometry, CanvasTexture, CircleGeometry, Color, ConeGeometry, CylinderGeometry,

package/starters/hero-rush-3d/src/move.ts

@@ -1,3 +1,5 @@
+// This same guarded step runs on the server and immediately for the local player.
+// Only pose/motion, input, ctx map/public tune/math/clocks: no scores, queries or random.
 import { defineMove, type Vec3 } from '@homie-rocks/studio/rules';
 
 import type { MoveBody, MoveContext } from '@homie-rocks/studio/rules/types';

package/starters/hero-rush-3d/src/rules.ts

@@ -1,3 +1,5 @@
+// Game truth lives here: declared fields, legal inputs, next-tick events and the server clock.
+// Read the game skill RULES.md before changing the mechanic; keep presentation in view.ts.
 import { defineRules, f, type GameWorld } from '@homie-rocks/studio/rules';
 import { move } from './move';
 

package/starters/hero-rush-3d/src/view.ts

@@ -1,3 +1,5 @@
+// Presentation only: openRoom gives predicted own movement and interpolated other bodies.
+// Send intent; rules decide outcomes. Keep rendered obstacles aligned with room.map.
 /** Hero Rush 3D: server rules, predicted jumps, and the original meadow and heroes. */
 import {
   AmbientLight, Box3, BoxGeometry, BufferAttribute, BufferGeometry, CanvasTexture, CircleGeometry, Color, ConeGeometry, CylinderGeometry,

package/worker/version.mjs

@@ -1,2 +1,2 @@
 /** The @homie-rocks/studio version this Worker code is (package.json's; a test keeps them equal). Cache-busts /_homie/site.js. */
-export const STUDIO_VERSION_TAG = '0.42.0';
+export const STUDIO_VERSION_TAG = '0.43.0';