@homie-rocks/studio 0.58.6 → 0.58.8

package/CHANGELOG.md

@@ -17,6 +17,41 @@ 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.58.8] - 2026-10-19
+
+**Plugin 0.58.3**
+
+Play falling-block games with visible standings, round winners and controls that follow a sliding thumb.
+
+### Fixed
+
+- Block Drop shows a live leaderboard on phones and ranked round results, keeps its controls above the room chip, enlarges the landscape well, and follows a thumb sliding between directional buttons. Its synthesized audio is more audible, and watching a falling piece no longer pauses the round after 60 seconds without input.
+- Concept previews label the outer page once, without injecting a second banner over embedded game and app controls. No-index headers remain on every response.
+
+## [0.58.7] - 2026-10-19
+
+**Plugin 0.58.3**
+
+A falling-block starter gives board-game requests a working mechanic to build on.
+
+### Added
+
+- `block-drop`: separate 10×20 wells, seven-piece bags, rotation and wall kicks, ghost pieces, line clears, keyboard and touch controls, procedural audio, bots and two-minute server rounds. A newcomer taking a bot seat gets a fresh well.
+- Regressions for independent player input, hard drops, line clearing, save/restore and bot-seat takeover.
+
+### Changed
+
+- Game guides and starter discovery point falling-block requests to Block Drop. They explain stationary anchors, player `seat`, room events and exact-location compiler repairs.
+- Editing guidance distinguishes a complete-file write from a targeted repair and explains recovery after an interrupted write.
+
+### Fixed
+
+- The late-join owner test retains its seat, round, roster, replication and clock checks for stationary games, but marks body steering N/A instead of falsely failing it. Actual board controls still need a directed play trial.
+
+### Upgrade notes
+
+- Existing games are unchanged. New falling-block games can use `game new <id> --from block-drop`.
+
 ## [0.58.6] - 2026-10-18
 
 **Plugin 0.58.2**

package/guides/game/RULES.md

@@ -120,6 +120,7 @@ length before taking an entry or using modulo.
 A player's kind currently requires a body and a named move handler even when the
 interface is a board, quiz or poll. Use `body: { shape: 'circle', radius: 0.1,
 maxSpeed: 0 }` and `defineMove({ participant() {} })` for a `participant` kind.
+The `block-drop` starter is a complete falling-block example: one stationary player anchor owns one 10×20 well, bots use their own input, and the view identifies players by `seat` (not `slot`). Its `pieces.ts` shares immutable geometry between rules and view. Read it before inventing a board-game API.
 The anchor need not be drawn. Use commands for choices; validate whose turn it is,
 then send an event to a room handler to update shared state. Do not fabricate movement
 or a score to satisfy a test.
@@ -277,6 +278,8 @@ Do not add a role, policy, owner or guide field to client input as a source of a
 
 ## Handler slots
 
+There is no `room.tick` hook. For periodic room work, schedule a declared room event with `world.after`; an entity can ask the room to act with `world.sendRoom`. Only the room handler calls `world.round.end()`.
+
 | Slot | Arguments and purpose |
 | --- | --- |
 | `room.start` | `(world)` once when a match starts; initialize shared state or spawn objects |

package/guides/game/SKILL.md

@@ -65,7 +65,7 @@ Cloudflare or physical-phone capacity guarantees.
 - **New game:** call the Homie MCP tool `game_make` (id, name) for the exact command
   and rules (without the connector, go on: the command is here and the rules are this skill's), then run
   `npx --no-install homie-studio game new <id> --from gem-rush --name "<Name>"`
-  (`--from gem-rush-3d` for a 3D game: three.js with free library models; `--from hero-rush-3d` for a 3D game with
+  (`--from block-drop` for a falling-block puzzle; `--from gem-rush-3d` for a 3D game: three.js with free library models; `--from hero-rush-3d` for a 3D game with
   animated characters that run, jump and swing). The id becomes the game's
   address (`/<id>/`); lowercase, digits, hyphens.
 - **Make an existing single-player web game multiplayer:** use the `port` skill (it
@@ -89,16 +89,16 @@ Prefer one indexed map revision for a generated maze; keep independently moving
 doors and platforms as live colliders. Generation and navigation baking spend the
 room handler's budget.
 
-**Read [RULES.md](RULES.md) before writing code.** All five starters use this contract.
+**Read [RULES.md](RULES.md) before writing code.** All starters use this contract.
 Work in few, large edits: read each source file once, decide its changes, then
 make every change it needs in ONE file_edit with an edits list. Build after each
-coherent change across rules, movement and view; use diagnostics to guide the next edit.
+coherent change across rules, movement and view. When a diagnostic names a file and line, read that exact location and repair the expression it names before unrelated cleanup. Rebuild to verify that error is gone. `room.me.seat` identifies a player; there is no `room.me.slot`. Prefer targeted edits for repairs. A write replaces the whole file: never send only its tail or resume a truncated file with a replacement containing the remaining lines.
 
 New games use `game.json` `"entry": "src/view.ts"`, `"room": { "host": "server" }`,
 and a studio-chosen `players.max`. HTML loads `<script type="module"
 src="./assets/main.js"></script>`, not the source-file URL. Choose seats, tick rate (20 by default), dimensions and
 starter yourself from the request; never ask the person an engineering question.
-`coin-dash` is the smallest reference; `gem-rush` adds bumps; `ember-vale` adds
+`block-drop` is the falling-block/board-game reference: separate stationary wells, seven-piece bags, rotation, line clears, real keyboard and touch controls. Use it for Tetris-like requests and retain its working mechanic while changing the requested look or features. `coin-dash` is the smallest movement reference; `gem-rush` adds bumps; `ember-vale` adds
 companions, decisions and character saves; the two 3D starters add models and jumps.
 A starter is a starting point: implement the requested mechanic, not a renamed gem collector.
 The build refuses a game with neither rules plus view nor a browser-hosted netplay contract;

package/lib/mcp-tools.mjs

@@ -936,7 +936,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: 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.',
+      description: 'Make a game in the studio from a multiplayer starter, under the id you choose, to change into the person\'s game: block-drop (falling-block puzzles such as Tetris: separate stationary wells, seven-piece bags, line clears, keyboard and touch controls), 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) => {

package/lib/port-check.mjs

@@ -717,7 +717,7 @@ export async function portCheck({ url, game, root, only = null, shots = null, lo
             const clockSkew = ic?.round && ib3?.round ? Math.abs(ic.round.leftMs - ib3.round.leftMs) : null;
             // The joiner must steer its body at once, not only hold a seat: a short press moves it.
             let steers = null;
-            if (ic?.v !== 'board' && oc.ok) {
+            if (ic?.v !== 'board' && ic?.movement !== 'stationary' && oc.ok) {
               await focusGame(C);
               const keysC = ic?.keys ?? { right: 'ArrowRight', left: 'ArrowLeft' };
               const r0 = (await rowsSince(C, 0)).filter(finite).pop();
@@ -729,7 +729,7 @@ export async function portCheck({ url, game, root, only = null, shots = null, lo
             }
             await shot(C, 'late-joiner');
             const ok = oc.ok && ic?.seat !== null && ic?.round && ib3?.round && ic.round.n === ib3.round.n && humans >= 2 && tookBot && snapIn > 5 && (clockSkew === null || clockSkew < 2500) && steers !== false;
-            row('late-join', Boolean(ok), { seatedMs: oc.ms, sinceJoinMs: Date.now() - joinAt, role: ic?.role, seat: ic?.seat, round: ic?.round, hostRound: ib3?.round, humans, bodies: slots.length, bodiesBefore: before.length, tookBot, steers, snapHzIn: snapIn, clockSkewMs: clockSkew,
+            row('late-join', Boolean(ok), { seatedMs: oc.ms, sinceJoinMs: Date.now() - joinAt, role: ic?.role, seat: ic?.seat, round: ic?.round, hostRound: ib3?.round, humans, bodies: slots.length, bodiesBefore: before.length, tookBot, steers, ...(ic?.movement === 'stationary' ? { steeringApplicable: false, steeringNote: 'Stationary player anchors: movement is N/A. Late-join admission and replication are checked here; exercise the actual board/turn controls separately.' } : {}), snapHzIn: snapIn, clockSkewMs: clockSkew,
               why: !oc.ok ? oc.why : ic?.round?.n !== ib3?.round?.n ? 'the late joiner is in a different round' : humans < 2 ? 'the late joiner is not one of the people in the roster' : !tookBot ? 'the late joiner added a body instead of taking a bot\'s place' : steers === false ? 'the late joiner has a seat but its keys do not move its body' : snapIn <= 5 ? 'no world is flowing to the late joiner' : clockSkew !== null && clockSkew >= 2500 ? `the late joiner's clock is ${clockSkew} ms off the host's` : undefined });
             collect(C); await close(C);
           }

package/lib/template-history.json

@@ -4428,6 +4428,90 @@
      }
     }
    }
+  },
+  "0.58.7": {
+   "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": "1dbdf22c03a1e505",
+    "site/src/worker.mjs": "6cc5c6131eaf6fd0"
+   },
+   "sections": {
+    "AGENTS.md": {
+     "(intro)": "af7f2f732505d379",
+     "## Version-matched authoring guides": "f6261a0e5801b96b",
+     "## Layout": "f3a280b8c96cd068",
+     "## Apps: one screen, roles and parts": "c10aa0441ea89702",
+     "## Commands (all through the pinned CLI in node_modules)": "c20d90de21cde0c7",
+     "## The site": "0cb8dd9a6f8a0096",
+     "## Making games": "bb715272fd1a615b",
+     "## The Game Codex and progress": "0738ef719cef3a4c",
+     "## Art direction and models": "a48fff7bf0a5f2fc",
+     "## Running live games (the back office)": "51ebf2ab756f6e4d",
+     "## Servers and AI seats": "1ccfd549d2369a60",
+     "## Selling things (the shop)": "0df5a5fe1833c624",
+     "## Continuing a build from the Claude app": "0d68081e924ca419",
+     "## Rules": "b2234d80f6cbe71d",
+     "## Telling Homie": "80b46fdd9e578db8",
+     "## Beta": "9d02638207a26e73"
+    }
+   },
+   "named": {
+    "Homie Arcade": {
+     "sections": {
+      "AGENTS.md": {
+       "## Commands (all through the pinned CLI in node_modules)": "8364e05cebefcba4"
+      }
+     }
+    }
+   }
+  },
+  "0.58.8": {
+   "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": "1dbdf22c03a1e505",
+    "site/src/worker.mjs": "6cc5c6131eaf6fd0"
+   },
+   "sections": {
+    "AGENTS.md": {
+     "(intro)": "af7f2f732505d379",
+     "## Version-matched authoring guides": "f6261a0e5801b96b",
+     "## Layout": "f3a280b8c96cd068",
+     "## Apps: one screen, roles and parts": "c10aa0441ea89702",
+     "## Commands (all through the pinned CLI in node_modules)": "c20d90de21cde0c7",
+     "## The site": "0cb8dd9a6f8a0096",
+     "## Making games": "bb715272fd1a615b",
+     "## The Game Codex and progress": "0738ef719cef3a4c",
+     "## Art direction and models": "a48fff7bf0a5f2fc",
+     "## Running live games (the back office)": "51ebf2ab756f6e4d",
+     "## Servers and AI seats": "1ccfd549d2369a60",
+     "## Selling things (the shop)": "0df5a5fe1833c624",
+     "## Continuing a build from the Claude app": "0d68081e924ca419",
+     "## Rules": "b2234d80f6cbe71d",
+     "## Telling Homie": "80b46fdd9e578db8",
+     "## Beta": "9d02638207a26e73"
+    }
+   },
+   "named": {
+    "Homie Arcade": {
+     "sections": {
+      "AGENTS.md": {
+       "## Commands (all through the pinned CLI in node_modules)": "8364e05cebefcba4"
+      }
+     }
+    }
+   }
   }
  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@homie-rocks/studio",
-  "version": "0.58.6",
+  "version": "0.58.8",
   "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/starters/block-drop/README.md

@@ -0,0 +1,14 @@
+# Block Drop
+
+Start here for a falling-block puzzle. It already plays: preserve the working mechanic while adding the requested theme or features.
+
+- `rules.ts`: each stationary player owns a 10×20 well. Immutable lists are copied, changed and assigned. Seven-piece bags use the room's saved random source. People and bots share one legal input path, but never one well. Room events alone end rounds.
+- `pieces.ts`: shared immutable piece geometry and collision checks. The view's ghost uses the same cells as the rules.
+- `move.ts`: an intentionally empty movement handler with maxSpeed 0. Movement probes are N/A; real keyboard/touch tests prove board controls.
+- `view.ts`: player identity comes from `room.me.seat` and `room.roster`. The full well fits above the native touch buttons. Effects unlock audio on real input. No score is decided in the view.
+
+Build and repair the exact diagnostic before adding more. A file write replaces its entire contents; use targeted edits for small repairs. After an interrupted edit, read the file before continuing.
+
+Exercise left/right, rotation, soft and hard drop on keyboard and with real touchscreen taps. Play two independent wells, clear a row, top out, finish/restart a round and join a bot's seat. Inspect computer, phone and sideways-phone frames. A green movement probe or compiler alone does not prove a board game plays.
+
+The room uses `rest: "quiet"`: gravity and the round clock keep running while a connected person watches. Do not use the movement starters' away-from-keyboard `idle` pause for this continuous falling-block game. Empty rooms still stop normally.

package/starters/block-drop/game.json

@@ -0,0 +1,7 @@
+{
+ "id":"block-drop","name":"Block Drop","blurb":"Seven shapes. One well. Stack, rotate and clear lines before the clock runs out.",
+ "players":{"min":1,"max":4},"entry":"src/view.ts","room":{"host":"server","rest":"quiet"},
+ "playtest":{"primary":{"label":"hard drop","computer":{"key":"Space"},"phone":{"selector":"[data-action=drop]"}}},
+ "screen":{"share":{"desk":"top-right","phone":"top-right"},"chat":{"lines":"sheet-only"}},
+ "landing":{"pitch":"Find the gap. Make the line.","about":"A falling-block puzzle with a separate well for every player. Seven-piece bags, ghost pieces, wall kicks and line-clear scoring. Play with a friend or a bot in two-minute rounds.","howToPlay":["Move and rotate each falling shape into a gap.","Fill a horizontal row to clear it. Clear four at once for the biggest score.","Use the ghost outline to aim a hard drop. Keep your stack below the top."],"controls":{"phone":"Tap the arrows to move, ↻ to rotate and DROP to place the piece.","computer":"Left/right to move, up to rotate, down for soft drop and space for hard drop.","tv":"Watch every well; each player uses their own phone."},"credits":[{"role":"Starter","name":"Homie · Block Drop"}]}
+}

package/starters/block-drop/index.html

@@ -0,0 +1,4 @@
+<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1,viewport-fit=cover"><title>Block Drop</title><link rel="icon" href="data:,"><style>
+*{box-sizing:border-box}html,body{margin:0;height:100%;background:#060b16;overflow:hidden;overscroll-behavior:none;font-family:system-ui;color:#edf5ff}canvas{position:fixed;inset:0;width:100%;height:100%;touch-action:none}#controls{position:fixed;bottom:max(44px,env(safe-area-inset-bottom));left:50%;transform:translateX(-50%);display:flex;gap:7px}button{width:55px;height:49px;border:1px solid #92b6e34d;border-radius:12px;background:#172741;color:#eaf4ff;font:600 19px system-ui;touch-action:none;user-select:none;-webkit-user-select:none;box-shadow:0 4px 0 #030713}button[data-action=drop]{width:70px;font-size:12px;background:#185950;border-color:#68e9cc66}button.pressed,button:active{transform:translateY(3px);background:#398b89;box-shadow:none}button[data-action=audio]{width:38px;font-size:16px}button:focus-visible{outline:2px solid #fff;outline-offset:3px}#hint{position:fixed;bottom:102px;left:0;right:0;text-align:center;font:10px system-ui;color:#a3b5ce;pointer-events:none}@media(max-width:600px){#hint{display:none}}@media(max-height:460px) and (min-width:600px){button{width:48px;height:44px}button[data-action=drop]{width:58px}#controls{left:14px;top:100px;bottom:auto;transform:none;display:grid;grid-template-columns:58px 58px;gap:9px}#hint{display:none}}
+</style></head><body><canvas></canvas><div id="hint">← → move · ↑ rotate · ↓ soft drop · SPACE hard drop</div><div id="controls" aria-label="Game controls"><button data-action="left" aria-label="Move left">←</button><button data-action="rotate" aria-label="Rotate">↻</button><button data-action="soft" aria-label="Soft drop">↓</button><button data-action="right" aria-label="Move right">→</button><button data-action="drop" aria-label="Hard drop">DROP</button><button data-action="audio" aria-label="Sound" aria-pressed="true">♪</button></div><script type="module" crossorigin src="./assets/main.js"></script></body></html>

package/starters/block-drop/map/main.json

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

package/starters/block-drop/src/move.ts

@@ -0,0 +1,3 @@
+import { defineMove } from '@homie-rocks/studio/rules';
+// A board player has an anchor, not a moving avatar. Generic movement checks are N/A.
+export const move = defineMove({ board() {} });

package/starters/block-drop/src/pieces.ts

@@ -0,0 +1,19 @@
+// Four occupied cells in a 4×4 box. Shared, immutable geometry for rules and view.
+const SHAPES = [[4,5,6,7],[1,2,5,6],[1,4,5,6],[1,2,4,5],[0,1,5,6],[0,4,5,6],[2,4,5,6]];
+export function cells(kind: number, rotation: number): number[] {
+  const source = SHAPES[Math.max(0, Math.min(6, kind - 1))];
+  const out: number[] = [];
+  for (const cell of source) {
+    let x = cell % 4, y = Math.floor(cell / 4);
+    for (let r = 0; r < (kind === 2 ? 0 : rotation % 4); r++) { const old = x; x = 3 - y; y = old; }
+    out.push(y * 4 + x);
+  }
+  return out;
+}
+export function fits(board: readonly number[], kind: number, rotation: number, x: number, y: number): boolean {
+  for (const cell of cells(kind, rotation)) {
+    const cx = x + cell % 4, cy = y + Math.floor(cell / 4);
+    if (cx < 0 || cx >= 10 || cy >= 20 || (cy >= 0 && board[cy * 10 + cx] !== 0)) return false;
+  }
+  return true;
+}

package/starters/block-drop/src/rules.ts

@@ -0,0 +1,114 @@
+// Separate wells: people and bots can only change their own falling piece.
+import { defineRules, f } from '@homie-rocks/studio/rules';
+import { move } from './move';
+import { cells, fits } from './pieces';
+
+type Well = {
+  grid: readonly number[]; bag: readonly number[]; piece: number; next: number;
+  x: number; y: number; rotation: number; score: number; lines: number;
+  dead: boolean; fallAt: number; repeatAt: number; botAt: number; target: number;
+};
+function take(s: Well, random: number): number {
+  const bag = s.bag.length ? s.bag.slice() : [1,2,3,4,5,6,7];
+  const at = Math.min(bag.length - 1, Math.floor(random * bag.length));
+  const kind = bag[at]; bag.splice(at, 1); s.bag = bag; return kind;
+}
+function spawn(s: Well, random: number): void {
+  s.piece = s.next; s.next = take(s, random); s.x = 3; s.y = -1; s.rotation = 0;
+  s.dead = !fits(s.grid, s.piece, s.rotation, s.x, s.y);
+  // A modest bot: aim for a low column; it uses the same input and lock path.
+  let best = 21, target = 3;
+  for (let x = 0; x < 10; x++) {
+    let height = 0;
+    for (let y = 0; y < 20; y++) if (s.grid[y * 10 + x]) { height = 20 - y; break; }
+    if (height < best) { best = height; target = Math.max(0, Math.min(6, x - 1)); }
+  }
+  s.target = target;
+}
+function reset(s: Well, a: number, b: number): void {
+  const grid: number[] = []; for (let i = 0; i < 200; i++) grid.push(0);
+  s.grid = grid; s.bag = []; s.score = 0; s.lines = 0; s.dead = false;
+  s.fallAt = 0; s.repeatAt = 0; s.botAt = 0; s.next = take(s, a); spawn(s, b);
+}
+function lock(s: Well): number {
+  const grid = s.grid.slice();
+  for (const cell of cells(s.piece, s.rotation)) {
+    const x = s.x + cell % 4, y = s.y + Math.floor(cell / 4);
+    if (y < 0) { s.dead = true; return 0; }
+    grid[y * 10 + x] = s.piece;
+  }
+  const kept: number[] = []; let cleared = 0;
+  for (let y = 0; y < 20; y++) {
+    let full = true; for (let x = 0; x < 10; x++) if (!grid[y * 10 + x]) full = false;
+    if (full) cleared++; else for (let x = 0; x < 10; x++) kept.push(grid[y * 10 + x]);
+  }
+  const next: number[] = []; for (let i = 0; i < cleared * 10; i++) next.push(0);
+  s.grid = next.concat(kept); s.lines += cleared;
+  s.score += [0,100,300,500,800][cleared] * (1 + Math.floor(s.lines / 10));
+  return cleared;
+}
+export default defineRules({
+  contract: 2, space: { dims: 2 }, move, map: './map', shared: {},
+  shapes: { events: { topped: {} }, effects: { placed: { rows: f.u8() }, moved: {}, turned: {} } },
+  entities: {
+    board: {
+      player: { away: 'think', leave: 'bot' },
+      body: { shape: 'circle', radius: 0.1, maxSpeed: 0 },
+      input: { dx: f.i8(), soft: f.bit(), rotate: f.press(), drop: f.press() },
+      fields: {
+        grid: f.list(f.u8(), 200), bag: f.list(f.u8(), 7), piece: f.u8(), next: f.u8(),
+        x: f.i8(), y: f.i8(), rotation: f.u8(), score: f.u32({ score: true }), lines: f.u16(),
+        dead: f.bit(), fallAt: f.tick(), repeatAt: f.tick(), botAt: f.tick(), target: f.i8(),
+      },
+      tick(world, self) {
+        if (world.round.phase !== 'live' || self.dead || !self.grid.length) return;
+        const dx = Math.sign(self.input.dx);
+        if (dx && world.tick >= self.repeatAt) {
+          if (fits(self.grid, self.piece, self.rotation, self.x + dx, self.y)) { self.x += dx; world.emit('moved', self.id, {}); }
+          self.repeatAt = world.tick + world.ticks(0.12);
+        } else if (!dx) self.repeatAt = 0;
+        if (self.input.rotate) {
+          const rotation = (self.rotation + 1) % 4;
+          for (const kick of [0,-1,1,-2,2]) if (fits(self.grid, self.piece, rotation, self.x + kick, self.y)) {
+            self.x += kick; self.rotation = rotation; world.emit('turned', self.id, {}); break;
+          }
+        }
+        let landed = false;
+        if (self.input.drop) {
+          for (let i = 0; i < 22; i++) { if (!fits(self.grid, self.piece, self.rotation, self.x, self.y + 1)) break; self.y++; self.score += 2; }
+          landed = true; self.botAt = world.tick + world.ticks(1.5);
+        } else if (world.tick >= self.fallAt || self.input.soft) {
+          if (fits(self.grid, self.piece, self.rotation, self.x, self.y + 1)) { self.y++; if (self.input.soft) self.score++; }
+          else landed = true;
+          self.fallAt = world.tick + world.ticks(Math.max(0.12, 0.7 - Math.floor(self.lines / 10) * 0.05));
+        }
+        if (landed) {
+          const rows = lock(self); world.emit('placed', self.id, { rows });
+          if (!self.dead) spawn(self, world.random());
+          self.fallAt = world.tick + world.ticks(0.7);
+          if (self.dead) world.sendRoom('topped', {});
+        }
+      },
+      think(world, self) {
+        return { dx: Math.sign(self.target - self.x), soft: false, rotate: false,
+          drop: !self.dead && self.x === self.target && world.tick >= self.botAt };
+      },
+      on: {
+        arrive(world, self) { reset(self, world.random(), world.random()); },
+        takeover(world, self) { if (self.driver === 'person') reset(self, world.random(), world.random()); },
+      },
+      onRoom: { roundStart(world, self) { reset(self, world.random(), world.random()); } },
+    },
+  },
+  room: {
+    rounds: { seconds: 120, breakSeconds: 6 }, bots: { keep: 2 },
+    join(_ctx, player) { return { kind: 'board', at: { x: player.seat, y: 0 } }; },
+    on: {
+      topped(world) {
+        // Only room handlers can end rounds. No invented room.tick callback.
+        const boards = world.near({ x: 0, y: 0, z: 0 }, 32, 'board');
+        if (boards.length && boards.every(b => b.dead)) world.round.end();
+      },
+    },
+  },
+});

package/starters/block-drop/src/view.ts

@@ -0,0 +1,153 @@
+import { openRoom } from '@homie-rocks/studio/rules/view';
+import { guardGestures } from '@homie-rocks/studio/netplay';
+import type rules from './rules';
+import { cells, fits } from './pieces';
+
+const room = openRoom<typeof rules>();
+room.probe({
+  alive: () => !!room.me && !room.me.dead,
+  busy: () => !room.me || room.me.dead || room.round?.phase !== 'live',
+  pieceX: () => room.me?.x, pieceY: () => room.me?.y, piece: () => room.me?.piece,
+  rotation: () => room.me?.rotation, lines: () => room.me?.lines,
+  lockedCells: () => room.me?.grid.filter(Boolean).length,
+});
+const canvas = document.querySelector('canvas')!;
+const g = canvas.getContext('2d')!;
+guardGestures({ touch: 'canvas' });
+const COLORS = ['#152038','#40dcf0','#ffd75b','#b78aff','#65e6ab','#ff6f91','#6d9eff','#ffa465'];
+const keys = new Set<string>();
+let rotate = false, drop = false, touchDx = 0, soft = false;
+let audio: AudioContext | null = null;
+let muted = false, note = 0, nextNote = 0;
+const melody = [659,494,523,587,523,494,440,440,523,659,587,523,494,523,587,659,523,440,440,0,587,698,880,784,698,659,523,659,587,523,494,494];
+function unlock(): void { audio ??= new AudioContext(); void audio.resume(); }
+function tone(hz: number, seconds = 0.055, volume = 0.055): void {
+  if (!audio || audio.state !== 'running' || muted) return;
+  const o = audio.createOscillator(), gain = audio.createGain();
+  o.type = 'triangle'; o.frequency.value = hz;
+  gain.gain.setValueAtTime(volume * 3, audio.currentTime);
+  gain.gain.exponentialRampToValueAtTime(0.001, audio.currentTime + seconds);
+  o.connect(gain).connect(audio.destination); o.start(); o.stop(audio.currentTime + seconds);
+}
+room.on('moved', e => { if (e.id === room.me?.id) tone(180, 0.04, 0.035); });
+room.on('turned', e => { if (e.id === room.me?.id) tone(330); });
+room.on('placed', e => { if (e.id === room.me?.id) { tone(e.rows ? 660 : 120, e.rows ? 0.23 : 0.09, 0.08); if (e.rows) navigator.vibrate?.(25); } });
+addEventListener('keydown', e => {
+  if ((e.target as HTMLElement)?.closest('input,textarea,[contenteditable]')) return;
+  if (!['ArrowLeft','ArrowRight','ArrowDown','ArrowUp','Space','KeyA','KeyD','KeyS','KeyW','KeyX'].includes(e.code)) return;
+  e.preventDefault(); unlock(); keys.add(e.code);
+  if (!e.repeat && ['ArrowUp','KeyW','KeyX'].includes(e.code)) rotate = true;
+  if (!e.repeat && e.code === 'Space') drop = true;
+});
+addEventListener('keyup', e => keys.delete(e.code));
+addEventListener('blur', () => { keys.clear(); touchDx = 0; soft = false; });
+for (const button of document.querySelectorAll<HTMLButtonElement>('[data-action]')) {
+  const action = button.dataset.action;
+  button.addEventListener('pointerdown', e => {
+    e.preventDefault(); unlock(); button.setPointerCapture(e.pointerId); button.classList.add('pressed');
+    if (action === 'left') touchDx = -1;
+    if (action === 'right') touchDx = 1;
+    if (action === 'soft') soft = true;
+    if (action === 'rotate') rotate = true;
+    if (action === 'drop') drop = true;
+    if (action === 'audio') { muted = !muted; button.textContent = muted ? '×♪' : '♪'; button.setAttribute('aria-pressed', String(!muted)); }
+  });
+  button.addEventListener('pointermove', e => {
+    if (!button.hasPointerCapture(e.pointerId) || !['left','right','soft'].includes(action ?? '')) return;
+    const target = document.elementFromPoint(e.clientX, e.clientY)?.closest<HTMLButtonElement>('[data-action]');
+    const next = target?.dataset.action;
+    touchDx = next === 'left' ? -1 : next === 'right' ? 1 : 0; soft = next === 'soft';
+    for (const control of document.querySelectorAll<HTMLButtonElement>('[data-action]'))
+      control.classList.toggle('pressed', control === target && ['left','right','soft'].includes(next ?? ''));
+  });
+  const release = (): void => { for (const control of document.querySelectorAll('[data-action]')) control.classList.remove('pressed'); if (['left','right','soft'].includes(action ?? '')) { touchDx = 0; soft = false; } };
+  button.addEventListener('pointerup', release); button.addEventListener('pointercancel', release);
+  // Keyboard activation for focused native buttons; pointer input is handled above.
+  button.addEventListener('click', e => { if (e.detail === 0) { unlock(); if (action === 'rotate') rotate = true; if (action === 'drop') drop = true; } });
+}
+let w = innerWidth, h = innerHeight;
+function size(): void { w = innerWidth; h = innerHeight; const dpr = Math.min(2, devicePixelRatio || 1); canvas.width = Math.round(w * dpr); canvas.height = Math.round(h * dpr); g.setTransform(dpr, 0, 0, dpr, 0, 0); }
+addEventListener('resize', size); size();
+type Board = NonNullable<typeof room.me>;
+function block(x: number, y: number, s: number, kind: number, ghost = false): void {
+  const gap = Math.max(1, s * 0.055);
+  g.fillStyle = ghost ? '#c6dcff12' : COLORS[kind];
+  g.fillRect(x + gap, y + gap, s - gap * 2, s - gap * 2);
+  g.strokeStyle = ghost ? '#b8d5ff72' : '#ffffff55'; g.lineWidth = 1;
+  g.strokeRect(x + gap + 0.5, y + gap + 0.5, s - gap * 2 - 1, s - gap * 2 - 1);
+  if (!ghost && s > 12) { g.fillStyle = '#ffffff30'; g.fillRect(x + gap + 1, y + gap + 1, s - gap * 2 - 2, s * 0.13); g.fillStyle = '#09101c25'; g.fillRect(x + gap + 1, y + s * 0.77, s - gap * 2 - 2, s * 0.15); }
+}
+function piece(b: Board, ox: number, oy: number, s: number, py: number, ghost = false): void {
+  for (const cell of cells(b.piece, b.rotation)) { const x = b.x + cell % 4, y = py + Math.floor(cell / 4); if (y >= 0 && y < 20) block(ox + x * s, oy + y * s, s, b.piece, ghost); }
+}
+function well(b: Board, x: number, y: number, s: number, own: boolean): void {
+  g.fillStyle = '#060d1a'; g.fillRect(x, y, 10 * s, 20 * s);
+  g.strokeStyle = own ? '#71e9e099' : '#7990b64d'; g.lineWidth = own ? 2 : 1; g.strokeRect(x - 1, y - 1, 10 * s + 2, 20 * s + 2);
+  g.strokeStyle = '#91b6ff0c'; g.lineWidth = 1;
+  for (let i = 1; i < 10; i++) { g.beginPath(); g.moveTo(x + i * s, y); g.lineTo(x + i * s, y + 20 * s); g.stroke(); }
+  for (let i = 1; i < 20; i++) { g.beginPath(); g.moveTo(x, y + i * s); g.lineTo(x + 10 * s, y + i * s); g.stroke(); }
+  for (let i = 0; i < b.grid.length; i++) if (b.grid[i]) block(x + i % 10 * s, y + Math.floor(i / 10) * s, s, b.grid[i]);
+  if (!b.dead && b.piece) {
+    let ghostY = b.y; for (let i = 0; i < 22; i++) { if (!fits(b.grid, b.piece, b.rotation, b.x, ghostY + 1)) break; ghostY++; }
+    piece(b, x, y, s, ghostY, true); piece(b, x, y, s, b.y);
+  }
+  if (b.dead) { g.fillStyle = '#060d1acb'; g.fillRect(x, y + 8 * s, 10 * s, 4 * s); g.fillStyle = '#ffabc0'; g.font = `700 ${Math.max(10, s * 0.65)}px system-ui`; g.textAlign = 'center'; g.fillText('TOP OUT', x + 5 * s, y + 10 * s); g.textAlign = 'left'; }
+}
+function text(value: string, x: number, y: number, size = 13, colour = '#a7b8d5'): void { g.fillStyle = colour; g.font = `600 ${size}px system-ui`; g.fillText(value, x, y); }
+function frame(): void {
+  const now = performance.now();
+  if (audio?.state === 'running' && now >= nextNote) { const hz = melody[note++ % melody.length]; if (hz) tone(hz, 0.21, 0.075); nextNote = now + 250; }
+  room.input({ dx: touchDx || (keys.has('ArrowRight') || keys.has('KeyD') ? 1 : 0) - (keys.has('ArrowLeft') || keys.has('KeyA') ? 1 : 0), soft: soft || keys.has('ArrowDown') || keys.has('KeyS'), rotate, drop }); rotate = false; drop = false;
+  const bg = g.createRadialGradient(w * 0.5, h * 0.3, 10, w * 0.5, h * 0.5, Math.max(w, h)); bg.addColorStop(0, '#172747'); bg.addColorStop(1, '#060b16'); g.fillStyle = bg; g.fillRect(0, 0, w, h);
+  text(document.title.toUpperCase(), 20, 61, 18, '#eef6ff');
+  const round = room.round;
+  text(round?.phase === 'over' ? `Next round in ${Math.ceil(round.secondsLeft)}` : round ? `${Math.ceil(round.secondsLeft)}s` : 'Joining…', 20, 80, 12);
+  const boards: Board[] = []; room.each('board', b => boards.push(b));
+  const me = room.me; const focus = me ?? boards[0];
+  if (focus) {
+    const compact = w < 640, landscape = w >= 640 && h <= 460, top = landscape ? 58 : 108, bottom = compact ? 174 : landscape ? 18 : 110;
+    const s = Math.max(5, Math.min(32, (h - top - bottom) / 20, (w - (compact ? 116 : 330)) / 10));
+    const total = 10 * s + 98 + (!compact && !landscape && boards.length > 1 ? 150 : 0);
+    const x = Math.max(12, (w - total) / 2), y = top;
+    const roster = room.roster.find(r => r.seat === focus.seat);
+    text(me ? 'YOUR WELL' : (roster?.name ?? 'WATCHING'), x, y - 13, 11, '#7aeee1');
+    well(focus, x, y, s, !!me);
+    const side = x + 10 * s + 18;
+    text('NEXT', side, y + 12, 10);
+    const preview = Math.min(17, s);
+    for (const cell of cells(focus.next || 1, 0)) block(side + cell % 4 * preview, y + 26 + Math.floor(cell / 4) * preview, preview, focus.next || 1);
+    text('SCORE', side, y + 110, 10); text(String(focus.score), side, y + 136, 21, '#f5f8ff');
+    if (h >= 350) { text('LINES', side, y + 170, 10); text(String(focus.lines), side, y + 194, 19, '#f5f8ff'); }
+    if (20 * s > 260) { text('LEVEL', side, y + 230, 10); text(String(1 + Math.floor(focus.lines / 10)), side, y + 254, 19, '#f5f8ff'); }
+    if (!compact && !landscape) {
+      let ry = y;
+      for (const rival of boards.filter(b => b.id !== focus.id).slice(0, 3)) {
+        const mini = Math.min(6, s * 0.25), rx = side + 112;
+        const r = room.roster.find(r => r.seat === rival.seat);
+        text(`${r?.driver === 'bot' ? 'BOT · ' : ''}${r?.name ?? 'Player'}`, rx, ry - 10, 10);
+        well(rival, rx, ry, mini, false); text(String(rival.score), rx + 10 * mini + 9, ry + 14, 12, '#eef6ff'); ry += 20 * mini + 38;
+      }
+    }
+    const ranked = boards.slice().sort((a, b) => b.score - a.score || a.seat - b.seat);
+    const nameOf = (b: Board): string => { const r = room.roster.find(r => r.seat === b.seat); return b.id === me?.id ? 'YOU' : `${r?.driver === 'bot' ? 'BOT ' : ''}${r?.name ?? 'Player'}`; };
+    const rank = ranked.findIndex(b => b.id === focus.id) + 1;
+    if (compact) {
+      text(`RANK ${rank}/${ranked.length} · LEADER ${ranked[0]?.score ?? 0}`, 16, h - 155, 12, '#7aeee1');
+      ranked.slice(0, 4).forEach((b, i) => text(`${i + 1}. ${nameOf(b).slice(0, 12)}  ${b.score}`, 16 + (i % 2) * (w / 2), h - 132 + Math.floor(i / 2) * 19, 11, b.id === me?.id ? '#f5f8ff' : '#a7b8d5'));
+    } else if (landscape) {
+      text(`RANK ${rank}/${ranked.length}`, side + 112, y + 142, 12, '#7aeee1');
+      ranked.slice(0, 4).forEach((b, i) => text(`${i + 1}. ${nameOf(b).slice(0, 10)} ${b.score}`, side + 112, y + 15 + i * 24, 12, b.id === me?.id ? '#f5f8ff' : '#a7b8d5'));
+    }
+    if (round?.phase === 'over') {
+      const results = round.results?.length ? round.results : ranked.map((b, i) => ({ name: nameOf(b), score: b.score, seat: b.seat, place: i + 1 }));
+      const pw = Math.min(340, w - 32), ph = 110 + results.length * 27, px = (w - pw) / 2, py = Math.max(42, (h - ph) / 2);
+      g.fillStyle = '#081329f5'; g.fillRect(px, py, pw, ph); g.strokeStyle = '#71e9e0'; g.strokeRect(px, py, pw, ph);
+      text(`${results[0]?.name ?? 'Player'} WINS`, px + 16, py + 30, 18, '#ffd75b');
+      text('FINAL SCORES', px + 16, py + 55, 11);
+      results.forEach((r, i) => text(`${r.place}. ${r.name.slice(0, 18)}${r.seat === me?.seat ? ' (YOU)' : ''}  ${r.score}`, px + 16, py + 82 + i * 27, 13, '#f5f8ff'));
+      text(`Next round in ${Math.ceil(round.secondsLeft)}s`, px + 16, py + ph - 15, 11);
+    }
+  } else text('Finding your seat…', Math.max(20, w / 2 - 70), h / 2, 15);
+  requestAnimationFrame(frame);
+}
+requestAnimationFrame(frame);

package/starters/block-drop/tunables.json

@@ -0,0 +1 @@
+{"public":{}}

package/worker/build-id.mjs

@@ -1,2 +1,2 @@
 // Generated by lib/build-identity.mjs; identifies the bundled runtime sources.
-export const STUDIO_BUILD = Object.freeze({"version":"0.58.6","sha256":"ffc278d1a25f0d09dfaa8c76a38f4d325971dec38e75e08b6b7fb4d7c6aad504"});
+export const STUDIO_BUILD = Object.freeze({"version":"0.58.8","sha256":"dd01f171a16a619c527dc71c2beaaf0c9a9b70c395cb28156214d3ac988f81c5"});

package/worker/index.mjs

@@ -99,7 +99,9 @@ export default {
     if(env.HOMIE_CONCEPT==='1' && res.status!==101) {
       const headers=new Headers(res.headers);headers.set('x-robots-tag','noindex, nofollow');
       let body=res.body;
-      if(/text\/html/i.test(headers.get('content-type')??'')) {
+      // The outer page labels the whole preview. Repeating that overlay in an
+      // embedded game/app obscures its HUD and counts as the game's own UI.
+      if(request.headers.get('sec-fetch-dest')!=='iframe' && /text\/html/i.test(headers.get('content-type')??'')) {
         const html=await res.text(),banner='<aside role="status" style="position:fixed;z-index:2147483647;top:0;left:0;right:0;text-align:center;background:#ffda44;color:#171717;padding:6px;font:bold 14px system-ui;pointer-events:none">TEST / CONCEPT</aside>';
         body=/<body[^>]*>/i.test(html)?html.replace(/<body[^>]*>/i,m=>m+banner):banner+html;
         headers.delete('content-length');

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.58.6';
+export const STUDIO_VERSION_TAG = '0.58.8';