@homie-rocks/studio 0.35.1 → 0.36.0

package/CHANGELOG.md

@@ -17,6 +17,30 @@ 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.36.0] - 2026-10-08
+
+**Plugin 0.37.0** · [#68](https://github.com/homie-rocks/homie/pull/68) · [#73](https://github.com/homie-rocks/homie/pull/73)
+
+The build plays your rules game and names problems before you publish it.
+
+### Added
+
+- **The build plays your rules game before it is written.** After checking the types in rules, movement and view against the game's own declarations, it seats generated players in a room on the real server runtime. They steer, hold every control, send every command the game declares, and sometimes send nothing at all; they leave, come back and give up their seats; the room is restarted as a deploy restarts it. A game with AI companions is played with them too.
+- **A build is refused only for what that play proved.** A handler that threw, a tick that used its whole budget, a character the server had to hold back because its movement outran its declared top speed, a room that did not come back the same from its own save, or a value the room had to change and lose: `NaN`, an infinite number in a fraction or a vector, more entries than a list or a map declares, a text longer than declared. The message names the file, the line of the write and the handler, says what a live room does with the value, and how to repair it. Everything else is an `info:` line that never fails a build: how much was played, which handlers never ran, and how often a whole number was held to its range.
+- **The same game gets the same answer on every computer.** The play is counted in ticks and in the rules' own budget units, never in seconds, so a slow or busy computer builds what a fast one builds and prints the same lines. A small game is played for fifteen minutes of the room's clock, which takes about a second; a heavy game is played until its units are used, a few seconds, and the line says how far that was. `homie-studio build --long-check` plays eight times as much, for a release or a CI run.
+- **A live room never stops for a value that does not fit its field.** It stores the nearest thing the type holds, as before: `NaN` becomes `0`, a list is cut to its size, a whole number is held to its range (`Infinity` is the top of it, so it can stand for "never"). The build is where such a write is caught. `-0` is now stored as `0`, so a room divides the same way before and after a restart, and a map keeps its keys in the order they were added. The `game` skill's `RULES.md` has the table. Saved matches are written in a new form: a match saved by a build made before this change starts afresh once.
+
+- **Let a player host a friends game.** Studios can choose `room.host: "browser"` to run the same rules in an elected player's browser. When that player leaves, another takes over with the saved seats, scores, round clock and AI companions. Server hosting remains the default.
+- **Play offline from the same rules.** Browsers and packaged apps can play with local bots without a connection, unless the studio turns offline play off. Offline progress stays local. The Game Lab uses the same rules with its stages and sliders; online rooms can also use AI guides and decisions.
+- **Browser hosting has different limits.** It depends on a player's device and connection and offers no protection against a modified host: that player can change scores or the match. It has no server recovery guarantee. When a host hides or closes the tab, another player takes over from the current tick; a crash can lose up to a second. Updates are paced to fit the connection, and a room whose state grows beyond the browser limits stops with a clear message. Choose server hosting for stronger authority or larger rooms.
+- **The netplay contract is revision 11** (`netplay/NETPLAY.md`, section 29): the server as a host, input as steps stamped with the room's tick, explicit browser runtime output, and checkpoint handover. Nothing a game written before sends or receives has changed.
+
+### Fixed
+
+- Local development publishes one complete rules build per restart, avoiding the two reloads caused by separate code and asset watchers.
+- Browser rooms recover after a hidden tab, sleep or a dropped connection. Returning players regain a playable body, unavailable offline files keep reconnecting, and failed rules explain why the room stopped.
+- Builds check the relay's browser state limits. A room that grows beyond them stops with a clear message instead of repeatedly changing hosts. Saved inputs and answers are checked before rules use them.
+
 ## [0.35.1] - 2026-10-08
 
 **Plugin 0.36.0** · [#71](https://github.com/homie-rocks/homie/pull/71)

package/agents/agents.ts

@@ -59,6 +59,8 @@ export interface AgentsOptions {
   /** Runtime integration: a room clock and an explicit beat replace the browser timer. */
   now?: () => number;
   manual?: boolean;
+  /** A rules view is always a client; the separate runtime owns guides. */
+  viewOnly?: boolean;
   /** Keep an asked-for goal through scripted floor decisions until completion or sixty seconds. */
   carryFloor?: boolean;
   restore?: AgentsSaved;
@@ -283,7 +285,7 @@ export function useAgents(net: Netplay<any, any, any>, vocab: Vocabulary, opts:
   function onAsk(slot: number, k: string, args: Record<string, unknown>, from: number): void {
     const def = own(vocab.asks, k);
     const s = slotOf(slot);
-    if (!def || !s || argsWhy(def.args, args, lastView.get(slot) ?? viewOf(slot), null)) { st.drops += 1; return; }
+    if (!def || !s || argsWhy(def.args, args, viewOf(slot), people())) { st.drops += 1; return; }
     const now = wall();
     if (def.leave) { const m = avoid.get(slot) ?? new Map<number, number>(); m.set(from, now + AGENT_RULES.leaveMs); avoid.set(slot, m); }
     asks.set(slot, [...(asks.get(slot) ?? []), { k, args, from, at: now }].slice(-4));
@@ -298,7 +300,7 @@ export function useAgents(net: Netplay<any, any, any>, vocab: Vocabulary, opts:
   const offEvent = net.on('event', (e: NetEvent) => {
     const k = e.k;
     const d = (e.d && typeof e.d === 'object' ? e.d : {}) as Record<string, unknown>;
-    if (net.isHost) {
+    if (net.isHost && !opts.viewOnly) {
       const s = slotOfSeat(e.from);
       if (k === 'agent:do' && s) {
         st.dos += 1;
@@ -311,11 +313,11 @@ export function useAgents(net: Netplay<any, any, any>, vocab: Vocabulary, opts:
       if (ask && e.from !== null && !net.isAgent(e.from) && Number.isInteger(d['slot'])) { onAsk(d['slot'] as number, ask, (d['args'] ?? {}) as Record<string, unknown>, e.from); return; }
       return;
     }
-    if (k === 'agent:offer' && e.from === net.host?.seat && Number.isInteger(d['slot']) && d['view'] && typeof d['view'] === 'object') { lastView.set(d['slot'] as number, d['view'] as Record<string, unknown>); return; }
+    if (k === 'agent:offer' && e.from === (opts.viewOnly ? null : net.host?.seat) && Number.isInteger(d['slot']) && d['view'] && typeof d['view'] === 'object') { lastView.set(d['slot'] as number, d['view'] as Record<string, unknown>); return; }
     // Every other browser: a guide's line the host relayed (Quiet AI already dropped it in the helper). Its words are
     // this browser's own copy of the vocabulary; an argument is a seat, a value of the line's list, or an id.
     const line = /^say:([a-z][a-z0-9_]{0,31})$/.exec(k)?.[1];
-    if (e.from === net.host?.seat && line && d['ai'] === true && Number.isInteger(d['slot'])) {
+    if (e.from === (opts.viewOnly ? null : net.host?.seat) && line && d['ai'] === true && Number.isInteger(d['slot'])) {
       const args = (d['args'] ?? {}) as Record<string, unknown>;
       const def = own(vocab.lines, line);
       const ids = Object.fromEntries(Object.entries(def?.args ?? {}).map(([n, t]) => [n, t]).filter(([, t]) => typeof t === 'string' && VIEW_ARG.test(t)).map(([n, t]) => [VIEW_ARG.exec(t as string)![1], /^[a-z0-9][a-z0-9_-]{0,39}$/.test(String(args[n as string] ?? '')) ? [args[n as string]] : []]));
@@ -327,7 +329,7 @@ export function useAgents(net: Netplay<any, any, any>, vocab: Vocabulary, opts:
 
   // The host's beat: views to the guides an AI holds (at most one every 2 s each), the floor for the rest.
   const beat = (): void => {
-    if (!net.isHost || net.offline) return;
+    if (opts.viewOnly || !net.isHost || net.offline) return;
     const now = wall();
     for (const s of guides()) {
       const seat = s.agent?.seat ?? null;
@@ -372,7 +374,7 @@ export function useAgents(net: Netplay<any, any, any>, vocab: Vocabulary, opts:
       const s = slotOf(slot);
       if (!def || !s) return false;
       const seat = s.agent?.seat ?? null;
-      if (net.isHost) {
+      if (net.isHost && !opts.viewOnly) {
         const me = net.offline ? 0 : net.seat;
         if (me === null) return false;
         onAsk(slot, k, args, me);

package/bin/homie-studio.mjs

@@ -15,10 +15,13 @@
  *                                          the cards (lib/mcp.mjs); --studios: the folder the studios live in
  *   homie-studio game new <id> [--from gem-rush] [--name "<Game Name>"]
  *   homie-studio games
- *   homie-studio build [<id>] [--maps] [--types]   (--maps: also keep each bundle's source map and module sizes in
- *                                          .studio/maps/<id>/, never in site/dist: what `perf` reads a CPU profile through;
- *                                          --types: check the games' TypeScript first, with the studio's own
- *                                          `typescript`; a type error stops the build. The site is built in a folder of
+ *   homie-studio build [<id>] [--maps] [--types] [--long-check]   (--maps: also keep each bundle's source map and
+ *                                          module sizes in .studio/maps/<id>/, never in site/dist: what `perf` reads a
+ *                                          CPU profile through; --types: check the games' TypeScript first, with the
+ *                                          studio's own `typescript`; a type error stops the build; --long-check: play
+ *                                          each rules game eight times as long before it is written (a rules game is
+ *                                          always type-checked and played; this is more of the same play, for a
+ *                                          release or a CI run). The site is built in a folder of
  *                                          its own and put in place only when all of it is there: a game that does not
  *                                          build fails the command and leaves site/dist as it was. Each game's line says
  *                                          changed or unchanged, its build hash, and whether its source is shared)
@@ -414,7 +417,7 @@ function print(result) {
       lines.push(`Built ${result.games.map((g) => `${g.id} (${Math.round(g.bytes / 1024)} KB)`).join(', ') || 'no games'} into ${relative(process.cwd(), result.dist) || result.dist}`);
       // Per game: did it change since the build before, which build it is (the hash the live site's manifest says once
       // deployed), and what loads later.
-      for (const g of result.games) lines.push(`  ${g.id}: ${g.changed ?? 'new'}, build ${g.hash ?? '?'}${g.bundle ? ` (${g.bundle}${g.chunks ? ` + ${g.chunks} ${g.chunks === 1 ? 'chunk' : 'chunks'} loaded later` : ''})` : ''}`);
+      for (const g of result.games) lines.push(`  ${g.id}: ${g.changed ?? 'new'}, build ${g.hash ?? '?'}${g.bundle ? ` (${g.bundle}${g.chunks ? ` + ${g.chunks} additional ${g.chunks === 1 ? 'chunk' : 'chunks'}` : ''})` : ''}`);
       if (result.retired) lines.push(`Note: ${result.retired}`);
       if (result.types) lines.push(`Types: ${result.types.games.filter((g) => g.checked).map((g) => g.id).join(', ') || 'no game has TypeScript to check'}${result.types.games.some((g) => g.checked) ? ` checked with TypeScript ${result.types.typescript ?? '?'}, no errors` : ''}`);
       if (result.songs?.length || result.videos?.length) lines.push(`Media pages: ${[...result.songs.map((x) => `/music/${x}/`), ...result.videos.map((x) => `/videos/${x}/`)].join(', ')}`);
@@ -906,7 +909,7 @@ async function main() {
   // go, so an old note, an old card or an agent's memory of the toolkit does not end at "unknown command".
   if (cmd === 'game' && sub === 'remix') return { ok: false, command: 'game remix', why: 'remix was retired: a game is no longer handed over whole, and no studio serves one. Games build on each other through parts, the pieces of a game its studio chose to share: find one with `homie-studio parts find <words>` and bring it in with `homie-studio parts add` (in chat: parts_find, part_add; parts/PARTS.md)' };
   if (cmd === 'games') return { ok: true, command: 'games', games: listGames(root).map(({ dir, ...g }) => ({ ...g, dir: relative(root, dir) })) };
-  if (cmd === 'build') return tracked(root, 'build', () => build(root, { only: positional[1] ?? null, log, maps: flags.has('maps'), types: flags.has('types') }), 'build');
+  if (cmd === 'build') return tracked(root, 'build', () => build(root, { only: positional[1] ?? null, log, maps: flags.has('maps'), types: flags.has('types'), longCheck: flags.has('long-check') }), 'build');
   if (cmd === 'preview') return preview(root, positional[1] ?? (listGames(root).length === 1 ? listGames(root)[0].id : null));
   if (cmd === 'perf' && sub === 'sizes') return perfSizes(root, positional[2] ?? listGames(root)[0]?.id);
   if (cmd === 'lab') return labCommand(root, sub);

package/lab/lab.ts

@@ -166,6 +166,21 @@ export const lab = {
     return out as Tuned<S>;
   },
 
+  /** Rules use the same slider file as the view. Public values keep their public. prefix in the Lab's UI. */
+  rulesTune(raw: Record<string, unknown>): Record<string, unknown> {
+    if (!ON) return raw;
+    const pub = raw.public && typeof raw.public === 'object' ? raw.public as Record<string, unknown> : {};
+    const spec: TunableFile = {};
+    for (const [k, v] of Object.entries(raw)) if (k !== 'public' && (typeof v === 'number' || typeof (v as TunableSpec)?.value === 'number')) spec[k] = v as TunableSpec | number;
+    for (const [k, v] of Object.entries(pub)) if (typeof v === 'number' || typeof (v as TunableSpec)?.value === 'number') spec[`public.${k}`] = v as TunableSpec | number;
+    const values = host!.tunables(spec);
+    const out: Record<string, unknown> & { public: Record<string, unknown> } = { ...raw, public: { ...pub } };
+    for (const k of Object.keys(spec)) if (Number.isFinite(values[k])) {
+      if (k.startsWith('public.')) out.public[k.slice(7)] = values[k]; else out[k] = values[k];
+    }
+    return out;
+  },
+
   /**
    * Dice for juice (particles, shake, sparks): its own stream in the lab, so a build that adds a particle never moves
    * a gem or a bot in the other build (Math.random() is the world's dice, the same in both). Math.random() outside.

package/lib/build.mjs

@@ -75,7 +75,7 @@ import { audienceOf } from '../worker/shop-rules.mjs';
 import { loungeConfig, loungeProblems } from '../worker/lounge-store.mjs';
 // GAME PARTS (parts/PARTS.md): the three call-outs below are all the build knows of them.
 import { buildParts, partsPlugin } from './parts-build.mjs';
-// RULES ON THE SERVER (NETPLAY.md section 29): a game with a src/rules.ts is built as a view bundle plus a rules module.
+// RULES ON THE SERVER (NETPLAY.md section 29): a game declaring a room object and src/rules.ts builds as a view bundle plus a rules module.
 
 /** Never copied into a static game's served folder. */
 const STATIC_SKIP = new Set(['node_modules', '.git', '.wrangler', '.port', '.DS_Store', 'game.json', 'PORT.md', 'CODEX.md', 'lab.json', 'codex']);
@@ -376,7 +376,7 @@ function pointAtBundle(html, bundle) {
  * game is served (/games/<id>/ on the site, /<id>/__game/ in its frame, the lab). A game with no dynamic import is
  * one file, as before. `hashed` (the site's build) names the bundle by its content too: see the top of this file.
  */
-export async function buildGameFiles(esbuild, root, g, out, { maps = false, sourcemap = null, cache = {}, log = () => {}, hashed = false } = {}) {
+export async function buildGameFiles(esbuild, root, g, out, { maps = false, sourcemap = null, cache = {}, log = () => {}, hashed = false, lab = false, longCheck = false } = {}) {
   rmSync(out, { recursive: true, force: true });
   mkdirSync(join(out, 'assets'), { recursive: true });
   const mode = g.build?.mode ?? 'bundle';
@@ -394,7 +394,7 @@ export async function buildGameFiles(esbuild, root, g, out, { maps = false, sour
   }
   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 }) : null;
+  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`);
@@ -406,7 +406,7 @@ export async function buildGameFiles(esbuild, root, g, out, { maps = false, sour
       // game.json assets.budgets, read by createModels() (assets/assets.ts): a constant in the bundle, never a fetch.
       define: { __HOMIE_MODEL_BUDGETS__: JSON.stringify(budgets ?? {}) },
       // GAME PARTS: `@parts/<host>/<id>` and `@parts/<id>` resolve to the part's entry, and the game is credited.
-      plugins: [partsPlugin(root, g.id), ...(rules ? [viewPlugin(g, rules, entry)] : [])],
+      plugins: [partsPlugin(root, g.id), ...(rules ? [viewPlugin(g, rules, entry, { lab })] : [])],
     };
     const failed = (error) => {
       const first = error.errors?.[0];
@@ -416,7 +416,7 @@ export async function buildGameFiles(esbuild, root, g, out, { maps = false, sour
     warnings += result.warnings.length;
     metafile = result.metafile;
     const outputs = Object.entries(result.metafile.outputs).filter(([k]) => k.endsWith('.js'));
-    const main = outputs.find(([, v]) => v.entryPoint)?.[0];
+    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}`);
     bundled = `assets/${basename(main)}`;
     chunks = outputs.filter(([k]) => k !== main).map(([k]) => `assets/${basename(k)}`).sort();
@@ -466,6 +466,7 @@ export async function buildGameFiles(esbuild, root, g, out, { maps = false, sour
     for (const file of [bundled, ...chunks].filter(Boolean)) digest.update(readFileSync(join(out, file)));
     digest.update(readFileSync(join(out, 'index.html')));
     rules.build = digest.digest('hex').slice(0, 32);
+    writeFileSync(join(out, 'rules.json'), `${JSON.stringify({ v: 1, host: rules.settings.host, offline: rules.settings.offline, build: rules.build, files: [bundled, ...chunks] })}\n`);
     if (g.netplay?.version !== undefined) log(`  ${g.id}: rules games use their build hash as the revision; netplay.version is not read`);
   }
   return { mode, warnings, metafile, bundle: bundled, chunks, rules };
@@ -486,7 +487,7 @@ export function orderGames(games, order, log = () => {}) {
   return [...games].sort((a, b) => (at.get(a.id) ?? Infinity) - (at.get(b.id) ?? Infinity) || a.id.localeCompare(b.id));
 }
 
-export async function build(root, { only = null, log = () => {}, deploy = process.env.WORKERS_CI === '1', maps = false, types = false } = {}) {
+export async function build(root, { only = null, log = () => {}, deploy = process.env.WORKERS_CI === '1', maps = false, types = false, beforePublish = async () => {}, longCheck = false } = {}) {
   const esbuild = await studioEsbuild(root);
   const studio = readStudio(root);
   // The shop first (shop/SHOP.md): invalid shop settings stop the build before anything is built.
@@ -504,13 +505,13 @@ export async function build(root, { only = null, log = () => {}, deploy = proces
   // from the site as it is.
   const dist = openStage(root, { from: only ? live : null });
   try {
-    return await buildInto(dist, { esbuild, studio, shop, live, games, before, typed, root, only, log, deploy, maps });
+    return await buildInto(dist, { esbuild, studio, shop, live, games, before, typed, root, only, log, deploy, maps, beforePublish, longCheck });
   } finally {
     rmSync(dist, { recursive: true, force: true });
   }
 }
 
-async function buildInto(dist, { esbuild, studio, shop, live, games, before, typed, root, only, log, deploy, maps }) {
+async function buildInto(dist, { esbuild, studio, shop, live, games, before, typed, root, only, log, deploy, maps, beforePublish, longCheck }) {
   const built = [];
   const retired = [];
   const cache = {};
@@ -519,7 +520,7 @@ async function buildInto(dist, { esbuild, studio, shop, live, games, before, typ
   for (const g of games) {
     const out = join(dist, 'games', g.id);
     const started = Date.now();
-    const { mode, warnings, bundle, chunks, rules } = await buildGameFiles(esbuild, root, g, out, { maps, cache, log, hashed: true });
+    const { mode, warnings, bundle, chunks, rules } = await buildGameFiles(esbuild, root, g, out, { maps, cache, log, hashed: true, longCheck });
     if (rules) ruled.push({ id: g.id, ...rules }); else browserHosted.push(g.id);
     // The guides' vocabulary (NETPLAY.md section 18): checked here, so a room never meets a line it cannot say.
     vocabFor(g, out);
@@ -542,11 +543,14 @@ async function buildInto(dist, { esbuild, studio, shop, live, games, before, typ
       id: g.id, name: g.name, mode, bytes, ms: Date.now() - started, warnings, seats: seats.max,
       ...(bundle ? { bundle } : {}), ...(chunks.length ? { chunks: chunks.length, chunkBytes: later } : {}),
     });
-    log(`built ${g.id} (${mode}, ${Math.round(bytes / 1024)} KB${chunks.length ? ` + ${chunks.length} ${chunks.length === 1 ? 'chunk' : 'chunks'} loaded later, ${Math.max(1, Math.round(later / 1024))} KB` : ''})`);
-    if (rules) log(`  ${g.id}: its rules run on the server (checked and guarded, ${Math.max(1, Math.round(rules.code.length / 1024))} KB, build ${rules.build}; three seconds with bots: the busiest tick used ${rules.tickUnits} of ${rules.settings.budget.tick} budget units, ${rules.units} of them in one handler)`);
+    log(`built ${g.id} (${mode}, ${Math.round(bytes / 1024)} KB${chunks.length ? ` + ${chunks.length} additional ${chunks.length === 1 ? 'chunk' : 'chunks'}, ${Math.max(1, Math.round(later / 1024))} KB` : ''})`);
+    if (rules && (rules.settings.offline || rules.settings.host === 'browser')) log(`${g.id}: this game's rules and tunables are sent to players' devices so it can be played offline`);
+    if (rules) log(`  ${g.id}: its rules run ${rules.settings.host === 'browser' ? "in a player's browser" : 'on the server'} (checked and guarded, ${Math.max(1, Math.round(rules.code.length / 1024))} KB, build ${rules.build}; ${rules.check.ticks} ticks played, the room rebuilt from its save ${rules.check.restores} times: the busiest tick used ${rules.tickUnits} of ${rules.settings.budget.tick} budget units, ${rules.units} of them in one handler; the largest save was ${rules.check.largestSaveBytes} bytes)`);
+    if (rules && rules.settings.host === 'server' && (rules.snapshotBytes > rules.snapshotCap || rules.checkpointBytes > rules.checkpointCap)) log(`  ${g.id}: this state fits server and offline play but exceeds browser hosting limits.`);
+    if (rules) log(`  ${g.id}: smoke-run largest snapshot ${rules.snapshotBytes} B / ${rules.snapshotCap} B browser cap; checkpoint ${rules.checkpointBytes} B / ${rules.checkpointCap} B browser cap (measured, not an upper bound)`);
   }
   // A game written before rules (its own code is the host) builds and runs exactly as it did. Said in one line.
-  if (browserHosted.length) log(`hosted by a player's browser, as before (no src/rules.ts; nothing to do): ${browserHosted.join(', ')}`);
+  if (browserHosted.length) log(`hosted by a player's browser, as before (no room object; nothing to do): ${browserHosted.join(', ')}`);
   const all = listGames(root);
   // No game is handed over whole any more (remix was retired; worker/license.mjs). A one-game build starts from the
   // site as it is, which an older toolkit may have built: what that wrote for remixers (a game's whole source, and
@@ -571,8 +575,8 @@ async function buildInto(dist, { esbuild, studio, shop, live, games, before, typ
   // studio.json site.order: the catalogue's order is every listing's order.
   const shown = orderGames(all.filter((g) => existsSync(join(dist, 'games', g.id, 'index.html'))), s.order, log);
   // Server-hosted games: what this build made, and for a one-game build what the catalogue before it said of the others.
-  const rulesOf = new Map(ruled.map((r) => [r.id, { host: 'server', tickHz: r.settings.tickHz, inputHz: r.settings.inputHz, contract: r.schema.contract, build: r.build, stateHash: r.stateHash, rounds: r.rounds }]));
-  if (only) for (const row of readJson(join(dist, 'games.json'))?.games ?? []) if (row?.room?.host === 'server' && row.id !== only && !rulesOf.has(row.id)) rulesOf.set(row.id, row.room);
+  const rulesOf = new Map(ruled.map((r) => [r.id, { host: r.settings.host, offline: r.settings.offline, tickHz: r.settings.tickHz, inputHz: r.settings.inputHz, contract: r.schema.contract, build: r.build, stateHash: r.stateHash, rounds: r.rounds }]));
+  if (only) for (const row of readJson(join(dist, 'games.json'))?.games ?? []) if (row?.room?.contract && row.id !== only && !rulesOf.has(row.id)) rulesOf.set(row.id, row.room);
   // What each game's build is (its landing's own pictures are not part of it): the digest the manifest names.
   const builds = {};
   const rows = shown.map((g) => {
@@ -714,7 +718,8 @@ async function buildInto(dist, { esbuild, studio, shop, live, games, before, typ
   if (deploy) for (const b of built) log(`  ${b.id}: ${b.changed}${b.changed === 'new' ? '' : ' since the last build here'}, build ${b.hash}`);
   // The rules of the server-hosted games, where the studio's Worker imports them (site/src/rules/). Written with the
   // site, never before: a game that did not build has left both as they were.
-  const hosted = (await rulesBuild()).writeRules(root, ruled, all.filter((g) => rulesOf.has(g.id)).map((g) => g.id));
+  await beforePublish();
+  const hosted = (await rulesBuild()).writeRules(root, ruled, all.filter((g) => rulesOf.get(g.id)?.host === 'server').map((g) => g.id));
   // All of it is there: now, and only now, it becomes site/dist (lib/stage.mjs).
   const swapped = swapIn(dist, live);
   return {

package/lib/dev.mjs

@@ -413,6 +413,7 @@ export async function dev(root, { port: askedPort = 8787, remoteAi = false, loca
   // A rules game saved while dev runs is built again (see rulesStamp), one game at a time.
   const stamps = new Map(listGames(root).filter(isRulesGame).map((g) => [g.id, rulesStamp(g)]));
   let rebuilding = false;
+  let published = Promise.resolve();
   const rulesLook = async () => {
     if (rebuilding || ending) return;
     for (const g of listGames(root).filter(isRulesGame)) {
@@ -424,7 +425,20 @@ export async function dev(root, { port: askedPort = 8787, remoteAi = false, loca
         log(`games/${g.id} changed: checking its rules and building it again…`);
         const hash = () => { try { return JSON.parse(readFileSync(join(root, 'site/dist/games.json'), 'utf8')).games.find((x) => x.id === g.id)?.room?.stateHash; } catch { return null; } };
         const before = hash();
-        await build(root, { only: g.id, log });
+        let release;
+        published = new Promise(resolve => { release = resolve; });
+        try {
+          await build(root, { only: g.id, log, beforePublish: async () => {
+            // Wrangler independently watches assets and code. Publishing both while it runs
+            // reloads the old bundle first, then the new one. Stop once at the publish boundary;
+            // the loop below starts once with the complete build and the same local storage.
+            if (!child || child.exitCode !== null) return;
+            restart = g.id;
+            const stopped = new Promise(resolve => child.once('close', resolve));
+            child.kill('SIGTERM');
+            await stopped;
+          } });
+        } finally { release(); }
         log(`games/${g.id} is rebuilt. ${before && before === hash() ? 'Local rooms resume their saved match; pages reconnect.' : 'The stored shape changed: local rooms reset to a fresh match; pages reconnect.'}`);
       } catch (error) {
         log(`games/${g.id} did not build, so the local site still runs what it had:\n${String(error?.message ?? error)}`);
@@ -461,6 +475,7 @@ export async function dev(root, { port: askedPort = 8787, remoteAi = false, loca
     writeFileSync(devFile(root), `${JSON.stringify({ pid: process.pid, child: child.pid, port: Number(port), at: new Date().toISOString() })}\n`);
     settle().catch(() => {});
     await new Promise((done) => { child.on('close', done); child.on('error', done); });
+    await published;
     if (!restart || ending) break;
     restart = null;
   }

package/lib/lab-check.mjs

@@ -25,7 +25,7 @@ import { mkdirSync, writeFileSync } from 'node:fs';
 import { join, relative } from 'node:path';
 import { chromeArgs, findChrome, noChrome, SOFTWARE_GL } from './chrome.mjs';
 import { labDir, startLabServer } from './lab.mjs';
-import { listGames } from './studio.mjs';
+import { isRulesGame, listGames } from './studio.mjs';
 
 const round = (v, d = 2) => (Number.isFinite(v) ? Math.round(v * 10 ** d) / 10 ** d : null);
 const pct = (xs, p) => { const s = xs.filter(Number.isFinite).sort((a, b) => a - b); return s.length ? s[Math.min(s.length - 1, Math.floor((s.length - 1) * p))] : null; };
@@ -58,6 +58,11 @@ export function summarise(pane, { fps, units }) {
   };
 }
 
+/** A rules take must actually advance its local runtime without joining a room. */
+export function rulesRun(s) {
+  return Boolean(s?.hosting && !s.connected && s.tick > 0 && s.status === 'playing');
+}
+
 /** Where two runs of one build first differ (frame number), or null when every frame matches. */
 export function firstDifference(a, b) {
   const n = Math.max(a?.length ?? 0, b?.length ?? 0);
@@ -137,8 +142,18 @@ export async function labCheck(root, id, { take = null, today = 'HEAD', device =
       new: first.new.available ? firstDifference(first.new.frames, second.new.frames) : null,
       today: first.today.available ? firstDifference(first.today.frames, second.today.frames) : null,
     };
+    const rules = isRulesGame(games.find((g) => g.id === game)) ? await page.evaluate(() => {
+      const out = {};
+      for (const pane of ['new', 'today']) {
+        const frame = [...document.querySelectorAll('iframe')].find((f) => f.src.includes('/' + pane + '/'));
+        const n = frame?.contentWindow?.__homieNet;
+        out[pane] = n ? { format: typeof n.probe?.hosted === 'function', hosting: n.rulesHosting, connected: n.connected, tick: n.probe?.tick?.(), status: n.probe?.status?.() } : null;
+      }
+      return out;
+    }) : null;
+    if (rules && (!rulesRun(rules.new) || (first.today.available && rules.today?.format && !rulesRun(rules.today)))) pageErrors.push('A rules pane did not play on its local host runtime.');
     const summary = {
-      ok: true, game, take: first.take, note: first.note, fps: first.fps, frames: first.frames, device: first.device, seed: first.seed, inputs: first.inputs,
+      ok: !rules || pageErrors.length === 0, rules, game, take: first.take, note: first.note, fps: first.fps, frames: first.frames, device: first.device, seed: first.seed, inputs: first.inputs,
       newBuild: first.newBuild, todayBuild: first.todayBuild, overrides: first.overrides, renderer, software: SOFTWARE_GL.test(String(renderer ?? '')),
       deterministic, new: summarise(first.new, first), today: summarise(first.today, first), pageErrors,
     };
@@ -182,7 +197,7 @@ export async function labCheck(root, id, { take = null, today = 'HEAD', device =
     };
     if (!out) writeFileSync(join(labDir(root, game), 'latest.json'), `${JSON.stringify(latest, null, 2)}\n`);
     return {
-      ok: true, command: 'lab check', game, take: summary.take, out: rel(dir), report: rel(join(dir, 'REPORT.md')), sheet: rel(join(dir, 'sheet.png')), still: rel(stillPath),
+      ok: summary.ok, rules: summary.rules, command: 'lab check', game, take: summary.take, out: rel(dir), report: rel(join(dir, 'REPORT.md')), sheet: rel(join(dir, 'sheet.png')), still: rel(stillPath),
       frames: summary.frames, fps: summary.fps, deterministic, renderer, software: summary.software,
       phases: { new: summary.new.phases?.map((p) => `${p.name} ${p.frames}f`) ?? [], today: summary.today.available ? summary.today.phases.map((p) => `${p.name} ${p.frames}f`) : null },
       timeline: { new: (summary.new.phases ?? []).map(({ name, from, to }) => ({ name, from, to })), today: summary.today.available ? summary.today.phases.map(({ name, from, to }) => ({ name, from, to })) : null },

package/lib/lab.mjs

@@ -67,6 +67,20 @@ export function readTunables(dir) {
   return json;
 }
 
+/** Rules keep public movement knobs grouped on disk; sliders name them public.speed, public.jump, and so on. */
+export function flatTunables(spec) {
+  if (!spec) return null;
+  const { public: pub, ...rest } = spec;
+  return { ...rest, ...Object.fromEntries(Object.entries(pub ?? {}).map(([k, v]) => [`public.${k}`, v])) };
+}
+export function setLabTunables(spec, values) {
+  const r = setTunables(flatTunables(spec), values);
+  if (!spec?.public) return r;
+  const out = { ...r.spec, public: { ...spec.public } };
+  for (const [k, v] of Object.entries(r.spec)) if (k.startsWith('public.')) { out.public[k.slice(7)] = v; delete out[k]; }
+  return { ...r, spec: out };
+}
+
 /** `homie-studio lab set <game> name=value ...`: values written into tunables.json, one tunable a line. */
 export function labSet(root, id, pairs) {
   const g = gameOf(root, id);
@@ -74,12 +88,12 @@ export function labSet(root, id, pairs) {
   if (!spec) return { ok: false, command: 'lab set', why: `games/${g.id} has no tunables.json yet: the lab skill says how a game gets one (lab.tunables)` };
   const values = {};
   for (const p of pairs) {
-    const m = /^([A-Za-z_$][\w$]{0,47})=(.+)$/.exec(String(p));
+    const m = /^((?:public\.)?[A-Za-z_$][\w$]{0,47})=(.+)$/.exec(String(p));
     if (!m) return { ok: false, command: 'lab set', why: `"${p}" is not name=value` };
     values[m[1]] = m[2];
   }
   if (!Object.keys(values).length) return { ok: false, command: 'lab set', why: 'usage: homie-studio lab set <game> <name>=<value> ...' };
-  const r = setTunables(spec, values);
+  const r = setLabTunables(spec, values);
   if (r.refused.length) return { ok: false, command: 'lab set', why: r.refused.join('; ') };
   writeFileSync(join(g.dir, 'tunables.json'), formatTunables(r.spec));
   return { ok: true, command: 'lab set', game: g.id, file: `games/${g.id}/tunables.json`, changed: r.changed };
@@ -179,7 +193,7 @@ class Builds {
     const t0 = Date.now();
     this.new = { ...this.new, building: true };
     try {
-      const r = await buildGameFiles(this.esbuild, this.root, g, out, { sourcemap: 'linked', log: this.log });
+      const r = await buildGameFiles(this.esbuild, this.root, g, out, { sourcemap: 'linked', lab: true, log: this.log });
       this.new = { ok: true, building: false, error: null, dir: out, at: new Date().toISOString(), ms: Date.now() - t0, bytes: sizeOf(join(out, 'assets', 'main.js')), metafile: r.metafile, mode: r.mode, dirty: dirtyOf(this.root, this.id) };
     } catch (error) {
       this.new = { ok: false, building: false, error: error.message, dir: out, at: new Date().toISOString() };
@@ -209,7 +223,7 @@ class Builds {
       const g = listGames(dir).find((x) => x.id === this.id);
       if (!g) throw new Error(`games/${this.id}/game.json is not in ${c.short}`);
       this.esbuild ??= await studioEsbuild(this.root);
-      await buildGameFiles(this.esbuild, dir, g, out, { sourcemap: 'linked', log: this.log });
+      await buildGameFiles(this.esbuild, dir, g, out, { sourcemap: 'linked', lab: true, log: this.log });
       let tunables = null;
       try { tunables = readTunables(g.dir); } catch { tunables = null; }
       const at = new Date().toISOString();
@@ -350,7 +364,7 @@ export async function startLabServer(root, { port = LAB_PORT, today = 'HEAD', lo
     if (what === 'tunables') {
       const spec = readTunables(dir);
       if (!spec) return send(res, 400, { ok: false, why: `games/${id} has no tunables.json` });
-      const r = setTunables(spec, json.values ?? {});
+      const r = setLabTunables(spec, json.values ?? {});
       if (r.refused.length) return send(res, 400, { ok: false, why: r.refused.join('; ') });
       writeFileSync(join(dir, 'tunables.json'), formatTunables(r.spec));
       log(`kept in games/${id}/tunables.json: ${r.changed.map((c) => `${c.name} ${c.from} -> ${c.to}`).join(', ') || 'nothing changed'}`);
@@ -422,7 +436,7 @@ function stateOf(root, b) {
   let tunablesError = null;
   try { tunables = readTunables(g.dir); } catch (error) { tunablesError = error.message; }
   const pane = (p) => ({ ok: p.ok, building: p.building, error: p.error ?? null, none: p.none ?? null, at: p.at ?? null, ms: p.ms ?? null, bytes: p.bytes ?? null });
-  const todayValues = b.today.tunables ? Object.fromEntries(Object.entries(b.today.tunables).map(([k, s]) => [k, tunableValue(s)])) : null;
+  const todayValues = b.today.tunables ? Object.fromEntries(Object.entries(flatTunables(b.today.tunables)).map(([k, s]) => [k, tunableValue(s)])) : null;
   return {
     ok: true,
     version: STUDIO_VERSION,
@@ -431,7 +445,7 @@ function stateOf(root, b) {
     new: { ...pane(b.new), dirty: b.new.dirty ?? null, mode: b.new.mode ?? null },
     today: { ...pane(b.today), ref: b.todayRef, commit: b.today.commit ?? null },
     takes: { default: takes.default, takes: takes.takes, problems: takes.problems, file: `games/${g.id}/lab.json`, exists: takes.exists },
-    tunables: { file: `games/${g.id}/tunables.json`, spec: tunables, today: todayValues, error: tunablesError },
+    tunables: { file: `games/${g.id}/tunables.json`, spec: flatTunables(tunables), today: todayValues, error: tunablesError },
   };
 }
 

package/lib/mcp-tools.mjs

@@ -28,7 +28,7 @@ import { cliJob, findNode, getJob, installJob, installed, jobView, runningJobs,
 import { Feed, currentId, publicFeed, readFeed, startProgress } from './progress.mjs';
 import { newStudio, slugify } from './scaffold.mjs';
 import { repoFromUrl, studioRepo } from './repo.mjs';
-import { GAME_ID, PACKAGE_ROOT, findStudio, listGames, readLocal, readStudio, siteUrl } from './studio.mjs';
+import { GAME_ID, PACKAGE_ROOT, findStudio, isRulesGame, listGames, readLocal, readStudio, siteUrl } from './studio.mjs';
 import { runningDev } from './dev.mjs';
 import { deployWords } from './deploy-state.mjs';
 import { partsForListing, publishBefore, publishesSoFar } from './directory.mjs';
@@ -1018,6 +1018,7 @@ export function toolDefs(ctx, avail = {}) {
         if (!game) return fail(games.length ? `which game? ${games.map((g) => g.id).join(', ')}` : 'there is no game to check yet');
         const url = a.url ? String(a.url) : await devUrl(ctx, root);
         return startRun(ctx, root, { kind: 'check', game, title: `${games.find((g) => g.id === game)?.name ?? game}: two-browser check`, 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)] },
         ] });
       },