@homie-rocks/studio 0.32.0 → 0.33.0

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

@@ -0,0 +1,86 @@
+/*
+ * COIN DASH — the rules: the example of a game whose rules run on the server.
+ *
+ * What is true in the game is decided here, in one place, on the studio's own Cloudflare: who took which coin, every
+ * score, when a round starts and ends. A player's browser sends what the player presses and draws what it is told
+ * (src/view.ts); it cannot change a score.
+ *
+ * HOW RULES ARE WRITTEN. Every entity owns its own state, in declared fields. A handler may write only the entity it
+ * runs for (`self`); everything else it reads is read-only. To affect another entity it sends an event, which arrives
+ * on a later tick. So a runner does not take a coin: it asks the coin (`take`), the coin answers the first one that
+ * asked (`score`) and is gone, and a second `take` finds nobody there.
+ *
+ * In this release a person's runner moves as today: its own browser says where it is, and the server holds each claim
+ * to the body's top speed (`move: 'owner'`). The server moves the bots with the same code (src/move.ts).
+ */
+import { defineRules, f } from '@homie-rocks/studio/rules';
+import { move } from './move';
+
+export default defineRules({
+  contract: 2,
+  space: { dims: 2 },
+  move,
+  shapes: {
+    events: { take: { by: f.ref() }, score: {} },
+    commands: {},
+    effects: { ding: {} },
+  },
+  entities: {
+    runner: {
+      player: { away: 'think', leave: 'bot' },
+      fields: { score: f.u16({ score: true }) },
+      motion: { frozenUntil: f.tick() },
+      input: { ax: f.i8(), ay: f.i8() },
+      body: { shape: 'circle', radius: 0.5, maxSpeed: 6, move: 'owner' },
+      tick(world, self) {
+        if (world.round.phase !== 'live') return;
+        // A second `take` sent before the coin is gone is dropped: the coin no longer exists.
+        for (const coin of world.near(self.pos, 1, 'coin')) world.send(coin.id, 'take', { by: self.id });
+      },
+      think(world, self) {                 // a bot, and a player who is away
+        const coin = world.near(self.pos, 64, 'coin')[0];
+        if (!coin) return { ax: 0, ay: 0 };
+        const d = world.math.norm(world.math.sub(coin.pos, self.pos));
+        return { ax: Math.round(d.x * 127), ay: Math.round(d.y * 127) };
+      },
+      on: {
+        score(world, self) { self.score += 1; },
+        arrive(world, self) {              // joined during a break: stand still with the others
+          if (world.round.phase === 'over') self.motion.frozenUntil = world.round.endsAt;
+        },
+      },
+      onRoom: {
+        roundStart(world, self) {
+          const spots = world.map.spots('start');
+          self.score = 0;
+          self.motion.frozenUntil = 0;
+          world.place(self, spots[self.seat % spots.length]);
+        },
+        roundOver(world, self) { self.motion.frozenUntil = world.round.endsAt; },   // stand still through the break
+      },
+    },
+    coin: {
+      on: {
+        take(world, self, e) {             // first taker wins: a despawned coin hears nothing more this tick
+          world.send(e.by, 'score', {});
+          world.emit('ding', self.pos, {});
+          world.despawn(self);
+        },
+      },
+      onRoom: { roundOver(world, self) { world.despawn(self); } },
+    },
+  },
+  shared: {},
+  room: {
+    rounds: { seconds: 60, breakSeconds: 8 },
+    bots: { keep: 4 },
+    join(ctx, player) {
+      const spots = ctx.map.spots('start');
+      return { kind: 'runner', at: spots[player.seat % spots.length] };
+    },
+    on: {
+      roundStart(world) { for (const spot of world.map.spots('coins')) world.spawn('coin', spot, {}); },
+    },
+  },
+  map: './map',
+});

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

@@ -0,0 +1,106 @@
+/*
+ * COIN DASH — the view: what a player sees, and what they press.
+ *
+ * The view draws the room it is told about and sends input. It decides nothing: the coins, the scores and the rounds
+ * are the rules' (src/rules.ts), which run on the server. `openRoom()` joins the room the play page names; `room.me`
+ * is the player's own runner, `room.each` every entity at render time, `room.on` the effects the rules emit.
+ *
+ * Canvas 2D on purpose: the point is the two halves, in a page of code each.
+ */
+import { openRoom } from '@homie-rocks/studio/rules/view';
+import { PALETTE, guardGestures } from '@homie-rocks/studio/netplay';
+import type rules from './rules';
+
+const room = openRoom<typeof rules>();
+const canvas = document.getElementById('c') as HTMLCanvasElement;
+const g = canvas.getContext('2d') as CanvasRenderingContext2D;
+guardGestures();
+
+/* ------------------------------------------------------------------ input: keys, or a thumb dragged from where it landed */
+const keys = new Set<string>();
+addEventListener('keydown', (e) => { keys.add(e.code); });
+addEventListener('keyup', (e) => { keys.delete(e.code); });
+addEventListener('blur', () => keys.clear());
+let thumb: { id: number; x0: number; y0: number; x: number; y: number } | null = null;
+canvas.addEventListener('pointerdown', (e) => { if (!thumb) thumb = { id: e.pointerId, x0: e.clientX, y0: e.clientY, x: e.clientX, y: e.clientY }; });
+addEventListener('pointermove', (e) => { if (thumb && e.pointerId === thumb.id) { thumb.x = e.clientX; thumb.y = e.clientY; } });
+const lift = (e: PointerEvent): void => { if (thumb && e.pointerId === thumb.id) thumb = null; };
+addEventListener('pointerup', lift);
+addEventListener('pointercancel', lift);
+
+function stick(): { ax: number; ay: number } {
+  let x = (keys.has('KeyD') || keys.has('ArrowRight') ? 1 : 0) - (keys.has('KeyA') || keys.has('ArrowLeft') ? 1 : 0);
+  let y = (keys.has('KeyW') || keys.has('ArrowUp') ? 1 : 0) - (keys.has('KeyS') || keys.has('ArrowDown') ? 1 : 0);
+  if (thumb) { x = (thumb.x - thumb.x0) / 48; y = -(thumb.y - thumb.y0) / 48; }
+  const l = Math.hypot(x, y);
+  if (l > 1) { x /= l; y /= l; }
+  return { ax: Math.round(x * 127), ay: Math.round(y * 127) };
+}
+
+/* ------------------------------------------------------------------ effects the rules emit */
+const dings: { x: number; y: number; at: number }[] = [];
+room.on('ding', (e) => { if (e.at) dings.push({ x: e.at.x, y: e.at.y, at: performance.now() }); });
+
+/* ------------------------------------------------------------------ drawing: metres to pixels, y up */
+const map = room.map;
+const W = map.bounds.max.x - map.bounds.min.x;
+const H = map.bounds.max.y - map.bounds.min.y;
+let scale = 1; let ox = 0; let oy = 0;
+const px = (x: number): number => ox + (x - map.bounds.min.x) * scale;
+const py = (y: number): number => oy + (map.bounds.max.y - y) * scale;
+
+function fit(): void {
+  const dpr = Math.min(2, devicePixelRatio || 1);
+  canvas.width = Math.round(innerWidth * dpr); canvas.height = Math.round(innerHeight * dpr);
+  scale = Math.min(canvas.width / (W + 1), canvas.height / (H + 3));
+  ox = (canvas.width - W * scale) / 2; oy = (canvas.height - H * scale) / 2 + scale * 0.6;
+}
+addEventListener('resize', fit);
+fit();
+
+function frame(): void {
+  room.input(stick());
+  g.fillStyle = '#0b1020'; g.fillRect(0, 0, canvas.width, canvas.height);
+  g.fillStyle = '#141b33'; g.fillRect(px(map.bounds.min.x), py(map.bounds.max.y), W * scale, H * scale);
+  g.fillStyle = '#2a3560';
+  for (const b of map.boxes) g.fillRect(px(b.min.x), py(b.max.y), (b.max.x - b.min.x) * scale, (b.max.y - b.min.y) * scale);
+  for (const c of map.circles) { g.beginPath(); g.arc(px(c.at.x), py(c.at.y), c.r * scale, 0, Math.PI * 2); g.fill(); }
+
+  room.each('coin', (c) => {
+    g.fillStyle = '#ffd166'; g.beginPath(); g.arc(px(c.pos.x), py(c.pos.y), 0.28 * scale, 0, Math.PI * 2); g.fill();
+    g.fillStyle = '#fff3c4'; g.beginPath(); g.arc(px(c.pos.x) - 0.08 * scale, py(c.pos.y) - 0.08 * scale, 0.09 * scale, 0, Math.PI * 2); g.fill();
+  });
+  const now = performance.now();
+  for (let i = dings.length - 1; i >= 0; i -= 1) {
+    const t = (now - dings[i].at) / 450;
+    if (t >= 1) { dings.splice(i, 1); continue; }
+    g.strokeStyle = `rgba(255, 209, 102, ${1 - t})`; g.lineWidth = 0.08 * scale;
+    g.beginPath(); g.arc(px(dings[i].x), py(dings[i].y), (0.3 + t * 0.9) * scale, 0, Math.PI * 2); g.stroke();
+  }
+  const names = new Map(room.roster.map((r) => [r.seat, r]));
+  g.textAlign = 'center'; g.font = `${Math.round(0.42 * scale)}px system-ui, sans-serif`;
+  room.each('runner', (r) => {
+    const x = px(r.pos.x); const y = py(r.pos.y);
+    g.fillStyle = PALETTE[(r.seat ?? 0) % PALETTE.length];
+    g.beginPath(); g.arc(x, y, 0.5 * scale, 0, Math.PI * 2); g.fill();
+    // A dot where the runner faces.
+    g.fillStyle = '#0b1020'; g.beginPath(); g.arc(x + r.heading.x * 0.28 * scale, y - r.heading.y * 0.28 * scale, 0.11 * scale, 0, Math.PI * 2); g.fill();
+    if (r.mine) { g.strokeStyle = '#ffffff'; g.lineWidth = 0.07 * scale; g.beginPath(); g.arc(x, y, 0.58 * scale, 0, Math.PI * 2); g.stroke(); }
+    g.fillStyle = r.away ? '#7c86a8' : '#e8ecff';
+    g.fillText(names.get(r.seat ?? -1)?.name ?? '', x, y - 0.75 * scale);
+  });
+
+  // The HUD: the clock (from the room's own), and the board (from the room's roster).
+  const round = room.round;
+  g.fillStyle = '#e8ecff'; g.font = `600 ${Math.round(0.7 * scale)}px system-ui, sans-serif`;
+  const top = oy - 0.5 * scale;
+  if (room.status !== 'playing') g.fillText(room.status === 'connecting' ? 'Joining the room…' : 'Coin Dash needs a connection to its room', canvas.width / 2, top);
+  else if (round) g.fillText(round.phase === 'live' ? `Round ${round.n}   ${Math.ceil(round.secondsLeft)}` : `Round ${round.n} is over. Next in ${Math.ceil(round.secondsLeft)}`, canvas.width / 2, top);
+  g.textAlign = 'left'; g.font = `${Math.round(0.42 * scale)}px system-ui, sans-serif`;
+  [...room.roster].sort((a, b) => b.score - a.score || a.seat - b.seat).forEach((r, i) => {
+    g.fillStyle = PALETTE[r.seat % PALETTE.length];
+    g.fillText(`${r.score}  ${r.name}${r.me ? '  (you)' : ''}`, ox + 0.3 * scale, oy + (0.6 + i * 0.55) * scale);
+  });
+  requestAnimationFrame(frame);
+}
+requestAnimationFrame(frame);

package/starters/coin-dash/tunables.json

@@ -0,0 +1,5 @@
+{
+  "public": {
+    "speed": { "value": 6, "min": 2, "max": 6, "step": 0.1, "unit": "m/s", "group": "Run", "note": "How fast a runner goes. Never above the body's maxSpeed in rules.ts (6): the server holds every runner to that" }
+  }
+}

package/starters/ember-vale/index.html

@@ -21,6 +21,17 @@
   .panel li { margin: 4px 0; color: #e7d9b4; }
   .panel li small { color: #a39a80; }
   .panel .close { float: right; background: none; border: 0; color: #c9c0a6; font-size: 20px; cursor: pointer; }
+  /* A panel never runs off a short screen (a phone on its side, a small frame in somebody's post): there the new
+     hero's card becomes two rows at the bottom, clear of the page's own buttons along the top. While a panel is
+     open the touch controls (drawn over everything, .hp-touch) are not drawn over it. */
+  .panel { max-height: calc(100vh - 16px); overflow: auto; }
+  body:has(.panel:not([hidden])) .hp-touch { visibility: hidden; }
+  @media (max-height: 340px) {
+    #make { top: auto; bottom: calc(8px + env(safe-area-inset-bottom)); transform: translateX(-50%); width: min(520px, calc(100vw - 24px)); padding: 10px 12px; display: grid; grid-template-columns: 1fr 1fr; gap: 8px 10px; align-items: center; }
+    #make h2 { margin: 0; font-size: 16px; }
+    #make p { display: none; }
+    #make label.hc { margin: 0; font-size: 11.5px; line-height: 1.25; }
+  }
   /* Asking a guide: buttons (agents.json "asks"), never a text box. On a computer: bottom centre. */
   .asks { left: 50%; transform: translateX(-50%); bottom: calc(14px + env(safe-area-inset-bottom)); max-width: min(560px, calc(100vw - 200px)); box-sizing: border-box; padding: 8px 10px; border-radius: 14px; background: rgba(10,20,18,.84); border: 1px solid rgba(127,216,200,.45); text-align: center; }
   .asks .who { font: 700 12.5px/1.2 inherit; font-family: inherit; color: #7fd8c8; margin: 0 0 6px; }

package/worker/brain.mjs

@@ -53,7 +53,8 @@ function argSpec(raw) {
 }
 
 function argsOf(raw, where, problems) {
-  const out = {};
+  // No prototype: an argument name comes from outside (a model's answer, a person's ask), and "constructor" is not one.
+  const out = Object.create(null);
   if (raw === undefined || raw === null) return out;
   if (typeof raw !== 'object' || Array.isArray(raw)) { problems.push(`${where}: args is an object of name: type`); return null; }
   const names = Object.keys(raw);
@@ -96,7 +97,7 @@ export function vocabularyOf(raw) {
     }
   }
   const section = (key, max, each) => {
-    const out = {};
+    const out = Object.create(null);
     const src = raw[key];
     if (src === undefined) return out;
     if (!src || typeof src !== 'object' || Array.isArray(src)) { problems.push(`${key} is an object of id: entry`); return out; }
@@ -173,7 +174,7 @@ export function checkArgs(specs, args, ctx = {}) {
 /** How a value reads aloud: its label in agents.json, else the value with dashes as spaces. */
 export function labelOf(vocab, value) {
   const v = String(value ?? '');
-  return vocab?.labels?.[v] ?? v.replace(/[-_]+/g, ' ');
+  return vocab?.labels && Object.hasOwn(vocab.labels, v) ? vocab.labels[v] : v.replace(/[-_]+/g, ' ');
 }
 
 /**
@@ -181,7 +182,7 @@ export function labelOf(vocab, value) {
  * the guide's own name for {me}. Null when the id or its arguments do not fit.
  */
 export function renderLine(vocab, id, args = {}, { nameOf = (seat) => `Player ${Number(seat) + 1}`, me = 'Guide', view = null, players = null, kind = 'lines' } = {}) {
-  const entry = vocab?.[kind]?.[id];
+  const entry = vocab?.[kind] && typeof id === 'string' && Object.hasOwn(vocab[kind], id) ? vocab[kind][id] : null;
   if (!entry) return null;
   if (checkArgs(entry.args, args, { view, players })) return null;
   return entry.text.replace(SLOT_IN_TEXT, (m, k) => (k === 'me' ? String(me) : entry.args[k]?.kind === 'player' ? String(nameOf(args[k]) ?? '') : labelOf(vocab, args[k])));
@@ -304,14 +305,14 @@ export function parseDecision(out, vocab, { view = null, players = null, avoid =
   }
   if (!o || typeof o !== 'object' || Array.isArray(o)) return bad('not an object');
   for (const k of Object.keys(o)) if (!['goal', 'args', 'say', 'sayArgs'].includes(k)) return bad(`extra field ${String(k).slice(0, 16)}`);
-  const goal = vocab.goals[o.goal];
+  const goal = (typeof o.goal === 'string' && Object.hasOwn(vocab.goals, o.goal) ? vocab.goals[o.goal] : null);
   if (typeof o.goal !== 'string' || !goal) return bad('goal is not one of the vocabulary\'s');
   const ga = o.args ?? {};
   const gw = checkArgs(goal.args, ga, { view, players });
   if (gw) return bad(`goal ${o.goal}: ${gw}`);
   let say = null; let sayArgs = {};
   if (o.say !== null && o.say !== undefined && o.say !== '') {
-    const line = vocab.lines[o.say];
+    const line = (typeof o.say === 'string' && Object.hasOwn(vocab.lines, o.say) ? vocab.lines[o.say] : null);
     if (typeof o.say !== 'string' || !line) return bad('say is not one of the vocabulary\'s lines');
     sayArgs = o.sayArgs ?? {};
     const lw = checkArgs(line.args, sayArgs, { view, players });
@@ -332,7 +333,7 @@ export function scripted(vocab, { asks = [], view = null, players = null, avoid
   const ctx = { view, players };
   const near = (specs, a) => Object.entries(specs).some(([k, s]) => s.kind === 'player' && avoid.includes(a[k]));
   for (const a of [...asks].sort((x, y) => (y.at ?? 0) - (x.at ?? 0))) {
-    const ask = vocab.asks[a.k];
+    const ask = typeof a.k === 'string' && Object.hasOwn(vocab.asks, a.k) ? vocab.asks[a.k] : null;
     if (!ask || (!ask.goal && !ask.say)) continue;
     // Arguments carry over by name; a player argument is the player who asked.
     const fill = (specs) => Object.fromEntries(Object.entries(specs).map(([k, s]) => [k, s.kind === 'player' ? a.from : a.args?.[k]]));

package/worker/chat-page.mjs

@@ -527,7 +527,7 @@ export const CHAT_JS = String.raw`(function () {
     else if (!typing && r.who === 'members') n = 'Only members of this server type here.';
     if (!reacts && !watchersOut && r.react === 'signed-in' && !cfg.acct) { n = 'Sign in to chat in this room. '; link = 'Sign in'; }
     note.textContent = n;
-    if (link) { var a = el('a', '', link); a.href = cfg.account + '?next=' + encodeURIComponent(location.pathname + location.search); a.target = surface === 'play' ? '_blank' : '_self'; note.appendChild(a); }
+    if (link) { var a = el('a', '', link); a.href = cfg.account + '?next=' + encodeURIComponent(window.__shell && window.__shell.returnPath ? window.__shell.returnPath() : location.pathname + location.search); a.target = surface === 'play' ? '_blank' : '_self'; note.appendChild(a); }
     note.hidden = !n;
     bubbleBox.parentNode.hidden = surface !== 'play' || !r.bubbles || mySeat() === null;
   }

package/worker/embed.mjs

@@ -0,0 +1,135 @@
+/**
+ * Player cards. X's reference: developer.x.com, "Cards: player card" (archived)
+ * (redirects to docs.x.com/overview as checked 2026-10-08). Surviving official sample:
+ * https://github.com/xdevplatform/cards-player-samples/blob/main/player/page.html
+ * https://devcommunity.x.com/t/player-cards-improved-security-and-faster-approval-times/50033
+ * https://devcommunity.x.com/t/fullscreen-for-player-cards/70717
+ * The archived reference reserves cards for linear audio/video and excludes games. Phone apps
+ * open twitter:player top-level in their in-app browser. The 2026-10-08 public X web bundle
+ * https://abs.twimg.com/x-web/x-web/assets/article-card-DEH89WAV.js (function Ts) only frames
+ * YouTube/SoundCloud/Periscope; other hosts link to card_url in a new tab. Not a signed-in test.
+ * X documents HTTPS media players and sandboxing, NOT a supported game API, a current exhaustive
+ * ancestor list, or guaranteed fullscreen. The X domain families and the sandbox below are observed
+ * (the frame-ancestors header of the live game page https://snekarena.com/r/main, read 2026-10-08, and
+ * the bundle above), not a promise from X.
+ * No og:video/stream tag: an HTML game is not a video. Consumers of Twitter player tags can use the
+ * same metadata; other platforms keep the OG image (https://ogp.me/). No universal game-card standard.
+ */
+export const PLAYER_ANCESTORS = ['https://x.com', 'https://*.x.com', 'https://twitter.com', 'https://*.twitter.com'];
+export const PLAYER_SANDBOX = 'allow-scripts allow-same-origin allow-popups allow-popups-to-escape-sandbox';
+/**
+ * The size the tags advertise: 480×480.
+ * - The two game pages whose posts showed a play button the week of 2026-10-08 both advertise 480×480
+ *   (tags read as Twitterbot from https://snekarena.com/r/main and from a game page on https://www.spawn.co),
+ *   with pictures of 1200×628 and 1200×800: X accepts a picture whose shape is not the player's.
+ * - X's reference says the player is scaled to the post's width at this width:height ratio. A phone's post is
+ *   about 358 px wide: a 16:9 player there is 201 px tall, too short for a game's own dialogs and this
+ *   shell's room sheet; a square one is 358 px tall.
+ * - X's web bundle (above) clamps the ratio to max(width/height, 1), so square is the tallest it shows.
+ * X's phone apps open the player address full screen, where this size only shapes the picture in the post.
+ */
+export const PLAYER_SIZE = { width: 480, height: 480 };
+/**
+ * What X's reference says a card picture must be for the card to render: JPG, PNG, WEBP or GIF, at least 68,600
+ * pixels (262×262, or 350×196), under 5 MB. It also says the picture "should" have the player's dimensions:
+ * advice, which the build passes on as a warning and never as a refusal (lib/player-image.mjs).
+ */
+export const PLAYER_IMAGE = { formats: ['jpeg', 'png', 'webp', 'gif'], minPixels: 68600, maxBytes: 5000000 };
+export const playerImageRule = (m) => (!m || !PLAYER_IMAGE.formats.includes(m.format) ? 'format'
+  : !(m.width * m.height >= PLAYER_IMAGE.minPixels) ? 'pixels' : !(m.bytes < PLAYER_IMAGE.maxBytes) ? 'bytes' : null);
+
+/** These are switches, not plan limits. TV-only games must declare their lack of a single-screen view. */
+export function playerEnabled(cat, game) {
+  return cat?.studio?.site?.playerCard !== false && game?.playerCard !== false &&
+    game?.screen?.singleScreen !== false && !['private', 'invite'].includes(game?.launch);
+}
+
+/** Exact HTTPS origins, or an HTTPS DNS wildcard, never arbitrary CSP text. An explicit [] denies all. */
+export function playerOrigins(value) {
+  if (!Array.isArray(value)) return [...PLAYER_ANCESTORS];
+  const origins = [];
+  for (const v of value) {
+    if (typeof v !== 'string' || !/^https:\/\/(?:\*\.)?[a-z0-9.-]+(?::[0-9]+)?$/i.test(v)) continue;
+    try {
+      const wildcard = v.includes('*.');
+      const u = new URL(v.replace('*.', ''));
+      const labels = u.hostname.split('.');
+      if (labels.length < 2 || labels.some(l => !/^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/i.test(l))) continue;
+      // A wildcard must name a domain, never a top-level suffix.
+      if (wildcard && (labels.length < 2 || /^(?:co|com|net|org)\.[a-z]{2}$/.test(u.hostname))) continue;
+      const origin = 'https://' + (wildcard ? '*.' : '') + u.host;
+      if (!origins.includes(origin)) origins.push(origin);
+      if (origins.length === 8) break;
+    } catch {}
+  }
+  return origins;
+}
+export function playerAncestors(cat) {
+  return playerOrigins(cat?.studio?.site?.playerCardOrigins).join(' ') || "'none'";
+}
+export function httpsAddress(value, origin) {
+  try { const u = new URL(value, origin); return u.protocol === 'https:' && !u.username && !u.password ? u.href : null; } catch { return null; }
+}
+export function playerProperties(cat, game, { origin = '', title = game?.name, description = game?.blurb } = {}) {
+  const player = httpsAddress(`/${game?.id}/play/embed`, origin);
+  const measured = game?.playerImage;
+  const picture = measured && httpsAddress(measured.src, origin);
+  // twitter:site goes out when the studio has set its handle; a card is never withheld for the lack of one
+  // (neither live game page above carries it).
+  const handle = /^@[A-Za-z0-9_]{1,15}$/.test(cat?.studio?.site?.twitterSite || '') ? cat.studio.site.twitterSite : null;
+  if (!playerEnabled(cat, game) || !player || !picture || playerImageRule(measured)) return {};
+  return { ...(handle ? { 'twitter:site': handle } : {}), 'twitter:card': 'player', 'twitter:player': player, 'twitter:player:width': PLAYER_SIZE.width,
+    'twitter:player:height': PLAYER_SIZE.height, 'twitter:image': picture, 'twitter:title': title,
+    'twitter:description': String(description || `Play ${game.name} in your browser.`).slice(0, 200) };
+}
+
+/** Browser restrictions belong to the outer host; failures must not kill a game's input loop.
+ * MDN, "iframe: sandbox"
+ * MDN, "Permissions Policy"
+ * Used only for the embedded instance, ahead of the game's scripts. Existing port/early provides
+ * storage/cookie shims for imported games; netplay and the shell already guard their own storage.
+ */
+export const EMBED_GAME_JS = String.raw`(function () {
+  function unavailable(feature) { parent.postMessage({t:'homie-net',what:'embed-unavailable',feature:feature}, '*'); }
+  function guarded(proto, name, feature) {
+    var real = proto && proto[name];
+    if (typeof real !== 'function') return;
+    try { proto[name] = function () {
+      try { var result = real.apply(this, arguments); return result && typeof result.catch === 'function' ? result.catch(function () { unavailable(feature); }) : result; }
+      catch (e) { unavailable(feature); return Promise.resolve(); }
+    }; } catch (e) {}
+  }
+  guarded(Element.prototype, 'requestPointerLock', 'pointer lock');
+  guarded(Element.prototype, 'requestFullscreen', 'fullscreen');
+  document.addEventListener('pointerlockerror', function () { unavailable('pointer lock'); });
+  document.addEventListener('fullscreenerror', function () { unavailable('fullscreen'); });
+  var pads = navigator.getGamepads;
+  if (pads) try { Object.defineProperty(navigator, 'getGamepads', { configurable:true, value:function () {
+    try { return pads.call(navigator); } catch (e) { if (!pads.warned) { pads.warned = true; unavailable('gamepad'); } return []; }
+  }}); } catch (e) {}
+  // Keep early requests pending and replay them on the first real press. A game that asks only once
+  // must start too; resolving a no-op resume/play loses that request.
+  var pressed = false, pending = [];
+  function afterPress(run) {
+    if (pressed) return run();
+    return new Promise(function (resolve, reject) { pending.push(function () { run().then(resolve, reject); }); });
+  }
+  ['AudioContext','webkitAudioContext'].forEach(function (name) {
+    var AC = window[name]; if (!AC) return;
+    try { window[name] = new Proxy(AC, { construct:function (ctor,args) {
+      var ctx = Reflect.construct(ctor,args), resume = ctx.resume.bind(ctx);
+      if (!pressed) ctx.suspend().catch(function () {});
+      ctx.resume = function () { return afterPress(resume); };
+      return ctx;
+    }}); } catch (e) {}
+  });
+  ['pointerdown','keydown','touchstart'].forEach(function (name) { addEventListener(name,function () {
+    if (pressed) return;
+    pressed = true; var queued = pending; pending = []; queued.forEach(function (run) { run(); });
+  },{capture:true,once:true}); });
+  var play = HTMLMediaElement.prototype.play;
+  HTMLMediaElement.prototype.play = function () {
+    var media = this;
+    return afterPress(function () { return play.call(media); });
+  };
+}());`;

package/worker/hosted.mjs

@@ -0,0 +1,56 @@
+/**
+ * Server-hosted games: the rules this studio's build put into its Worker, and the host runtime a Table runs for one
+ * room of such a game (NETPLAY.md section 29; rules/host.ts is the runtime, worker/room.mjs the relay it serves).
+ *
+ * `homie-studio build` writes every server-hosted game's rules, guarded (lib/rules-guard.mjs), into the studio's
+ * site/src/rules/, with a table of them (site/src/rules/index.mjs): per game its rules module, its tunables, its map,
+ * its settings and its seats. The studio's site/src/worker.mjs hands that table over once, when the Worker loads:
+ *
+ *   import { hostRules } from '@homie-rocks/studio/worker';
+ *   import rules from './rules/index.mjs';
+ *   hostRules(rules);
+ *
+ * Only the studio's own games are in it: no rules from outside the studio run on its server. The rules run in this
+ * Worker's isolate, behind the build's wall and the runtime's budget, until rules get an isolate of their own.
+ */
+import { createHost } from '../rules/host.ts';
+import { compileMap, compileRules } from '../rules/rules.ts';
+
+/** game id → { rules, tune, map, settings, seats, build } as the build wrote it, and what compiling each gave. */
+const games = new Map();
+const compiled = new Map();
+
+/** The table of this studio's server-hosted games (the build's site/src/rules/index.mjs). Called once, at load. */
+export function hostRules(table) {
+  games.clear();
+  compiled.clear();
+  if (!table || typeof table !== 'object') return 0;
+  for (const [id, entry] of Object.entries(table)) if (entry && typeof entry === 'object' && entry.rules) games.set(id, entry);
+  return games.size;
+}
+
+/** Whether this Worker holds rules for a game. */
+export const hostedGame = (id) => games.has(id);
+export const hostedBuild = (id) => games.get(id);
+
+/** A game's rules, compiled once per isolate. Throws, naming the declaration, when they do not fit the contract. */
+export function compiledFor(id) {
+  if (compiled.has(id)) return compiled.get(id);
+  const e = games.get(id);
+  if (!e) throw new Error('this build of the site holds no rules for this game');
+  const c = compileRules(e.rules, { tune: e.tune, map: compileMap(e.map, e.map?.name ?? 'main'), settings: e.settings, seats: e.seats });
+  compiled.set(id, c);
+  return c;
+}
+
+/**
+ * The host runtime for one room. `send(frame, text)` is the relay's `hostFrame`; the clock is the Worker's own, and the
+ * tick loop a timer chain inside the object. The Table supplies its synchronous store and recovery settings.
+ */
+export function startHost(game, { send, log, onPause, onResume, onEnd, ...recovery }) {
+  return createHost({
+    game, build: games.get(game)?.build ?? undefined, compiled: compiledFor(game), send, log, onPause, onResume, onEnd,
+    clock: { now: () => Date.now(), setTimer: (fn, ms) => setTimeout(fn, ms), clearTimer: (h) => clearTimeout(h) },
+    ...recovery,
+  });
+}