@homie-rocks/studio 0.14.0 → 0.14.1

package/README.md

@@ -100,8 +100,8 @@ site. A game made with Homie's arcade controls that knocks for a Homie box (`/__
 A studio pins one version, so nothing changes until it asks. To take a newer one:
 
 ```sh
-npx -y @homie-rocks/studio@0.14.0 upgrade          # the plan; changes nothing
-npx -y @homie-rocks/studio@0.14.0 upgrade --apply  # after the person agrees
+npx -y @homie-rocks/studio@0.14.1 upgrade          # the plan; changes nothing
+npx -y @homie-rocks/studio@0.14.1 upgrade --apply  # after the person agrees
 npm install && npm run build
 ```
 
@@ -204,7 +204,9 @@ npx homie-studio office key                             # a key for the Homie MC
 
 Going private or invite-only never cuts a round short: each live room finishes its current round with a notice to
 the players, then everyone the new state leaves out is sent out with a thank-you (the owner, and in a beta the
-invited, play on). Mute drops a player's `say…`, `chat…` and `emote…` events, so a game that sends its chat and
+invited, play on). A known edge: a room that opens in the same moment as the change can be missed by it, because the
+office reaches the rooms its Lobby already knows. Each room therefore reads its game's launch state once, on its
+first heartbeat after it opens, and re-gates the same way; nobody new can join a game that is not public meanwhile. Mute drops a player's `say…`, `chat…` and `emote…` events, so a game that sends its chat and
 emotes under those kinds needs nothing more (`netplay/NETPLAY.md` section 15). Kicking a whole network address is in
 the studio's API (`address: true`) and deliberately not in the office. A Preview (a branch's own unlisted address, with
 no D1) enforces no launch state and has no office.
@@ -230,7 +232,7 @@ device; the owner's own passkey account (`homie-studio players owner`) counts as
 ## Setup status
 
 ```sh
-npx -y @homie-rocks/studio@0.14.0 setup status --connector yes   # before a studio exists
+npx -y @homie-rocks/studio@0.14.1 setup status --connector yes   # before a studio exists
 npx homie-studio setup status                                    # in a studio (also: homie-studio doctor)
 ```
 

package/lib/template-history.json

@@ -299,6 +299,33 @@
      "## Beta": "9d02638207a26e73"
     }
    }
+  },
+  "0.14.1": {
+   "files": {
+    "CLAUDE.md": "ddf2b2a0376202f6",
+    "README.md": "684b3cca8001673c",
+    "HANDOFF.md": "ce7a8fd91c6bbee2",
+    "games/README.md": "5ad32fe80c61f117",
+    "music/README.md": "b8a828de9311bd28",
+    "videos/README.md": "70614388cbb203c7",
+    "posts/README.md": "37841aae476bd540",
+    "site/README.md": "ca131cd0472464fb",
+    "site/src/worker.mjs": "ca3f1630f2420ad3"
+   },
+   "sections": {
+    "AGENTS.md": {
+     "(intro)": "214aa46eb3a895d5",
+     "## Layout": "f14d641159480e6c",
+     "## Commands (all through the pinned CLI in node_modules)": "e579cd6ce3ce342a",
+     "## The site": "7c1618431bae6324",
+     "## Making games": "63069b31c87a2aa2",
+     "## The Game Codex and progress": "0738ef719cef3a4c",
+     "## Running live games (the back office)": "f0566f07cff04113",
+     "## Continuing a build from the Claude app": "0d68081e924ca419",
+     "## Rules": "969318425c99f5a5",
+     "## Beta": "9d02638207a26e73"
+    }
+   }
   }
  }
 }

package/netplay/NETPLAY.md

@@ -660,7 +660,7 @@ tools). The room's relay enforces five controls:
 | `announce` | `text` (one line, at most 280 characters; empty takes it down), `seconds` (5–3600, default 30) | Everyone and every watching shell gets `announce { id, text, at, until, from: 'studio' }`; a joiner gets it in `welcome.announce` until it ends. |
 | `close` | `minutes`, or `seconds` (10 s up to a day), `message?`, or `reopen: true` | Every socket gets `error room-closed { until, message }` and is closed; the room forgets its play as an empty room does (section 4); watchers get `closed`. Until `until` every `hello` is refused with `room-closed`, and the Lobby sends nobody there. `reopen` opens it at once. |
 | `seats` | `max` | The room's seats while it runs (the owner's "players per room"). Players already seated above it keep their seat; nobody new is seated there. Never above the room's own cap (the game's manifest). |
-| `regate` | `allow` (holder kinds: `o` the owner, `i` an invite, `p` a player account), `notice?`, `message?`; no `allow` calls a waiting one off | A game's launch state narrowed (private, or an invite-only beta). The current round finishes first: the `notice` goes up as an announcement, and 5 s after the host's `round` with `phase: 'over'` (at the latest 20 s after its `endsAt`, or 30 s when no round is running; never later than 15 minutes) every socket whose ticket names no allowed holder gets `error room-closed { message }` (no `until`: they come back through the game's door if they have access) and is closed; its seat is freed and the others play on. A room with nobody to send out does nothing. |
+| `regate` | `allow` (holder kinds: `o` the owner, `i` an invite, `p` a player account), `notice?`, `message?`; no `allow` calls a waiting one off | A game's launch state narrowed (private, or an invite-only beta). The current round finishes first: the `notice` goes up as an announcement, and 5 s after the host's `round` with `phase: 'over'` (at the latest 20 s after its `endsAt`, or 30 s when no round is running; never later than 15 minutes) every socket whose ticket names no allowed holder gets `error room-closed { message }` (no `until`: they come back through the game's door if they have access) and is closed; its seat is freed and the others play on. A room with nobody to send out does nothing. The studio's Worker sends it to every live room the game's Lobby knows; a room that opens in the same moment reads its game's launch state once on its first heartbeat and re-gates itself the same way. |
 
 **Signed by the studio, checked by the room.** A control reaches the relay only from the
 studio's own Worker, as

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@homie-rocks/studio",
-  "version": "0.14.0",
+  "version": "0.14.1",
   "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, optional R2 storage for large media, deploy, and the homie.rocks directory.",
   "type": "module",
   "license": "Apache-2.0",

package/worker/index.mjs

@@ -66,7 +66,7 @@ import { count, countVisit, counter, isQa, onlyOf, ownerAllowed, playedByGame, p
 import { ownerRoutes } from './stats-page.mjs';
 import { playerRoutes, players as playerAccounts } from './players.mjs';
 import {
-  accessOf, accountSub, gatePage, holders, isOwner, joinHolders, launchOf, officeRoutes, publicCatalogue, redeemInvite, remixOf, seatsFor, settingsOf, ticketAllows, ticketFor,
+  accessOf, accountSub, gatePage, holders, isOwner, joinHolders, launchOf, regateArgs, officeRoutes, publicCatalogue, redeemInvite, remixOf, seatsFor, settingsOf, ticketAllows, ticketFor,
   ticketSub, usePlayers, verifyControl,
 } from './office.mjs';
 
@@ -815,6 +815,9 @@ export class Table {
       const room = this.room;
       if (!room) return;
       room.tick();
+      // A room that just opened reads its game's launch state once: a change made in the moment it opened (before the
+      // Lobby knew of it) still reaches it, after the current round as always.
+      if (room.openedAt && this.launchReadFor !== room.openedAt) { this.launchReadFor = room.openedAt; this.ctx.waitUntil(this.rereadLaunch().catch(() => {})); }
       // A launch change the room applied by itself (after its round): its stored state says so too.
       if (room.officeDirty) { room.officeDirty = false; this.ctx.storage.put('office', room.officeSaved()).catch(() => {}); }
       n += 1;
@@ -824,6 +827,22 @@ export class Table {
     }, 250);
   }
 
+  /**
+   * The game's launch state, read once when the room opens (one D1 read): a private or invite-only game whose room
+   * holds anyone the state leaves out re-gates after the current round. Never in a Preview (no launch states there).
+   */
+  async rereadLaunch() {
+    const room = this.room;
+    if (!room || !this.game || !this.env.DB || this.env.HOMIE_PREVIEW === '1' || room.regate) return null;
+    let launch = null;
+    try { launch = (await this.env.DB.prepare('SELECT launch FROM office_games WHERE game = ?1').bind(this.game).first())?.launch ?? null; } catch { return null; }
+    const args = regateArgs(launch);
+    if (!args.allow) return null;
+    const res = room.control('regate', args);
+    if (res.ok && res.leaving) await this.ctx.storage.put('office', room.officeSaved()).catch(() => {});
+    return res;
+  }
+
   /** Tell the Lobby this room closed (until when; 0 when it opened again), so it sends nobody here meanwhile. */
   tellLobby(extra) {
     if (!this.game || !this.code) return;

package/worker/office.mjs

@@ -57,6 +57,21 @@ const TICKET_TTL_MS = 12 * 3600_000;
 /** Who may stay in a live room after a launch change, by the kinds of holder a ticket names (o, i-…, p-…). */
 const ALLOW = Object.freeze({ private: ['o'], invite: ['o', 'i'], public: null });
 
+/**
+ * The room control for a launch state (NETPLAY.md section 15 `regate`): who may stay, the notice everyone sees while
+ * the round finishes, and the words for whoever then leaves. Public calls a waiting change off.
+ */
+export function regateArgs(launch, name = 'This game') {
+  if (!ALLOW[launch]) return {};
+  return {
+    allow: ALLOW[launch],
+    ...{
+      private: { notice: `${name} goes private after this round. Thanks for playing!`, message: `${name} is private now. Thanks for playing!` },
+      invite: { notice: `${name} becomes an invite-only beta after this round. Invited players keep playing.`, message: `${name} is an invite-only beta now. Have an invite? Enter it on the game's page. Thanks for playing!` },
+    }[launch],
+  };
+}
+
 const json = (body, status = 200, extra = {}) => new Response(`${JSON.stringify(body)}\n`, {
   status, headers: { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store, private', 'x-robots-tag': 'noindex', ...extra },
 });
@@ -578,12 +593,7 @@ export async function perform(env, cat, a) {
       // state leaves out is sent out of it (the owner, and in an invite-only beta the invited, play on). Back to a
       // wider state, a change still waiting is called off.
       if (launch !== prev) {
-        const words = {
-          private: { notice: `${meta.name} goes private after this round. Thanks for playing!`, message: `${meta.name} is private now. Thanks for playing!` },
-          invite: { notice: `${meta.name} becomes an invite-only beta after this round. Invited players keep playing.`, message: `${meta.name} is an invite-only beta now. Have an invite? Enter it on the game's page. Thanks for playing!` },
-          public: {},
-        }[launch];
-        const res = await Promise.all(rooms.map((r) => roomControl(env, meta, fresh, r.room, 'regate', ALLOW[launch] ? { allow: ALLOW[launch], ...words } : {})));
+        const res = await Promise.all(rooms.map((r) => roomControl(env, meta, fresh, r.room, 'regate', regateArgs(launch, meta.name))));
         done.regating = res.filter((r) => r.ok && r.leaving > 0).length;
       }
       if (a.maxPlayers !== undefined) {

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